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/.gemini/config.yaml b/.gemini/config.yaml
new file mode 100644
index 00000000000..71adf793964
--- /dev/null
+++ b/.gemini/config.yaml
@@ -0,0 +1,13 @@
+have_fun: false
+memory_config:
+  disabled: false
+code_review:
+  disable: false
+  comment_severity_threshold: MEDIUM
+  max_review_comments: -1
+  pull_request_opened:
+    help: false
+    summary: false
+    code_review: false
+    include_drafts: false
+ignore_patterns: []
diff --git a/.gitattributes b/.gitattributes
index 6d0661ec5a4..4343b9bd8ec 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -1,4 +1,4 @@
-TestService.java.txt binary
-TestServiceLite.java.txt binary
-TestDeprecatedService.java.txt binary
-TestDeprecatedServiceLite.java.txt binary
+TestService.java.txt -text
+TestServiceLite.java.txt -text
+TestDeprecatedService.java.txt -text
+TestDeprecatedServiceLite.java.txt -text
diff --git a/.github/lock.yml b/.github/lock.yml
deleted file mode 100644
index 119e4840bee..00000000000
--- a/.github/lock.yml
+++ /dev/null
@@ -1,2 +0,0 @@
-daysUntilLock: 90
-lockComment: false
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
index 0bde8aeca18..da1e2fed114 100644
--- a/.github/workflows/gradle-wrapper-validation.yml
+++ b/.github/workflows/gradle-wrapper-validation.yml
@@ -1,10 +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@v2
-      - uses: gradle/wrapper-validation-action@v1
+      - 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..8793cfb82fe
--- /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: 8.7.0
+
+    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 }} --enable_workspace=${{ !matrix.bzlmod }}
+
+    - name: Run bazel test
+      run: bazelisk test //... --enable_bzlmod=${{ matrix.bzlmod }} --enable_workspace=${{ !matrix.bzlmod }}
+
+    - name: Run example bazel build
+      run: bazelisk build //... --enable_bzlmod=${{ matrix.bzlmod }} --enable_workspace=${{ !matrix.bzlmod }}
+      working-directory: ./examples
diff --git a/.gitignore b/.gitignore
index afa204c2ccb..b078d891adf 100644
--- a/.gitignore
+++ b/.gitignore
@@ -15,12 +15,14 @@ bazel-genfiles
 bazel-grpc-java
 bazel-out
 bazel-testlogs
+MODULE.bazel.lock
 
 # IntelliJ IDEA
 .idea
 *.iml
 *.ipr
 *.iws
+.ijwb
 
 # Eclipse
 .classpath
@@ -29,6 +31,9 @@ bazel-testlogs
 .gitignore
 bin
 
+# VsCode
+.vscode
+
 # OS X
 .DS_Store
 
@@ -38,3 +43,6 @@ bin
 
 # 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 4a37defdafb..00000000000
--- a/.travis.yml
+++ /dev/null
@@ -1,65 +0,0 @@
-language: java
-
-env:
-  global:
-    - GRADLE_OPTS=-Xmx512m
-    - LDFLAGS=-L/tmp/protobuf/lib
-    - CXXFLAGS=-I/tmp/protobuf/include
-    - LD_LIBRARY_PATH=/tmp/protobuf/lib
-
-before_install:
-  - rm ~/.m2/settings.xml || true # Avoid repository.apache.org, which has QPS limits and is useless
-  - 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
-  - buildscripts/make_dependencies.sh # build protoc into /tmp/protobuf
-  - mkdir -p $HOME/.gradle
-  - echo "checkstyle.ignoreFailures=false" >> $HOME/.gradle/gradle.properties
-  - echo "failOnWarnings=true" >> $HOME/.gradle/gradle.properties
-  - echo "errorProne=true" >> $HOME/.gradle/gradle.properties
-  - echo "skipAndroid=true" >> $HOME/.gradle/gradle.properties
-
-install:
-  - ./gradlew assemble syncGeneratedSources publishToMavenLocal
-  - pushd examples && ./gradlew build && popd
-  - pushd examples && mvn verify && popd
-  - pushd examples/example-alts && ../gradlew build && popd
-  - pushd examples/example-hostname && ../gradlew build && popd
-  - pushd examples/example-hostname && mvn verify && popd
-  - pushd examples/example-tls && ../gradlew clean build && popd
-  - pushd examples/example-xds && ../gradlew build && 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:
-    # Upload to coveralls once, instead of for each job in the matrix
-  - if [[ "$TRAVIS_JOB_NUMBER" == *.1 ]]; then ./gradlew :grpc-all:coveralls; fi
-  - bash <(curl -s https://codecov.io/bash)
-
-os:
-  - linux
-
-dist: xenial
-
-jdk:
-  - openjdk8
-  - openjdk11
-
-notifications:
-  email: false
-
-cache:
-  directories:
-    - /tmp/protobuf-cache
-    - /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/BUILD.bazel b/BUILD.bazel
index 4bf8cdbc9b5..27a99fb62eb 100644
--- a/BUILD.bazel
+++ b/BUILD.bazel
@@ -12,6 +12,9 @@
 # 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(
@@ -32,10 +35,9 @@ java_library(
         "//api",
         "//protobuf",
         "//stub",
-        "//stub:javax_annotation",
-        "@com_google_code_findbugs_jsr305//jar",
-        "@com_google_guava_guava//jar",
         "@com_google_protobuf//:protobuf_java",
+        artifact("com.google.code.findbugs:jsr305"),
+        artifact("com.google.guava:guava"),
     ],
 )
 
@@ -46,8 +48,24 @@ java_library(
         "//api",
         "//protobuf-lite",
         "//stub",
-        "//stub:javax_annotation",
-        "@com_google_code_findbugs_jsr305//jar",
-        "@com_google_guava_guava//jar",
+        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/COMPILING.md b/COMPILING.md
index c37d45bda4b..b7df1319beb 100644
--- a/COMPILING.md
+++ b/COMPILING.md
@@ -15,6 +15,7 @@ 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:
 ```
@@ -43,11 +44,11 @@ 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.12.0 or later.
+The codegen plugin is C++ code and requires protobuf 22.5 or later.
 
 For Linux, Mac and MinGW:
 ```
-$ PROTOBUF_VERSION=3.12.0
+$ 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
@@ -67,7 +68,7 @@ For Visual C++, please refer to the [Protobuf README](https://github.com/google/
 for how to compile Protobuf. gRPC-java assumes a Release build.
 
 #### 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:
 ```
@@ -80,16 +81,16 @@ When building on Windows and VC++, you need to specify project properties for
 Gradle to find protobuf:
 ```
 .\gradlew publishToMavenLocal ^
-    -PvcProtobufInclude=C:\path\to\protobuf-3.12.0\src ^
-    -PvcProtobufLibs=C:\path\to\protobuf-3.12.0\vsprojects\Release ^
+    -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.12.0\\src
-vcProtobufLibs=C:\\path\\to\\protobuf-3.12.0\\vsprojects\\Release
+vcProtobufInclude=C:\\path\\to\\protobuf\\src
+vcProtobufLibs=C:\\path\\to\\protobuf\\vsprojects\\Release
 targetArch=x86_32
 ```
 
@@ -131,23 +132,21 @@ of Android SDK being installed is shown at `Android SDK Location` at the same pa
 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 Android SDK Manager
-Go to [Android SDK](https://developer.android.com/studio) and navigate to __Command line tools only__.
-Download and unzip the package for your build machine OS into somewhere easy to find 
-(e.g., `$HOME/Android/sdk`). This will be your Android SDK home directory. 
-The Android SDK Manager tool is in `tools/bin/sdkmanager`.
-
-Run the `sdkmanager` tool:
-```
-$ tools/bin/sdkmanager --update
-$ tools/bin/sdkmanager "platforms;android-28"
-```
-This installs Android SDK 28 into `platforms/android-28` of your Android SDK home directory.
-More usage of `sdkmanager` can be found at [Android User Guide](https://developer.android.com/studio/command-line/sdkmanager).
-
-
-After Android SDK is installed, you need to set the `ANDROID_HOME` environment variable to your
-Android SDK home directory:
-```
-$ export ANDROID_HOME=<path-to-your-android-sdk>
+### 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 ea98a3d5bea..646a7d986fd 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -30,56 +30,36 @@ 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`.
 
-## Maintaining clean commit history
-
-We have few conventions for keeping history clean and making code reviews easier
-for reviewers:
-
-* First line of commit messages should be in format of
-
-  `package-name: summary of change`
-
-  where the summary finishes the sentence: `This commit improves gRPC to ____________.`
-
-  for example:
-
-  `core,netty,interop-testing: add capacitive duractance to turbo encabulators`
-
-* Every time you receive a feedback on your pull request, push changes that
-  address it as a separate one or multiple commits with a descriptive commit
-  message (try avoid using vauge `addressed pr feedback` type of messages).
-
-  Project maintainers are obligated to squash those commits into one when
-  merging.
-
-## Running tests
-
-### Jetty ALPN setup for IntelliJ
-
-The tests in interop-testing project require jetty-alpn agent running in the background
-otherwise they'll fail. Here are instructions on how to setup IntellJ IDEA to enable running
-those tests in IDE:
-
-* Settings -> Build Tools -> Gradle -> Runner -> select Gradle Test Runner
-* View -> Tool Windows -> Gradle -> Edit Run Configuration -> Defaults -> JUnit -> Before lauch -> + -> Run Gradle task, enter the task in the build.gradle that sets the javaagent.
-
-Step 1 must be taken, otherwise by the default JUnit Test Runner running a single test in IDE will trigger all the tests.
-
 ## 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 first. If you are suggesting a behavioral or API change, consider starting with a [gRFC proposal](https://github.com/grpc/proposal). 
- 
-- Provide a good **PR description** as a record of **what** change is being made and **why** it was made. Link to a github issue if it exists.
- 
-- Don't fix code style and formatting unless you are already changing that line to address an issue. PRs with irrelevant changes won't be merged. 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. We expect you to be reasonably responsive to those comments, otherwise the PR will be closed after 2-3 weeks of inactivity.
- 
-- Maintain **clean commit history** and use **meaningful commit messages**. See [maintaining clean commit history](#maintaining-clean-commit-history) for details.
- 
+- 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.
+
 - Keep your PR up to date with upstream/master (if there are merge conflicts, we can't really merge your change).
 
 - **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**.
diff --git a/MAINTAINERS.md b/MAINTAINERS.md
index 5ff2c5157b5..5048c7c5aca 100644
--- a/MAINTAINERS.md
+++ b/MAINTAINERS.md
@@ -8,22 +8,28 @@ See [CONTRIBUTING.md](https://github.com/grpc/grpc-community/blob/master/CONTRIB
 for general contribution guidelines.
 
 ## Maintainers (in alphabetical order)
-- [creamsoup](https://github.com/creamsoup), Google LLC
-- [dapengzhang0](https://github.com/dapengzhang0), Google LLC
 - [ejona86](https://github.com/ejona86), Google LLC
-- [ericgribkoff](https://github.com/ericgribkoff), Google LLC
-- [jiangtaoli2016](https://github.com/jiangtaoli2016), 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
-- [sanjaypujare](https://github.com/sanjaypujare), Google LLC
 - [sergiitk](https://github.com/sergiitk), Google LLC
-- [srini100](https://github.com/srini100), Google LLC
-- [voidzcy](https://github.com/voidzcy), 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), Google LLC
-- [jtattermusch](https://github.com/jtattermusch), Google LLC
-- [louiscryan](https://github.com/louiscryan), Google LLC
-- [nicolasnoble](https://github.com/nicolasnoble), Google LLC
-- [nmittler](https://github.com/nmittler), Google LLC
-- [zpencer](https://github.com/zpencer), Google LLC
+- [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..50fd1f95d34
--- /dev/null
+++ b/MODULE.bazel
@@ -0,0 +1,160 @@
+module(
+    name = "grpc-java",
+    version = "1.82.0-SNAPSHOT",  # CURRENT_GRPC_VERSION
+    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.64.1",
+    "com.google.auth:google-auth-library-credentials:1.42.1",
+    "com.google.auth:google-auth-library-oauth2-http:1.42.1",
+    "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.13.2",
+    "com.google.errorprone:error_prone_annotations:2.48.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.133.Final",
+    "io.netty:netty-codec-http2:4.1.133.Final",
+    "io.netty:netty-codec-http:4.1.133.Final",
+    "io.netty:netty-codec-socks:4.1.133.Final",
+    "io.netty:netty-codec:4.1.133.Final",
+    "io.netty:netty-common:4.1.133.Final",
+    "io.netty:netty-handler-proxy:4.1.133.Final",
+    "io.netty:netty-handler:4.1.133.Final",
+    "io.netty:netty-resolver:4.1.133.Final",
+    "io.netty:netty-tcnative-boringssl-static:2.0.75.Final",
+    "io.netty:netty-tcnative-classes:2.0.75.Final",
+    "io.netty:netty-transport-native-epoll:jar:linux-x86_64:4.1.133.Final",
+    "io.netty:netty-transport-native-unix-common:4.1.133.Final",
+    "io.netty:netty-transport:4.1.133.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.mockito:mockito-core:4.4.0",
+    "org.checkerframework:checker-qual:3.49.5",
+    "org.codehaus.mojo:animal-sniffer-annotations:1.27",
+]
+# GRPC_DEPS_END
+
+bazel_dep(name = "abseil-cpp", version = "20250512.1")
+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/README.md b/README.md
index db22e97c7dc..8e6620c927e 100644
--- a/README.md
+++ b/README.md
@@ -1,13 +1,6 @@
 gRPC-Java - An RPC library and framework
 ========================================
 
-gRPC-Java works with JDK 7. gRPC-Java clients are supported on Android API
-levels 16 and up (Jelly Bean and later). Deploying gRPC servers on an Android
-device is not supported.
-
-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>
@@ -20,10 +13,30 @@ Provider on Android. Please see the [Security 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)
+[![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 23 (Marshmallow) 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
 ---------------
 
@@ -31,8 +44,8 @@ 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.36.0/examples) and the
-[Android example](https://github.com/grpc/grpc-java/tree/v1.36.0/examples/android)
+The [examples](https://github.com/grpc/grpc-java/tree/v1.81.0/examples) and the
+[Android example](https://github.com/grpc/grpc-java/tree/v1.81.0/examples/android)
 are standalone projects that showcase the usage of gRPC.
 
 Download
@@ -43,48 +56,45 @@ Download [the JARs][]. Or for Maven with non-Android, add to your `pom.xml`:
 <dependency>
   <groupId>io.grpc</groupId>
   <artifactId>grpc-netty-shaded</artifactId>
-  <version>1.36.0</version>
+  <version>1.81.0</version>
+  <scope>runtime</scope>
 </dependency>
 <dependency>
   <groupId>io.grpc</groupId>
   <artifactId>grpc-protobuf</artifactId>
-  <version>1.36.0</version>
+  <version>1.81.0</version>
 </dependency>
 <dependency>
   <groupId>io.grpc</groupId>
   <artifactId>grpc-stub</artifactId>
-  <version>1.36.0</version>
-</dependency>
-<dependency> <!-- necessary for Java 9+ -->
-  <groupId>org.apache.tomcat</groupId>
-  <artifactId>annotations-api</artifactId>
-  <version>6.0.53</version>
-  <scope>provided</scope>
+  <version>1.81.0</version>
 </dependency>
 ```
 
 Or for Gradle with non-Android, add to your dependencies:
 ```gradle
-implementation 'io.grpc:grpc-netty-shaded:1.36.0'
-implementation 'io.grpc:grpc-protobuf:1.36.0'
-implementation 'io.grpc:grpc-stub:1.36.0'
-compileOnly 'org.apache.tomcat:annotations-api:6.0.53' // necessary for Java 9+
+runtimeOnly 'io.grpc:grpc-netty-shaded:1.81.0'
+implementation 'io.grpc:grpc-protobuf:1.81.0'
+implementation 'io.grpc:grpc-stub:1.81.0'
 ```
 
 For Android client, use `grpc-okhttp` instead of `grpc-netty-shaded` and
 `grpc-protobuf-lite` instead of `grpc-protobuf`:
 ```gradle
-implementation 'io.grpc:grpc-okhttp:1.36.0'
-implementation 'io.grpc:grpc-protobuf-lite:1.36.0'
-implementation 'io.grpc:grpc-stub:1.36.0'
-compileOnly 'org.apache.tomcat:annotations-api:6.0.53' // necessary for Java 9+
+implementation 'io.grpc:grpc-okhttp:1.81.0'
+implementation 'io.grpc:grpc-protobuf-lite:1.81.0'
+implementation 'io.grpc:grpc-stub:1.81.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]:
-https://search.maven.org/search?q=g:io.grpc%20AND%20v:1.36.0
+https://search.maven.org/search?q=g:io.grpc%20AND%20v:1.81.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
 --------------
@@ -102,7 +112,7 @@ 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.6.2</version>
+      <version>1.7.1</version>
     </extension>
   </extensions>
   <plugins>
@@ -111,9 +121,9 @@ For protobuf-based codegen integrated with the Maven build system, you can use
       <artifactId>protobuf-maven-plugin</artifactId>
       <version>0.6.1</version>
       <configuration>
-        <protocArtifact>com.google.protobuf:protoc:3.12.0: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.36.0:exe:${os.detected.classifier}</pluginArtifact>
+        <pluginArtifact>io.grpc:protoc-gen-grpc-java:1.81.0:exe:${os.detected.classifier}</pluginArtifact>
       </configuration>
       <executions>
         <execution>
@@ -134,16 +144,16 @@ For non-Android protobuf-based codegen integrated with the Gradle build system,
 you can use [protobuf-gradle-plugin][]:
 ```gradle
 plugins {
-    id 'com.google.protobuf' version '0.8.15'
+    id 'com.google.protobuf' version '0.9.5'
 }
 
 protobuf {
   protoc {
-    artifact = "com.google.protobuf:protoc:3.12.0"
+    artifact = "com.google.protobuf:protoc:3.25.8"
   }
   plugins {
     grpc {
-      artifact = 'io.grpc:protoc-gen-grpc-java:1.36.0'
+      artifact = 'io.grpc:protoc-gen-grpc-java:1.81.0'
     }
   }
   generateProtoTasks {
@@ -160,23 +170,23 @@ 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/testing/x86_64/grpc-java
+[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.8.15'
+    id 'com.google.protobuf' version '0.9.5'
 }
 
 protobuf {
   protoc {
-    artifact = "com.google.protobuf:protoc:3.12.0"
+    artifact = "com.google.protobuf:protoc:3.25.8"
   }
   plugins {
     grpc {
-      artifact = 'io.grpc:protoc-gen-grpc-java:1.36.0'
+      artifact = 'io.grpc:protoc-gen-grpc-java:1.81.0'
     }
   }
   generateProtoTasks {
@@ -193,6 +203,11 @@ protobuf {
 
 ```
 
+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
 -------------
 
@@ -242,12 +257,18 @@ wire. The interfaces to it are abstract just enough to allow plugging in of
 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 three Transport implementations:
+gRPC comes with multiple Transport implementations:
 
-1. The Netty-based transport is the main transport implementation based on
-   [Netty](https://netty.io). It is for both the client and the server.
-2. The OkHttp-based transport is a lightweight transport based on
-   [OkHttp](https://square.github.io/okhttp/). It is mainly for use on Android
-   and is for client only.
+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 useful for testing, while also being safe for production use.
+   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 a0852f4216d..c57829b8c25 100644
--- a/RELEASING.md
+++ b/RELEASING.md
@@ -10,45 +10,26 @@ We deploy GRPC to Maven Central under the following systems:
 
 Other systems may also work, but we haven't verified them.
 
-Prerequisites
--------------
-
-### Set Up OSSRH Account
-
-If you haven't deployed artifacts to Maven Central before, you need to setup
-your OSSRH (OSS Repository Hosting) account.
-- Follow the instructions on [this
-  page](https://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.
-
 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=(
+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-alts/build.gradle
-  examples/example-gauth/build.gradle
-  examples/example-gauth/pom.xml
-  examples/example-jwt-auth/build.gradle
-  examples/example-jwt-auth/pom.xml
-  examples/example-hostname/build.gradle
-  examples/example-hostname/pom.xml
-  examples/example-tls/build.gradle
-  examples/example-tls/pom.xml
-  examples/example-xds/build.gradle
+  examples/example-*/build.gradle
+  examples/example-*/pom.xml
   )
 ```
 
@@ -61,35 +42,34 @@ convention of `v<major>.<minor>.x`, while the tags include the patch version
 `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. For `master`, change root build files to the next minor snapshot (e.g.
+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.
    ``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[@]}"
-   $ sed -i s/$MAJOR.$MINOR.$PATCH/$MAJOR.$((MINOR+1)).0/ \
+   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"
+   ./gradlew build
+   git commit -a -m "Start $MAJOR.$((MINOR+1)).0 development cycle"
    ```
-2. Go through PR review and submit.
-3. Create the release branch starting just before your commit and push it to GitHub:
+3. Go through PR review and submit.
+4. Create the release branch starting just before your commit and push it to GitHub:
 
    ```bash
-   $ 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
+   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
    ```
-4. Ask a project admin to go to [Travis CI settings](https://travis-ci.org/grpc/grpc-java/settings)
-   and add a _Cron Job_:
-   * Branch: `v$MAJOR.$MINOR.x`
-   * Interval: `weekly`
-   * Options: `Do not run if there has been a build in the last 24h`
-   * Click _Add_ button
-5. Continue with Google-internal steps at go/grpc/java/releasing.
+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
@@ -97,144 +77,176 @@ would be used to create all `v1.7` tags (e.g. `v1.7.0`, `v1.7.1`).
 8. Begin compiling release notes. This produces a starting point:
 
    ```bash
-   $ echo "## gRPC Java $MAJOR.$MINOR.0 Release Notes" && echo && \
-     git shortlog "$(git merge-base upstream/v$MAJOR.$((MINOR-1)).x upstream/v$MAJOR.$MINOR.x)"..upstream/v$MAJOR.$MINOR.x | cat && \
+   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 cherry -v v$MAJOR.$((MINOR-1)).0 upstream/v$MAJOR.$MINOR.x | grep ^-
+     git log --oneline "$(git merge-base v$MAJOR.$((MINOR-1)).0 upstream/v$MAJOR.$MINOR.x)"..v$MAJOR.$((MINOR-1)).0^
    ```
 
+[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
+
 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.
-2. For vMajor.Minor.x branch, change `README.md` to refer to the next release
+   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
-   $ git checkout v$MAJOR.$MINOR.x
-   $ git pull upstream v$MAJOR.$MINOR.x
-   $ git checkout -b release
-   # Bump documented versions. Don't forget protobuf version
-   $ ${EDITOR:-nano -w} README.md
-   $ ${EDITOR:-nano -w} documentation/android-channel-builder.md
-   $ ${EDITOR:-nano -w} cronet/README.md
-   $ git commit -a -m "Update README etc to reference $MAJOR.$MINOR.$PATCH"
+   git checkout v$MAJOR.$MINOR.x
+   git pull upstream v$MAJOR.$MINOR.x
+   git checkout -b release-v$MAJOR.$MINOR.$PATCH
+   
+   # Bump documented gRPC versions.
+   # Also update protoc version to match protobuf version in gradle/libs.versions.toml.
+   ${EDITOR:-nano -w} README.md
+   
+   git commit -a -m "Update README etc to reference $MAJOR.$MINOR.$PATCH"
    ```
-3. Change root build files to remove "-SNAPSHOT" for the next release version
+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
    # 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"
+   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"
    ```
-4. Change root build files to the next snapshot version (e.g. `0.7.1-SNAPSHOT`).
+5. 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/' \
+   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/ \
+   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"
+   ./gradlew build
+   git commit -a -m "Bump version to $MAJOR.$MINOR.$((PATCH+1))-SNAPSHOT"
+   git push -u origin release-v$MAJOR.$MINOR.$PATCH
    ```
-5. Go through PR review and push the release tag and updated release branch to
-   GitHub:
+   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
-   $ git push upstream v$MAJOR.$MINOR.x
-   $ git push upstream v$MAJOR.$MINOR.$PATCH
+   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
    ```
-6. Close the release milestone.
-
-Build Artifacts
----------------
-
-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 `unix.sh` (called directly for OS X;
-called within the Docker environment on Linux). 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.
-
-Releasing on Maven Central
---------------------------
-
-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/pages/releasing-the-deployment.html).
-
-Build interop container image
------------------------------
-
-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](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).
-
-Update README.md
-----------------
-After waiting ~1 day and verifying that the release appears on [Maven
-Central](https://search.maven.org/search?q=g:io.grpc), 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
-[config.yaml](https://github.com/grpc/grpc.io/blob/master/config.yaml)
-of the grpc.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`).
-    1. Check if JCenter has picked up the new release (https://jcenter.bintray.com/io/grpc/)
-       and include its availability in the release announcement email. JCenter should mirror
-       everything on Maven Central, but users have reported delays.
-
-Update Hosted Javadoc
+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.
 
-Now we need to update gh-pages with the new Javadoc:
+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.
+
+Upgrade the regular dependencies in `gradle/libs.versions.toml`, except for
+Netty and netty-tcnative. To find available upgrades:
 
 ```bash
-git checkout gh-pages
-git pull --ff-only upstream 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
-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"
+./gradlew checkForUpdates
 ```
 
-Push gh-pages to the main repository and verify the current version is [live
-on grpc.io](https://grpc.io/grpc-java/javadoc/).
+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.
+
+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 9bebf5b709d..e710ceaabe1 100644
--- a/SECURITY.md
+++ b/SECURITY.md
@@ -1,10 +1,16 @@
 # Security Policy
 
-For information on gRPC Security Policy and reporting potentional security issues, please see [gRPC CVE Process](https://github.com/grpc/proposal/blob/master/P4-grpc-cve-process.md).
+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)
 
@@ -19,25 +25,28 @@ BoringSSL](#tls-with-netty-tcnative-on-boringssl).
 ## TLS on Android
 
 On Android we recommend the use of the [Play Services Dynamic Security
-Provider](https://www.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
-cipher-suites and a reliable ALPN implementation. This requires [updating the
-security provider at
-runtime](https://developer.android.com/training/articles/security-gms-provider.html).
+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's OkHttpProtocolNegotiator statically initializes the security protocol(s) available to gRPC, which means that changes to the security provider after the first channel is created will not be picked up by gRPC.*
+*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
 
 ### Bundling Conscrypt
 
 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](https://search.maven.org/#search%7Cga%7C1%7Cg%3Aorg.conscrypt%20a%3Aconscrypt-android).
+on [Maven Central][conscrypt-maven].
 
 Like the Play Services Dynamic Security Provider, you must still "install"
 Conscrypt before use.
@@ -50,16 +59,22 @@ import java.security.Security;
 Security.insertProviderAt(Conscrypt.newProvider(), 1);
 ```
 
+[conscrypt-maven]: https://search.maven.org/#search%7Cga%7C1%7Cg%3Aorg.conscrypt%20a%3Aconscrypt-android
+
 ## TLS on non-Android
 
-JDK versions prior to Java 9 do not support ALPN and are either missing AES GCM
-support or have 2% the performance of OpenSSL.
+OpenJDK versions prior to Java 8u252 do not support ALPN. Java 8 has 10% the
+performance of 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.
 
+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.
+
 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
@@ -69,7 +84,7 @@ with OpenSSL](#tls-with-netty-tcnative-on-openssl) are other valid options.
 [Apache Tomcat's tcnative](https://tomcat.apache.org/native-doc/) and is a JNI
 wrapper around OpenSSL/BoringSSL/LibreSSL.
 
-We recommend BoringSSL for its simplicitly and low occurrence of security
+We recommend BoringSSL for its simplicity and low occurrence of security
 vulnerabilities relative to OpenSSL. BoringSSL is used by Conscrypt as well.
 
 ### TLS with netty-tcnative on BoringSSL
@@ -155,7 +170,7 @@ the dependency.
       <extension>
         <groupId>kr.motd.maven</groupId>
         <artifactId>os-maven-plugin</artifactId>
-        <version>1.6.2</version>
+        <version>1.7.1</version>
       </extension>
     </extensions>
     <plugins>
@@ -239,37 +254,6 @@ import java.security.Security;
 Security.insertProviderAt(Conscrypt.newProvider(), 1);
 ```
 
-### TLS with Jetty ALPN
-
-**Please do not use Jetty ALPN**
-
-gRPC historically supported Jetty ALPN for ALPN on Java 8. While functional, it
-suffers from poor performance and breakages when the JRE is upgraded.
-When mis-matched to the JRE version, it can also produce unpredictable errors
-that are hard to diagnose. When using it, it became common practice that any
-time we saw a TLS failure that made no sense we would blame a Jetty ALPN/JRE
-version mismatch and we were overwhelmingly correct. The Jetty ALPN agent makes
-it much easier to use, but we still strongly discourage Jetty ALPN's use.
-
-When using Jetty ALPN with Java 8, realize that performance will be 2-10% that
-of the other options due to a slow AES GCM implementation in Java.
-
-#### Configuring Jetty ALPN in Web Containers
-
-Some web containers, such as [Jetty](https://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
@@ -277,35 +261,36 @@ 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(clientCAsFile)
-        .clientAuth(ClientAuth.REQUIRE)
-        .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 `TRANSPORT_ATTR_SSL_SESSION` attribute of <a href="https://github.com/grpc/grpc-java/blob/master/core/src/main/java/io/grpc/Grpc.java">Grpc</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
-// The application uses this in its handlers
-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<ReqT, RespT> call,
@@ -314,8 +299,12 @@ public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(ServerCall<ReqT, Re
     if (sslSession == null) {
         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, sslSession), call, headers, next);
+        Context.current().withValue(SECURITY_INFO, info), call, headers, next);
 }
 ```
 
@@ -341,23 +330,15 @@ 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 and you see "Error loading shared library libcrypt.so.1: No
-such file or directory". Run `apk update && apk add libc6-compat` to install the
-necessary dependency.
-
-If on Alpine Linux, try to use `grpc-netty-shaded` instead of `grpc-netty` or
-(if you need `grpc-netty`) `netty-tcnative-boringssl-static` instead of
-`netty-tcnative`. If those are not an option, you may consider using
-[netty-tcnative-alpine](https://github.com/pires/netty-tcnative-alpine).
+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.
 
-If you are running inside of an embedded Tomcat runtime (e.g., Spring Boot),
-then some versions of `netty-tcnative-boringssl-static` will have conflicts and
-won't work. You must use gRPC 1.4.0 or later.
-
 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`
@@ -383,7 +364,7 @@ If you are running in a runtime environment that also uses Netty (e.g., Hadoop,
 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
@@ -404,24 +385,32 @@ grpc-netty version | netty-handler version | netty-tcnative-boringssl-static ver
 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-            | 4.1.52.Final          | 2.0.34.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-1.80.x      | 4.1.130.Final         | 2.0.74.Final
+1.81.x-            | 4.1.132.Final         | 2.0.75.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 versions of:
- - `io.grpc:grpc-okhttp`
- - `com.squareup.okhttp:okhttp`
-
-If you don't have `grpc-okhttp`, you should add it as a dependency.
-
-If you have both `io.grpc:grpc-netty` and `io.grpc:grpc-okhttp`, you may also have issues. Remove `grpc-netty` if you are on Android.
-
-If you have `okhttp` version below 2.5.0, then it may not work with gRPC.
+If you are using gRPC on Android devices, you are most likely using
+`grpc-okhttp` transport.
 
-It is OK to have both `okhttp` 2.x and 3.x since they have different group name and under different packages.
+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
 
@@ -432,17 +421,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("dns:///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
index dad4842a7a7..1efdf2793a8 100644
--- a/WORKSPACE
+++ b/WORKSPACE
@@ -1,35 +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 = "62133c125bf4109dfd9d2af64830208356ce4ef8b165a6ef15bbff7460b35c3a",
-    strip_prefix = "rules_jvm_external-3.0",
-    url = "https://github.com/bazelbuild/rules_jvm_external/archive/3.0.zip",
+    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")
-load("//:repositories.bzl", "IO_GRPC_GRPC_JAVA_ARTIFACTS")
-load("//:repositories.bzl", "IO_GRPC_GRPC_JAVA_OVERRIDE_TARGETS")
 
 maven_install(
-    artifacts = IO_GRPC_GRPC_JAVA_ARTIFACTS,
-    generate_compat_repositories = True,
+    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,
 )
-
-load("@maven//:compat.bzl", "compat_repositories")
-
-compat_repositories()
-
-load("//:repositories.bzl", "grpc_java_repositories")
-
-grpc_java_repositories()
-
-load("@com_google_protobuf//:protobuf_deps.bzl", "protobuf_deps")
-
-protobuf_deps()
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 90ec11aebd3..11eec4b7ff8 100644
--- a/all/build.gradle
+++ b/all/build.gradle
@@ -10,32 +10,39 @@ description = "gRPC: All"
 def subprojects = [
     project(':grpc-api'),
     project(':grpc-auth'),
-    project(':grpc-context'),
     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 {
     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,24 +51,18 @@ javadoc {
             continue;
         }
         source subproject.javadoc.source
-        options.links subproject.javadoc.options.links.toArray(new String[0])
+        options.linksOffline.addAll subproject.javadoc.options.linksOffline
     }
 }
 
-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)
+    mustRunAfter(project(':grpc-interop-testing').jacocoTestReport.mustRunAfter)
+    executionData.from files(subprojects.jacocoTestReport.executionData)
             .plus(project(':grpc-interop-testing').jacocoTestReport.executionData)
-            .filter { f -> f.exists() }
-}
-
-jacocoTestReport {
-    dependsOn(jacocoMerge)
     reports {
-        xml.enabled = true
-        html.enabled = true
+        xml.required = true
+        html.required = true
     }
 
     subprojects.each { subproject ->
@@ -75,4 +76,4 @@ 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
index c99689bac11..f29df303fbe 100644
--- a/alts/BUILD.bazel
+++ b/alts/BUILD.bazel
@@ -1,4 +1,7 @@
-load("@rules_proto//proto:defs.bzl", "proto_library")
+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(
@@ -11,19 +14,18 @@ java_library(
         ":handshaker_java_proto",
         "//api",
         "//core:internal",
-        "//grpclb",
         "//netty",
         "//stub",
-        "@com_google_code_findbugs_jsr305//jar",
-        "@com_google_guava_guava//jar",
-        "@com_google_j2objc_j2objc_annotations//jar",
         "@com_google_protobuf//:protobuf_java",
         "@com_google_protobuf//:protobuf_java_util",
-        "@io_netty_netty_buffer//jar",
-        "@io_netty_netty_codec//jar",
-        "@io_netty_netty_common//jar",
-        "@io_netty_netty_handler//jar",
-        "@io_netty_netty_transport//jar",
+        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"),
     ],
 )
 
@@ -35,19 +37,18 @@ java_library(
     visibility = ["//visibility:public"],
     deps = [
         ":alts_internal",
-        ":handshaker_java_proto",
         ":handshaker_java_grpc",
+        ":handshaker_java_proto",
         "//api",
         "//auth",
         "//core:internal",
         "//netty",
-        "@com_google_auth_google_auth_library_oauth2_http//jar",
-        "@com_google_code_findbugs_jsr305//jar",
-        "@com_google_guava_guava//jar",
-        "@com_google_j2objc_j2objc_annotations//jar",
-        "@io_netty_netty_common//jar",
-        "@io_netty_netty_handler//jar",
-        "@io_netty_netty_transport//jar",
+        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"),
     ],
 )
 
diff --git a/alts/build.gradle b/alts/build.gradle
index fa4dda2b790..c206a37bcef 100644
--- a/alts/build.gradle
+++ b/alts/build.gradle
@@ -2,74 +2,78 @@ plugins {
     id "java-library"
     id "maven-publish"
 
-    id "com.github.johnrengelman.shadow"
     id "com.google.protobuf"
+    id "com.gradleup.shadow"
     id "ru.vyarus.animalsniffer"
 }
 
 description = "gRPC: ALTS"
 
-sourceCompatibility = 1.7
-targetCompatibility = 1.7
-
 dependencies {
-    api project(':grpc-core')
+    api project(':grpc-api')
     implementation project(':grpc-auth'),
-            project(':grpc-grpclb'),
+            project(':grpc-core'),
+            project(":grpc-context"), // Override google-auth dependency with our newer version
             project(':grpc-protobuf'),
             project(':grpc-stub'),
-            libraries.protobuf,
-            libraries.conscrypt
+            libraries.protobuf.java,
+            libraries.conscrypt,
+            libraries.google.auth.oauth2Http
     def nettyDependency = implementation project(':grpc-netty')
-    googleOauth2Dependency 'implementation'
-    guavaDependency 'implementation'
-    compileOnly libraries.javax_annotation
 
     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,
+            libraries.mockito.core,
             libraries.truth
 
-    testImplementation (libraries.guava_testlib) {
-        exclude group: 'junit', module: 'junit'
+    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"
+        }
     }
-    testRuntimeOnly libraries.netty_tcnative,
-            libraries.netty_epoll
-    signature 'org.codehaus.mojo.signature:java17:1.0@signature'
 }
 
 configureProtoCompilation()
 
 import net.ltgt.gradle.errorprone.CheckSeverity
 
-[compileJava, compileTestJava].each() {
-    // protobuf calls valueof. Will be fixed in next release (google/protobuf#4046)
-    it.options.compilerArgs += [
-        "-Xlint:-deprecation"
-    ]
+[tasks.named("compileJava"), tasks.named("compileTestJava")]*.configure {
     // ALTS returns a lot of futures that we mostly don't care about.
-    it.options.errorprone.check("FutureReturnValueIgnored", CheckSeverity.OFF)
+    options.errorprone.check("FutureReturnValueIgnored", CheckSeverity.OFF)
 }
 
-javadoc {
+tasks.named("javadoc").configure {
     exclude 'io/grpc/alts/internal/**'
     exclude 'io/grpc/alts/Internal*'
 }
 
-jar {
-    // Must use a different classifier to avoid conflicting with shadowJar
-    classifier = 'original'
+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.
-shadowJar {
-    classifier = null
+tasks.named("shadowJar").configure {
+    archiveClassifier = null
     dependencies {
         exclude(dependency {true})
     }
@@ -90,8 +94,7 @@ publishing {
                     def dependencyNode = dependenciesNode.appendNode('dependency')
                     dependencyNode.appendNode('groupId', dep.group)
                     dependencyNode.appendNode('artifactId', dep.name)
-                    def version = (dep.name == 'grpc-netty-shaded') ? '[' + dep.version + ']' : dep.version
-                    dependencyNode.appendNode('version', version)
+                    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
index 3d78f15f767..07e4256eb75 100644
--- a/alts/src/generated/main/grpc/io/grpc/alts/internal/HandshakerServiceGrpc.java
+++ b/alts/src/generated/main/grpc/io/grpc/alts/internal/HandshakerServiceGrpc.java
@@ -4,14 +4,12 @@
 
 /**
  */
-@javax.annotation.Generated(
-    value = "by gRPC proto compiler",
-    comments = "Source: grpc/gcp/handshaker.proto")
+@io.grpc.stub.annotations.GrpcGenerated
 public final class HandshakerServiceGrpc {
 
   private HandshakerServiceGrpc() {}
 
-  public static final String SERVICE_NAME = "grpc.gcp.HandshakerService";
+  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,
@@ -59,6 +57,21 @@ public HandshakerServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOption
     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
    */
@@ -91,7 +104,7 @@ public HandshakerServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.Call
 
   /**
    */
-  public static abstract class HandshakerServiceImplBase implements io.grpc.BindableService {
+  public interface AsyncService {
 
     /**
      * <pre>
@@ -103,27 +116,28 @@ public static abstract class HandshakerServiceImplBase implements io.grpc.Bindab
      * response before sending next request.
      * </pre>
      */
-    public io.grpc.stub.StreamObserver<io.grpc.alts.internal.HandshakerReq> doHandshake(
+    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 io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
-          .addMethod(
-            getDoHandshakeMethod(),
-            io.grpc.stub.ServerCalls.asyncBidiStreamingCall(
-              new MethodHandlers<
-                io.grpc.alts.internal.HandshakerReq,
-                io.grpc.alts.internal.HandshakerResp>(
-                  this, METHODID_DO_HANDSHAKE)))
-          .build();
+      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> {
+  public static final class HandshakerServiceStub
+      extends io.grpc.stub.AbstractAsyncStub<HandshakerServiceStub> {
     private HandshakerServiceStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -153,8 +167,44 @@ public io.grpc.stub.StreamObserver<io.grpc.alts.internal.HandshakerReq> doHandsh
   }
 
   /**
+   * 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> {
+  public static final class HandshakerServiceBlockingStub
+      extends io.grpc.stub.AbstractBlockingStub<HandshakerServiceBlockingStub> {
     private HandshakerServiceBlockingStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -168,8 +218,10 @@ protected HandshakerServiceBlockingStub build(
   }
 
   /**
+   * 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> {
+  public static final class HandshakerServiceFutureStub
+      extends io.grpc.stub.AbstractFutureStub<HandshakerServiceFutureStub> {
     private HandshakerServiceFutureStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -189,10 +241,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 HandshakerServiceImplBase serviceImpl;
+    private final AsyncService serviceImpl;
     private final int methodId;
 
-    MethodHandlers(HandshakerServiceImplBase serviceImpl, int methodId) {
+    MethodHandlers(AsyncService serviceImpl, int methodId) {
       this.serviceImpl = serviceImpl;
       this.methodId = methodId;
     }
@@ -220,6 +272,18 @@ public io.grpc.stub.StreamObserver<Req> invoke(
     }
   }
 
+  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() {}
@@ -243,9 +307,9 @@ private static final class HandshakerServiceFileDescriptorSupplier
   private static final class HandshakerServiceMethodDescriptorSupplier
       extends HandshakerServiceBaseDescriptorSupplier
       implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
-    private final String methodName;
+    private final java.lang.String methodName;
 
-    HandshakerServiceMethodDescriptorSupplier(String methodName) {
+    HandshakerServiceMethodDescriptorSupplier(java.lang.String methodName) {
       this.methodName = methodName;
     }
 
diff --git a/alts/src/main/java/io/grpc/alts/AltsChannelBuilder.java b/alts/src/main/java/io/grpc/alts/AltsChannelBuilder.java
index 969cef9cc10..ca33f8b00b9 100644
--- a/alts/src/main/java/io/grpc/alts/AltsChannelBuilder.java
+++ b/alts/src/main/java/io/grpc/alts/AltsChannelBuilder.java
@@ -18,7 +18,7 @@
 
 import com.google.common.annotations.VisibleForTesting;
 import io.grpc.ExperimentalApi;
-import io.grpc.ForwardingChannelBuilder;
+import io.grpc.ForwardingChannelBuilder2;
 import io.grpc.ManagedChannel;
 import io.grpc.ManagedChannelBuilder;
 import io.grpc.internal.GrpcUtil;
@@ -29,16 +29,16 @@
 
 /**
  * ALTS version of {@code ManagedChannelBuilder}. This class sets up a secure and authenticated
- * commmunication between two cloud VMs using ALTS.
+ * communication between two cloud VMs using ALTS.
  */
 @ExperimentalApi("https://github.com/grpc/grpc-java/issues/4151")
-public final class AltsChannelBuilder extends ForwardingChannelBuilder<AltsChannelBuilder> {
+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 final AltsChannelBuilder forTarget(String target) {
+  public static AltsChannelBuilder forTarget(String target) {
     return new AltsChannelBuilder(target);
   }
 
diff --git a/alts/src/main/java/io/grpc/alts/AltsChannelCredentials.java b/alts/src/main/java/io/grpc/alts/AltsChannelCredentials.java
index 7c603d31fcd..e12344f73d7 100644
--- a/alts/src/main/java/io/grpc/alts/AltsChannelCredentials.java
+++ b/alts/src/main/java/io/grpc/alts/AltsChannelCredentials.java
@@ -36,7 +36,7 @@
 import java.util.logging.Logger;
 
 /**
- * Provides secure and authenticated commmunication between two cloud VMs using ALTS.
+ * Provides secure and authenticated communication between two cloud VMs using ALTS.
  */
 @ExperimentalApi("https://github.com/grpc/grpc-java/issues/4151")
 public final class AltsChannelCredentials {
diff --git a/alts/src/main/java/io/grpc/alts/AltsContext.java b/alts/src/main/java/io/grpc/alts/AltsContext.java
index f264ad112d7..7680de4160e 100644
--- a/alts/src/main/java/io/grpc/alts/AltsContext.java
+++ b/alts/src/main/java/io/grpc/alts/AltsContext.java
@@ -20,7 +20,6 @@
 import io.grpc.alts.internal.AltsInternalContext;
 import io.grpc.alts.internal.HandshakerResult;
 import io.grpc.alts.internal.Identity;
-import io.grpc.alts.internal.SecurityLevel;
 
 /** {@code AltsContext} contains security-related information on the ALTS channel. */
 @ExperimentalApi("https://github.com/grpc/grpc-java/issues/7864")
diff --git a/alts/src/main/java/io/grpc/alts/AltsContextUtil.java b/alts/src/main/java/io/grpc/alts/AltsContextUtil.java
index a5d7c0e3ff9..f45179bbd91 100644
--- a/alts/src/main/java/io/grpc/alts/AltsContextUtil.java
+++ b/alts/src/main/java/io/grpc/alts/AltsContextUtil.java
@@ -14,9 +14,10 @@
  * 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;
@@ -26,17 +27,39 @@
 @ExperimentalApi("https://github.com/grpc/grpc-java/issues/7864")
 public final class AltsContextUtil {
 
-  private AltsContextUtil(){}
+  private AltsContextUtil() {}
 
   /**
-   * Creates a {@link AltsContext} from ALTS context information in the {@link ServerCall}.
+   * 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) {
-    Object authContext = call.getAttributes().get(AltsProtocolNegotiator.AUTH_CONTEXT_KEY);
+  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");
     }
@@ -49,8 +72,28 @@ public static AltsContext createFrom(ServerCall<?,?> call) {
    * @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) {
-    Object authContext = call.getAttributes().get(AltsProtocolNegotiator.AUTH_CONTEXT_KEY);
+  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
index 108b294e215..e307fd1c63a 100644
--- a/alts/src/main/java/io/grpc/alts/AltsServerBuilder.java
+++ b/alts/src/main/java/io/grpc/alts/AltsServerBuilder.java
@@ -20,6 +20,7 @@
 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;
@@ -38,7 +39,7 @@
  * a production server on Google Cloud Platform.
  */
 @ExperimentalApi("https://github.com/grpc/grpc-java/issues/4151")
-public final class AltsServerBuilder extends ServerBuilder<AltsServerBuilder> {
+public final class AltsServerBuilder extends ForwardingServerBuilder<AltsServerBuilder> {
   private final NettyServerBuilder delegate;
   private final AltsServerCredentials.Builder credentialsBuilder =
       new AltsServerCredentials.Builder();
@@ -68,6 +69,11 @@ public AltsServerBuilder setHandshakerAddressForTesting(String handshakerAddress
     return this;
   }
 
+  @Override
+  protected ServerBuilder<?> delegate() {
+    return delegate;
+  }
+
   /** {@inheritDoc} */
   @Override
   public AltsServerBuilder handshakeTimeout(long timeout, TimeUnit unit) {
diff --git a/alts/src/main/java/io/grpc/alts/AltsServerCredentials.java b/alts/src/main/java/io/grpc/alts/AltsServerCredentials.java
index dd56e310cc1..36dc9f6a4ae 100644
--- a/alts/src/main/java/io/grpc/alts/AltsServerCredentials.java
+++ b/alts/src/main/java/io/grpc/alts/AltsServerCredentials.java
@@ -32,7 +32,7 @@
  * 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/7621")
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/4151")
 public final class AltsServerCredentials {
   private static final Logger logger = Logger.getLogger(AltsServerCredentials.class.getName());
 
@@ -46,7 +46,7 @@ public static Builder newBuilder() {
     return new Builder();
   }
 
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/7621")
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/4151")
   public static final class Builder {
     private ObjectPool<Channel> handshakerChannelPool =
         SharedResourcePool.forResource(HandshakerServiceChannel.SHARED_HANDSHAKER_CHANNEL);
diff --git a/alts/src/main/java/io/grpc/alts/ComputeEngineChannelBuilder.java b/alts/src/main/java/io/grpc/alts/ComputeEngineChannelBuilder.java
index c8c0a08ed0a..b5ee6a8d362 100644
--- a/alts/src/main/java/io/grpc/alts/ComputeEngineChannelBuilder.java
+++ b/alts/src/main/java/io/grpc/alts/ComputeEngineChannelBuilder.java
@@ -35,7 +35,7 @@ private ComputeEngineChannelBuilder(String target) {
   }
 
   /** "Overrides" the static method in {@link ManagedChannelBuilder}. */
-  public static final ComputeEngineChannelBuilder forTarget(String target) {
+  public static ComputeEngineChannelBuilder forTarget(String target) {
     return new ComputeEngineChannelBuilder(target);
   }
 
@@ -45,6 +45,7 @@ public static ComputeEngineChannelBuilder forAddress(String name, int 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
index ff5bab6ec74..518642a675d 100644
--- a/alts/src/main/java/io/grpc/alts/ComputeEngineChannelCredentials.java
+++ b/alts/src/main/java/io/grpc/alts/ComputeEngineChannelCredentials.java
@@ -21,7 +21,6 @@
 import io.grpc.CallCredentials;
 import io.grpc.ChannelCredentials;
 import io.grpc.CompositeChannelCredentials;
-import io.grpc.ExperimentalApi;
 import io.grpc.Status;
 import io.grpc.alts.internal.AltsProtocolNegotiator.GoogleDefaultProtocolNegotiatorFactory;
 import io.grpc.auth.MoreCallCredentials;
@@ -37,7 +36,6 @@
  * 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}.
  */
-@ExperimentalApi("https://github.com/grpc/grpc-java/issues/7479")
 public final class ComputeEngineChannelCredentials {
   private ComputeEngineChannelCredentials() {}
 
@@ -69,7 +67,6 @@ private static InternalProtocolNegotiator.ClientFactory createClientFactory() {
     return new GoogleDefaultProtocolNegotiatorFactory(
         /* targetServiceAccounts= */ ImmutableList.<String>of(),
         SharedResourcePool.forResource(HandshakerServiceChannel.SHARED_HANDSHAKER_CHANNEL),
-        sslContext,
-        null);
+        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
index dbe0821abe9..3c59c5b6d09 100644
--- a/alts/src/main/java/io/grpc/alts/FailingCallCredentials.java
+++ b/alts/src/main/java/io/grpc/alts/FailingCallCredentials.java
@@ -38,7 +38,4 @@ public void applyRequestMetadata(
       CallCredentials.MetadataApplier applier) {
     applier.fail(status);
   }
-
-  @Override
-  public void thisUsesUnstableApi() {}
 }
diff --git a/alts/src/main/java/io/grpc/alts/GoogleDefaultChannelBuilder.java b/alts/src/main/java/io/grpc/alts/GoogleDefaultChannelBuilder.java
index 4e006b60649..c78b94417c4 100644
--- a/alts/src/main/java/io/grpc/alts/GoogleDefaultChannelBuilder.java
+++ b/alts/src/main/java/io/grpc/alts/GoogleDefaultChannelBuilder.java
@@ -35,7 +35,7 @@ private GoogleDefaultChannelBuilder(String target) {
   }
 
   /** "Overrides" the static method in {@link ManagedChannelBuilder}. */
-  public static final GoogleDefaultChannelBuilder forTarget(String target) {
+  public static GoogleDefaultChannelBuilder forTarget(String target) {
     return new GoogleDefaultChannelBuilder(target);
   }
 
@@ -45,6 +45,7 @@ public static GoogleDefaultChannelBuilder forAddress(String name, int 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
index 41c6b998277..1b5880120a4 100644
--- a/alts/src/main/java/io/grpc/alts/GoogleDefaultChannelCredentials.java
+++ b/alts/src/main/java/io/grpc/alts/GoogleDefaultChannelCredentials.java
@@ -18,11 +18,9 @@
 
 import com.google.auth.oauth2.GoogleCredentials;
 import com.google.common.collect.ImmutableList;
-import io.grpc.Attributes;
 import io.grpc.CallCredentials;
 import io.grpc.ChannelCredentials;
 import io.grpc.CompositeChannelCredentials;
-import io.grpc.ExperimentalApi;
 import io.grpc.Status;
 import io.grpc.alts.internal.AltsProtocolNegotiator.GoogleDefaultProtocolNegotiatorFactory;
 import io.grpc.auth.MoreCallCredentials;
@@ -32,18 +30,13 @@
 import io.grpc.netty.InternalProtocolNegotiator;
 import io.netty.handler.ssl.SslContext;
 import java.io.IOException;
-import java.util.logging.Level;
-import java.util.logging.Logger;
 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.
  */
-@ExperimentalApi("https://github.com/grpc/grpc-java/issues/7479")
 public final class GoogleDefaultChannelCredentials {
-  private static Logger logger = Logger.getLogger(GoogleDefaultChannelCredentials.class.getName());
-
   private GoogleDefaultChannelCredentials() {}
 
   /**
@@ -51,48 +44,75 @@ private GoogleDefaultChannelCredentials() {}
    * as fallback.
    */
   public static ChannelCredentials create() {
-    ChannelCredentials nettyCredentials =
-        InternalNettyChannelCredentials.create(createClientFactory());
-    CallCredentials callCredentials;
-    try {
-      callCredentials = MoreCallCredentials.from(GoogleCredentials.getApplicationDefault());
-    } catch (IOException e) {
-      // TODO(ejona): Should this just throw?
-      callCredentials = new FailingCallCredentials(
-          Status.UNAUTHENTICATED
-              .withDescription("Failed to get Google default credentials")
-              .withCause(e));
-    }
-    return CompositeChannelCredentials.create(nettyCredentials, callCredentials);
+    return newBuilder().build();
+  }
+
+  /**
+   * Returns a new instance of {@link Builder}.
+   *
+   * @since 1.43.0
+   */
+  public static Builder newBuilder() {
+    return new Builder();
   }
 
-  @SuppressWarnings("unchecked")
-  private static InternalProtocolNegotiator.ClientFactory createClientFactory() {
-    SslContext sslContext;
-    try {
-      sslContext = GrpcSslContexts.forClient().build();
-    } catch (SSLException e) {
-      throw new RuntimeException(e);
+  /**
+   * 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;
     }
-    Attributes.Key<String> clusterNameAttrKey = null;
-    try {
-      Class<?> klass = Class.forName("io.grpc.xds.InternalXdsAttributes");
-      clusterNameAttrKey =
-          (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);
+
+    /** 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);
     }
-    return new GoogleDefaultProtocolNegotiatorFactory(
-        /* targetServiceAccounts= */ ImmutableList.<String>of(),
-        SharedResourcePool.forResource(HandshakerServiceChannel.SHARED_HANDSHAKER_CHANNEL),
-        sslContext,
-        clusterNameAttrKey);
   }
 }
diff --git a/alts/src/main/java/io/grpc/alts/HandshakerServiceChannel.java b/alts/src/main/java/io/grpc/alts/HandshakerServiceChannel.java
index 169afe3078c..5e32d22d901 100644
--- a/alts/src/main/java/io/grpc/alts/HandshakerServiceChannel.java
+++ b/alts/src/main/java/io/grpc/alts/HandshakerServiceChannel.java
@@ -21,12 +21,14 @@
 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;
 
 /**
@@ -35,15 +37,37 @@
  * 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("metadata.google.internal.:8080");
-
+      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;
 
@@ -56,12 +80,16 @@ public Channel create() {
       /* Use its own event loop thread pool to avoid blocking. */
       EventLoopGroup eventGroup =
           new NioEventLoopGroup(1, new DefaultThreadFactory("handshaker pool", true));
-      ManagedChannel channel = NettyChannelBuilder.forTarget(target)
-          .channelType(NioSocketChannel.class)
+      NettyChannelBuilder channelBuilder =
+          NettyChannelBuilder.forTarget(target)
+          .channelType(NioSocketChannel.class, InetSocketAddress.class)
           .directExecutor()
           .eventLoopGroup(eventGroup)
-          .usePlaintext()
-          .build();
+          .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);
     }
 
diff --git a/alts/src/main/java/io/grpc/alts/InternalCheckGcpEnvironment.java b/alts/src/main/java/io/grpc/alts/InternalCheckGcpEnvironment.java
index dc6b776e116..aae4a45d530 100644
--- a/alts/src/main/java/io/grpc/alts/InternalCheckGcpEnvironment.java
+++ b/alts/src/main/java/io/grpc/alts/InternalCheckGcpEnvironment.java
@@ -30,25 +30,22 @@
 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.
+ * 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 DMI_PRODUCT_NAME = "/sys/class/dmi/id/product_name";
   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).
-   */
+  /** Returns {@code true} if currently running on Google Cloud Platform (GCP). */
   public static synchronized boolean isOnGcp() {
     if (cachedResult == null) {
       cachedResult = isRunningOnGcp();
@@ -73,13 +70,14 @@ static boolean checkBiosDataOnWindows(BufferedReader reader) throws IOException
     }
     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(DMI_PRODUCT_NAME), UTF_8));
+        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 =
diff --git a/alts/src/main/java/io/grpc/alts/internal/AltsHandshakerClient.java b/alts/src/main/java/io/grpc/alts/internal/AltsHandshakerClient.java
index 3b6a0c69616..9eb07f3e86d 100644
--- a/alts/src/main/java/io/grpc/alts/internal/AltsHandshakerClient.java
+++ b/alts/src/main/java/io/grpc/alts/internal/AltsHandshakerClient.java
@@ -20,19 +20,17 @@
 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;
-import java.util.logging.Level;
-import java.util.logging.Logger;
 
 /** An API for conducting handshakes via ALTS handshaker service. */
 class AltsHandshakerClient {
-  private static final Logger logger = Logger.getLogger(AltsHandshakerClient.class.getName());
-
   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();
@@ -41,17 +39,22 @@ class AltsHandshakerClient {
   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) {
+  AltsHandshakerClient(
+      HandshakerServiceStub stub, AltsHandshakerOptions options, ChannelLogger logger) {
     handshakerStub = new AltsHandshakerStub(stub);
     handshakerOptions = options;
+    this.logger = logger;
   }
 
   @VisibleForTesting
-  AltsHandshakerClient(AltsHandshakerStub handshakerStub, AltsHandshakerOptions options) {
+  AltsHandshakerClient(
+      AltsHandshakerStub handshakerStub, AltsHandshakerOptions options, ChannelLogger logger) {
     this.handshakerStub = handshakerStub;
     handshakerOptions = options;
+    this.logger = logger;
   }
 
   static String getApplicationProtocol() {
@@ -154,7 +157,7 @@ private void handleResponse(HandshakerResp resp) throws GeneralSecurityException
     }
     if (status.getCode() != Status.Code.OK.value()) {
       String error = "Handshaker service error: " + status.getDetails();
-      logger.log(Level.INFO, error);
+      logger.log(ChannelLogLevel.DEBUG, error);
       close();
       throw new GeneralSecurityException(error);
     }
@@ -173,7 +176,9 @@ public ByteBuffer startClientHandshake() throws GeneralSecurityException {
     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);
     }
@@ -223,7 +228,9 @@ public ByteBuffer next(ByteBuffer inBytes) throws GeneralSecurityException {
                     .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);
     }
diff --git a/alts/src/main/java/io/grpc/alts/internal/AltsHandshakerStub.java b/alts/src/main/java/io/grpc/alts/internal/AltsHandshakerStub.java
index 61d9fd2f894..6c2748dcc9c 100644
--- a/alts/src/main/java/io/grpc/alts/internal/AltsHandshakerStub.java
+++ b/alts/src/main/java/io/grpc/alts/internal/AltsHandshakerStub.java
@@ -33,7 +33,7 @@ class AltsHandshakerStub {
   private final HandshakerServiceStub serviceStub;
   private final ArrayBlockingQueue<Optional<HandshakerResp>> responseQueue =
       new ArrayBlockingQueue<>(1);
-  private final AtomicReference<String> exceptionMessage = new AtomicReference<>();
+  private final AtomicReference<ThrowableInfo> exceptionMessage = new AtomicReference<>();
 
   private static final long HANDSHAKE_RPC_DEADLINE_SECS = 20;
 
@@ -64,12 +64,18 @@ public HandshakerResp send(HandshakerReq req) throws InterruptedException, IOExc
     if (!responseQueue.isEmpty()) {
       throw new IOException("Received an unexpected response.");
     }
+
     writer.onNext(req);
     Optional<HandshakerResp> result = responseQueue.take();
-    if (!result.isPresent()) {
-      maybeThrowIoException();
+    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");
     }
-    return result.get();
   }
 
   /** Create a new writer if the writer is null. */
@@ -83,7 +89,7 @@ private void createWriterIfNull() {
   /** Throw exception if there is an outstanding exception. */
   private void maybeThrowIoException() throws IOException {
     if (exceptionMessage.get() != null) {
-      throw new IOException(exceptionMessage.get());
+      throw new IOException(exceptionMessage.get().info, exceptionMessage.get().throwable);
     }
   }
 
@@ -102,7 +108,7 @@ public void onNext(HandshakerResp resp) {
         AltsHandshakerStub.this.responseQueue.add(Optional.of(resp));
       } catch (IllegalStateException e) {
         AltsHandshakerStub.this.exceptionMessage.compareAndSet(
-            null, "Received an unexpected response.");
+            null, new ThrowableInfo(e, "Received an unexpected response."));
         AltsHandshakerStub.this.close();
       }
     }
@@ -111,7 +117,7 @@ public void onNext(HandshakerResp resp) {
     @Override
     public void onError(Throwable t) {
       AltsHandshakerStub.this.exceptionMessage.compareAndSet(
-          null, "Received a terminating error: " + t.toString());
+          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);
@@ -120,10 +126,22 @@ public void onError(Throwable t) {
     /** Receive the closing message from the server. */
     @Override
     public void onCompleted() {
-      AltsHandshakerStub.this.exceptionMessage.compareAndSet(null, "Response stream closed.");
+      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/AltsProtocolNegotiator.java b/alts/src/main/java/io/grpc/alts/internal/AltsProtocolNegotiator.java
index 0ea16248123..9c51cf6a053 100644
--- a/alts/src/main/java/io/grpc/alts/internal/AltsProtocolNegotiator.java
+++ b/alts/src/main/java/io/grpc/alts/internal/AltsProtocolNegotiator.java
@@ -23,13 +23,13 @@
 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.grpclb.GrpclbConstants;
 import io.grpc.internal.ObjectPool;
 import io.grpc.netty.GrpcHttp2ConnectionHandler;
 import io.grpc.netty.InternalProtocolNegotiator;
@@ -38,8 +38,11 @@
 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;
 
@@ -50,19 +53,28 @@
 // TODO(carl-mastrangelo): rename this AltsProtocolNegotiators.
 public final class AltsProtocolNegotiator {
   private static final Logger logger = Logger.getLogger(AltsProtocolNegotiator.class.getName());
-  // Avoid performing too many handshakes in parallel, as it may cause queuing in the handshake
-  // server and cause unbounded blocking on the event loop (b/168808426). This is a workaround until
-  // there is an async TSI handshaking API to avoid the blocking.
-  private static final AsyncSemaphore handshakeSemaphore = new AsyncSemaphore(32);
+
+  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("TSI_PEER");
+  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("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.
@@ -111,12 +123,16 @@ public AsciiString scheme() {
 
     @Override
     public ChannelHandler newHandler(GrpcHttp2ConnectionHandler grpcHandler) {
-      TsiHandshaker handshaker = handshakerFactory.newHandshaker(grpcHandler.getAuthority());
+      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);
-      ChannelHandler wuah = InternalProtocolNegotiators.waitUntilActiveHandler(thh);
+          gnh, nettyHandshaker, new AltsHandshakeValidator(), handshakeSemaphore,
+          negotiationLogger);
+      ChannelHandler wuah = InternalProtocolNegotiators.waitUntilActiveHandler(thh,
+          negotiationLogger);
       return wuah;
     }
 
@@ -135,11 +151,13 @@ public static ProtocolNegotiator serverAltsProtocolNegotiator(
     final class ServerTsiHandshakerFactory implements TsiHandshakerFactory {
 
       @Override
-      public TsiHandshaker newHandshaker(@Nullable String authority) {
+      public TsiHandshaker newHandshaker(
+          @Nullable String authority, ChannelLogger negotiationLogger) {
         assert authority == null;
         return AltsTsiHandshaker.newServer(
             HandshakerServiceGrpc.newStub(lazyHandshakerChannel.get()),
-            new AltsHandshakerOptions(RpcProtocolVersionsUtil.getRpcProtocolVersions()));
+            new AltsHandshakerOptions(RpcProtocolVersionsUtil.getRpcProtocolVersions()),
+            negotiationLogger);
       }
     }
 
@@ -166,12 +184,16 @@ public AsciiString scheme() {
 
     @Override
     public ChannelHandler newHandler(GrpcHttp2ConnectionHandler grpcHandler) {
-      TsiHandshaker handshaker = handshakerFactory.newHandshaker(/* authority= */ null);
+      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);
-      ChannelHandler wuah = InternalProtocolNegotiators.waitUntilActiveHandler(thh);
+          gnh, nettyHandshaker, new AltsHandshakeValidator(), handshakeSemaphore,
+          negotiationLogger);
+      ChannelHandler wuah = InternalProtocolNegotiators.waitUntilActiveHandler(thh,
+          negotiationLogger);
       return wuah;
     }
 
@@ -187,11 +209,12 @@ public void close() {
    */
   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;
-    @Nullable
-    private final Attributes.Key<String> clusterNameAttrKey;
 
     /**
      * Creates Negotiator Factory, which will either use the targetServiceAccounts and
@@ -200,12 +223,10 @@ public static final class GoogleDefaultProtocolNegotiatorFactory
     public GoogleDefaultProtocolNegotiatorFactory(
         List<String> targetServiceAccounts,
         ObjectPool<Channel> handshakerChannelPool,
-        SslContext sslContext,
-        @Nullable Attributes.Key<String> clusterNameAttrKey) {
+        SslContext sslContext) {
       this.targetServiceAccounts = ImmutableList.copyOf(targetServiceAccounts);
       this.handshakerChannelPool = checkNotNull(handshakerChannelPool, "handshakerChannelPool");
       this.sslContext = checkNotNull(sslContext, "sslContext");
-      this.clusterNameAttrKey = clusterNameAttrKey;
     }
 
     @Override
@@ -221,6 +242,26 @@ public ProtocolNegotiator newNegotiator() {
     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 {
@@ -250,29 +291,49 @@ public AsciiString scheme() {
     @Override
     public ChannelHandler newHandler(GrpcHttp2ConnectionHandler grpcHandler) {
       ChannelHandler gnh = InternalProtocolNegotiators.grpcNegotiationHandler(grpcHandler);
+      ChannelLogger negotiationLogger = grpcHandler.getNegotiationLogger();
       ChannelHandler securityHandler;
       boolean isXdsDirectPath = false;
       if (clusterNameAttrKey != null) {
-        String clusterName = grpcHandler.getEagAttributes().get(clusterNameAttrKey);
-        if (clusterName != null && !clusterName.equals("google_cfe")) {
-          isXdsDirectPath = true;
-        }
+        isXdsDirectPath = isDirectPathCluster(
+            grpcHandler.getEagAttributes().get(clusterNameAttrKey));
       }
-      if (grpcHandler.getEagAttributes().get(GrpclbConstants.ATTR_LB_ADDR_AUTHORITY) != null
-          || grpcHandler.getEagAttributes().get(GrpclbConstants.ATTR_LB_PROVIDED_BACKEND) != null
-          || isXdsDirectPath) {
-        TsiHandshaker handshaker = handshakerFactory.newHandshaker(grpcHandler.getAuthority());
+      if (isXdsDirectPath) {
+        TsiHandshaker handshaker =
+            handshakerFactory.newHandshaker(grpcHandler.getAuthority(), negotiationLogger); 
         NettyTsiHandshaker nettyHandshaker = new NettyTsiHandshaker(handshaker);
         securityHandler = new TsiHandshakeHandler(
-            gnh, nettyHandshaker, new AltsHandshakeValidator(), handshakeSemaphore);
+            gnh, nettyHandshaker, new AltsHandshakeValidator(), handshakeSemaphore,
+            negotiationLogger);
       } else {
         securityHandler = InternalProtocolNegotiators.clientTlsHandler(
-            gnh, sslContext, grpcHandler.getAuthority());
+            gnh, sslContext, grpcHandler.getAuthority(), negotiationLogger);
       }
-      ChannelHandler wuah = InternalProtocolNegotiators.waitUntilActiveHandler(securityHandler);
+      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");
@@ -292,7 +353,8 @@ private static final class ClientTsiHandshakerFactory implements TsiHandshakerFa
     }
 
     @Override
-    public TsiHandshaker newHandshaker(@Nullable String authority) {
+    public TsiHandshaker newHandshaker(
+        @Nullable String authority, ChannelLogger negotiationLogger) {
       AltsClientOptions handshakerOptions =
           new AltsClientOptions.Builder()
               .setRpcProtocolVersions(RpcProtocolVersionsUtil.getRpcProtocolVersions())
@@ -300,7 +362,9 @@ public TsiHandshaker newHandshaker(@Nullable String authority) {
               .setTargetName(authority)
               .build();
       return AltsTsiHandshaker.newClient(
-          HandshakerServiceGrpc.newStub(lazyHandshakerChannel.get()), handshakerOptions);
+          HandshakerServiceGrpc.newStub(lazyHandshakerChannel.get()),
+          handshakerOptions,
+          negotiationLogger);
     }
   }
 
@@ -359,5 +423,30 @@ public SecurityDetails validatePeerObject(Object peerObject) throws GeneralSecur
     }
   }
 
+  @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/AltsTsiHandshaker.java b/alts/src/main/java/io/grpc/alts/internal/AltsTsiHandshaker.java
index cc750a72a7a..2d6c322c1b1 100644
--- a/alts/src/main/java/io/grpc/alts/internal/AltsTsiHandshaker.java
+++ b/alts/src/main/java/io/grpc/alts/internal/AltsTsiHandshaker.java
@@ -20,6 +20,8 @@
 
 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;
@@ -27,14 +29,12 @@
 import java.security.GeneralSecurityException;
 import java.util.ArrayList;
 import java.util.List;
-import java.util.logging.Level;
-import java.util.logging.Logger;
 
 /**
  * Negotiates a grpc channel key to be used by the TsiFrameProtector, using ALTs handshaker service.
  */
 public final class AltsTsiHandshaker implements TsiHandshaker {
-  private static final Logger logger = Logger.getLogger(AltsTsiHandshaker.class.getName());
+  private final ChannelLogger logger;
 
   public static final String TSI_SERVICE_ACCOUNT_PEER_PROPERTY = "service_account";
 
@@ -45,15 +45,20 @@ public final class AltsTsiHandshaker implements TsiHandshaker {
 
   /** Starts a new TSI handshaker with client options. */
   private AltsTsiHandshaker(
-      boolean isClient, HandshakerServiceStub stub, AltsHandshakerOptions options) {
+      boolean isClient,
+      HandshakerServiceStub stub,
+      AltsHandshakerOptions options,
+      ChannelLogger logger) {
     this.isClient = isClient;
-    handshaker = new AltsHandshakerClient(stub, options);
+    this.logger = logger;
+    handshaker = new AltsHandshakerClient(stub, options, logger);
   }
 
   @VisibleForTesting
-  AltsTsiHandshaker(boolean isClient, AltsHandshakerClient handshaker) {
+  AltsTsiHandshaker(boolean isClient, AltsHandshakerClient handshaker, ChannelLogger logger) {
     this.isClient = isClient;
     this.handshaker = handshaker;
+    this.logger = logger;
   }
 
   /**
@@ -75,11 +80,12 @@ public boolean processBytesFromPeer(ByteBuffer bytes) throws GeneralSecurityExce
       return true;
     }
     int remaining = bytes.remaining();
-    // Call handshaker service to proceess the bytes.
+    // 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.
@@ -124,13 +130,15 @@ public Object extractPeerObject() throws GeneralSecurityException {
   }
 
   /** Creates a new TsiHandshaker for use by the client. */
-  public static TsiHandshaker newClient(HandshakerServiceStub stub, AltsHandshakerOptions options) {
-    return new AltsTsiHandshaker(true, stub, options);
+  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) {
-    return new AltsTsiHandshaker(false, stub, options);
+  public static TsiHandshaker newServer(
+      HandshakerServiceStub stub, AltsHandshakerOptions options, ChannelLogger logger) {
+    return new AltsTsiHandshaker(false, stub, options, logger);
   }
 
   /**
@@ -142,12 +150,14 @@ public static TsiHandshaker newServer(HandshakerServiceStub stub, AltsHandshaker
   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()) {
@@ -159,7 +169,7 @@ public void getBytesToSendToPeer(ByteBuffer bytes) throws GeneralSecurityExcepti
   }
 
   /**
-   * Returns true if and only if the handshake is still in progress
+   * Returns true if and only if the handshake is still in progress.
    *
    * @return true, if the handshake is still in progress, false otherwise.
    */
@@ -190,7 +200,7 @@ public TsiFrameProtector createFrameProtector(int maxFrameSize, ByteBufAllocator
       maxFrameSize = Math.min(peerMaxFrameSize, AltsTsiFrameProtector.getMaxFrameSize());
       maxFrameSize = Math.max(AltsTsiFrameProtector.getMinFrameSize(), maxFrameSize);
     }
-    logger.log(Level.FINE, "Maximum frame size value is {0}.", maxFrameSize);
+    logger.log(ChannelLogLevel.INFO, "Maximum frame size value is {0}.", maxFrameSize);
     return new AltsTsiFrameProtector(maxFrameSize, new AltsChannelCrypter(key, isClient), alloc);
   }
 
diff --git a/alts/src/main/java/io/grpc/alts/internal/AsyncSemaphore.java b/alts/src/main/java/io/grpc/alts/internal/AsyncSemaphore.java
index 3ccdcfc763a..a8251c7fbd3 100644
--- a/alts/src/main/java/io/grpc/alts/internal/AsyncSemaphore.java
+++ b/alts/src/main/java/io/grpc/alts/internal/AsyncSemaphore.java
@@ -16,12 +16,12 @@
 
 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;
-import javax.annotation.concurrent.GuardedBy;
 
 /** Provides a semaphore primitive, without blocking waiting on permits. */
 final class AsyncSemaphore {
diff --git a/alts/src/main/java/io/grpc/alts/internal/ChannelCrypterNetty.java b/alts/src/main/java/io/grpc/alts/internal/ChannelCrypterNetty.java
index 4164560e7a0..e2e7d4046fb 100644
--- a/alts/src/main/java/io/grpc/alts/internal/ChannelCrypterNetty.java
+++ b/alts/src/main/java/io/grpc/alts/internal/ChannelCrypterNetty.java
@@ -21,8 +21,8 @@
 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
+ * 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
diff --git a/alts/src/main/java/io/grpc/alts/internal/NettyTsiHandshaker.java b/alts/src/main/java/io/grpc/alts/internal/NettyTsiHandshaker.java
index 5087123ab06..b91cfdad08c 100644
--- a/alts/src/main/java/io/grpc/alts/internal/NettyTsiHandshaker.java
+++ b/alts/src/main/java/io/grpc/alts/internal/NettyTsiHandshaker.java
@@ -99,7 +99,7 @@ boolean processBytesFromPeer(ByteBuf data) throws GeneralSecurityException {
   }
 
   /**
-   * Returns true if and only if the handshake is still in progress
+   * Returns true if and only if the handshake is still in progress.
    *
    * @return true, if the handshake is still in progress, false otherwise.
    */
diff --git a/alts/src/main/java/io/grpc/alts/internal/ProtectedPromise.java b/alts/src/main/java/io/grpc/alts/internal/ProtectedPromise.java
index e204acdd5f9..871a51f1bea 100644
--- a/alts/src/main/java/io/grpc/alts/internal/ProtectedPromise.java
+++ b/alts/src/main/java/io/grpc/alts/internal/ProtectedPromise.java
@@ -78,7 +78,7 @@ public ChannelPromise doneAllocatingPromises() {
     if (!doneAllocating) {
       doneAllocating = true;
       if (successfulCount == expectedCount) {
-        trySuccessInternal(null);
+        trySuccessInternal();
         return super.setSuccess(null);
       }
     }
@@ -117,18 +117,18 @@ private boolean awaitingPromises() {
   }
 
   @Override
-  public ChannelPromise setSuccess(Void result) {
-    trySuccess(result);
+  public ChannelPromise setSuccess(Void unused) {
+    trySuccess(null);
     return this;
   }
 
   @Override
-  public boolean trySuccess(Void result) {
+  public boolean trySuccess(Void unused) {
     if (awaitingPromises()) {
       ++successfulCount;
       if (successfulCount == expectedCount && doneAllocating) {
-        trySuccessInternal(result);
-        return super.trySuccess(result);
+        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.
@@ -137,9 +137,9 @@ public boolean trySuccess(Void result) {
     return false;
   }
 
-  private void trySuccessInternal(Void result) {
+  private void trySuccessInternal() {
     for (int i = 0; i < unprotectedPromises.size(); ++i) {
-      unprotectedPromises.get(i).trySuccess(result);
+      unprotectedPromises.get(i).trySuccess(null);
     }
   }
 
diff --git a/alts/src/main/java/io/grpc/alts/internal/TsiHandshakeHandler.java b/alts/src/main/java/io/grpc/alts/internal/TsiHandshakeHandler.java
index f2e19d3dedb..7964b122f8c 100644
--- a/alts/src/main/java/io/grpc/alts/internal/TsiHandshakeHandler.java
+++ b/alts/src/main/java/io/grpc/alts/internal/TsiHandshakeHandler.java
@@ -22,13 +22,13 @@
 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.InternalProtocolNegotiators;
 import io.grpc.netty.ProtocolNegotiationEvent;
 import io.netty.buffer.ByteBuf;
 import io.netty.channel.ChannelFuture;
@@ -87,13 +87,15 @@ public abstract SecurityDetails validatePeerObject(Object peerObject)
 
   private ProtocolNegotiationEvent pne;
   private boolean semaphoreAcquired;
+  private final ChannelLogger negotiationLogger;
 
   /**
    * Constructs a TsiHandshakeHandler.
    */
   public TsiHandshakeHandler(
-      ChannelHandler next, NettyTsiHandshaker handshaker, HandshakeValidator handshakeValidator) {
-    this(next, handshaker, handshakeValidator, null);
+      ChannelHandler next, NettyTsiHandshaker handshaker, HandshakeValidator handshakeValidator,
+      ChannelLogger negotiationLogger) {
+    this(next, handshaker, handshakeValidator, null, negotiationLogger);
   }
 
   /**
@@ -102,11 +104,12 @@ public TsiHandshakeHandler(
    */
   public TsiHandshakeHandler(
       ChannelHandler next, NettyTsiHandshaker handshaker, HandshakeValidator handshakeValidator,
-      AsyncSemaphore semaphore) {
+      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
@@ -155,8 +158,7 @@ public void userEventTriggered(final ChannelHandlerContext ctx, Object evt) thro
     if (evt instanceof ProtocolNegotiationEvent) {
       checkState(pne == null, "negotiation already started");
       pne = (ProtocolNegotiationEvent) evt;
-      InternalProtocolNegotiators.negotiationLogger(ctx)
-          .log(ChannelLogLevel.INFO, "TsiHandshake started");
+      negotiationLogger.log(ChannelLogLevel.INFO, "TsiHandshake started");
       ChannelFuture acquire = semaphoreAcquire(ctx);
       if (acquire.isSuccess()) {
         semaphoreAcquired = true;
@@ -190,8 +192,7 @@ public void userEventTriggered(final ChannelHandlerContext ctx, Object evt) thro
   private void fireProtocolNegotiationEvent(
       ChannelHandlerContext ctx, TsiPeer peer, Object authContext, SecurityDetails details) {
     checkState(pne != null, "negotiation not yet complete");
-    InternalProtocolNegotiators.negotiationLogger(ctx)
-        .log(ChannelLogLevel.INFO, "TsiHandshake finished");
+    negotiationLogger.log(ChannelLogLevel.INFO, "TsiHandshake finished");
     ProtocolNegotiationEvent localPne = pne;
     Attributes.Builder attrs = InternalProtocolNegotiationEvent.getAttributes(localPne).toBuilder()
         .set(TSI_PEER_KEY, peer)
diff --git a/alts/src/main/java/io/grpc/alts/internal/TsiHandshaker.java b/alts/src/main/java/io/grpc/alts/internal/TsiHandshaker.java
index 35b945770d2..6580a4433c7 100644
--- a/alts/src/main/java/io/grpc/alts/internal/TsiHandshaker.java
+++ b/alts/src/main/java/io/grpc/alts/internal/TsiHandshaker.java
@@ -68,7 +68,7 @@ public interface TsiHandshaker {
   boolean processBytesFromPeer(ByteBuffer bytes) throws GeneralSecurityException;
 
   /**
-   * Returns true if and only if the handshake is still in progress
+   * Returns true if and only if the handshake is still in progress.
    *
    * @return true, if the handshake is still in progress, false otherwise.
    */
@@ -86,7 +86,7 @@ public interface TsiHandshaker {
    *
    * @return the extracted peer.
    */
-  public Object extractPeerObject() throws GeneralSecurityException;
+  Object extractPeerObject() throws GeneralSecurityException;
 
   /**
    * Creates a frame protector from a completed handshake. No other methods may be called after the
diff --git a/alts/src/main/java/io/grpc/alts/internal/TsiHandshakerFactory.java b/alts/src/main/java/io/grpc/alts/internal/TsiHandshakerFactory.java
index 996bd003654..7d17a3954c8 100644
--- a/alts/src/main/java/io/grpc/alts/internal/TsiHandshakerFactory.java
+++ b/alts/src/main/java/io/grpc/alts/internal/TsiHandshakerFactory.java
@@ -16,11 +16,12 @@
 
 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);
+  TsiHandshaker newHandshaker(@Nullable String authority, ChannelLogger logger);
 }
diff --git a/alts/src/test/java/io/grpc/alts/AltsContextUtilTest.java b/alts/src/test/java/io/grpc/alts/AltsContextUtilTest.java
index 6fd2d840d45..675fa29fc99 100644
--- a/alts/src/test/java/io/grpc/alts/AltsContextUtilTest.java
+++ b/alts/src/test/java/io/grpc/alts/AltsContextUtilTest.java
@@ -24,6 +24,7 @@
 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;
@@ -37,27 +38,38 @@
 /** Unit tests for {@link AltsContextUtil}. */
 @RunWith(JUnit4.class)
 public class AltsContextUtilTest {
-
-  private final ServerCall<?,?> call = mock(ServerCall.class);
-
   @Test
   public void check_noAttributeValue() {
-    when(call.getAttributes()).thenReturn(Attributes.newBuilder().build());
+    assertFalse(AltsContextUtil.check(Attributes.newBuilder().build()));
+  }
 
-    assertFalse(AltsContextUtil.check(call));
+  @Test
+  public void check_unexpectedAttributeValueType() {
+    assertFalse(AltsContextUtil.check(Attributes.newBuilder()
+        .set(AltsProtocolNegotiator.AUTH_CONTEXT_KEY, new Object())
+        .build()));
   }
 
   @Test
-  public void contains_unexpectedAttributeValueType() {
+  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, new Object())
+        .set(AltsProtocolNegotiator.AUTH_CONTEXT_KEY, AltsInternalContext.getDefaultInstance())
         .build());
 
-    assertFalse(AltsContextUtil.check(call));
+    assertTrue(AltsContextUtil.check(call));
   }
 
   @Test
-  public void contains_altsInternalContext() {
+  public void checkClient_altsInternalContext() {
+    ClientCall<?,?> call = mock(ClientCall.class);
     when(call.getAttributes()).thenReturn(Attributes.newBuilder()
         .set(AltsProtocolNegotiator.AUTH_CONTEXT_KEY, AltsInternalContext.getDefaultInstance())
         .build());
@@ -66,26 +78,57 @@ public void contains_altsInternalContext() {
   }
 
   @Test
-  public void from_altsInternalContext() {
+  public void createFrom_altsInternalContext() {
     HandshakerResult handshakerResult =
         HandshakerResult.newBuilder()
             .setPeerIdentity(Identity.newBuilder().setServiceAccount("remote@peer"))
             .setLocalIdentity(Identity.newBuilder().setServiceAccount("local@peer"))
             .build();
-    when(call.getAttributes()).thenReturn(Attributes.newBuilder()
-        .set(AltsProtocolNegotiator.AUTH_CONTEXT_KEY,  new AltsInternalContext(handshakerResult))
-        .build());
 
-    AltsContext context = AltsContextUtil.createFrom(call);
+    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 from_noAttributeValue() {
-    when(call.getAttributes()).thenReturn(Attributes.newBuilder().build());
+  public void createFrom_noAttributeValue() {
+    AltsContextUtil.createFrom(Attributes.newBuilder().build());
+  }
 
-    AltsContextUtil.createFrom(call);
+  @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/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/HandshakerServiceChannelTest.java b/alts/src/test/java/io/grpc/alts/HandshakerServiceChannelTest.java
index dc297492fe3..221001157f1 100644
--- a/alts/src/test/java/io/grpc/alts/HandshakerServiceChannelTest.java
+++ b/alts/src/test/java/io/grpc/alts/HandshakerServiceChannelTest.java
@@ -46,7 +46,7 @@ public void unaryRpc(SimpleRequest request, StreamObserver<SimpleResponse> so) {
             so.onCompleted();
           }
         })
-        .build());
+          .build());
   private Resource<Channel> resource;
 
   @Before
@@ -67,6 +67,24 @@ public void sharedChannel_authority() {
     }
   }
 
+  @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();
diff --git a/alts/src/test/java/io/grpc/alts/internal/AesGcmHkdfAeadCrypterTest.java b/alts/src/test/java/io/grpc/alts/internal/AesGcmHkdfAeadCrypterTest.java
index d655a6e8358..06f2ff5365f 100644
--- a/alts/src/test/java/io/grpc/alts/internal/AesGcmHkdfAeadCrypterTest.java
+++ b/alts/src/test/java/io/grpc/alts/internal/AesGcmHkdfAeadCrypterTest.java
@@ -117,7 +117,7 @@ public void testVectorEncrypt() throws GeneralSecurityException {
           ByteBuffer.wrap(testVector.plaintext),
           ByteBuffer.wrap(testVector.aad),
           testVector.nonce);
-      String msg = "Failure for test vector " + i;
+      String msg = "Failure for test vector " + i + " " + testVector.comment;
       assertWithMessage(msg)
           .that(ciphertextBuffer.remaining())
           .isEqualTo(bufferSize - testVector.ciphertext.length);
@@ -142,7 +142,7 @@ public void testVectorDecrypt() throws GeneralSecurityException {
           ByteBuffer.wrap(testVector.ciphertext),
           ByteBuffer.wrap(testVector.aad),
           testVector.nonce);
-      String msg = "Failure for test vector " + i;
+      String msg = "Failure for test vector " + i + " " + testVector.comment;
       assertWithMessage(msg)
           .that(plaintextBuffer.remaining())
           .isEqualTo(bufferSize - testVector.plaintext.length);
diff --git a/alts/src/test/java/io/grpc/alts/internal/AltsHandshakerClientTest.java b/alts/src/test/java/io/grpc/alts/internal/AltsHandshakerClientTest.java
index 27ad16ee2d3..5a41fc0fc4f 100644
--- a/alts/src/test/java/io/grpc/alts/internal/AltsHandshakerClientTest.java
+++ b/alts/src/test/java/io/grpc/alts/internal/AltsHandshakerClientTest.java
@@ -29,6 +29,7 @@
 
 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;
@@ -60,7 +61,8 @@ public void setUp() {
             .setTargetName(TEST_TARGET_NAME)
             .setTargetServiceAccounts(ImmutableList.of(TEST_TARGET_SERVICE_ACCOUNT))
             .build();
-    handshaker = new AltsHandshakerClient(mockStub, clientOptions);
+    NoopChannelLogger channelLogger = new NoopChannelLogger();
+    handshaker = new AltsHandshakerClient(mockStub, clientOptions, channelLogger);
   }
 
   @Test
@@ -266,7 +268,8 @@ public void setRpcVersions() throws Exception {
             .setTargetServiceAccounts(ImmutableList.of(TEST_TARGET_SERVICE_ACCOUNT))
             .setRpcProtocolVersions(rpcVersions)
             .build();
-    handshaker = new AltsHandshakerClient(mockStub, clientOptions);
+    NoopChannelLogger channelLogger = new NoopChannelLogger();
+    handshaker = new AltsHandshakerClient(mockStub, clientOptions, channelLogger);
 
     handshaker.startClientHandshake();
 
diff --git a/alts/src/test/java/io/grpc/alts/internal/AltsHandshakerStubTest.java b/alts/src/test/java/io/grpc/alts/internal/AltsHandshakerStubTest.java
index 2267a765a90..7a6018b5064 100644
--- a/alts/src/test/java/io/grpc/alts/internal/AltsHandshakerStubTest.java
+++ b/alts/src/test/java/io/grpc/alts/internal/AltsHandshakerStubTest.java
@@ -32,7 +32,7 @@
 @RunWith(JUnit4.class)
 public class AltsHandshakerStubTest {
   /** Mock status of handshaker service. */
-  private static enum Status {
+  private enum Status {
     OK,
     ERROR,
     COMPLETE
@@ -68,6 +68,7 @@ private void sendAndExpectError() throws InterruptedException {
       fail("Exception expected");
     } catch (IOException ex) {
       assertThat(ex).hasMessageThat().contains("Received a terminating error");
+      assertThat(ex.getCause()).hasMessageThat().contains("Root cause message");
     }
   }
 
@@ -152,7 +153,7 @@ public void onNext(final HandshakerReq req) {
           reader.onNext(resp.setOutFrames(req.getNext().getInBytes()).build());
           break;
         case ERROR:
-          reader.onError(new RuntimeException());
+          reader.onError(new RuntimeException("Root cause message"));
           break;
         case COMPLETE:
           reader.onCompleted();
diff --git a/alts/src/test/java/io/grpc/alts/internal/AltsProtocolNegotiatorTest.java b/alts/src/test/java/io/grpc/alts/internal/AltsProtocolNegotiatorTest.java
index 3cc8c9c3ff7..d47607ed90f 100644
--- a/alts/src/test/java/io/grpc/alts/internal/AltsProtocolNegotiatorTest.java
+++ b/alts/src/test/java/io/grpc/alts/internal/AltsProtocolNegotiatorTest.java
@@ -26,6 +26,7 @@
 
 import io.grpc.Attributes;
 import io.grpc.Channel;
+import io.grpc.ChannelLogger;
 import io.grpc.Grpc;
 import io.grpc.InternalChannelz;
 import io.grpc.ManagedChannel;
@@ -37,6 +38,7 @@
 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;
@@ -130,8 +132,8 @@ public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws E
     TsiHandshakerFactory handshakerFactory =
         new DelegatingTsiHandshakerFactory(FakeTsiHandshaker.clientHandshakerFactory()) {
           @Override
-          public TsiHandshaker newHandshaker(String authority) {
-            return new DelegatingTsiHandshaker(super.newHandshaker(authority)) {
+          public TsiHandshaker newHandshaker(String authority, ChannelLogger logger) {
+            return new DelegatingTsiHandshaker(super.newHandshaker(authority, logger)) {
               @Override
               public TsiPeer extractPeer() throws GeneralSecurityException {
                 return mockedTsiPeer;
@@ -200,8 +202,11 @@ public void operationComplete(ChannelFuture future) throws Exception {
     channel.flush();
 
     // Capture the protected data written to the wire.
-    assertEquals(1, channel.outboundMessages().size());
-    ByteBuf protectedData = channel.readOutbound();
+    assertThat(channel.outboundMessages()).isNotEmpty();
+    ByteBuf protectedData = channel.alloc().buffer();
+    while (!channel.outboundMessages().isEmpty()) {
+      protectedData.writeBytes((ByteBuf) channel.readOutbound());
+    }
     assertEquals(message.length(), writeCount.get());
 
     // Read the protected message at the server and verify it matches the original message.
@@ -325,16 +330,18 @@ public void doNotFlushEmptyBuffer() throws Exception {
     String message = "hello";
     ByteBuf in = Unpooled.copiedBuffer(message, UTF_8);
 
-    assertEquals(0, protector.flushes.get());
+    int flushes = protector.flushes.get();
     Future<?> done = channel.write(in);
     channel.flush();
+    flushes++;
     done.get(5, TimeUnit.SECONDS);
-    assertEquals(1, protector.flushes.get());
+    assertEquals(flushes, protector.flushes.get());
 
+    // Flush does not propagate
     done = channel.write(Unpooled.EMPTY_BUFFER);
     channel.flush();
     done.get(5, TimeUnit.SECONDS);
-    assertEquals(1, protector.flushes.get());
+    assertEquals(flushes, protector.flushes.get());
   }
 
   @Test
@@ -352,6 +359,29 @@ public void peerPropagated() throws Exception {
         .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());
@@ -404,7 +434,7 @@ private CapturingGrpcHttp2ConnectionHandler(
         Http2ConnectionDecoder decoder,
         Http2ConnectionEncoder encoder,
         Http2Settings initialSettings) {
-      super(null, decoder, encoder, initialSettings);
+      super(null, decoder, encoder, initialSettings, new NoopChannelLogger());
     }
 
     @Override
@@ -426,8 +456,8 @@ private static class DelegatingTsiHandshakerFactory implements TsiHandshakerFact
     }
 
     @Override
-    public TsiHandshaker newHandshaker(String authority) {
-      return delegate.newHandshaker(authority);
+    public TsiHandshaker newHandshaker(String authority, ChannelLogger logger) {
+      return delegate.newHandshaker(authority, logger);
     }
   }
 
diff --git a/alts/src/test/java/io/grpc/alts/internal/AltsTsiHandshakerTest.java b/alts/src/test/java/io/grpc/alts/internal/AltsTsiHandshakerTest.java
index b0b2f8f9faa..ae1696401be 100644
--- a/alts/src/test/java/io/grpc/alts/internal/AltsTsiHandshakerTest.java
+++ b/alts/src/test/java/io/grpc/alts/internal/AltsTsiHandshakerTest.java
@@ -26,6 +26,7 @@
 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;
@@ -71,8 +72,9 @@ public class AltsTsiHandshakerTest {
   public void setUp() throws Exception {
     mockClient = mock(AltsHandshakerClient.class);
     mockServer = mock(AltsHandshakerClient.class);
-    handshakerClient = new AltsTsiHandshaker(true, mockClient);
-    handshakerServer = new AltsTsiHandshaker(false, mockServer);
+    NoopChannelLogger channelLogger = new NoopChannelLogger();
+    handshakerClient = new AltsTsiHandshaker(true, mockClient, channelLogger);
+    handshakerServer = new AltsTsiHandshaker(false, mockServer, channelLogger);
   }
 
   private HandshakerResult getHandshakerResult(boolean isClient) {
diff --git a/alts/src/test/java/io/grpc/alts/internal/AltsTsiTest.java b/alts/src/test/java/io/grpc/alts/internal/AltsTsiTest.java
index a6832ad8de2..cb39abb9ddc 100644
--- a/alts/src/test/java/io/grpc/alts/internal/AltsTsiTest.java
+++ b/alts/src/test/java/io/grpc/alts/internal/AltsTsiTest.java
@@ -21,6 +21,7 @@
 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;
@@ -61,8 +62,9 @@ public void setUp() throws Exception {
     AltsHandshakerOptions handshakerOptions = new AltsHandshakerOptions(null);
     MockAltsHandshakerStub clientStub = new MockAltsHandshakerStub();
     MockAltsHandshakerStub serverStub = new MockAltsHandshakerStub();
-    client = new AltsHandshakerClient(clientStub, handshakerOptions);
-    server = new AltsHandshakerClient(serverStub, handshakerOptions);
+    NoopChannelLogger channelLogger = new NoopChannelLogger();
+    client = new AltsHandshakerClient(clientStub, handshakerOptions, channelLogger);
+    server = new AltsHandshakerClient(serverStub, handshakerOptions, channelLogger);
   }
 
   @After
@@ -76,8 +78,9 @@ public void tearDown() {
   }
 
   private Handshakers newHandshakers() {
-    TsiHandshaker clientHandshaker = new AltsTsiHandshaker(true, client);
-    TsiHandshaker serverHandshaker = new AltsTsiHandshaker(false, server);
+    NoopChannelLogger channelLogger = new NoopChannelLogger();
+    TsiHandshaker clientHandshaker = new AltsTsiHandshaker(true, client, channelLogger);
+    TsiHandshaker serverHandshaker = new AltsTsiHandshaker(false, server, channelLogger);
     return new Handshakers(clientHandshaker, serverHandshaker);
   }
 
diff --git a/alts/src/test/java/io/grpc/alts/internal/FakeTsiHandshaker.java b/alts/src/test/java/io/grpc/alts/internal/FakeTsiHandshaker.java
index fcc33681732..7a6119dc0be 100644
--- a/alts/src/test/java/io/grpc/alts/internal/FakeTsiHandshaker.java
+++ b/alts/src/test/java/io/grpc/alts/internal/FakeTsiHandshaker.java
@@ -19,7 +19,9 @@
 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;
@@ -37,7 +39,7 @@ public class FakeTsiHandshaker implements TsiHandshaker {
   private static final TsiHandshakerFactory clientHandshakerFactory =
       new TsiHandshakerFactory() {
         @Override
-        public TsiHandshaker newHandshaker(String authority) {
+        public TsiHandshaker newHandshaker(String authority, ChannelLogger logger) {
           return new FakeTsiHandshaker(true);
         }
       };
@@ -45,7 +47,7 @@ public TsiHandshaker newHandshaker(String authority) {
   private static final TsiHandshakerFactory serverHandshakerFactory =
       new TsiHandshakerFactory() {
         @Override
-        public TsiHandshaker newHandshaker(String authority) {
+        public TsiHandshaker newHandshaker(String authority, ChannelLogger logger) {
           return new FakeTsiHandshaker(false);
         }
       };
@@ -66,6 +68,7 @@ enum State {
     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];
@@ -83,11 +86,13 @@ public static TsiHandshakerFactory serverHandshakerFactory() {
   }
 
   public static TsiHandshaker newFakeHandshakerClient() {
-    return clientHandshakerFactory.newHandshaker(null);
+    NoopChannelLogger channelLogger = new NoopChannelLogger();
+    return clientHandshakerFactory.newHandshaker(null, channelLogger);
   }
 
   public static TsiHandshaker newFakeHandshakerServer() {
-    return serverHandshakerFactory.newHandshaker(null);
+    NoopChannelLogger channelLogger = new NoopChannelLogger();
+    return serverHandshakerFactory.newHandshaker(null, channelLogger);
   }
 
   protected FakeTsiHandshaker(boolean isClient) {
@@ -143,7 +148,7 @@ public void getBytesToSendToPeer(ByteBuffer bytes) throws GeneralSecurityExcepti
       return;
     }
 
-    // Prepare the next message, if neeeded.
+    // Prepare the next message, if needed.
     if (sendBuffer == null) {
       if (sendState.next() != receiveState) {
         // We're still waiting for bytes from the peer, so bail.
diff --git a/alts/src/test/java/io/grpc/alts/internal/GoogleDefaultProtocolNegotiatorTest.java b/alts/src/test/java/io/grpc/alts/internal/GoogleDefaultProtocolNegotiatorTest.java
index 5ac2669b3ab..14c19e554ae 100644
--- a/alts/src/test/java/io/grpc/alts/internal/GoogleDefaultProtocolNegotiatorTest.java
+++ b/alts/src/test/java/io/grpc/alts/internal/GoogleDefaultProtocolNegotiatorTest.java
@@ -17,14 +17,18 @@
 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.grpclb.GrpclbConstants;
 import io.grpc.inprocess.InProcessChannelBuilder;
 import io.grpc.internal.ObjectPool;
 import io.grpc.netty.GrpcHttp2ConnectionHandler;
@@ -51,6 +55,7 @@ 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
@@ -68,30 +73,27 @@ public Channel returnObject(Object object) {
     @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,
-          getClusterNameAttrKey())
+          sslContext)
           .newNegotiator();
     }
 
     @After
     public void tearDown() {
       googleProtocolNegotiator.close();
+      AltsProtocolNegotiator.GoogleDefaultProtocolNegotiatorFactory.clusterNameAttrKey =
+          originalClusterNameAttrKey;
     }
 
     @Nullable
     abstract Attributes.Key<String> getClusterNameAttrKey();
 
-    @Test
-    public void altsHandler_lbProvidedBackend() {
-      Attributes attrs =
-          Attributes.newBuilder().set(GrpclbConstants.ATTR_LB_PROVIDED_BACKEND, true).build();
-      subtest_altsHandler(attrs);
-    }
-
     @Test
     public void tlsHandler_emptyAttributes() {
       subtest_tlsHandler(Attributes.EMPTY);
@@ -100,6 +102,9 @@ public void tlsHandler_emptyAttributes() {
     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() {
@@ -125,6 +130,9 @@ 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);
@@ -165,9 +173,51 @@ public void altsHandler_xdsCluster() {
 
     @Test
     public void tlsHandler_googleCfe() {
-      Attributes attrs =
-          Attributes.newBuilder().set(XDS_CLUSTER_NAME_ATTR_KEY, "google_cfe").build();
+      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/TsiTest.java b/alts/src/test/java/io/grpc/alts/internal/TsiTest.java
index f677a44a754..0241182f2db 100644
--- a/alts/src/test/java/io/grpc/alts/internal/TsiTest.java
+++ b/alts/src/test/java/io/grpc/alts/internal/TsiTest.java
@@ -34,13 +34,13 @@
 import java.util.List;
 import javax.crypto.AEADBadTagException;
 
-/** Utility class that provides tests for implementations of @{link TsiHandshaker}. */
+/** 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 static final String DECRYPTION_FAILURE_RE = "Tag mismatch|BAD_DECRYPT";
 
   private TsiTest() {}
 
-  /** A @{code TsiHandshaker} pair for running tests. */
+  /** A {@code TsiHandshaker} pair for running tests. */
   public static class Handshakers {
     private final TsiHandshaker client;
     private final TsiHandshaker server;
diff --git a/android-interop-testing/build.gradle b/android-interop-testing/build.gradle
index 91e75fcfad8..b61d50a6763 100644
--- a/android-interop-testing/build.gradle
+++ b/android-interop-testing/build.gradle
@@ -7,10 +7,10 @@ description = 'gRPC: Android Integration Testing'
 
 repositories {
     google()
-    jcenter()
 }
 
 android {
+    namespace = 'io.grpc.android.integrationtest'
     sourceSets {
         main {
             java {
@@ -25,16 +25,19 @@ android {
             }
         }
     }
-    compileSdkVersion 26
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_8
+        targetCompatibility JavaVersion.VERSION_1_8
+    }
+    compileSdkVersion 34
 
     defaultConfig {
         applicationId "io.grpc.android.integrationtest"
-        minSdkVersion 16
-        targetSdkVersion 26
+        minSdkVersion 23
+        targetSdkVersion 33
         versionCode 1
         versionName "1.0"
         testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
-        multiDexEnabled true
     }
     buildTypes {
         debug { minifyEnabled false }
@@ -43,33 +46,42 @@ android {
             proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
         }
     }
-    lintOptions { disable 'InvalidPackage', 'HardcodedText' }
+    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'
+    }
 }
 
 dependencies {
-    implementation 'com.android.support:appcompat-v7:26.1.0'
-    implementation 'com.android.support:multidex:1.0.3'
-    implementation 'com.android.support:support-annotations:26.1.0'
-    implementation 'com.google.android.gms:play-services-base:16.1.0'
+    implementation 'androidx.appcompat:appcompat:1.3.0'
+    implementation libraries.androidx.annotation
+    implementation 'com.google.android.gms:play-services-base:18.0.1'
 
-    implementation project(':grpc-auth'),
+    implementation project(':grpc-android'),
+            project(':grpc-api'),
+            project(':grpc-core'),
             project(':grpc-census'),
             project(':grpc-okhttp'),
             project(':grpc-protobuf-lite'),
             project(':grpc-stub'),
             project(':grpc-testing'),
             libraries.junit,
-            libraries.truth
+            libraries.truth,
+            libraries.androidx.test.rules,
+            libraries.androidx.test.core,
+            libraries.opencensus.contrib.grpc.metrics
 
-    implementation (libraries.google_auth_oauth2_http) {
-        exclude group: 'org.apache.httpcomponents'
+    implementation (project(':grpc-services')) {
+        exclude group: 'com.google.protobuf'
+        exclude group: 'com.google.guava'
     }
-    censusGrpcMetricDependency 'implementation'
 
-    compileOnly libraries.javax_annotation
-
-    androidTestImplementation 'androidx.test:rules:1.1.0-alpha1'
-    androidTestImplementation 'androidx.test:runner:1.1.0-alpha1'
+    androidTestImplementation libraries.androidx.test.ext.junit,
+            libraries.androidx.test.runner
 }
 
 // Checkstyle doesn't run automatically with android
@@ -89,13 +101,46 @@ project.tasks['check'].dependsOn checkStyleMain, checkStyleTest
 
 import net.ltgt.gradle.errorprone.CheckSeverity
 
-tasks.withType(JavaCompile) {
+tasks.withType(JavaCompile).configureEach {
     options.compilerArgs += [
-            "-Xlint:-cast"
+            "-Xlint:-cast",
     ]
     appendToProperty(it.options.errorprone.excludedPaths, ".*/R.java", "|")
-    // Reuses source code from grpc-interop-testing, which targets Java 7 (no method references)
-    options.errorprone.check("UnnecessaryAnonymousClass", CheckSeverity.OFF)
+    appendToProperty(
+            it.options.errorprone.excludedPaths,
+            ".*/src/generated/.*",
+            "|")
+}
+
+// Workaround error seen with Gradle 8.14.3 and AGP 7.4.1 when building:
+//   ./gradlew clean :grpc-android-interop-testing:build -PskipAndroid=false \
+//       -Pandroid.useAndroidX=true --no-build-cache
+//
+// Error message:
+//
+// Execution failed for task ':grpc-android-interop-testing:mergeExtDexDebug'.
+// > Could not resolve all files for configuration ':grpc-android-interop-testing:debugRuntimeClasspath'.
+//    > Failed to transform opencensus-contrib-grpc-metrics-0.31.1.jar (io.opencensus:opencensus-contrib-grpc-metrics:0.31.1) to match attributes {artifactType=android-dex, asm-transformed-variant=NONE, dexing-enable-desugaring=true, dexing-enable-jacoco-instrumentation=false, dexing-is-debuggable=true, dexing-min-sdk=23, org.gradle.category=library, org.gradle.libraryelements=jar, org.gradle.status=release, org.gradle.usage=java-runtime}.
+//       > Could not resolve all files for configuration ':grpc-android-interop-testing:debugRuntimeClasspath'.
+//          > Failed to transform grpc-api-1.81.0-SNAPSHOT.jar (project :grpc-api) to match attributes {artifactType=android-classes-jar, org.gradle.category=library, org.gradle.dependency.bundling=external, org.gradle.jvm.version=8, org.gradle.libraryelements=jar, org.gradle.usage=java-runtime}.
+//             > Execution failed for IdentityTransform: grpc-java/api/build/libs/grpc-api-1.81.0-SNAPSHOT.jar.
+//                > File/directory does not exist: grpc-java/api/build/libs/grpc-api-1.81.0-SNAPSHOT.jar
+tasks.configureEach { task ->
+    if (task.name.equals("mergeExtDexDebug")) {
+        dependsOn(':grpc-api:jar')
+    }
+}
+
+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
index 8af80352076..a9e696958b9 100644
--- a/android-interop-testing/proguard-rules.pro
+++ b/android-interop-testing/proguard-rules.pro
@@ -21,3 +21,7 @@
 
 # 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/src/androidTest/AndroidManifest.xml b/android-interop-testing/src/androidTest/AndroidManifest.xml
index 916a1c04332..3cc0a29a85f 100644
--- a/android-interop-testing/src/androidTest/AndroidManifest.xml
+++ b/android-interop-testing/src/androidTest/AndroidManifest.xml
@@ -1,13 +1,11 @@
 <?xml version="1.0" encoding="utf-8"?>
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-    package="io.grpc.android.integrationtest.test" >
+<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:debuggable="true" >
-        <uses-library android:name="android.test.runner" />
+    <application>
     </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
index e6a2c85fda5..a5870063a87 100644
--- 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
@@ -16,21 +16,22 @@
 
 package io.grpc.android.integrationtest;
 
-import static junit.framework.Assert.assertEquals;
+import static org.junit.Assert.assertEquals;
 
 import android.util.Log;
-import androidx.test.InstrumentationRegistry;
-import androidx.test.rule.ActivityTestRule;
-import androidx.test.runner.AndroidJUnit4;
+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 com.google.common.util.concurrent.SettableFuture;
-import io.grpc.android.integrationtest.InteropTask.Listener;
 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.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 
@@ -45,12 +46,7 @@ public class InteropInstrumentationTest {
   private String serverHostOverride;
   private boolean useTestCa;
   private String testCase;
-
-  // 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);
+  private ExecutorService executor = Executors.newSingleThreadExecutor();
 
   @Before
   public void setUp() throws Exception {
@@ -67,7 +63,7 @@ public void setUp() throws Exception {
 
     if (useTls) {
       try {
-        ProviderInstaller.installIfNeeded(InstrumentationRegistry.getTargetContext());
+        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.
@@ -108,26 +104,22 @@ public void interopTests() throws Exception {
   }
 
   private void runTest(String testCase) throws Exception {
-    final SettableFuture<String> resultFuture = SettableFuture.create();
-    InteropTask.Listener listener =
-        new Listener() {
-          @Override
-          public void onComplete(String result) {
-            resultFuture.set(result);
-          }
-        };
     InputStream testCa;
     if (useTestCa) {
-      testCa = InstrumentationRegistry.getTargetContext().getResources().openRawResource(R.raw.ca);
+      testCa = ApplicationProvider.getApplicationContext().getResources().openRawResource(R.raw.ca);
     } else {
       testCa = null;
     }
-    new InteropTask(
-            listener,
-            TesterOkHttpChannelBuilder.build(host, port, serverHostOverride, useTls, testCa),
-            testCase)
-        .execute();
-    String result = resultFuture.get(TIMEOUT_SECONDS, TimeUnit.SECONDS);
-    assertEquals(testCase + " failed", InteropTask.SUCCESS_MESSAGE, result);
+
+    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..5b98665ba29
--- /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.ext.junit.rules.ActivityScenarioRule;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import androidx.test.platform.app.InstrumentationRegistry;
+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 ActivityScenarioRule<TesterActivity> activityRule =
+      new ActivityScenarioRule<>(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
index a685679a2e8..33b914bb4b3 100644
--- 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
@@ -7,14 +7,12 @@
  * A service used to obtain stats for verifying LB behavior.
  * </pre>
  */
-@javax.annotation.Generated(
-    value = "by gRPC proto compiler",
-    comments = "Source: grpc/testing/test.proto")
+@io.grpc.stub.annotations.GrpcGenerated
 public final class LoadBalancerStatsServiceGrpc {
 
   private LoadBalancerStatsServiceGrpc() {}
 
-  public static final String SERVICE_NAME = "grpc.testing.LoadBalancerStatsService";
+  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,
@@ -91,6 +89,21 @@ public LoadBalancerStatsServiceStub newStub(io.grpc.Channel channel, io.grpc.Cal
     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
    */
@@ -126,14 +139,14 @@ public LoadBalancerStatsServiceFutureStub newStub(io.grpc.Channel channel, io.gr
    * A service used to obtain stats for verifying LB behavior.
    * </pre>
    */
-  public static abstract class LoadBalancerStatsServiceImplBase implements io.grpc.BindableService {
+  public interface AsyncService {
 
     /**
      * <pre>
      * Gets the backend distribution for RPCs sent by a test client.
      * </pre>
      */
-    public void getClientStats(io.grpc.testing.integration.Messages.LoadBalancerStatsRequest request,
+    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);
     }
@@ -143,37 +156,34 @@ public void getClientStats(io.grpc.testing.integration.Messages.LoadBalancerStat
      * Gets the accumulated stats for RPCs sent by a test client.
      * </pre>
      */
-    public void getClientAccumulatedStats(io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsRequest request,
+    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 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>(
-                  this, 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>(
-                  this, METHODID_GET_CLIENT_ACCUMULATED_STATS)))
-          .build();
+      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> {
+  public static final class LoadBalancerStatsServiceStub
+      extends io.grpc.stub.AbstractAsyncStub<LoadBalancerStatsServiceStub> {
     private LoadBalancerStatsServiceStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -209,11 +219,53 @@ public void getClientAccumulatedStats(io.grpc.testing.integration.Messages.LoadB
   }
 
   /**
+   * 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 LoadBalancerStatsServiceBlockingStub extends io.grpc.stub.AbstractBlockingStub<LoadBalancerStatsServiceBlockingStub> {
+  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);
@@ -247,11 +299,13 @@ public io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsResponse
   }
 
   /**
+   * 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> {
+  public static final class LoadBalancerStatsServiceFutureStub
+      extends io.grpc.stub.AbstractFutureStub<LoadBalancerStatsServiceFutureStub> {
     private LoadBalancerStatsServiceFutureStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -294,10 +348,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 LoadBalancerStatsServiceImplBase serviceImpl;
+    private final AsyncService serviceImpl;
     private final int methodId;
 
-    MethodHandlers(LoadBalancerStatsServiceImplBase serviceImpl, int methodId) {
+    MethodHandlers(AsyncService serviceImpl, int methodId) {
       this.serviceImpl = serviceImpl;
       this.methodId = methodId;
     }
@@ -330,6 +384,25 @@ public io.grpc.stub.StreamObserver<Req> invoke(
     }
   }
 
+  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() {
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
index 66cf6267be6..c99abcff7cb 100644
--- 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
@@ -4,14 +4,12 @@
 
 /**
  */
-@javax.annotation.Generated(
-    value = "by gRPC proto compiler",
-    comments = "Source: grpc/testing/metrics.proto")
+@io.grpc.stub.annotations.GrpcGenerated
 public final class MetricsServiceGrpc {
 
   private MetricsServiceGrpc() {}
 
-  public static final String SERVICE_NAME = "grpc.testing.MetricsService";
+  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,
@@ -88,6 +86,21 @@ public MetricsServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions c
     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
    */
@@ -120,7 +133,7 @@ public MetricsServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOpt
 
   /**
    */
-  public static abstract class MetricsServiceImplBase implements io.grpc.BindableService {
+  public interface AsyncService {
 
     /**
      * <pre>
@@ -128,7 +141,7 @@ public static abstract class MetricsServiceImplBase implements io.grpc.BindableS
      * the service
      * </pre>
      */
-    public void getAllGauges(io.grpc.testing.integration.Metrics.EmptyMessage request,
+    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);
     }
@@ -138,34 +151,28 @@ public void getAllGauges(io.grpc.testing.integration.Metrics.EmptyMessage reques
      * Returns the value of one gauge
      * </pre>
      */
-    public void getGauge(io.grpc.testing.integration.Metrics.GaugeRequest request,
+    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 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>(
-                  this, 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>(
-                  this, METHODID_GET_GAUGE)))
-          .build();
+      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> {
+  public static final class MetricsServiceStub
+      extends io.grpc.stub.AbstractAsyncStub<MetricsServiceStub> {
     private MetricsServiceStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -202,8 +209,50 @@ public void getGauge(io.grpc.testing.integration.Metrics.GaugeRequest request,
   }
 
   /**
+   * 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> {
+  public static final class MetricsServiceBlockingStub
+      extends io.grpc.stub.AbstractBlockingStub<MetricsServiceBlockingStub> {
     private MetricsServiceBlockingStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -239,8 +288,10 @@ public io.grpc.testing.integration.Metrics.GaugeResponse getGauge(io.grpc.testin
   }
 
   /**
+   * 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> {
+  public static final class MetricsServiceFutureStub
+      extends io.grpc.stub.AbstractFutureStub<MetricsServiceFutureStub> {
     private MetricsServiceFutureStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -272,10 +323,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 MetricsServiceImplBase serviceImpl;
+    private final AsyncService serviceImpl;
     private final int methodId;
 
-    MethodHandlers(MetricsServiceImplBase serviceImpl, int methodId) {
+    MethodHandlers(AsyncService serviceImpl, int methodId) {
       this.serviceImpl = serviceImpl;
       this.methodId = methodId;
     }
@@ -308,6 +359,25 @@ public io.grpc.stub.StreamObserver<Req> invoke(
     }
   }
 
+  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() {
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
index 32e8e5e40d1..fffcaad2df2 100644
--- 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
@@ -7,37 +7,35 @@
  * A service used to control reconnect server.
  * </pre>
  */
-@javax.annotation.Generated(
-    value = "by gRPC proto compiler",
-    comments = "Source: grpc/testing/test.proto")
+@io.grpc.stub.annotations.GrpcGenerated
 public final class ReconnectServiceGrpc {
 
   private ReconnectServiceGrpc() {}
 
-  public static final String SERVICE_NAME = "grpc.testing.ReconnectService";
+  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.EmptyProtos.Empty,
+  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.EmptyProtos.Empty.class,
+      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.EmptyProtos.Empty,
+  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.EmptyProtos.Empty, 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.EmptyProtos.Empty, io.grpc.testing.integration.EmptyProtos.Empty>newBuilder()
+              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.EmptyProtos.Empty.getDefaultInstance()))
+                  io.grpc.testing.integration.Messages.ReconnectParams.getDefaultInstance()))
               .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
                   io.grpc.testing.integration.EmptyProtos.Empty.getDefaultInstance()))
               .build();
@@ -91,6 +89,21 @@ public ReconnectServiceStub newStub(io.grpc.Channel channel, io.grpc.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
    */
@@ -126,48 +139,45 @@ public ReconnectServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallO
    * A service used to control reconnect server.
    * </pre>
    */
-  public static abstract class ReconnectServiceImplBase implements io.grpc.BindableService {
+  public interface AsyncService {
 
     /**
      */
-    public void start(io.grpc.testing.integration.EmptyProtos.Empty request,
+    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);
     }
 
     /**
      */
-    public void stop(io.grpc.testing.integration.EmptyProtos.Empty request,
+    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 io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
-          .addMethod(
-            getStartMethod(),
-            io.grpc.stub.ServerCalls.asyncUnaryCall(
-              new MethodHandlers<
-                io.grpc.testing.integration.EmptyProtos.Empty,
-                io.grpc.testing.integration.EmptyProtos.Empty>(
-                  this, METHODID_START)))
-          .addMethod(
-            getStopMethod(),
-            io.grpc.stub.ServerCalls.asyncUnaryCall(
-              new MethodHandlers<
-                io.grpc.testing.integration.EmptyProtos.Empty,
-                io.grpc.testing.integration.Messages.ReconnectInfo>(
-                  this, METHODID_STOP)))
-          .build();
+      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> {
+  public static final class ReconnectServiceStub
+      extends io.grpc.stub.AbstractAsyncStub<ReconnectServiceStub> {
     private ReconnectServiceStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -181,7 +191,7 @@ protected ReconnectServiceStub build(
 
     /**
      */
-    public void start(io.grpc.testing.integration.EmptyProtos.Empty request,
+    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);
@@ -197,11 +207,47 @@ public void stop(io.grpc.testing.integration.EmptyProtos.Empty request,
   }
 
   /**
+   * 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 ReconnectServiceBlockingStub extends io.grpc.stub.AbstractBlockingStub<ReconnectServiceBlockingStub> {
+  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);
@@ -215,7 +261,7 @@ protected ReconnectServiceBlockingStub build(
 
     /**
      */
-    public io.grpc.testing.integration.EmptyProtos.Empty start(io.grpc.testing.integration.EmptyProtos.Empty request) {
+    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);
     }
@@ -229,11 +275,13 @@ public io.grpc.testing.integration.Messages.ReconnectInfo stop(io.grpc.testing.i
   }
 
   /**
+   * 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> {
+  public static final class ReconnectServiceFutureStub
+      extends io.grpc.stub.AbstractFutureStub<ReconnectServiceFutureStub> {
     private ReconnectServiceFutureStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -248,7 +296,7 @@ protected ReconnectServiceFutureStub build(
     /**
      */
     public com.google.common.util.concurrent.ListenableFuture<io.grpc.testing.integration.EmptyProtos.Empty> start(
-        io.grpc.testing.integration.EmptyProtos.Empty request) {
+        io.grpc.testing.integration.Messages.ReconnectParams request) {
       return io.grpc.stub.ClientCalls.futureUnaryCall(
           getChannel().newCall(getStartMethod(), getCallOptions()), request);
     }
@@ -270,10 +318,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 ReconnectServiceImplBase serviceImpl;
+    private final AsyncService serviceImpl;
     private final int methodId;
 
-    MethodHandlers(ReconnectServiceImplBase serviceImpl, int methodId) {
+    MethodHandlers(AsyncService serviceImpl, int methodId) {
       this.serviceImpl = serviceImpl;
       this.methodId = methodId;
     }
@@ -283,7 +331,7 @@ private static final class MethodHandlers<Req, Resp> implements
     public void invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserver) {
       switch (methodId) {
         case METHODID_START:
-          serviceImpl.start((io.grpc.testing.integration.EmptyProtos.Empty) request,
+          serviceImpl.start((io.grpc.testing.integration.Messages.ReconnectParams) request,
               (io.grpc.stub.StreamObserver<io.grpc.testing.integration.EmptyProtos.Empty>) responseObserver);
           break;
         case METHODID_STOP:
@@ -306,6 +354,25 @@ public io.grpc.stub.StreamObserver<Req> invoke(
     }
   }
 
+  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() {
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
index 5f767f314c8..1d7805e3a3f 100644
--- 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
@@ -8,14 +8,12 @@
  * performance with various types of payload.
  * </pre>
  */
-@javax.annotation.Generated(
-    value = "by gRPC proto compiler",
-    comments = "Source: grpc/testing/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.TestService";
 
   // Static method descriptors that strictly reflect the proto.
   private static volatile io.grpc.MethodDescriptor<io.grpc.testing.integration.EmptyProtos.Empty,
@@ -272,6 +270,21 @@ public TestServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions call
     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
    */
@@ -308,14 +321,14 @@ public TestServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOption
    * performance with various types of payload.
    * </pre>
    */
-  public static abstract class TestServiceImplBase implements io.grpc.BindableService {
+  public interface AsyncService {
 
     /**
      * <pre>
      * One empty request followed by one empty response.
      * </pre>
      */
-    public void emptyCall(io.grpc.testing.integration.EmptyProtos.Empty request,
+    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);
     }
@@ -325,7 +338,7 @@ public void emptyCall(io.grpc.testing.integration.EmptyProtos.Empty request,
      * One request followed by one response.
      * </pre>
      */
-    public void unaryCall(io.grpc.testing.integration.Messages.SimpleRequest request,
+    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);
     }
@@ -337,7 +350,7 @@ public void unaryCall(io.grpc.testing.integration.Messages.SimpleRequest request
      * satisfy subsequent requests.
      * </pre>
      */
-    public void cacheableUnaryCall(io.grpc.testing.integration.Messages.SimpleRequest request,
+    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);
     }
@@ -348,7 +361,7 @@ public void cacheableUnaryCall(io.grpc.testing.integration.Messages.SimpleReques
      * The server returns the payload with client desired type and sizes.
      * </pre>
      */
-    public void streamingOutputCall(io.grpc.testing.integration.Messages.StreamingOutputCallRequest request,
+    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);
     }
@@ -359,7 +372,7 @@ public void streamingOutputCall(io.grpc.testing.integration.Messages.StreamingOu
      * 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(
+    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);
     }
@@ -371,7 +384,7 @@ public io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.Streamin
      * demonstrates the idea of full duplexing.
      * </pre>
      */
-    public io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingOutputCallRequest> fullDuplexCall(
+    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);
     }
@@ -384,7 +397,7 @@ public io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.Streamin
      * first request.
      * </pre>
      */
-    public io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingOutputCallRequest> halfDuplexCall(
+    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);
     }
@@ -395,80 +408,36 @@ public io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.Streamin
      * to test the behavior when clients call unimplemented methods.
      * </pre>
      */
-    public void unimplementedCall(io.grpc.testing.integration.EmptyProtos.Empty request,
+    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 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>(
-                  this, METHODID_EMPTY_CALL)))
-          .addMethod(
-            getUnaryCallMethod(),
-            io.grpc.stub.ServerCalls.asyncUnaryCall(
-              new MethodHandlers<
-                io.grpc.testing.integration.Messages.SimpleRequest,
-                io.grpc.testing.integration.Messages.SimpleResponse>(
-                  this, METHODID_UNARY_CALL)))
-          .addMethod(
-            getCacheableUnaryCallMethod(),
-            io.grpc.stub.ServerCalls.asyncUnaryCall(
-              new MethodHandlers<
-                io.grpc.testing.integration.Messages.SimpleRequest,
-                io.grpc.testing.integration.Messages.SimpleResponse>(
-                  this, 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>(
-                  this, 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>(
-                  this, 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>(
-                  this, 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>(
-                  this, 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>(
-                  this, METHODID_UNIMPLEMENTED_CALL)))
-          .build();
+      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> {
+  public static final class TestServiceStub
+      extends io.grpc.stub.AbstractAsyncStub<TestServiceStub> {
     private TestServiceStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -580,12 +549,133 @@ public void unimplementedCall(io.grpc.testing.integration.EmptyProtos.Empty requ
   }
 
   /**
+   * 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> {
+  public static final class TestServiceBlockingStub
+      extends io.grpc.stub.AbstractBlockingStub<TestServiceBlockingStub> {
     private TestServiceBlockingStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -654,12 +744,14 @@ public io.grpc.testing.integration.EmptyProtos.Empty unimplementedCall(io.grpc.t
   }
 
   /**
+   * 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> {
+  public static final class TestServiceFutureStub
+      extends io.grpc.stub.AbstractFutureStub<TestServiceFutureStub> {
     private TestServiceFutureStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -733,10 +825,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 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;
     }
@@ -790,6 +882,67 @@ public io.grpc.stub.StreamObserver<Req> invoke(
     }
   }
 
+  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() {
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
index 26870496f49..bec9b5a723a 100644
--- 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
@@ -8,14 +8,12 @@
  * that case.
  * </pre>
  */
-@javax.annotation.Generated(
-    value = "by gRPC proto compiler",
-    comments = "Source: grpc/testing/test.proto")
+@io.grpc.stub.annotations.GrpcGenerated
 public final class UnimplementedServiceGrpc {
 
   private UnimplementedServiceGrpc() {}
 
-  public static final String SERVICE_NAME = "grpc.testing.UnimplementedService";
+  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,
@@ -62,6 +60,21 @@ public UnimplementedServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOpt
     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
    */
@@ -98,38 +111,43 @@ public UnimplementedServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.C
    * that case.
    * </pre>
    */
-  public static abstract class UnimplementedServiceImplBase implements io.grpc.BindableService {
+  public interface AsyncService {
 
     /**
      * <pre>
      * A call that no server should implement
      * </pre>
      */
-    public void unimplementedCall(io.grpc.testing.integration.EmptyProtos.Empty request,
+    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 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>(
-                  this, METHODID_UNIMPLEMENTED_CALL)))
-          .build();
+      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> {
+  public static final class UnimplementedServiceStub
+      extends io.grpc.stub.AbstractAsyncStub<UnimplementedServiceStub> {
     private UnimplementedServiceStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -154,12 +172,45 @@ public void unimplementedCall(io.grpc.testing.integration.EmptyProtos.Empty requ
   }
 
   /**
+   * 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> {
+  public static final class UnimplementedServiceBlockingStub
+      extends io.grpc.stub.AbstractBlockingStub<UnimplementedServiceBlockingStub> {
     private UnimplementedServiceBlockingStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -183,12 +234,14 @@ public io.grpc.testing.integration.EmptyProtos.Empty unimplementedCall(io.grpc.t
   }
 
   /**
+   * 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> {
+  public static final class UnimplementedServiceFutureStub
+      extends io.grpc.stub.AbstractFutureStub<UnimplementedServiceFutureStub> {
     private UnimplementedServiceFutureStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -219,10 +272,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 UnimplementedServiceImplBase serviceImpl;
+    private final AsyncService serviceImpl;
     private final int methodId;
 
-    MethodHandlers(UnimplementedServiceImplBase serviceImpl, int methodId) {
+    MethodHandlers(AsyncService serviceImpl, int methodId) {
       this.serviceImpl = serviceImpl;
       this.methodId = methodId;
     }
@@ -251,6 +304,18 @@ public io.grpc.stub.StreamObserver<Req> invoke(
     }
   }
 
+  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() {
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
index 47293f3b172..3453b6c01be 100644
--- 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
@@ -7,14 +7,12 @@
  * A service to dynamically update the configuration of an xDS test client.
  * </pre>
  */
-@javax.annotation.Generated(
-    value = "by gRPC proto compiler",
-    comments = "Source: grpc/testing/test.proto")
+@io.grpc.stub.annotations.GrpcGenerated
 public final class XdsUpdateClientConfigureServiceGrpc {
 
   private XdsUpdateClientConfigureServiceGrpc() {}
 
-  public static final String SERVICE_NAME = "grpc.testing.XdsUpdateClientConfigureService";
+  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,
@@ -61,6 +59,21 @@ public XdsUpdateClientConfigureServiceStub newStub(io.grpc.Channel channel, io.g
     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
    */
@@ -96,37 +109,41 @@ public XdsUpdateClientConfigureServiceFutureStub newStub(io.grpc.Channel channel
    * A service to dynamically update the configuration of an xDS test client.
    * </pre>
    */
-  public static abstract class XdsUpdateClientConfigureServiceImplBase implements io.grpc.BindableService {
+  public interface AsyncService {
 
     /**
      * <pre>
      * Update the tes client's configuration.
      * </pre>
      */
-    public void configure(io.grpc.testing.integration.Messages.ClientConfigureRequest request,
+    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 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>(
-                  this, METHODID_CONFIGURE)))
-          .build();
+      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> {
+  public static final class XdsUpdateClientConfigureServiceStub
+      extends io.grpc.stub.AbstractAsyncStub<XdsUpdateClientConfigureServiceStub> {
     private XdsUpdateClientConfigureServiceStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -151,11 +168,43 @@ public void configure(io.grpc.testing.integration.Messages.ClientConfigureReques
   }
 
   /**
+   * 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> {
+  public static final class XdsUpdateClientConfigureServiceBlockingStub
+      extends io.grpc.stub.AbstractBlockingStub<XdsUpdateClientConfigureServiceBlockingStub> {
     private XdsUpdateClientConfigureServiceBlockingStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -179,11 +228,13 @@ public io.grpc.testing.integration.Messages.ClientConfigureResponse configure(io
   }
 
   /**
+   * 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> {
+  public static final class XdsUpdateClientConfigureServiceFutureStub
+      extends io.grpc.stub.AbstractFutureStub<XdsUpdateClientConfigureServiceFutureStub> {
     private XdsUpdateClientConfigureServiceFutureStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -214,10 +265,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 XdsUpdateClientConfigureServiceImplBase serviceImpl;
+    private final AsyncService serviceImpl;
     private final int methodId;
 
-    MethodHandlers(XdsUpdateClientConfigureServiceImplBase serviceImpl, int methodId) {
+    MethodHandlers(AsyncService serviceImpl, int methodId) {
       this.serviceImpl = serviceImpl;
       this.methodId = methodId;
     }
@@ -246,6 +297,18 @@ public io.grpc.stub.StreamObserver<Req> invoke(
     }
   }
 
+  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() {
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
index 3ee2e416431..fb5f2cdebc7 100644
--- 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
@@ -7,14 +7,12 @@
  * A service to remotely control health status of an xDS test server.
  * </pre>
  */
-@javax.annotation.Generated(
-    value = "by gRPC proto compiler",
-    comments = "Source: grpc/testing/test.proto")
+@io.grpc.stub.annotations.GrpcGenerated
 public final class XdsUpdateHealthServiceGrpc {
 
   private XdsUpdateHealthServiceGrpc() {}
 
-  public static final String SERVICE_NAME = "grpc.testing.XdsUpdateHealthService";
+  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,
@@ -91,6 +89,21 @@ public XdsUpdateHealthServiceStub newStub(io.grpc.Channel channel, io.grpc.CallO
     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
    */
@@ -126,48 +139,45 @@ public XdsUpdateHealthServiceFutureStub newStub(io.grpc.Channel channel, io.grpc
    * A service to remotely control health status of an xDS test server.
    * </pre>
    */
-  public static abstract class XdsUpdateHealthServiceImplBase implements io.grpc.BindableService {
+  public interface AsyncService {
 
     /**
      */
-    public void setServing(io.grpc.testing.integration.EmptyProtos.Empty request,
+    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);
     }
 
     /**
      */
-    public void setNotServing(io.grpc.testing.integration.EmptyProtos.Empty request,
+    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 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>(
-                  this, METHODID_SET_SERVING)))
-          .addMethod(
-            getSetNotServingMethod(),
-            io.grpc.stub.ServerCalls.asyncUnaryCall(
-              new MethodHandlers<
-                io.grpc.testing.integration.EmptyProtos.Empty,
-                io.grpc.testing.integration.EmptyProtos.Empty>(
-                  this, METHODID_SET_NOT_SERVING)))
-          .build();
+      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> {
+  public static final class XdsUpdateHealthServiceStub
+      extends io.grpc.stub.AbstractAsyncStub<XdsUpdateHealthServiceStub> {
     private XdsUpdateHealthServiceStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -197,11 +207,47 @@ public void setNotServing(io.grpc.testing.integration.EmptyProtos.Empty request,
   }
 
   /**
+   * 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 XdsUpdateHealthServiceBlockingStub extends io.grpc.stub.AbstractBlockingStub<XdsUpdateHealthServiceBlockingStub> {
+  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);
@@ -229,11 +275,13 @@ public io.grpc.testing.integration.EmptyProtos.Empty setNotServing(io.grpc.testi
   }
 
   /**
+   * 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> {
+  public static final class XdsUpdateHealthServiceFutureStub
+      extends io.grpc.stub.AbstractFutureStub<XdsUpdateHealthServiceFutureStub> {
     private XdsUpdateHealthServiceFutureStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -270,10 +318,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 XdsUpdateHealthServiceImplBase serviceImpl;
+    private final AsyncService serviceImpl;
     private final int methodId;
 
-    MethodHandlers(XdsUpdateHealthServiceImplBase serviceImpl, int methodId) {
+    MethodHandlers(AsyncService serviceImpl, int methodId) {
       this.serviceImpl = serviceImpl;
       this.methodId = methodId;
     }
@@ -306,6 +354,25 @@ public io.grpc.stub.StreamObserver<Req> invoke(
     }
   }
 
+  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() {
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
index a685679a2e8..33b914bb4b3 100644
--- 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
@@ -7,14 +7,12 @@
  * A service used to obtain stats for verifying LB behavior.
  * </pre>
  */
-@javax.annotation.Generated(
-    value = "by gRPC proto compiler",
-    comments = "Source: grpc/testing/test.proto")
+@io.grpc.stub.annotations.GrpcGenerated
 public final class LoadBalancerStatsServiceGrpc {
 
   private LoadBalancerStatsServiceGrpc() {}
 
-  public static final String SERVICE_NAME = "grpc.testing.LoadBalancerStatsService";
+  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,
@@ -91,6 +89,21 @@ public LoadBalancerStatsServiceStub newStub(io.grpc.Channel channel, io.grpc.Cal
     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
    */
@@ -126,14 +139,14 @@ public LoadBalancerStatsServiceFutureStub newStub(io.grpc.Channel channel, io.gr
    * A service used to obtain stats for verifying LB behavior.
    * </pre>
    */
-  public static abstract class LoadBalancerStatsServiceImplBase implements io.grpc.BindableService {
+  public interface AsyncService {
 
     /**
      * <pre>
      * Gets the backend distribution for RPCs sent by a test client.
      * </pre>
      */
-    public void getClientStats(io.grpc.testing.integration.Messages.LoadBalancerStatsRequest request,
+    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);
     }
@@ -143,37 +156,34 @@ public void getClientStats(io.grpc.testing.integration.Messages.LoadBalancerStat
      * Gets the accumulated stats for RPCs sent by a test client.
      * </pre>
      */
-    public void getClientAccumulatedStats(io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsRequest request,
+    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 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>(
-                  this, 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>(
-                  this, METHODID_GET_CLIENT_ACCUMULATED_STATS)))
-          .build();
+      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> {
+  public static final class LoadBalancerStatsServiceStub
+      extends io.grpc.stub.AbstractAsyncStub<LoadBalancerStatsServiceStub> {
     private LoadBalancerStatsServiceStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -209,11 +219,53 @@ public void getClientAccumulatedStats(io.grpc.testing.integration.Messages.LoadB
   }
 
   /**
+   * 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 LoadBalancerStatsServiceBlockingStub extends io.grpc.stub.AbstractBlockingStub<LoadBalancerStatsServiceBlockingStub> {
+  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);
@@ -247,11 +299,13 @@ public io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsResponse
   }
 
   /**
+   * 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> {
+  public static final class LoadBalancerStatsServiceFutureStub
+      extends io.grpc.stub.AbstractFutureStub<LoadBalancerStatsServiceFutureStub> {
     private LoadBalancerStatsServiceFutureStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -294,10 +348,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 LoadBalancerStatsServiceImplBase serviceImpl;
+    private final AsyncService serviceImpl;
     private final int methodId;
 
-    MethodHandlers(LoadBalancerStatsServiceImplBase serviceImpl, int methodId) {
+    MethodHandlers(AsyncService serviceImpl, int methodId) {
       this.serviceImpl = serviceImpl;
       this.methodId = methodId;
     }
@@ -330,6 +384,25 @@ public io.grpc.stub.StreamObserver<Req> invoke(
     }
   }
 
+  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() {
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
index 66cf6267be6..c99abcff7cb 100644
--- 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
@@ -4,14 +4,12 @@
 
 /**
  */
-@javax.annotation.Generated(
-    value = "by gRPC proto compiler",
-    comments = "Source: grpc/testing/metrics.proto")
+@io.grpc.stub.annotations.GrpcGenerated
 public final class MetricsServiceGrpc {
 
   private MetricsServiceGrpc() {}
 
-  public static final String SERVICE_NAME = "grpc.testing.MetricsService";
+  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,
@@ -88,6 +86,21 @@ public MetricsServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions c
     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
    */
@@ -120,7 +133,7 @@ public MetricsServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOpt
 
   /**
    */
-  public static abstract class MetricsServiceImplBase implements io.grpc.BindableService {
+  public interface AsyncService {
 
     /**
      * <pre>
@@ -128,7 +141,7 @@ public static abstract class MetricsServiceImplBase implements io.grpc.BindableS
      * the service
      * </pre>
      */
-    public void getAllGauges(io.grpc.testing.integration.Metrics.EmptyMessage request,
+    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);
     }
@@ -138,34 +151,28 @@ public void getAllGauges(io.grpc.testing.integration.Metrics.EmptyMessage reques
      * Returns the value of one gauge
      * </pre>
      */
-    public void getGauge(io.grpc.testing.integration.Metrics.GaugeRequest request,
+    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 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>(
-                  this, 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>(
-                  this, METHODID_GET_GAUGE)))
-          .build();
+      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> {
+  public static final class MetricsServiceStub
+      extends io.grpc.stub.AbstractAsyncStub<MetricsServiceStub> {
     private MetricsServiceStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -202,8 +209,50 @@ public void getGauge(io.grpc.testing.integration.Metrics.GaugeRequest request,
   }
 
   /**
+   * 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> {
+  public static final class MetricsServiceBlockingStub
+      extends io.grpc.stub.AbstractBlockingStub<MetricsServiceBlockingStub> {
     private MetricsServiceBlockingStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -239,8 +288,10 @@ public io.grpc.testing.integration.Metrics.GaugeResponse getGauge(io.grpc.testin
   }
 
   /**
+   * 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> {
+  public static final class MetricsServiceFutureStub
+      extends io.grpc.stub.AbstractFutureStub<MetricsServiceFutureStub> {
     private MetricsServiceFutureStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -272,10 +323,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 MetricsServiceImplBase serviceImpl;
+    private final AsyncService serviceImpl;
     private final int methodId;
 
-    MethodHandlers(MetricsServiceImplBase serviceImpl, int methodId) {
+    MethodHandlers(AsyncService serviceImpl, int methodId) {
       this.serviceImpl = serviceImpl;
       this.methodId = methodId;
     }
@@ -308,6 +359,25 @@ public io.grpc.stub.StreamObserver<Req> invoke(
     }
   }
 
+  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() {
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
index 32e8e5e40d1..fffcaad2df2 100644
--- 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
@@ -7,37 +7,35 @@
  * A service used to control reconnect server.
  * </pre>
  */
-@javax.annotation.Generated(
-    value = "by gRPC proto compiler",
-    comments = "Source: grpc/testing/test.proto")
+@io.grpc.stub.annotations.GrpcGenerated
 public final class ReconnectServiceGrpc {
 
   private ReconnectServiceGrpc() {}
 
-  public static final String SERVICE_NAME = "grpc.testing.ReconnectService";
+  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.EmptyProtos.Empty,
+  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.EmptyProtos.Empty.class,
+      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.EmptyProtos.Empty,
+  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.EmptyProtos.Empty, 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.EmptyProtos.Empty, io.grpc.testing.integration.EmptyProtos.Empty>newBuilder()
+              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.EmptyProtos.Empty.getDefaultInstance()))
+                  io.grpc.testing.integration.Messages.ReconnectParams.getDefaultInstance()))
               .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
                   io.grpc.testing.integration.EmptyProtos.Empty.getDefaultInstance()))
               .build();
@@ -91,6 +89,21 @@ public ReconnectServiceStub newStub(io.grpc.Channel channel, io.grpc.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
    */
@@ -126,48 +139,45 @@ public ReconnectServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallO
    * A service used to control reconnect server.
    * </pre>
    */
-  public static abstract class ReconnectServiceImplBase implements io.grpc.BindableService {
+  public interface AsyncService {
 
     /**
      */
-    public void start(io.grpc.testing.integration.EmptyProtos.Empty request,
+    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);
     }
 
     /**
      */
-    public void stop(io.grpc.testing.integration.EmptyProtos.Empty request,
+    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 io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
-          .addMethod(
-            getStartMethod(),
-            io.grpc.stub.ServerCalls.asyncUnaryCall(
-              new MethodHandlers<
-                io.grpc.testing.integration.EmptyProtos.Empty,
-                io.grpc.testing.integration.EmptyProtos.Empty>(
-                  this, METHODID_START)))
-          .addMethod(
-            getStopMethod(),
-            io.grpc.stub.ServerCalls.asyncUnaryCall(
-              new MethodHandlers<
-                io.grpc.testing.integration.EmptyProtos.Empty,
-                io.grpc.testing.integration.Messages.ReconnectInfo>(
-                  this, METHODID_STOP)))
-          .build();
+      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> {
+  public static final class ReconnectServiceStub
+      extends io.grpc.stub.AbstractAsyncStub<ReconnectServiceStub> {
     private ReconnectServiceStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -181,7 +191,7 @@ protected ReconnectServiceStub build(
 
     /**
      */
-    public void start(io.grpc.testing.integration.EmptyProtos.Empty request,
+    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);
@@ -197,11 +207,47 @@ public void stop(io.grpc.testing.integration.EmptyProtos.Empty request,
   }
 
   /**
+   * 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 ReconnectServiceBlockingStub extends io.grpc.stub.AbstractBlockingStub<ReconnectServiceBlockingStub> {
+  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);
@@ -215,7 +261,7 @@ protected ReconnectServiceBlockingStub build(
 
     /**
      */
-    public io.grpc.testing.integration.EmptyProtos.Empty start(io.grpc.testing.integration.EmptyProtos.Empty request) {
+    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);
     }
@@ -229,11 +275,13 @@ public io.grpc.testing.integration.Messages.ReconnectInfo stop(io.grpc.testing.i
   }
 
   /**
+   * 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> {
+  public static final class ReconnectServiceFutureStub
+      extends io.grpc.stub.AbstractFutureStub<ReconnectServiceFutureStub> {
     private ReconnectServiceFutureStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -248,7 +296,7 @@ protected ReconnectServiceFutureStub build(
     /**
      */
     public com.google.common.util.concurrent.ListenableFuture<io.grpc.testing.integration.EmptyProtos.Empty> start(
-        io.grpc.testing.integration.EmptyProtos.Empty request) {
+        io.grpc.testing.integration.Messages.ReconnectParams request) {
       return io.grpc.stub.ClientCalls.futureUnaryCall(
           getChannel().newCall(getStartMethod(), getCallOptions()), request);
     }
@@ -270,10 +318,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 ReconnectServiceImplBase serviceImpl;
+    private final AsyncService serviceImpl;
     private final int methodId;
 
-    MethodHandlers(ReconnectServiceImplBase serviceImpl, int methodId) {
+    MethodHandlers(AsyncService serviceImpl, int methodId) {
       this.serviceImpl = serviceImpl;
       this.methodId = methodId;
     }
@@ -283,7 +331,7 @@ private static final class MethodHandlers<Req, Resp> implements
     public void invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserver) {
       switch (methodId) {
         case METHODID_START:
-          serviceImpl.start((io.grpc.testing.integration.EmptyProtos.Empty) request,
+          serviceImpl.start((io.grpc.testing.integration.Messages.ReconnectParams) request,
               (io.grpc.stub.StreamObserver<io.grpc.testing.integration.EmptyProtos.Empty>) responseObserver);
           break;
         case METHODID_STOP:
@@ -306,6 +354,25 @@ public io.grpc.stub.StreamObserver<Req> invoke(
     }
   }
 
+  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() {
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
index 5f767f314c8..1d7805e3a3f 100644
--- 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
@@ -8,14 +8,12 @@
  * performance with various types of payload.
  * </pre>
  */
-@javax.annotation.Generated(
-    value = "by gRPC proto compiler",
-    comments = "Source: grpc/testing/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.TestService";
 
   // Static method descriptors that strictly reflect the proto.
   private static volatile io.grpc.MethodDescriptor<io.grpc.testing.integration.EmptyProtos.Empty,
@@ -272,6 +270,21 @@ public TestServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions call
     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
    */
@@ -308,14 +321,14 @@ public TestServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOption
    * performance with various types of payload.
    * </pre>
    */
-  public static abstract class TestServiceImplBase implements io.grpc.BindableService {
+  public interface AsyncService {
 
     /**
      * <pre>
      * One empty request followed by one empty response.
      * </pre>
      */
-    public void emptyCall(io.grpc.testing.integration.EmptyProtos.Empty request,
+    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);
     }
@@ -325,7 +338,7 @@ public void emptyCall(io.grpc.testing.integration.EmptyProtos.Empty request,
      * One request followed by one response.
      * </pre>
      */
-    public void unaryCall(io.grpc.testing.integration.Messages.SimpleRequest request,
+    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);
     }
@@ -337,7 +350,7 @@ public void unaryCall(io.grpc.testing.integration.Messages.SimpleRequest request
      * satisfy subsequent requests.
      * </pre>
      */
-    public void cacheableUnaryCall(io.grpc.testing.integration.Messages.SimpleRequest request,
+    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);
     }
@@ -348,7 +361,7 @@ public void cacheableUnaryCall(io.grpc.testing.integration.Messages.SimpleReques
      * The server returns the payload with client desired type and sizes.
      * </pre>
      */
-    public void streamingOutputCall(io.grpc.testing.integration.Messages.StreamingOutputCallRequest request,
+    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);
     }
@@ -359,7 +372,7 @@ public void streamingOutputCall(io.grpc.testing.integration.Messages.StreamingOu
      * 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(
+    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);
     }
@@ -371,7 +384,7 @@ public io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.Streamin
      * demonstrates the idea of full duplexing.
      * </pre>
      */
-    public io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingOutputCallRequest> fullDuplexCall(
+    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);
     }
@@ -384,7 +397,7 @@ public io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.Streamin
      * first request.
      * </pre>
      */
-    public io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingOutputCallRequest> halfDuplexCall(
+    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);
     }
@@ -395,80 +408,36 @@ public io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.Streamin
      * to test the behavior when clients call unimplemented methods.
      * </pre>
      */
-    public void unimplementedCall(io.grpc.testing.integration.EmptyProtos.Empty request,
+    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 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>(
-                  this, METHODID_EMPTY_CALL)))
-          .addMethod(
-            getUnaryCallMethod(),
-            io.grpc.stub.ServerCalls.asyncUnaryCall(
-              new MethodHandlers<
-                io.grpc.testing.integration.Messages.SimpleRequest,
-                io.grpc.testing.integration.Messages.SimpleResponse>(
-                  this, METHODID_UNARY_CALL)))
-          .addMethod(
-            getCacheableUnaryCallMethod(),
-            io.grpc.stub.ServerCalls.asyncUnaryCall(
-              new MethodHandlers<
-                io.grpc.testing.integration.Messages.SimpleRequest,
-                io.grpc.testing.integration.Messages.SimpleResponse>(
-                  this, 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>(
-                  this, 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>(
-                  this, 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>(
-                  this, 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>(
-                  this, 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>(
-                  this, METHODID_UNIMPLEMENTED_CALL)))
-          .build();
+      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> {
+  public static final class TestServiceStub
+      extends io.grpc.stub.AbstractAsyncStub<TestServiceStub> {
     private TestServiceStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -580,12 +549,133 @@ public void unimplementedCall(io.grpc.testing.integration.EmptyProtos.Empty requ
   }
 
   /**
+   * 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> {
+  public static final class TestServiceBlockingStub
+      extends io.grpc.stub.AbstractBlockingStub<TestServiceBlockingStub> {
     private TestServiceBlockingStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -654,12 +744,14 @@ public io.grpc.testing.integration.EmptyProtos.Empty unimplementedCall(io.grpc.t
   }
 
   /**
+   * 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> {
+  public static final class TestServiceFutureStub
+      extends io.grpc.stub.AbstractFutureStub<TestServiceFutureStub> {
     private TestServiceFutureStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -733,10 +825,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 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;
     }
@@ -790,6 +882,67 @@ public io.grpc.stub.StreamObserver<Req> invoke(
     }
   }
 
+  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() {
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
index 26870496f49..bec9b5a723a 100644
--- 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
@@ -8,14 +8,12 @@
  * that case.
  * </pre>
  */
-@javax.annotation.Generated(
-    value = "by gRPC proto compiler",
-    comments = "Source: grpc/testing/test.proto")
+@io.grpc.stub.annotations.GrpcGenerated
 public final class UnimplementedServiceGrpc {
 
   private UnimplementedServiceGrpc() {}
 
-  public static final String SERVICE_NAME = "grpc.testing.UnimplementedService";
+  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,
@@ -62,6 +60,21 @@ public UnimplementedServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOpt
     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
    */
@@ -98,38 +111,43 @@ public UnimplementedServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.C
    * that case.
    * </pre>
    */
-  public static abstract class UnimplementedServiceImplBase implements io.grpc.BindableService {
+  public interface AsyncService {
 
     /**
      * <pre>
      * A call that no server should implement
      * </pre>
      */
-    public void unimplementedCall(io.grpc.testing.integration.EmptyProtos.Empty request,
+    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 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>(
-                  this, METHODID_UNIMPLEMENTED_CALL)))
-          .build();
+      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> {
+  public static final class UnimplementedServiceStub
+      extends io.grpc.stub.AbstractAsyncStub<UnimplementedServiceStub> {
     private UnimplementedServiceStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -154,12 +172,45 @@ public void unimplementedCall(io.grpc.testing.integration.EmptyProtos.Empty requ
   }
 
   /**
+   * 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> {
+  public static final class UnimplementedServiceBlockingStub
+      extends io.grpc.stub.AbstractBlockingStub<UnimplementedServiceBlockingStub> {
     private UnimplementedServiceBlockingStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -183,12 +234,14 @@ public io.grpc.testing.integration.EmptyProtos.Empty unimplementedCall(io.grpc.t
   }
 
   /**
+   * 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> {
+  public static final class UnimplementedServiceFutureStub
+      extends io.grpc.stub.AbstractFutureStub<UnimplementedServiceFutureStub> {
     private UnimplementedServiceFutureStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -219,10 +272,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 UnimplementedServiceImplBase serviceImpl;
+    private final AsyncService serviceImpl;
     private final int methodId;
 
-    MethodHandlers(UnimplementedServiceImplBase serviceImpl, int methodId) {
+    MethodHandlers(AsyncService serviceImpl, int methodId) {
       this.serviceImpl = serviceImpl;
       this.methodId = methodId;
     }
@@ -251,6 +304,18 @@ public io.grpc.stub.StreamObserver<Req> invoke(
     }
   }
 
+  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() {
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
index 47293f3b172..3453b6c01be 100644
--- 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
@@ -7,14 +7,12 @@
  * A service to dynamically update the configuration of an xDS test client.
  * </pre>
  */
-@javax.annotation.Generated(
-    value = "by gRPC proto compiler",
-    comments = "Source: grpc/testing/test.proto")
+@io.grpc.stub.annotations.GrpcGenerated
 public final class XdsUpdateClientConfigureServiceGrpc {
 
   private XdsUpdateClientConfigureServiceGrpc() {}
 
-  public static final String SERVICE_NAME = "grpc.testing.XdsUpdateClientConfigureService";
+  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,
@@ -61,6 +59,21 @@ public XdsUpdateClientConfigureServiceStub newStub(io.grpc.Channel channel, io.g
     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
    */
@@ -96,37 +109,41 @@ public XdsUpdateClientConfigureServiceFutureStub newStub(io.grpc.Channel channel
    * A service to dynamically update the configuration of an xDS test client.
    * </pre>
    */
-  public static abstract class XdsUpdateClientConfigureServiceImplBase implements io.grpc.BindableService {
+  public interface AsyncService {
 
     /**
      * <pre>
      * Update the tes client's configuration.
      * </pre>
      */
-    public void configure(io.grpc.testing.integration.Messages.ClientConfigureRequest request,
+    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 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>(
-                  this, METHODID_CONFIGURE)))
-          .build();
+      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> {
+  public static final class XdsUpdateClientConfigureServiceStub
+      extends io.grpc.stub.AbstractAsyncStub<XdsUpdateClientConfigureServiceStub> {
     private XdsUpdateClientConfigureServiceStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -151,11 +168,43 @@ public void configure(io.grpc.testing.integration.Messages.ClientConfigureReques
   }
 
   /**
+   * 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> {
+  public static final class XdsUpdateClientConfigureServiceBlockingStub
+      extends io.grpc.stub.AbstractBlockingStub<XdsUpdateClientConfigureServiceBlockingStub> {
     private XdsUpdateClientConfigureServiceBlockingStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -179,11 +228,13 @@ public io.grpc.testing.integration.Messages.ClientConfigureResponse configure(io
   }
 
   /**
+   * 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> {
+  public static final class XdsUpdateClientConfigureServiceFutureStub
+      extends io.grpc.stub.AbstractFutureStub<XdsUpdateClientConfigureServiceFutureStub> {
     private XdsUpdateClientConfigureServiceFutureStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -214,10 +265,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 XdsUpdateClientConfigureServiceImplBase serviceImpl;
+    private final AsyncService serviceImpl;
     private final int methodId;
 
-    MethodHandlers(XdsUpdateClientConfigureServiceImplBase serviceImpl, int methodId) {
+    MethodHandlers(AsyncService serviceImpl, int methodId) {
       this.serviceImpl = serviceImpl;
       this.methodId = methodId;
     }
@@ -246,6 +297,18 @@ public io.grpc.stub.StreamObserver<Req> invoke(
     }
   }
 
+  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() {
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
index 3ee2e416431..fb5f2cdebc7 100644
--- 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
@@ -7,14 +7,12 @@
  * A service to remotely control health status of an xDS test server.
  * </pre>
  */
-@javax.annotation.Generated(
-    value = "by gRPC proto compiler",
-    comments = "Source: grpc/testing/test.proto")
+@io.grpc.stub.annotations.GrpcGenerated
 public final class XdsUpdateHealthServiceGrpc {
 
   private XdsUpdateHealthServiceGrpc() {}
 
-  public static final String SERVICE_NAME = "grpc.testing.XdsUpdateHealthService";
+  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,
@@ -91,6 +89,21 @@ public XdsUpdateHealthServiceStub newStub(io.grpc.Channel channel, io.grpc.CallO
     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
    */
@@ -126,48 +139,45 @@ public XdsUpdateHealthServiceFutureStub newStub(io.grpc.Channel channel, io.grpc
    * A service to remotely control health status of an xDS test server.
    * </pre>
    */
-  public static abstract class XdsUpdateHealthServiceImplBase implements io.grpc.BindableService {
+  public interface AsyncService {
 
     /**
      */
-    public void setServing(io.grpc.testing.integration.EmptyProtos.Empty request,
+    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);
     }
 
     /**
      */
-    public void setNotServing(io.grpc.testing.integration.EmptyProtos.Empty request,
+    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 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>(
-                  this, METHODID_SET_SERVING)))
-          .addMethod(
-            getSetNotServingMethod(),
-            io.grpc.stub.ServerCalls.asyncUnaryCall(
-              new MethodHandlers<
-                io.grpc.testing.integration.EmptyProtos.Empty,
-                io.grpc.testing.integration.EmptyProtos.Empty>(
-                  this, METHODID_SET_NOT_SERVING)))
-          .build();
+      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> {
+  public static final class XdsUpdateHealthServiceStub
+      extends io.grpc.stub.AbstractAsyncStub<XdsUpdateHealthServiceStub> {
     private XdsUpdateHealthServiceStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -197,11 +207,47 @@ public void setNotServing(io.grpc.testing.integration.EmptyProtos.Empty request,
   }
 
   /**
+   * 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 XdsUpdateHealthServiceBlockingStub extends io.grpc.stub.AbstractBlockingStub<XdsUpdateHealthServiceBlockingStub> {
+  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);
@@ -229,11 +275,13 @@ public io.grpc.testing.integration.EmptyProtos.Empty setNotServing(io.grpc.testi
   }
 
   /**
+   * 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> {
+  public static final class XdsUpdateHealthServiceFutureStub
+      extends io.grpc.stub.AbstractFutureStub<XdsUpdateHealthServiceFutureStub> {
     private XdsUpdateHealthServiceFutureStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -270,10 +318,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 XdsUpdateHealthServiceImplBase serviceImpl;
+    private final AsyncService serviceImpl;
     private final int methodId;
 
-    MethodHandlers(XdsUpdateHealthServiceImplBase serviceImpl, int methodId) {
+    MethodHandlers(AsyncService serviceImpl, int methodId) {
       this.serviceImpl = serviceImpl;
       this.methodId = methodId;
     }
@@ -306,6 +354,25 @@ public io.grpc.stub.StreamObserver<Req> invoke(
     }
   }
 
+  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() {
diff --git a/android-interop-testing/src/main/AndroidManifest.xml b/android-interop-testing/src/main/AndroidManifest.xml
index c3f35131ad4..08c139e5880 100644
--- a/android-interop-testing/src/main/AndroidManifest.xml
+++ b/android-interop-testing/src/main/AndroidManifest.xml
@@ -1,24 +1,32 @@
 <?xml version="1.0" encoding="utf-8"?>
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
-    package="io.grpc.android.integrationtest" >
+    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="android.support.multidex.MultiDexApplication" >
+        android:theme="@style/Base.V7.Theme.AppCompat.Light">
         <activity
             android:name=".TesterActivity"
-            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>
+        <!-- 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/InteropTask.java b/android-interop-testing/src/main/java/io/grpc/android/integrationtest/InteropTask.java
deleted file mode 100644
index 8beaea3ec9c..00000000000
--- a/android-interop-testing/src/main/java/io/grpc/android/integrationtest/InteropTask.java
+++ /dev/null
@@ -1,170 +0,0 @@
-/*
- * 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.integrationtest;
-
-import android.os.AsyncTask;
-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.lang.ref.WeakReference;
-import org.junit.AssumptionViolatedException;
-
-/** AsyncTask for interop test cases. */
-final class InteropTask extends AsyncTask<Void, Void, String> {
-  private static final String LOG_TAG = "GrpcInteropTask";
-
-  interface Listener {
-    void onComplete(String result);
-  }
-
-  static final String SUCCESS_MESSAGE = "Success!";
-
-  private final WeakReference<Listener> listenerReference;
-  private final String testCase;
-  private final Tester tester;
-
-  InteropTask(
-      Listener listener,
-      ManagedChannel channel,
-      String testCase) {
-    this.listenerReference = new WeakReference<Listener>(listener);
-    this.testCase = testCase;
-    this.tester = new Tester(channel);
-  }
-
-  @Override
-  protected void onPreExecute() {
-    tester.setUp();
-  }
-
-  @SuppressWarnings("Finally")
-  @Override
-  protected String doInBackground(Void... ignored) {
-    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;
-    } finally {
-      try {
-        tester.tearDown();
-      } catch (RuntimeException ex) {
-        throw ex;
-      } catch (Exception ex) {
-        throw new RuntimeException(ex);
-      }
-    }
-  }
-
-  private void runTest(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);
-    }
-  }
-
-  @Override
-  protected void onPostExecute(String result) {
-    Listener listener = listenerReference.get();
-    if (listener != null) {
-      listener.onComplete(result);
-    }
-  }
-
-  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/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
index 004950e7380..17c7e24cbfa 100644
--- 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
@@ -18,8 +18,8 @@
 
 import android.content.Context;
 import android.content.Intent;
+import android.net.LocalSocketAddress.Namespace;
 import android.os.Bundle;
-import android.support.v7.app.AppCompatActivity;
 import android.text.TextUtils;
 import android.util.Log;
 import android.view.View;
@@ -28,22 +28,34 @@
 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, InteropTask.Listener {
+    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);
@@ -57,12 +69,26 @@ protected void onCreate(Bundle savedInstanceState) {
 
     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) {
@@ -91,21 +117,18 @@ private void enableButtons(boolean enable) {
     }
   }
 
-  @Override
-  public void onComplete(String result) {
-    resultText.setText(result);
-    enableButtons(true);
-  }
-
   private void startTest(String testCase) {
     ((InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE)).hideSoftInputFromWindow(
         hostEdit.getWindowToken(), 0);
     enableButtons(false);
-    resultText.setText("Testing...");
+    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;
@@ -116,10 +139,39 @@ private void startTest(String testCase) {
       serverHostOverride = null;
       testCert = null;
     }
-    ManagedChannel channel =
-        TesterOkHttpChannelBuilder.build(host, port, serverHostOverride, true, testCert);
 
-    new InteropTask(this, channel, testCase).execute();
+    // 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
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
index f4d8f5abcdc..a663378dbf3 100644
--- 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
@@ -16,7 +16,7 @@
 
 package io.grpc.android.integrationtest;
 
-import android.support.annotation.Nullable;
+import androidx.annotation.Nullable;
 import io.grpc.ChannelCredentials;
 import io.grpc.Grpc;
 import io.grpc.InsecureChannelCredentials;
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
index f1339330227..042da6437c0 100644
--- a/android-interop-testing/src/main/res/layout/activity_tester.xml
+++ b/android-interop-testing/src/main/res/layout/activity_tester.xml
@@ -16,6 +16,7 @@
         android:layout_weight="2"
         android:layout_width="0dp"
         android:layout_height="wrap_content"
+        android:inputType="text"
         android:hint="Enter Host"
         />
     <EditText
@@ -28,6 +29,28 @@
         />
   </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"
@@ -36,6 +59,7 @@
     <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>
@@ -46,6 +70,7 @@
       android:layout_height="wrap_content"
       android:onClick="startEmptyUnary"
       android:text="Empty Unary"
+      tools:ignore="OnClick"
       />
 
   <Button
@@ -54,6 +79,7 @@
       android:layout_height="wrap_content"
       android:onClick="startLargeUnary"
       android:text="Large Unary"
+      tools:ignore="OnClick"
       />
 
   <Button
@@ -62,6 +88,7 @@
       android:layout_height="wrap_content"
       android:onClick="startClientStreaming"
       android:text="Client Streaming"
+      tools:ignore="OnClick"
       />
 
   <Button
@@ -70,6 +97,7 @@
       android:layout_height="wrap_content"
       android:onClick="startServerStreaming"
       android:text="Server Streaming"
+      tools:ignore="OnClick"
       />
 
   <Button
@@ -78,6 +106,7 @@
       android:layout_height="wrap_content"
       android:onClick="startPingPong"
       android:text="Ping Pong"
+      tools:ignore="OnClick"
       />
 
   <TextView
diff --git a/android-interop-testing/src/main/res/values/strings.xml b/android-interop-testing/src/main/res/values/strings.xml
index 6d5cb2a79ce..33b28eb9456 100644
--- a/android-interop-testing/src/main/res/values/strings.xml
+++ b/android-interop-testing/src/main/res/values/strings.xml
@@ -1,3 +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
index 1fa8fbad937..e94bf03ff37 100644
--- a/android/build.gradle
+++ b/android/build.gradle
@@ -2,43 +2,49 @@ plugins {
     id "maven-publish"
 
     id "com.android.library"
-    id "digital.wup.android-maven-publish"
 }
 
 description = 'gRPC: Android'
 
 android {
-    compileSdkVersion 29
+    namespace = 'io.grpc.android'
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_8
+        targetCompatibility JavaVersion.VERSION_1_8
+    }
+    compileSdkVersion 34
     defaultConfig {
-        consumerProguardFiles "proguard-rules.txt"
-        minSdkVersion 16
-        targetSdkVersion 29
+        minSdkVersion 23
+        targetSdkVersion 33
         versionCode 1
         versionName "1.0"
         testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
     }
-    lintOptions { abortOnError true }
+    lintOptions { abortOnError = true }
+    publishing {
+        singleVariant('release') {
+            withSourcesJar()
+            withJavadocJar()
+        }
+    }
 }
 
 repositories {
     google()
-    jcenter()
 }
 
 dependencies {
-    api project(':grpc-core')
-    guavaDependency 'implementation'
+    api project(':grpc-api')
+    implementation project(':grpc-core')
+    implementation libraries.guava
     testImplementation project('::grpc-okhttp')
-    testImplementation libraries.androidx_test
+    testImplementation libraries.androidx.test.core
     testImplementation libraries.junit
-    testImplementation (libraries.robolectric) {
-        // Unreleased change: https://github.com/robolectric/robolectric/pull/5432
-        exclude group: 'com.google.auto.service', module: 'auto-service'
-    }
+    testImplementation libraries.robolectric
     testImplementation libraries.truth
 }
 
-task javadocs(type: Javadoc) {
+tasks.register("javadocs", Javadoc) {
     source = android.sourceSets.main.java.srcDirs
     classpath += files(android.getBootClasspath())
     classpath += files({
@@ -54,23 +60,23 @@ task javadocs(type: Javadoc) {
     }
 }
 
-task javadocJar(type: Jar, dependsOn: javadocs) {
-    classifier = 'javadoc'
+tasks.register("javadocJar", Jar) {
+    dependsOn javadocs
+    archiveClassifier = 'javadoc'
     from javadocs.destinationDir
 }
 
-task sourcesJar(type: Jar) {
-    classifier = 'sources'
+tasks.register("sourcesJar", Jar) {
+    archiveClassifier = 'sources'
     from android.sourceSets.main.java.srcDirs
 }
 
 publishing {
     publications {
         maven {
-            from components.android
-
-            artifact javadocJar
-            artifact sourcesJar
+            afterEvaluate {
+                from components.release
+            }
         }
     }
 }
diff --git a/android/proguard-rules.txt b/android/proguard-rules.txt
deleted file mode 100644
index dc17f4058ed..00000000000
--- a/android/proguard-rules.txt
+++ /dev/null
@@ -1,6 +0,0 @@
--keepclassmembers class io.grpc.okhttp.OkHttpChannelBuilder {
-  io.grpc.okhttp.OkHttpChannelBuilder forTarget(java.lang.String);
-  io.grpc.okhttp.OkHttpChannelBuilder scheduledExecutorService(java.util.concurrent.ScheduledExecutorService);
-  io.grpc.okhttp.OkHttpChannelBuilder sslSocketFactory(javax.net.ssl.SSLSocketFactory);
-  io.grpc.okhttp.OkHttpChannelBuilder transportExecutor(java.util.concurrent.Executor);
-}
diff --git a/android/src/main/AndroidManifest.xml b/android/src/main/AndroidManifest.xml
index 53836739596..d6bda33f101 100644
--- a/android/src/main/AndroidManifest.xml
+++ b/android/src/main/AndroidManifest.xml
@@ -1,5 +1,4 @@
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-    package="io.grpc.android">
+<manifest xmlns:android="http://schemas.android.com/apk/res/android" >
 
   <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
 
diff --git a/android/src/main/java/io/grpc/android/AndroidChannelBuilder.java b/android/src/main/java/io/grpc/android/AndroidChannelBuilder.java
index e09a58ae428..3a750e02795 100644
--- a/android/src/main/java/io/grpc/android/AndroidChannelBuilder.java
+++ b/android/src/main/java/io/grpc/android/AndroidChannelBuilder.java
@@ -27,18 +27,21 @@
 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;
-import javax.annotation.concurrent.GuardedBy;
 
 /**
  * Builds a {@link ManagedChannel} that, when provided with a {@link Context}, will automatically
@@ -54,14 +57,35 @@ public final class AndroidChannelBuilder extends ForwardingChannelBuilder<Androi
 
   private static final String LOG_TAG = "AndroidChannelBuilder";
 
-  @Nullable private static final Class<?> OKHTTP_CHANNEL_BUILDER_CLASS = findOkHttp();
+  @Nullable private static final ManagedChannelProvider OKHTTP_CHANNEL_PROVIDER = findOkHttp();
 
-  private static Class<?> findOkHttp() {
+  private static ManagedChannelProvider findOkHttp() {
+    Class<?> klassRaw;
     try {
-      return Class.forName("io.grpc.okhttp.OkHttpChannelBuilder");
+      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;
@@ -90,6 +114,9 @@ public static AndroidChannelBuilder forAddress(String name, int port) {
    */
   @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);
   }
@@ -109,18 +136,11 @@ public static AndroidChannelBuilder usingBuilder(ManagedChannelBuilder<?> builde
   }
 
   private AndroidChannelBuilder(String target) {
-    if (OKHTTP_CHANNEL_BUILDER_CLASS == null) {
-      throw new UnsupportedOperationException("No ManagedChannelBuilder found on the classpath");
-    }
-    try {
-      delegateBuilder =
-          (ManagedChannelBuilder)
-              OKHTTP_CHANNEL_BUILDER_CLASS
-                  .getMethod("forTarget", String.class)
-                  .invoke(null, target);
-    } catch (Exception e) {
-      throw new RuntimeException("Failed to create ManagedChannelBuilder", e);
+    if (OKHTTP_CHANNEL_PROVIDER == null) {
+      throw new UnsupportedOperationException("Unable to load OkHttpChannelProvider");
     }
+    delegateBuilder =
+        InternalManagedChannelProvider.builderForTarget(OKHTTP_CHANNEL_PROVIDER, target);
   }
 
   private AndroidChannelBuilder(ManagedChannelBuilder<?> delegateBuilder) {
@@ -136,6 +156,7 @@ public AndroidChannelBuilder context(Context context) {
   }
 
   @Override
+  @SuppressWarnings("deprecation") // Not extending ForwardingChannelBuilder2 to preserve ABI.
   protected ManagedChannelBuilder<?> delegate() {
     return delegateBuilder;
   }
@@ -150,7 +171,7 @@ public ManagedChannel build() {
 
   /**
    * Wraps an OkHttp channel and handles invoking the appropriate methods (e.g., {@link
-   * ManagedChannel#enterIdle) when the device network state changes.
+   * ManagedChannel#enterIdle}) when the device network state changes.
    */
   @VisibleForTesting
   static final class AndroidChannel extends ManagedChannel {
@@ -196,7 +217,6 @@ private void configureNetworkMonitoring() {
         connectivityManager.registerDefaultNetworkCallback(defaultNetworkCallback);
         unregisterRunnable =
             new Runnable() {
-              @TargetApi(Build.VERSION_CODES.LOLLIPOP)
               @Override
               public void run() {
                 connectivityManager.unregisterNetworkCallback(defaultNetworkCallback);
@@ -210,7 +230,6 @@ public void run() {
         context.registerReceiver(networkReceiver, networkIntentFilter);
         unregisterRunnable =
             new Runnable() {
-              @TargetApi(Build.VERSION_CODES.LOLLIPOP)
               @Override
               public void run() {
                 context.unregisterReceiver(networkReceiver);
@@ -293,11 +312,17 @@ private class DefaultNetworkCallback extends ConnectivityManager.NetworkCallback
       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 {
-      private boolean isConnected = false;
 
       @SuppressWarnings("deprecation")
       @Override
@@ -305,9 +330,8 @@ public void onReceive(Context context, Intent intent) {
         ConnectivityManager conn =
             (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
         android.net.NetworkInfo networkInfo = conn.getActiveNetworkInfo();
-        boolean wasConnected = isConnected;
-        isConnected = networkInfo != null && networkInfo.isConnected();
-        if (isConnected && !wasConnected) {
+
+        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
index 83367d93b32..c0884e4d7cf 100644
--- a/android/src/test/java/io/grpc/android/AndroidChannelBuilderTest.java
+++ b/android/src/test/java/io/grpc/android/AndroidChannelBuilderTest.java
@@ -152,12 +152,6 @@ public void networkChanges_api23() {
         .sendBroadcast(new Intent(ConnectivityManager.CONNECTIVITY_ACTION));
     assertThat(delegateChannel.enterIdleCount).isEqualTo(1);
 
-    // The broadcast receiver may fire when the active network status has not actually changed
-    ApplicationProvider
-        .getApplicationContext()
-        .sendBroadcast(new Intent(ConnectivityManager.CONNECTIVITY_ACTION));
-    assertThat(delegateChannel.enterIdleCount).isEqualTo(1);
-
     // Drop the connection
     shadowOf(connectivityManager).setActiveNetworkInfo(null);
     ApplicationProvider
diff --git a/api/BUILD.bazel b/api/BUILD.bazel
index b3ff0e3536d..6de00d6272d 100644
--- a/api/BUILD.bazel
+++ b/api/BUILD.bazel
@@ -1,14 +1,35 @@
+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 = [
-        "//context",
-        "@com_google_code_findbugs_jsr305//jar",
-        "@com_google_guava_failureaccess//jar",  # future transitive dep of Guava. See #5214
-        "@com_google_guava_guava//jar",
-        "@com_google_j2objc_j2objc_annotations//jar",
+        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"),
+    ],
+)
+
+java_library(
+    name = "test_fixtures",
+    testonly = 1,
+    srcs = glob([
+        "src/testFixtures/java/io/grpc/**/*.java",
+    ]),
+    visibility = ["//xds:__pkg__"],
+    deps = [
+        "//core",
+        artifact("com.google.code.findbugs:jsr305"),
+        artifact("com.google.errorprone:error_prone_annotations"),
+        artifact("com.google.guava:guava"),
+        artifact("com.google.truth:truth"),
+        artifact("junit:junit"),
+        artifact("org.mockito:mockito-core"),
     ],
 )
diff --git a/api/build.gradle b/api/build.gradle
index 1574cdd8b4a..745fa00b3f1 100644
--- a/api/build.gradle
+++ b/api/build.gradle
@@ -1,33 +1,84 @@
 plugins {
     id "java-library"
+    id "java-test-fixtures"
     id "maven-publish"
 
-    id "me.champeau.gradle.jmh"
+    id "me.champeau.jmh"
     id "ru.vyarus.animalsniffer"
 }
 
 description = 'gRPC: API'
 
-evaluationDependsOn(project(':grpc-context').path)
+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 {
-    api project(':grpc-context'),
-            libraries.jsr305
-    guavaDependency 'implementation'
-
-    testImplementation project(':grpc-context').sourceSets.test.output,
-            project(':grpc-testing'),
-            project(':grpc-grpclb')
-    testImplementation (libraries.guava_testlib) {
-        exclude group: 'junit', module: 'junit'
+    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"
+        }
     }
-    jmh project(':grpc-core')
+    signature (libraries.signature.android) {
+        artifact {
+            extension = "signature"
+        }
+    }
+}
 
-    signature "org.codehaus.mojo.signature:java17:1.0@signature"
-    signature "net.sf.androidscents.signature:android-api-level-14:4.0_r4@signature"
+animalsniffer {
+    annotation = 'io.grpc.IgnoreJRERequirement'
 }
 
-javadoc {
+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/context/src/main/java/io/grpc/Context.java b/api/src/context/java/io/grpc/Context.java
similarity index 96%
rename from context/src/main/java/io/grpc/Context.java
rename to api/src/context/java/io/grpc/Context.java
index 530052d7478..c19d2db9da3 100644
--- a/context/src/main/java/io/grpc/Context.java
+++ b/api/src/context/java/io/grpc/Context.java
@@ -57,26 +57,13 @@
  * </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
+ * 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}. For example:
- * <pre>
- *   CancellableContext withCancellation = Context.current().withCancellation();
- *   try {
- *     withCancellation.run(new Runnable() {
- *       public void run() {
- *         while (waitingForData() &amp;&amp; !Context.current().isCancelled()) {}
- *       }
- *     });
- *     doSomeWork();
- *   } catch (Throwable t) {
- *      withCancellation.cancel(t);
- *   }
- * </pre>
+ * 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.
@@ -821,7 +808,7 @@ public boolean isCurrent() {
      * <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.
+     *         {@code false} if the context was already cancelled.
      */
     @CanIgnoreReturnValue
     public boolean cancel(Throwable cause) {
@@ -955,7 +942,12 @@ public interface CancellationListener {
   }
 
   /**
-   * Key for indexing values stored in a 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;
@@ -1007,14 +999,6 @@ public String toString() {
    * subject to change.
    */
   public abstract static class Storage {
-    /**
-     * @deprecated This is an old API that is no longer used.
-     */
-    @Deprecated
-    public void attach(Context toAttach) {
-      throw new UnsupportedOperationException("Deprecated. Do not call.");
-    }
-
     /**
      * Implements {@link io.grpc.Context#attach}.
      *
@@ -1028,16 +1012,10 @@ public void attach(Context toAttach) {
      *        as the {@code toRestore} parameter. {@code null} is a valid return value, but see
      *        caution note.
      */
-    public Context doAttach(Context toAttach) {
-      // This is a default implementation to help migrate existing Storage implementations that
-      // have an attach() method but no doAttach() method.
-      Context current = current();
-      attach(toAttach);
-      return current;
-    }
+    public abstract Context doAttach(Context toAttach);
 
     /**
-     * Implements {@link io.grpc.Context#detach}
+     * 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
@@ -1050,7 +1028,7 @@ public Context doAttach(Context toAttach) {
      * Implements {@link io.grpc.Context#current}.
      *
      * <p>Caution: {@link Context} interprets a return value of {@code null} to mean the same
-     * thing as {@code Context{@link #ROOT}}.
+     * thing as {@link Context#ROOT}.
      *
      * <p>See also {@link #doAttach(Context)}.
      *
diff --git a/context/src/main/java/io/grpc/Deadline.java b/api/src/context/java/io/grpc/Deadline.java
similarity index 87%
rename from context/src/main/java/io/grpc/Deadline.java
rename to api/src/context/java/io/grpc/Deadline.java
index 73c87605953..92eeba5ffce 100644
--- a/context/src/main/java/io/grpc/Deadline.java
+++ b/api/src/context/java/io/grpc/Deadline.java
@@ -16,8 +16,10 @@
 
 package io.grpc;
 
-import java.util.Arrays;
+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;
@@ -33,7 +35,7 @@
  * passed to the various components unambiguously.
  */
 public final class Deadline implements Comparable<Deadline> {
-  private static final SystemTicker SYSTEM_TICKER = new SystemTicker();
+  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);
@@ -45,7 +47,7 @@ public final class Deadline implements Comparable<Deadline> {
    *
    * <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
-   * <href a="https://github.com/grpc/grpc-java/issues/6030">let us know</a>.
+   * <a href="https://github.com/grpc/grpc-java/issues/6030">let us know</a>.
    *
    * @since 1.24.0
    */
@@ -81,7 +83,7 @@ public static Deadline after(long duration, TimeUnit units) {
    *
    * <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
-   * <href a="https://github.com/grpc/grpc-java/issues/6030">let us know</a>.
+   * <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.
@@ -91,7 +93,7 @@ public static Deadline after(long duration, TimeUnit units) {
    * @since 1.24.0
    */
   public static Deadline after(long duration, TimeUnit units, Ticker ticker) {
-    checkNotNull(units, "units");
+    requireNonNull(units, "units");
     return new Deadline(ticker, units.toNanos(duration), true);
   }
 
@@ -113,7 +115,8 @@ private Deadline(Ticker ticker, long baseInstant, long offset,
   }
 
   /**
-   * Has this deadline expired
+   * Returns whether this has deadline expired.
+   *
    * @return {@code true} if it has, otherwise {@code false}.
    */
   public boolean isExpired() {
@@ -190,8 +193,8 @@ public long timeRemaining(TimeUnit unit) {
    * @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");
+    requireNonNull(task, "task");
+    requireNonNull(scheduler, "scheduler");
     return scheduler.schedule(task, deadlineNanos - ticker.nanoTime(), TimeUnit.NANOSECONDS);
   }
 
@@ -224,37 +227,27 @@ public String toString() {
   @Override
   public int compareTo(Deadline that) {
     checkTicker(that);
-    long diff = this.deadlineNanos - that.deadlineNanos;
-    if (diff < 0) {
-      return -1;
-    } else if (diff > 0) {
-      return 1;
-    }
-    return 0;
+    return Long.compare(this.deadlineNanos, that.deadlineNanos);
   }
 
   @Override
   public int hashCode() {
-    return Arrays.asList(this.ticker, this.deadlineNanos).hashCode();
+    return Objects.hash(this.ticker, this.deadlineNanos);
   }
 
   @Override
-  public boolean equals(final Object o) {
-    if (o == this) {
+  public boolean equals(final Object object) {
+    if (object == this) {
       return true;
     }
-    if (!(o instanceof Deadline)) {
-      return false;
-    }
-
-    final Deadline other = (Deadline) o;
-    if (this.ticker == null ? other.ticker != null : this.ticker != other.ticker) {
+    if (!(object instanceof Deadline)) {
       return false;
     }
-    if (this.deadlineNanos != other.deadlineNanos) {
+    final Deadline that = (Deadline) object;
+    if (this.ticker == null ? that.ticker != null : this.ticker != that.ticker) {
       return false;
     }
-    return true;
+    return this.deadlineNanos == that.deadlineNanos;
   }
 
   /**
@@ -266,7 +259,7 @@ public boolean equals(final Object o) {
    *
    * <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
-   * <href a="https://github.com/grpc/grpc-java/issues/6030">let us know</a>.
+   * <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.
@@ -274,24 +267,17 @@ public boolean equals(final Object o) {
    * @since 1.24.0
    */
   public abstract static class Ticker {
-    /** Returns the number of nanoseconds since this source's epoch. */
+    /** Returns the number of nanoseconds elapsed since this ticker's reference point in time. */
     public abstract long nanoTime();
   }
 
-  private static class SystemTicker extends Ticker {
+  private static final class SystemTicker extends Ticker {
     @Override
     public long nanoTime() {
       return System.nanoTime();
     }
   }
 
-  private static <T> T checkNotNull(T reference, Object errorMessage) {
-    if (reference == null) {
-      throw new NullPointerException(String.valueOf(errorMessage));
-    }
-    return reference;
-  }
-
   private void checkTicker(Deadline other) {
     if (ticker != other.ticker) {
       throw new AssertionError(
diff --git a/context/src/main/java/io/grpc/PersistentHashArrayMappedTrie.java b/api/src/context/java/io/grpc/PersistentHashArrayMappedTrie.java
similarity index 100%
rename from context/src/main/java/io/grpc/PersistentHashArrayMappedTrie.java
rename to api/src/context/java/io/grpc/PersistentHashArrayMappedTrie.java
diff --git a/context/src/main/java/io/grpc/ThreadLocalContextStorage.java b/api/src/context/java/io/grpc/ThreadLocalContextStorage.java
similarity index 100%
rename from context/src/main/java/io/grpc/ThreadLocalContextStorage.java
rename to api/src/context/java/io/grpc/ThreadLocalContextStorage.java
diff --git a/context/src/jmh/java/io/grpc/AttachDetachBenchmark.java b/api/src/jmh/java/io/grpc/AttachDetachBenchmark.java
similarity index 100%
rename from context/src/jmh/java/io/grpc/AttachDetachBenchmark.java
rename to api/src/jmh/java/io/grpc/AttachDetachBenchmark.java
diff --git a/context/src/jmh/java/io/grpc/ReadBenchmark.java b/api/src/jmh/java/io/grpc/ReadBenchmark.java
similarity index 100%
rename from context/src/jmh/java/io/grpc/ReadBenchmark.java
rename to api/src/jmh/java/io/grpc/ReadBenchmark.java
diff --git a/context/src/jmh/java/io/grpc/WriteBenchmark.java b/api/src/jmh/java/io/grpc/WriteBenchmark.java
similarity index 100%
rename from context/src/jmh/java/io/grpc/WriteBenchmark.java
rename to api/src/jmh/java/io/grpc/WriteBenchmark.java
diff --git a/api/src/main/java/io/grpc/Attributes.java b/api/src/main/java/io/grpc/Attributes.java
index b70cc2bc8c3..c8550d176b4 100644
--- a/api/src/main/java/io/grpc/Attributes.java
+++ b/api/src/main/java/io/grpc/Attributes.java
@@ -46,11 +46,13 @@
 @Immutable
 public final class Attributes {
 
-  private final Map<Key<?>, Object> data;
+  private final IdentityHashMap<Key<?>, Object> data;
 
-  public static final Attributes EMPTY = new Attributes(Collections.<Key<?>, Object>emptyMap());
+  private static final IdentityHashMap<Key<?>, Object> EMPTY_MAP =
+      new IdentityHashMap<Key<?>, Object>();
+  public static final Attributes EMPTY = new Attributes(EMPTY_MAP);
 
-  private Attributes(Map<Key<?>, Object> data) {
+  private Attributes(IdentityHashMap<Key<?>, Object> data) {
     assert data != null;
     this.data = data;
   }
@@ -108,10 +110,12 @@ public Builder toBuilder() {
   }
 
   /**
-   * Key for an key-value pair.
+   * 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;
 
@@ -211,18 +215,22 @@ public int 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 Map<Key<?>, Object> newdata;
+    private IdentityHashMap<Key<?>, Object> newdata;
 
     private Builder(Attributes base) {
       assert base != null;
       this.base = base;
     }
 
-    private Map<Key<?>, Object> data(int size) {
+    private IdentityHashMap<Key<?>, Object> data(int size) {
       if (newdata == null) {
-        newdata = new IdentityHashMap<>(size);
+        newdata = new IdentityHashMap<>(base.data.size() + size);
+        newdata.putAll(base.data);
+        base = null;
       }
+      assert base == null;
       return newdata;
     }
 
@@ -232,20 +240,18 @@ public <T> Builder set(Key<T> key, T value) {
     }
 
     /**
-     * Removes the key and associated value from the attribtues.
+     * Removes the key and associated value from the attributes.
      *
      * @since 1.22.0
      * @param key The key to remove
      * @return this
      */
-    @ExperimentalApi("https://github.com/grpc/grpc-java/issues/5777")
     public <T> Builder discard(Key<T> key) {
-      if (base.data.containsKey(key)) {
-        Map<Key<?>, Object> newBaseData = new IdentityHashMap<>(base.data);
-        newBaseData.remove(key);
-        base = new Attributes(newBaseData);
-      }
-      if (newdata != null) {
+      if (base != null) {
+        if (base.data.containsKey(key)) {
+          data(0).remove(key);
+        }
+      } else {
         newdata.remove(key);
       }
       return this;
@@ -261,11 +267,6 @@ public Builder setAll(Attributes other) {
      */
     public Attributes build() {
       if (newdata != null) {
-        for (Map.Entry<Key<?>, Object> entry : base.data.entrySet()) {
-          if (!newdata.containsKey(entry.getKey())) {
-            newdata.put(entry.getKey(), entry.getValue());
-          }
-        }
         base = new Attributes(newdata);
         newdata = null;
       }
diff --git a/api/src/main/java/io/grpc/CallCredentials.java b/api/src/main/java/io/grpc/CallCredentials.java
index 3e588e24027..eb92a6f15fa 100644
--- a/api/src/main/java/io/grpc/CallCredentials.java
+++ b/api/src/main/java/io/grpc/CallCredentials.java
@@ -43,7 +43,7 @@ public abstract class CallCredentials {
    * <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
+   * 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
@@ -56,18 +56,20 @@ public abstract void applyRequestMetadata(
       RequestInfo requestInfo, Executor appExecutor, CallCredentials.MetadataApplier applier);
 
   /**
-   * Should be a noop but never called; tries to make it clearer to implementors that they may break
-   * in the future.
+   * 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")
-  public abstract void thisUsesUnstableApi();
+  @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.
    */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1914")
   public abstract static class MetadataApplier {
     /**
      * Called when headers are successfully generated. They will be merged into the original
@@ -84,13 +86,19 @@ public abstract static class MetadataApplier {
   /**
    * The request-related information passed to {@code CallCredentials.applyRequestMetadata()}.
    */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1914")
   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.
      */
diff --git a/api/src/main/java/io/grpc/CallCredentials2.java b/api/src/main/java/io/grpc/CallCredentials2.java
deleted file mode 100644
index fdb7f51070a..00000000000
--- a/api/src/main/java/io/grpc/CallCredentials2.java
+++ /dev/null
@@ -1,73 +0,0 @@
-/*
- * 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;
-
-/**
- * The new interface for {@link CallCredentials}.
- *
- * <p>THIS CLASS NAME IS TEMPORARY and is part of a migration. This class will BE DELETED as it
- * replaces {@link CallCredentials} in short-term.  THIS CLASS IS ONLY REFERENCED BY IMPLEMENTIONS.
- * All consumers should be always referencing {@link CallCredentials}.
- *
- * @deprecated the new interface has been promoted into {@link CallCredentials}.  Implementations
- *             should switch back to "{@code extends CallCredentials}".
- */
-@Deprecated
-@ExperimentalApi("https://github.com/grpc/grpc-java/issues/4901")
-public abstract class CallCredentials2 extends CallCredentials {
-  /**
-   * 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 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.
-   */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1914")
-  public abstract void applyRequestMetadata(
-      RequestInfo requestInfo, Executor appExecutor, MetadataApplier applier);
-
-  @Override
-  public final void applyRequestMetadata(
-      RequestInfo requestInfo, Executor appExecutor,
-      final CallCredentials.MetadataApplier applier) {
-    applyRequestMetadata(requestInfo, appExecutor, new MetadataApplier() {
-        @Override
-        public void apply(Metadata headers) {
-          applier.apply(headers);
-        }
-
-        @Override
-        public void fail(Status status) {
-          applier.fail(status);
-        }
-      });
-  }
-
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1914")
-  public abstract static class MetadataApplier extends CallCredentials.MetadataApplier {}
-}
diff --git a/api/src/main/java/io/grpc/CallOptions.java b/api/src/main/java/io/grpc/CallOptions.java
index c7504a6506a..800bdfb6c90 100644
--- a/api/src/main/java/io/grpc/CallOptions.java
+++ b/api/src/main/java/io/grpc/CallOptions.java
@@ -17,16 +17,18 @@
 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.CheckReturnValue;
 import javax.annotation.Nullable;
 import javax.annotation.concurrent.Immutable;
 
@@ -41,42 +43,79 @@ public final class CallOptions {
   /**
    * A blank {@code CallOptions} that all fields are not set.
    */
-  public static final CallOptions DEFAULT = new CallOptions();
+  public static final CallOptions DEFAULT;
+
+  static {
+    Builder b = new Builder();
+    b.customOptions = new Object[0][2];
+    b.streamTracerFactories = Collections.emptyList();
+    DEFAULT = b.build();
+  }
 
-  // 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.
   @Nullable
-  private Deadline deadline;
-  
+  private final Deadline deadline;
+
   @Nullable
-  private Executor executor;
+  private final Executor executor;
 
   @Nullable
-  private String authority;
+  private final String authority;
 
   @Nullable
-  private CallCredentials credentials;
+  private final CallCredentials credentials;
 
   @Nullable
-  private String compressorName;
+  private final String compressorName;
 
-  private Object[][] customOptions;
+  private final Object[][] customOptions;
 
-  // Unmodifiable list
-  private List<ClientStreamTracer.Factory> streamTracerFactories = Collections.emptyList();
+  private final List<ClientStreamTracer.Factory> streamTracerFactories;
 
   /**
    * Opposite to fail fast.
    */
   @Nullable
-  private Boolean waitForReady;
+  private final Boolean waitForReady;
 
   @Nullable
-  private Integer maxInboundMessageSize;
+  private final Integer maxInboundMessageSize;
+  @Nullable
+  private final Integer maxOutboundMessageSize;
   @Nullable
-  private Integer maxOutboundMessageSize;
+  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
@@ -89,33 +128,32 @@ public final class CallOptions {
    */
   @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;
+    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) {
-    CallOptions newOptions = new CallOptions(this);
-    newOptions.credentials = credentials;
-    return newOptions;
+    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}.
+   * {@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.
    */
-  @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;
+    Builder builder = toBuilder(this);
+    builder.compressorName = compressorName;
+    return builder.build();
   }
 
   /**
@@ -127,9 +165,9 @@ public CallOptions withCompression(@Nullable String compressorName) {
    * @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;
+    Builder builder = toBuilder(this);
+    builder.deadline = deadline;
+    return builder.build();
   }
 
   /**
@@ -140,6 +178,11 @@ 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.
    */
@@ -156,9 +199,9 @@ public Deadline getDeadline() {
    * fails RPCs without sending them if unable to connect.
    */
   public CallOptions withWaitForReady() {
-    CallOptions newOptions = new CallOptions(this);
-    newOptions.waitForReady = Boolean.TRUE;
-    return newOptions;
+    Builder builder = toBuilder(this);
+    builder.waitForReady = Boolean.TRUE;
+    return builder.build();
   }
 
   /**
@@ -166,15 +209,54 @@ public CallOptions withWaitForReady() {
    * This method should be rarely used because the default is without 'wait for ready'.
    */
   public CallOptions withoutWaitForReady() {
-    CallOptions newOptions = new CallOptions(this);
-    newOptions.waitForReady = Boolean.FALSE;
-    return newOptions;
+    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.
    */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1704")
   @Nullable
   public String getCompressor() {
     return compressorName;
@@ -208,9 +290,9 @@ public CallCredentials getCredentials() {
    * executor specified with {@link ManagedChannelBuilder#executor}.
    */
   public CallOptions withExecutor(@Nullable Executor executor) {
-    CallOptions newOptions = new CallOptions(this);
-    newOptions.executor = executor;
-    return newOptions;
+    Builder builder = toBuilder(this);
+    builder.executor = executor;
+    return builder.build();
   }
 
   /**
@@ -221,13 +303,13 @@ public CallOptions withExecutor(@Nullable Executor executor) {
    */
   @ExperimentalApi("https://github.com/grpc/grpc-java/issues/2861")
   public CallOptions withStreamTracerFactory(ClientStreamTracer.Factory factory) {
-    CallOptions newOptions = new CallOptions(this);
     ArrayList<ClientStreamTracer.Factory> newList =
         new ArrayList<>(streamTracerFactories.size() + 1);
     newList.addAll(streamTracerFactories);
     newList.add(factory);
-    newOptions.streamTracerFactories = Collections.unmodifiableList(newList);
-    return newOptions;
+    Builder builder = toBuilder(this);
+    builder.streamTracerFactories = Collections.unmodifiableList(newList);
+    return builder.build();
   }
 
   /**
@@ -319,7 +401,7 @@ public <T> CallOptions withOption(Key<T> key, T value) {
     Preconditions.checkNotNull(key, "key");
     Preconditions.checkNotNull(value, "value");
 
-    CallOptions newOptions = new CallOptions(this);
+    Builder builder = toBuilder(this);
     int existingIdx = -1;
     for (int i = 0; i < customOptions.length; i++) {
       if (key.equals(customOptions[i][0])) {
@@ -328,18 +410,18 @@ public <T> CallOptions withOption(Key<T> key, T value) {
       }
     }
 
-    newOptions.customOptions = new Object[customOptions.length + (existingIdx == -1 ? 1 : 0)][2];
-    System.arraycopy(customOptions, 0, newOptions.customOptions, 0, customOptions.length);
+    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
-      newOptions.customOptions[customOptions.length] = new Object[] {key, value};
+      builder.customOptions[customOptions.length] = new Object[] {key, value};
     } else {
       // Replace an existing option
-      newOptions.customOptions[existingIdx] = new Object[] {key, value};
+      builder.customOptions[existingIdx] = new Object[] {key, value};
     }
 
-    return newOptions;
+    return builder.build();
   }
 
   /**
@@ -358,15 +440,16 @@ public <T> T getOption(Key<T> key) {
     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;
   }
 
-  private CallOptions() {
-    customOptions = new Object[0][2];
-  }
-
   /**
    * 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
@@ -387,9 +470,9 @@ Boolean getWaitForReady() {
   @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;
+    Builder builder = toBuilder(this);
+    builder.maxInboundMessageSize = maxSize;
+    return builder.build();
   }
 
   /**
@@ -398,9 +481,9 @@ public CallOptions withMaxInboundMessageSize(int maxSize) {
   @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;
+    Builder builder = toBuilder(this);
+    builder.maxOutboundMessageSize = maxSize;
+    return builder.build();
   }
 
   /**
@@ -422,19 +505,22 @@ public Integer getMaxOutboundMessageSize() {
   }
 
   /**
-   * Copy constructor.
+   * Copy CallOptions.
    */
-  private CallOptions(CallOptions other) {
-    deadline = other.deadline;
-    authority = other.authority;
-    credentials = other.credentials;
-    executor = other.executor;
-    compressorName = other.compressorName;
-    customOptions = other.customOptions;
-    waitForReady = other.waitForReady;
-    maxInboundMessageSize = other.maxInboundMessageSize;
-    maxOutboundMessageSize = other.maxOutboundMessageSize;
-    streamTracerFactories = other.streamTracerFactories;
+  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
@@ -449,6 +535,7 @@ public String toString() {
         .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/ChannelCredentials.java b/api/src/main/java/io/grpc/ChannelCredentials.java
index df02ac438be..d95fc375eb6 100644
--- a/api/src/main/java/io/grpc/ChannelCredentials.java
+++ b/api/src/main/java/io/grpc/ChannelCredentials.java
@@ -34,7 +34,6 @@
  * would only be used after {@code instanceof} checks (which must consider
  * {@code ChoiceChannelCredentials}!).
  */
-@ExperimentalApi("https://github.com/grpc/grpc-java/issues/7479")
 public abstract class ChannelCredentials {
   /**
    * Returns the ChannelCredentials stripped of its CallCredentials. In the future,
diff --git a/api/src/main/java/io/grpc/ChannelLogger.java b/api/src/main/java/io/grpc/ChannelLogger.java
index a0f6114fbc3..ce654ec9d5b 100644
--- a/api/src/main/java/io/grpc/ChannelLogger.java
+++ b/api/src/main/java/io/grpc/ChannelLogger.java
@@ -36,8 +36,8 @@ public abstract class ChannelLogger {
    * | ChannelLogger Level | Channelz Severity | Java Logger Level |
    * +---------------------+-------------------+-------------------+
    * | DEBUG               | N/A               | FINEST            |
-   * | INFO                | CT_INFO           | FINEST            |
-   * | WARNING             | CT_WARNING        | FINER             |
+   * | INFO                | CT_INFO           | FINER             |
+   * | WARNING             | CT_WARNING        | FINE             |
    * | ERROR               | CT_ERROR          | FINE              |
    * +---------------------+-------------------+-------------------+
    * </pre>
diff --git a/api/src/main/java/io/grpc/ChoiceChannelCredentials.java b/api/src/main/java/io/grpc/ChoiceChannelCredentials.java
index a32a6b4be97..55d9c592da3 100644
--- a/api/src/main/java/io/grpc/ChoiceChannelCredentials.java
+++ b/api/src/main/java/io/grpc/ChoiceChannelCredentials.java
@@ -26,7 +26,6 @@
  * Provides a list of {@link ChannelCredentials}, where any one may be used. The credentials are in
  * preference order.
  */
-@ExperimentalApi("https://github.com/grpc/grpc-java/issues/7479")
 public final class ChoiceChannelCredentials extends ChannelCredentials {
   /**
    * Constructs with the provided {@code creds} as options, with preferred credentials first.
diff --git a/api/src/main/java/io/grpc/ChoiceServerCredentials.java b/api/src/main/java/io/grpc/ChoiceServerCredentials.java
index df777bf2001..87777d2e912 100644
--- a/api/src/main/java/io/grpc/ChoiceServerCredentials.java
+++ b/api/src/main/java/io/grpc/ChoiceServerCredentials.java
@@ -25,7 +25,6 @@
  * Provides a list of {@link ServerCredentials}, where any one may be used. The credentials are in
  * preference order.
  */
-@ExperimentalApi("https://github.com/grpc/grpc-java/issues/7621")
 public final class ChoiceServerCredentials extends ServerCredentials {
   /**
    * Constructs with the provided {@code creds} as options, with preferred credentials first.
diff --git a/api/src/main/java/io/grpc/ClientCall.java b/api/src/main/java/io/grpc/ClientCall.java
index b572f1ee55b..c915c8beaac 100644
--- a/api/src/main/java/io/grpc/ClientCall.java
+++ b/api/src/main/java/io/grpc/ClientCall.java
@@ -67,7 +67,7 @@
  * manner, and notifies gRPC library to receive additional response after one is consumed by
  * a fictional <code>processResponse()</code>.
  *
- * <p><pre>
+ * <pre>
  *   call = channel.newCall(bidiStreamingMethod, callOptions);
  *   listener = new ClientCall.Listener&lt;FooResponse&gt;() {
  *     &#64;Override
@@ -108,6 +108,8 @@ public abstract class ClientCall<ReqT, RespT> {
    * 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> {
 
@@ -268,7 +270,6 @@ public boolean isReady() {
    * 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
   }
diff --git a/api/src/main/java/io/grpc/ClientInterceptors.java b/api/src/main/java/io/grpc/ClientInterceptors.java
index b6fe077f744..81d0cf6da24 100644
--- a/api/src/main/java/io/grpc/ClientInterceptors.java
+++ b/api/src/main/java/io/grpc/ClientInterceptors.java
@@ -236,7 +236,11 @@ public final void start(Listener<RespT> responseListener, Metadata headers) {
         // 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());
+        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
index 6259522487a..42e1fdfebea 100644
--- a/api/src/main/java/io/grpc/ClientStreamTracer.java
+++ b/api/src/main/java/io/grpc/ClientStreamTracer.java
@@ -19,7 +19,6 @@
 import static com.google.common.base.Preconditions.checkNotNull;
 
 import com.google.common.base.MoreObjects;
-import io.grpc.Grpc;
 import javax.annotation.concurrent.ThreadSafe;
 
 /**
@@ -28,6 +27,36 @@
 @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.
    */
@@ -41,35 +70,39 @@ public void inboundHeaders() {
   }
 
   /**
-   * Trailing metadata has been received from the server.
+   * 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 trailers the mutable trailing metadata.  Modifications to it 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.
-     *
-     * @param callOptions the effective CallOptions of the call
-     * @param headers the mutable headers of the stream. 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.
-     *
-     * @deprecated use {@link
-     * #newClientStreamTracer(io.grpc.ClientStreamTracer.StreamInfo, io.grpc.Metadata)} instead.
-     */
-    @Deprecated
-    public ClientStreamTracer newClientStreamTracer(CallOptions callOptions, Metadata headers) {
-      throw new UnsupportedOperationException("Not implemented");
-    }
-
     /**
      * Creates a {@link ClientStreamTracer} for a new client stream.  This is called inside the
      * transport when it's creating the stream.
@@ -81,9 +114,8 @@ public ClientStreamTracer newClientStreamTracer(CallOptions callOptions, Metadat
      *
      * @since 1.20.0
      */
-    @SuppressWarnings("deprecation")
     public ClientStreamTracer newClientStreamTracer(StreamInfo info, Metadata headers) {
-      return newClientStreamTracer(info.getCallOptions(), headers);
+      throw new UnsupportedOperationException("Not implemented");
     }
   }
 
@@ -97,27 +129,52 @@ public ClientStreamTracer newClientStreamTracer(StreamInfo info, Metadata header
    */
   @ExperimentalApi("https://github.com/grpc/grpc-java/issues/2861")
   public static final class StreamInfo {
-    private final Attributes transportAttrs;
     private final CallOptions callOptions;
+    private final int previousAttempts;
+    private final boolean isTransparentRetry;
+    private final boolean isHedging;
 
-    StreamInfo(Attributes transportAttrs, CallOptions callOptions) {
-      this.transportAttrs = checkNotNull(transportAttrs, "transportAttrs");
+    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 attributes of the transport that this stream was created on.
+     * Returns the number of preceding attempts for the RPC.
+     *
+     * @since 1.40.0
      */
-    @Grpc.TransportAttr
-    public Attributes getTransportAttrs() {
-      return transportAttrs;
+    public int getPreviousAttempts() {
+      return previousAttempts;
     }
 
     /**
-     * Returns the effective CallOptions of the call.
+     * Whether the stream is a transparent retry.
+     *
+     * @since 1.40.0
      */
-    public CallOptions getCallOptions() {
-      return callOptions;
+    public boolean isTransparentRetry() {
+      return isTransparentRetry;
+    }
+
+    /**
+     * Whether the stream is hedging.
+     *
+     * @since 1.74.0
+     */
+    public boolean isHedging() {
+      return isHedging;
     }
 
     /**
@@ -126,10 +183,12 @@ public CallOptions getCallOptions() {
      * @since 1.21.0
      */
     public Builder toBuilder() {
-      Builder builder = new Builder();
-      builder.setTransportAttrs(transportAttrs);
-      builder.setCallOptions(callOptions);
-      return builder;
+      return new Builder()
+          .setCallOptions(callOptions)
+          .setPreviousAttempts(previousAttempts)
+          .setIsTransparentRetry(isTransparentRetry)
+          .setIsHedging(isHedging);
+
     }
 
     /**
@@ -144,8 +203,10 @@ public static Builder newBuilder() {
     @Override
     public String toString() {
       return MoreObjects.toStringHelper(this)
-          .add("transportAttrs", transportAttrs)
           .add("callOptions", callOptions)
+          .add("previousAttempts", previousAttempts)
+          .add("isTransparentRetry", isTransparentRetry)
+          .add("isHedging", isHedging)
           .toString();
     }
 
@@ -155,27 +216,49 @@ public String toString() {
      * @since 1.21.0
      */
     public static final class Builder {
-      private Attributes transportAttrs = Attributes.EMPTY;
       private CallOptions callOptions = CallOptions.DEFAULT;
+      private int previousAttempts;
+      private boolean isTransparentRetry;
+      private boolean isHedging;
 
       Builder() {
       }
 
       /**
-       * Sets the attributes of the transport that this stream was created on.  This field is
-       * optional.
+       * Sets the effective CallOptions of the call.  This field is optional.
        */
-      @Grpc.TransportAttr
-      public Builder setTransportAttrs(Attributes transportAttrs) {
-        this.transportAttrs = checkNotNull(transportAttrs, "transportAttrs cannot be null");
+      public Builder setCallOptions(CallOptions callOptions) {
+        this.callOptions = checkNotNull(callOptions, "callOptions cannot be null");
         return this;
       }
 
       /**
-       * Sets the effective CallOptions of the call.  This field is optional.
+       * Set the number of preceding attempts of the RPC.
+       *
+       * @since 1.40.0
        */
-      public Builder setCallOptions(CallOptions callOptions) {
-        this.callOptions = checkNotNull(callOptions, "callOptions cannot be null");
+      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;
       }
 
@@ -183,7 +266,7 @@ public Builder setCallOptions(CallOptions callOptions) {
        * Builds a new StreamInfo.
        */
       public StreamInfo build() {
-        return new StreamInfo(transportAttrs, callOptions);
+        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/CompositeCallCredentials.java b/api/src/main/java/io/grpc/CompositeCallCredentials.java
index 1b3e5a52d5d..6a8ac3872ea 100644
--- a/api/src/main/java/io/grpc/CompositeCallCredentials.java
+++ b/api/src/main/java/io/grpc/CompositeCallCredentials.java
@@ -23,7 +23,7 @@
  * 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/7479")
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/1914")
 public final class CompositeCallCredentials extends CallCredentials {
   private final CallCredentials credentials1;
   private final CallCredentials credentials2;
@@ -40,9 +40,6 @@ public void applyRequestMetadata(
         new WrappingMetadataApplier(requestInfo, appExecutor, applier, Context.current()));
   }
 
-  @Override
-  public void thisUsesUnstableApi() {}
-
   private final class WrappingMetadataApplier extends MetadataApplier {
     private final RequestInfo requestInfo;
     private final Executor appExecutor;
diff --git a/api/src/main/java/io/grpc/CompositeChannelCredentials.java b/api/src/main/java/io/grpc/CompositeChannelCredentials.java
index 6f2324b71ac..3efa8b8627b 100644
--- a/api/src/main/java/io/grpc/CompositeChannelCredentials.java
+++ b/api/src/main/java/io/grpc/CompositeChannelCredentials.java
@@ -24,7 +24,6 @@
  * composite credential), then all of the {@code CallCredentials} should be used; one {@code
  * CallCredentials} does not override another.
  */
-@ExperimentalApi("https://github.com/grpc/grpc-java/issues/7479")
 public final class CompositeChannelCredentials extends ChannelCredentials {
   public static ChannelCredentials create(
       ChannelCredentials channelCreds, CallCredentials callCreds) {
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
index 677039b2517..a7407efb2e9 100644
--- a/api/src/main/java/io/grpc/ConnectivityState.java
+++ b/api/src/main/java/io/grpc/ConnectivityState.java
@@ -20,7 +20,7 @@
  * The connectivity states.
  *
  * @see <a href="https://github.com/grpc/grpc/blob/master/doc/connectivity-semantics-and-api.md">
- * more information</a>
+ *     more information</a>
  */
 @ExperimentalApi("https://github.com/grpc/grpc-java/issues/4359")
 public enum ConnectivityState {
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/EquivalentAddressGroup.java b/api/src/main/java/io/grpc/EquivalentAddressGroup.java
index 34b2957d836..2dd52fe7f21 100644
--- a/api/src/main/java/io/grpc/EquivalentAddressGroup.java
+++ b/api/src/main/java/io/grpc/EquivalentAddressGroup.java
@@ -40,11 +40,36 @@ public final class 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.authorityOverride");
+      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");
+  /**
+   * The backend service associated with this EquivalentAddressGroup.
+   */
+  @Attr
+  static final Attributes.Key<String> ATTR_BACKEND_SERVICE =
+      Attributes.Key.create("io.grpc.EquivalentAddressGroup.BACKEND_SERVICE");
+  /**
+   * Endpoint weight for load balancing purposes. While the type is Long, it must be a valid uint32.
+   * Must not be zero. The weight is proportional to the other endpoints; if an endpoint's weight is
+   * twice that of another endpoint, it is intended to receive twice the load.
+   */
+  @Attr
+  static final Attributes.Key<Long> ATTR_WEIGHT =
+      Attributes.Key.create("io.grpc.EquivalentAddressGroup.ATTR_WEIGHT");
+
   private final List<SocketAddress> addrs;
   private final Attributes attrs;
 
@@ -103,7 +128,9 @@ public Attributes getAttributes() {
 
   @Override
   public String toString() {
-    // TODO(zpencer): Summarize return value if addr is very large
+    // EquivalentAddressGroup is intended to contain a small number of addresses for the same
+    // endpoint(e.g., IPv4/IPv6). Aggregating many groups into a single EquivalentAddressGroup
+    // is no longer done, so this no longer needs summarization.
     return "[" + addrs + "/" + attrs + "]";
   }
 
@@ -123,6 +150,9 @@ public int hashCode() {
    */
   @Override
   public boolean equals(Object other) {
+    if (this == other) {
+      return true;
+    }
     if (!(other instanceof EquivalentAddressGroup)) {
       return false;
     }
diff --git a/api/src/main/java/io/grpc/FeatureFlags.java b/api/src/main/java/io/grpc/FeatureFlags.java
new file mode 100644
index 00000000000..0e414ed7b31
--- /dev/null
+++ b/api/src/main/java/io/grpc/FeatureFlags.java
@@ -0,0 +1,54 @@
+/*
+ * 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;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Strings;
+
+class FeatureFlags {
+  private static boolean enableRfc3986Uris = 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 = enableRfc3986Uris;
+    enableRfc3986Uris = value;
+    return prevValue;
+  }
+
+  /** Whether to parse targets as RFC 3986 URIs (true), or use {@link java.net.URI} (false). */
+  static boolean getRfc3986UrisEnabled() {
+    return enableRfc3986Uris;
+  }
+
+  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 FeatureFlags() {}
+}
diff --git a/api/src/main/java/io/grpc/ForwardingChannelBuilder.java b/api/src/main/java/io/grpc/ForwardingChannelBuilder.java
index 5fe0464bbc9..1202582421a 100644
--- a/api/src/main/java/io/grpc/ForwardingChannelBuilder.java
+++ b/api/src/main/java/io/grpc/ForwardingChannelBuilder.java
@@ -16,7 +16,6 @@
 
 package io.grpc;
 
-import com.google.common.base.MoreObjects;
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.Executor;
@@ -27,36 +26,39 @@
  * A {@link ManagedChannelBuilder} that delegates all its builder methods to another builder by
  * default.
  *
- * @param <T> The type of the subclass extending this abstract class.
+ * <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
  */
-@ExperimentalApi("https://github.com/grpc/grpc-java/issues/3363")
 public abstract class ForwardingChannelBuilder<T extends ForwardingChannelBuilder<T>>
-    extends ManagedChannelBuilder<T> {
-
+    extends ForwardingChannelBuilder2<T> {
   /**
    * The default constructor.
    */
-  protected ForwardingChannelBuilder() {}
-
-  /**
-   * This method serves to force sub classes to "hide" this static factory.
-   */
-  public static ManagedChannelBuilder<?> forAddress(String name, int port) {
-    throw new UnsupportedOperationException("Subclass failed to hide static factory");
+  protected ForwardingChannelBuilder() {
   }
 
-  /**
-   * This method serves to force sub classes to "hide" this static factory.
-   */
-  public static ManagedChannelBuilder<?> forTarget(String target) {
-    throw new UnsupportedOperationException("Subclass failed to hide static factory");
-  }
 
   /**
    * 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
@@ -126,12 +128,6 @@ public T defaultLoadBalancingPolicy(String policy) {
     return thisT();
   }
 
-  @Override
-  public T enableFullStreamDecompression() {
-    delegate().enableFullStreamDecompression();
-    return thisT();
-  }
-
   @Override
   public T decompressorRegistry(DecompressorRegistry registry) {
     delegate().decompressorRegistry(registry);
@@ -246,24 +242,10 @@ public T disableServiceConfigLookUp() {
     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.
    */
-  protected final T thisT() {
+  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/ForwardingServerBuilder.java b/api/src/main/java/io/grpc/ForwardingServerBuilder.java
index 27358d06992..d1f183dd824 100644
--- a/api/src/main/java/io/grpc/ForwardingServerBuilder.java
+++ b/api/src/main/java/io/grpc/ForwardingServerBuilder.java
@@ -17,6 +17,7 @@
 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;
@@ -29,7 +30,6 @@
  * @param <T> The type of the subclass extending this abstract class.
  * @since 1.34.0
  */
-@ExperimentalApi("https://github.com/grpc/grpc-java/issues/7393")
 public abstract class ForwardingServerBuilder<T extends ServerBuilder<T>> extends ServerBuilder<T> {
 
   /** The default constructor. */
@@ -38,6 +38,7 @@ 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");
   }
@@ -59,6 +60,12 @@ public T executor(@Nullable Executor executor) {
     return thisT();
   }
 
+  @Override
+  public T callExecutor(ServerCallExecutorSupplier executorSupplier) {
+    delegate().callExecutor(executorSupplier);
+    return thisT();
+  }
+
   @Override
   public T addService(ServerServiceDefinition service) {
     delegate().addService(service);
@@ -125,6 +132,48 @@ public T handshakeTimeout(long timeout, TimeUnit 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);
@@ -152,6 +201,12 @@ public Server build() {
     return delegate().build();
   }
 
+  @Override
+  public T addMetricSink(MetricSink metricSink) {
+    delegate().addMetricSink(metricSink);
+    return thisT();
+  }
+
   @Override
   public String toString() {
     return MoreObjects.toStringHelper(this).add("delegate", delegate()).toString();
diff --git a/api/src/main/java/io/grpc/ForwardingServerCall.java b/api/src/main/java/io/grpc/ForwardingServerCall.java
index 6e64e7764f9..d513d72dabf 100644
--- a/api/src/main/java/io/grpc/ForwardingServerCall.java
+++ b/api/src/main/java/io/grpc/ForwardingServerCall.java
@@ -32,6 +32,11 @@ 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.
@@ -49,10 +54,5 @@ protected SimpleForwardingServerCall(ServerCall<ReqT, RespT> delegate) {
     protected ServerCall<ReqT, RespT> delegate() {
       return delegate;
     }
-
-    @Override
-    public MethodDescriptor<ReqT, RespT> getMethodDescriptor() {
-      return delegate.getMethodDescriptor();
-    }
   }
 }
diff --git a/api/src/main/java/io/grpc/Grpc.java b/api/src/main/java/io/grpc/Grpc.java
index 7f9fc1caf93..a45c613fd18 100644
--- a/api/src/main/java/io/grpc/Grpc.java
+++ b/api/src/main/java/io/grpc/Grpc.java
@@ -38,7 +38,7 @@ private Grpc() {
   @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1710")
   @TransportAttr
   public static final Attributes.Key<SocketAddress> TRANSPORT_ATTR_REMOTE_ADDR =
-      Attributes.Key.create("remote-addr");
+      Attributes.Key.create("io.grpc.Grpc.TRANSPORT_ATTR_REMOTE_ADDR");
 
   /**
    * Attribute key for the local address of a transport.
@@ -46,7 +46,7 @@ private Grpc() {
   @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1710")
   @TransportAttr
   public static final Attributes.Key<SocketAddress> TRANSPORT_ATTR_LOCAL_ADDR =
-      Attributes.Key.create("local-addr");
+      Attributes.Key.create("io.grpc.Grpc.TRANSPORT_ATTR_LOCAL_ADDR");
 
   /**
    * Attribute key for SSL session of a transport.
@@ -54,7 +54,14 @@ private Grpc() {
   @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1710")
   @TransportAttr
   public static final Attributes.Key<SSLSession> TRANSPORT_ATTR_SSL_SESSION =
-      Attributes.Key.create("ssl-session");
+      Attributes.Key.create("io.grpc.Grpc.TRANSPORT_ATTR_SSL_SESSION");
+
+  /**
+   * The value for the custom label of per-RPC metrics. Defaults to empty string when unset. Must
+   * not be set to {@code null}.
+   */
+  public static final CallOptions.Key<String> CALL_OPTION_CUSTOM_LABEL =
+      CallOptions.Key.createWithDefault("io.grpc.Grpc.CALL_OPTION_CUSTOM_LABEL", "");
 
   /**
    * Annotation for transport attributes. It follows the annotation semantics defined
@@ -96,7 +103,6 @@ private Grpc() {
    *   <li>{@code "[2001:db8:85a3:8d3:1319:8a2e:370:7348]:443"}</li>
    * </ul>
    */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/7479")
   public static ManagedChannelBuilder<?> newChannelBuilder(
       String target, ChannelCredentials creds) {
     return ManagedChannelRegistry.getDefaultRegistry().newChannelBuilder(target, creds);
@@ -107,7 +113,6 @@ public static ManagedChannelBuilder<?> newChannelBuilder(
    * form an authority string and then passed to {@link #newChannelBuilder(String,
    * ChannelCredentials)}. IPv6 addresses are properly surrounded by square brackets ("[]").
    */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/7479")
   public static ManagedChannelBuilder<?> newChannelBuilderForAddress(
       String host, int port, ChannelCredentials creds) {
     return newChannelBuilder(authorityFromHostAndPort(host, port), creds);
@@ -131,7 +136,6 @@ private static String authorityFromHostAndPort(String host, int port) {
    * @param port the port to listen on
    * @param creds the server identity
    */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/7621")
   public static ServerBuilder<?> newServerBuilderForPort(int port, ServerCredentials creds) {
     return ServerRegistry.getDefaultRegistry().newServerBuilderForPort(port, creds);
   }
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
index 2d620523ff8..0df8dc452c1 100644
--- a/api/src/main/java/io/grpc/HttpConnectProxiedSocketAddress.java
+++ b/api/src/main/java/io/grpc/HttpConnectProxiedSocketAddress.java
@@ -23,17 +23,21 @@
 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.
  */
-@ExperimentalApi("https://github.com/grpc/grpc-java/issues/5279")
 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
@@ -42,6 +46,7 @@ public final class HttpConnectProxiedSocketAddress extends ProxiedSocketAddress
   private HttpConnectProxiedSocketAddress(
       SocketAddress proxyAddress,
       InetSocketAddress targetAddress,
+      Map<String, String> headers,
       @Nullable String username,
       @Nullable String password) {
     checkNotNull(proxyAddress, "proxyAddress");
@@ -54,6 +59,7 @@ private HttpConnectProxiedSocketAddress(
     }
     this.proxyAddress = proxyAddress;
     this.targetAddress = targetAddress;
+    this.headers = headers;
     this.username = username;
     this.password = password;
   }
@@ -88,6 +94,14 @@ 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)) {
@@ -96,13 +110,14 @@ public boolean equals(Object o) {
     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);
+    return Objects.hashCode(proxyAddress, targetAddress, username, password, headers);
   }
 
   @Override
@@ -110,6 +125,7 @@ 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)
@@ -130,6 +146,7 @@ public static final class Builder {
 
     private SocketAddress proxyAddress;
     private InetSocketAddress targetAddress;
+    private Map<String, String> headers = Collections.emptyMap();
     @Nullable
     private String username;
     @Nullable
@@ -154,6 +171,18 @@ public Builder setTargetAddress(InetSocketAddress 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}.
@@ -176,7 +205,8 @@ public Builder setPassword(@Nullable String password) {
      * Creates an {@code HttpConnectProxiedSocketAddress}.
      */
     public HttpConnectProxiedSocketAddress build() {
-      return new HttpConnectProxiedSocketAddress(proxyAddress, targetAddress, username, password);
+      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
index ec5ff959854..f198d9ae480 100644
--- a/api/src/main/java/io/grpc/InsecureChannelCredentials.java
+++ b/api/src/main/java/io/grpc/InsecureChannelCredentials.java
@@ -17,7 +17,6 @@
 package io.grpc;
 
 /** No client identity, authentication, or encryption is to be used. */
-@ExperimentalApi("https://github.com/grpc/grpc-java/issues/7479")
 public final class InsecureChannelCredentials extends ChannelCredentials {
   public static ChannelCredentials create() {
     return new InsecureChannelCredentials();
diff --git a/api/src/main/java/io/grpc/InsecureServerCredentials.java b/api/src/main/java/io/grpc/InsecureServerCredentials.java
index 959f63537fe..b33f64a688e 100644
--- a/api/src/main/java/io/grpc/InsecureServerCredentials.java
+++ b/api/src/main/java/io/grpc/InsecureServerCredentials.java
@@ -17,7 +17,6 @@
 package io.grpc;
 
 /** No server identity or encryption is to be used. */
-@ExperimentalApi("https://github.com/grpc/grpc-java/issues/7621")
 public final class InsecureServerCredentials extends ServerCredentials {
   public static ServerCredentials create() {
     return new InsecureServerCredentials();
diff --git a/api/src/main/java/io/grpc/InternalConfigSelector.java b/api/src/main/java/io/grpc/InternalConfigSelector.java
index fa8ac5c9c60..a63009361d4 100644
--- a/api/src/main/java/io/grpc/InternalConfigSelector.java
+++ b/api/src/main/java/io/grpc/InternalConfigSelector.java
@@ -32,10 +32,10 @@
 public abstract class InternalConfigSelector {
   @NameResolver.ResolutionResultAttr
   public static final Attributes.Key<io.grpc.InternalConfigSelector> KEY
-      = Attributes.Key.create("io.grpc.config-selector");
+      = Attributes.Key.create("internal:io.grpc.config-selector");
 
   // Use PickSubchannelArgs for SelectConfigArgs for now. May change over time.
-  /** Selects the config for an PRC. */
+  /** Selects the config for an RPC. */
   public abstract Result selectConfig(LoadBalancer.PickSubchannelArgs args);
 
   public static final class Result {
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/InternalEquivalentAddressGroup.java b/api/src/main/java/io/grpc/InternalEquivalentAddressGroup.java
new file mode 100644
index 00000000000..cd171208af7
--- /dev/null
+++ b/api/src/main/java/io/grpc/InternalEquivalentAddressGroup.java
@@ -0,0 +1,35 @@
+/*
+ * 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
+public final class InternalEquivalentAddressGroup {
+  private InternalEquivalentAddressGroup() {}
+
+  /**
+   * Endpoint weight for load balancing purposes. While the type is Long, it must be a valid uint32.
+   * Must not be zero. The weight is proportional to the other endpoints; if an endpoint's weight is
+   * twice that of another endpoint, it is intended to receive twice the load.
+   */
+  public static final Attributes.Key<Long> ATTR_WEIGHT = EquivalentAddressGroup.ATTR_WEIGHT;
+
+  /**
+   * The backend service associated with this EquivalentAddressGroup.
+   */
+  public static final Attributes.Key<String> ATTR_BACKEND_SERVICE =
+      EquivalentAddressGroup.ATTR_BACKEND_SERVICE;
+}
diff --git a/api/src/main/java/io/grpc/InternalFeatureFlags.java b/api/src/main/java/io/grpc/InternalFeatureFlags.java
new file mode 100644
index 00000000000..a1e771a7571
--- /dev/null
+++ b/api/src/main/java/io/grpc/InternalFeatureFlags.java
@@ -0,0 +1,41 @@
+/*
+ * 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;
+
+import com.google.common.annotations.VisibleForTesting;
+
+/** Global variables that govern major changes to the behavior of more than one grpc module. */
+@Internal
+public class InternalFeatureFlags {
+
+  /** Whether to parse targets as RFC 3986 URIs (true), or use {@link java.net.URI} (false). */
+  @VisibleForTesting
+  public static boolean setRfc3986UrisEnabled(boolean value) {
+    return FeatureFlags.setRfc3986UrisEnabled(value);
+  }
+
+  /** Whether to parse targets as RFC 3986 URIs (true), or use {@link java.net.URI} (false). */
+  public static boolean getRfc3986UrisEnabled() {
+    return FeatureFlags.getRfc3986UrisEnabled();
+  }
+
+  public static boolean getFlag(String envVarName, boolean enableByDefault) {
+    return FeatureFlags.getFlag(envVarName, enableByDefault);
+  }
+
+  private InternalFeatureFlags() {}
+}
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
index 2823882952f..cbf6b72aaf0 100644
--- a/api/src/main/java/io/grpc/InternalMetadata.java
+++ b/api/src/main/java/io/grpc/InternalMetadata.java
@@ -19,6 +19,7 @@
 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;
 
 /**
@@ -100,7 +101,7 @@ public static Object[] serializePartial(Metadata md) {
   /**
    * Creates a holder for a pre-parsed value read by the transport.
    *
-   * @param marshaller The {@link Metadata#BinaryStreamMarshaller} associated with this value.
+   * @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.
    */
diff --git a/api/src/main/java/io/grpc/InternalMethodDescriptor.java b/api/src/main/java/io/grpc/InternalMethodDescriptor.java
index 23bb039e0f1..345f6065813 100644
--- a/api/src/main/java/io/grpc/InternalMethodDescriptor.java
+++ b/api/src/main/java/io/grpc/InternalMethodDescriptor.java
@@ -30,10 +30,12 @@ public InternalMethodDescriptor(InternalKnownTransport transport) {
     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/InternalServerInterceptors.java b/api/src/main/java/io/grpc/InternalServerInterceptors.java
index 26c0b352b3a..e48c1468f1e 100644
--- a/api/src/main/java/io/grpc/InternalServerInterceptors.java
+++ b/api/src/main/java/io/grpc/InternalServerInterceptors.java
@@ -21,11 +21,6 @@
  */
 @Internal
 public final class InternalServerInterceptors {
-  public static <ReqT, RespT> ServerCallHandler<ReqT, RespT> interceptCallHandler(
-      ServerInterceptor interceptor, ServerCallHandler<ReqT, RespT> callHandler) {
-    return ServerInterceptors.InterceptCallHandler.create(interceptor, callHandler);
-  }
-
   public static <OrigReqT, OrigRespT, WrapReqT, WrapRespT>
       ServerMethodDefinition<WrapReqT, WrapRespT> wrapMethod(
       final ServerMethodDefinition<OrigReqT, OrigRespT> definition,
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
index c72e01db67a..debc786a82a 100644
--- a/api/src/main/java/io/grpc/InternalServiceProviders.java
+++ b/api/src/main/java/io/grpc/InternalServiceProviders.java
@@ -17,7 +17,9 @@
 package io.grpc;
 
 import com.google.common.annotations.VisibleForTesting;
+import java.util.Iterator;
 import java.util.List;
+import java.util.ServiceLoader;
 
 @Internal
 public final class InternalServiceProviders {
@@ -27,12 +29,17 @@ private InternalServiceProviders() {
   /**
    * Accessor for method.
    */
-  public static <T> T load(
+  @Deprecated
+  public static <T> List<T> loadAll(
       Class<T> klass,
-      Iterable<Class<?>> hardcoded,
+      Iterable<Class<?>> hardCodedClasses,
       ClassLoader classLoader,
       PriorityAccessor<T> priorityAccessor) {
-    return ServiceProviders.load(klass, hardcoded, classLoader, priorityAccessor);
+    return loadAll(
+        klass,
+        ServiceLoader.load(klass, classLoader).iterator(),
+        () -> hardCodedClasses,
+        priorityAccessor);
   }
 
   /**
@@ -40,10 +47,10 @@ public static <T> T load(
    */
   public static <T> List<T> loadAll(
       Class<T> klass,
-      Iterable<Class<?>> hardCodedClasses,
-      ClassLoader classLoader,
+      Iterator<T> serviceLoader,
+      Supplier<Iterable<Class<?>>> hardCodedClasses,
       PriorityAccessor<T> priorityAccessor) {
-    return ServiceProviders.loadAll(klass, hardCodedClasses, classLoader, priorityAccessor);
+    return ServiceProviders.loadAll(klass, serviceLoader, hardCodedClasses::get, priorityAccessor);
   }
 
   /**
@@ -71,4 +78,8 @@ public static boolean isAndroid(ClassLoader cl) {
   }
 
   public interface PriorityAccessor<T> extends ServiceProviders.PriorityAccessor<T> {}
+
+  public interface Supplier<T> {
+    T get();
+  }
 }
diff --git a/api/src/main/java/io/grpc/InternalStatus.java b/api/src/main/java/io/grpc/InternalStatus.java
index 9f6854a2de2..56df1decf38 100644
--- a/api/src/main/java/io/grpc/InternalStatus.java
+++ b/api/src/main/java/io/grpc/InternalStatus.java
@@ -16,6 +16,8 @@
 
 package io.grpc;
 
+import javax.annotation.Nullable;
+
 /**
  * Accesses internal data.  Do not use this.
  */
@@ -34,4 +36,13 @@ private InternalStatus() {}
    */
   @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/InternalTcpMetrics.java b/api/src/main/java/io/grpc/InternalTcpMetrics.java
new file mode 100644
index 00000000000..3dd89b6f76c
--- /dev/null
+++ b/api/src/main/java/io/grpc/InternalTcpMetrics.java
@@ -0,0 +1,98 @@
+/*
+ * 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;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * TCP Metrics defined to be shared across transport implementations.
+ * These metrics and their definitions are specified in
+ * <a href=
+ * "https://github.com/grpc/proposal/blob/master/A80-tcp-metrics.md">gRFC
+ * A80</a>.
+ */
+@Internal
+public final class InternalTcpMetrics {
+
+  private InternalTcpMetrics() {
+  }
+
+  private static final List<String> OPTIONAL_LABELS = Arrays.asList(
+      "network.local.address",
+      "network.local.port",
+      "network.peer.address",
+      "network.peer.port");
+
+  public static final DoubleHistogramMetricInstrument MIN_RTT_INSTRUMENT =
+      MetricInstrumentRegistry.getDefaultRegistry()
+          .registerDoubleHistogram(
+              "grpc.tcp.min_rtt",
+              "Minimum round-trip time of a TCP connection",
+              "s",
+              Collections.emptyList(),
+              Collections.emptyList(),
+              OPTIONAL_LABELS,
+              false);
+
+  public static final LongCounterMetricInstrument CONNECTIONS_CREATED_INSTRUMENT =
+      MetricInstrumentRegistry
+          .getDefaultRegistry()
+          .registerLongCounter(
+              "grpc.tcp.connections_created",
+              "The total number of TCP connections established.",
+              "{connection}",
+              Collections.emptyList(),
+              OPTIONAL_LABELS,
+              false);
+
+  public static final LongUpDownCounterMetricInstrument CONNECTION_COUNT_INSTRUMENT =
+      MetricInstrumentRegistry
+          .getDefaultRegistry()
+          .registerLongUpDownCounter(
+              "grpc.tcp.connection_count",
+              "The current number of active TCP connections.",
+              "{connection}",
+              Collections.emptyList(),
+              OPTIONAL_LABELS,
+              false);
+
+  public static final LongCounterMetricInstrument PACKETS_RETRANSMITTED_INSTRUMENT =
+      MetricInstrumentRegistry
+          .getDefaultRegistry()
+          .registerLongCounter(
+              "grpc.tcp.packets_retransmitted",
+              "The total number of packets retransmitted for all TCP connections.",
+              "{packet}",
+              Collections.emptyList(),
+              OPTIONAL_LABELS,
+              false);
+
+  public static final LongCounterMetricInstrument RECURRING_RETRANSMITS_INSTRUMENT =
+      MetricInstrumentRegistry
+          .getDefaultRegistry()
+          .registerLongCounter(
+              "grpc.tcp.recurring_retransmits",
+              "The total number of times the retransmit timer "
+                  + "popped for all TCP connections.",
+              "{timeout}",
+              Collections.emptyList(),
+              OPTIONAL_LABELS,
+              false);
+
+}
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/LoadBalancer.java b/api/src/main/java/io/grpc/LoadBalancer.java
index b0cf9791185..3187ae8ef1b 100644
--- a/api/src/main/java/io/grpc/LoadBalancer.java
+++ b/api/src/main/java/io/grpc/LoadBalancer.java
@@ -114,49 +114,94 @@ public abstract class LoadBalancer {
   @Internal
   @NameResolver.ResolutionResultAttr
   public static final Attributes.Key<Map<String, ?>> ATTR_HEALTH_CHECKING_CONFIG =
-      Attributes.Key.create("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.
+   * Handles newly resolved addresses and metadata attributes from name resolution system.
+   * Addresses 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
    *
-   * @param servers the resolved server addresses, never empty.
-   * @param attributes extra information from naming system.
-   * @deprecated override {@link #handleResolvedAddresses(ResolvedAddresses) instead}
-   * @since 1.2.0
+   * @deprecated  Use instead {@link #acceptResolvedAddresses(ResolvedAddresses)}
    */
   @Deprecated
-  public void handleResolvedAddressGroups(
-      List<EquivalentAddressGroup> servers,
-      @NameResolver.ResolutionResultAttr Attributes attributes) {
+  public void handleResolvedAddresses(ResolvedAddresses resolvedAddresses) {
     if (recursionCount++ == 0) {
-      handleResolvedAddresses(
-          ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(attributes).build());
+      // 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;
   }
 
   /**
-   * 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.
+   * 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 should not modify the given {@code servers}.
+   * @param resolvedAddresses the resolved server addresses, attributes, and config
+   * @return {@code Status.OK} if the resolved addresses were accepted, otherwise an error to report
+   *     to the name resolver
    *
-   * @param resolvedAddresses the resolved server addresses, attributes, and config.
-   * @since 1.21.0
+   * @since 1.49.0
    */
-  @SuppressWarnings("deprecation")
-  public void handleResolvedAddresses(ResolvedAddresses resolvedAddresses) {
-    if (recursionCount++ == 0) {
-      handleResolvedAddressGroups(
-          resolvedAddresses.getAddresses(), resolvedAddresses.getAttributes());
+  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;
     }
-    recursionCount = 0;
   }
 
   /**
@@ -166,7 +211,7 @@ public void handleResolvedAddresses(ResolvedAddresses resolvedAddresses) {
    *
    * @since 1.21.0
    */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1771")
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/11657")
   public static final class ResolvedAddresses {
     private final List<EquivalentAddressGroup> addresses;
     @NameResolver.ResolutionResultAttr
@@ -372,7 +417,16 @@ public void handleSubchannelState(
    *
    * <p>This method should always return a constant value.  It's not specified when this will be
    * called.
+   * 
+   * <p>Note that this method is only called when implementing {@code handleResolvedAddresses()}
+   * instead of {@code acceptResolvedAddresses()}.
+   *
+   * @deprecated Instead of overwriting this and {@code handleResolvedAddresses()}, only
+   *     overwrite {@code acceptResolvedAddresses()} which indicates if the addresses provided
+   *     by the name resolver are acceptable with the {@code boolean} return value.
    */
+  @Deprecated
+  @SuppressWarnings("InlineMeSuggester")
   public boolean canHandleEmptyAddressListFromNameResolution() {
     return false;
   }
@@ -406,18 +460,6 @@ public abstract static class SubchannelPicker {
      * @since 1.3.0
      */
     public abstract PickResult pickSubchannel(PickSubchannelArgs args);
-
-    /**
-     * Tries to establish connections now so that the upcoming RPC may then just pick a ready
-     * connection without having to connect first.
-     *
-     * <p>No-op if unsupported.
-     *
-     * @deprecated override {@link LoadBalancer#requestConnection} instead.
-     * @since 1.11.0
-     */
-    @Deprecated
-    public void requestConnection() {}
   }
 
   /**
@@ -450,6 +492,29 @@ public abstract static class PickSubchannelArgs {
      * @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");
+    }
   }
 
   /**
@@ -483,6 +548,7 @@ public static final class PickResult {
     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,
@@ -491,6 +557,17 @@ private PickResult(
       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;
     }
 
     /**
@@ -563,6 +640,8 @@ private PickResult(
      *                            stream is created at all in some cases.
      * @since 1.3.0
      */
+    // TODO(shivaspeaks): Need to deprecate old APIs and create new ones, 
+    // per https://github.com/grpc/grpc-java/issues/12662.
     public static PickResult withSubchannel(
         Subchannel subchannel, @Nullable ClientStreamTracer.Factory streamTracerFactory) {
       return new PickResult(
@@ -570,6 +649,19 @@ public static PickResult withSubchannel(
           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)}.
      *
@@ -579,6 +671,28 @@ public static PickResult withSubchannel(Subchannel subchannel) {
       return withSubchannel(subchannel, null);
     }
 
+    /**
+     * Creates a new {@code PickResult} with the given {@code subchannel},
+     * but retains all other properties from this {@code PickResult}.
+     *
+     * @since 1.80.0
+     */
+    public PickResult copyWithSubchannel(Subchannel subchannel) {
+      return new PickResult(checkNotNull(subchannel, "subchannel"), streamTracerFactory,
+          status, drop, authorityOverride);
+    }
+
+    /**
+     * Creates a new {@code PickResult} with the given {@code streamTracerFactory},
+     * but retains all other properties from this {@code PickResult}.
+     *
+     * @since 1.80.0
+     */
+    public PickResult copyWithStreamTracerFactory(
+        @Nullable ClientStreamTracer.Factory streamTracerFactory) {
+      return new PickResult(subchannel, streamTracerFactory, status, drop, authorityOverride);
+    }
+
     /**
      * 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
@@ -613,6 +727,13 @@ 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.
@@ -653,6 +774,13 @@ 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)
@@ -660,6 +788,7 @@ public String toString() {
           .add("streamTracerFactory", streamTracerFactory)
           .add("status", status)
           .add("drop", drop)
+          .add("authority-override", authorityOverride)
           .toString();
     }
 
@@ -758,14 +887,16 @@ public String 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 = new Object[0][2];
+      private Object[][] customOptions = EMPTY_CUSTOM_OPTIONS;
 
       Builder() {
       }
 
-      private <T> Builder copyCustomOptions(Object[][] options) {
+      private Builder copyCustomOptions(Object[][] options) {
         customOptions = new Object[options.length][2];
         System.arraycopy(options, 0, customOptions, 0, options.length);
         return this;
@@ -915,6 +1046,8 @@ public abstract static class Helper {
      *
      * <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) {
@@ -922,19 +1055,29 @@ public Subchannel createSubchannel(CreateSubchannelArgs args) {
     }
 
     /**
-     * Out-of-band channel for LoadBalancer’s own RPC needs, e.g., talking to an external
-     * load-balancer service.
+     * 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
      */
-    // TODO(ejona): Allow passing a List<EAG> here and to updateOobChannelAddresses, but want to
-    // wait until https://github.com/grpc/grpc-java/issues/4469 is done.
-    // https://github.com/grpc/grpc-java/issues/4618
     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
@@ -949,6 +1092,15 @@ public void updateOobChannelAddresses(ManagedChannel channel, EquivalentAddressG
       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
@@ -1045,10 +1197,36 @@ 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.
@@ -1084,6 +1262,13 @@ public ScheduledExecutorService getScheduledExecutorService() {
      */
     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.
      *
@@ -1134,6 +1319,16 @@ public NameResolver.Args getNameResolverArgs() {
     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() {};
+    }
   }
 
   /**
@@ -1211,7 +1406,8 @@ public void start(SubchannelStateListener listener) {
      */
     public final EquivalentAddressGroup getAddresses() {
       List<EquivalentAddressGroup> groups = getAllAddresses();
-      Preconditions.checkState(groups.size() == 1, "%s does not have exactly one group", groups);
+      Preconditions.checkState(groups != null && groups.size() == 1,
+          "%s does not have exactly one group", groups);
       return groups.get(0);
     }
 
@@ -1302,6 +1498,18 @@ public void updateAddresses(List<EquivalentAddressGroup> addrs) {
     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();
+    }
   }
 
   /**
@@ -1322,13 +1530,19 @@ public interface SubchannelStateListener {
      * 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
      *
+     * @param newState the new state
      * @since 1.22.0
      */
     void onSubchannelState(ConnectivityStateInfo newState);
@@ -1349,4 +1563,64 @@ public abstract static class Factory {
      */
     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
index bb4c574211e..7dc30d6baaf 100644
--- a/api/src/main/java/io/grpc/LoadBalancerProvider.java
+++ b/api/src/main/java/io/grpc/LoadBalancerProvider.java
@@ -81,7 +81,7 @@ public abstract class LoadBalancerProvider extends LoadBalancer.Factory {
    * @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>
+   *     A24-lb-policy-config.md</a>
    */
   public ConfigOrError parseLoadBalancingPolicyConfig(Map<String, ?> rawLoadBalancingPolicyConfig) {
     return UNKNOWN_CONFIG;
diff --git a/api/src/main/java/io/grpc/LoadBalancerRegistry.java b/api/src/main/java/io/grpc/LoadBalancerRegistry.java
index a215c4108d1..a8fbc102f5f 100644
--- a/api/src/main/java/io/grpc/LoadBalancerRegistry.java
+++ b/api/src/main/java/io/grpc/LoadBalancerRegistry.java
@@ -26,6 +26,7 @@
 import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.ServiceLoader;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 import javax.annotation.Nullable;
@@ -42,7 +43,6 @@
 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<>();
@@ -101,15 +101,15 @@ public static synchronized LoadBalancerRegistry getDefaultRegistry() {
     if (instance == null) {
       List<LoadBalancerProvider> providerList = ServiceProviders.loadAll(
           LoadBalancerProvider.class,
-          HARDCODED_CLASSES,
-          LoadBalancerProvider.class.getClassLoader(),
+          ServiceLoader
+            .load(LoadBalancerProvider.class, LoadBalancerProvider.class.getClassLoader())
+            .iterator(),
+          LoadBalancerRegistry::getHardCodedClasses,
           new LoadBalancerPriorityAccessor());
       instance = new LoadBalancerRegistry();
       for (LoadBalancerProvider provider : providerList) {
         logger.fine("Service loader found " + provider);
-        if (provider.isAvailable()) {
-          instance.addProvider(provider);
-        }
+        instance.addProvider(provider);
       }
       instance.refreshProviderMap();
     }
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/ManagedChannelBuilder.java b/api/src/main/java/io/grpc/ManagedChannelBuilder.java
index e4a4611541d..3f370ab3003 100644
--- a/api/src/main/java/io/grpc/ManagedChannelBuilder.java
+++ b/api/src/main/java/io/grpc/ManagedChannelBuilder.java
@@ -32,6 +32,11 @@ 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
    */
@@ -70,6 +75,11 @@ public static ManagedChannelBuilder<?> forAddress(String name, int port) {
    *   <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) {
@@ -107,7 +117,9 @@ public static ManagedChannelBuilder<?> forTarget(String target) {
   public abstract T executor(Executor executor);
 
   /**
-   * Provides a custom executor that will be used for operations that block or are expensive.
+   * 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.
@@ -119,7 +131,6 @@ public static ManagedChannelBuilder<?> forTarget(String target) {
    * @throws UnsupportedOperationException if unsupported
    * @since 1.25.0
    */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/6279")
   public T offloadExecutor(Executor executor) {
     throw new UnsupportedOperationException();
   }
@@ -148,6 +159,33 @@ public T offloadExecutor(Executor executor) {
    */
   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.
    *
@@ -194,14 +232,16 @@ public T usePlaintext() {
   }
 
   /**
-   * Makes the client use TLS.
+   * 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
    */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/3713")
   public T useTransportSecurity() {
     throw new UnsupportedOperationException();
   }
@@ -245,22 +285,6 @@ public T defaultLoadBalancingPolicy(String policy) {
     throw new UnsupportedOperationException();
   }
 
-  /**
-   * Enables full-stream decompression of inbound streams. This will cause the channel's outbound
-   * headers to advertise support for GZIP compressed streams, and gRPC servers which support the
-   * feature may respond with a GZIP compressed stream.
-   *
-   * <p>EXPERIMENTAL: This method is here to enable an experimental feature, and may be changed or
-   * removed once the feature is stable.
-   *
-   * @throws UnsupportedOperationException if unsupported
-   * @since 1.7.0
-   */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/3399")
-  public T enableFullStreamDecompression() {
-    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
@@ -350,7 +374,17 @@ public T maxInboundMetadataSize(int bytes) {
    * 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) {
@@ -365,6 +399,10 @@ public T keepAliveTime(long keepAliveTime, TimeUnit timeUnit) {
    * <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) {
@@ -382,6 +420,8 @@ public T keepAliveTimeout(long keepAliveTimeout, TimeUnit timeUnit) {
    *
    * @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) {
@@ -467,7 +507,6 @@ public T perRpcBufferLimit(long bytes) {
    * @return this
    * @since 1.11.0
    */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/3982")
   public T disableRetry() {
     throw new UnsupportedOperationException();
   }
@@ -479,13 +518,9 @@ public T disableRetry() {
    * 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}.
    *
-   * <p>For the current release, this method may have a side effect that disables Census stats and
-   * tracing.
-   *
    * @return this
    * @since 1.11.0
    */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/3982")
   public T enableRetry() {
     throw new UnsupportedOperationException();
   }
@@ -523,7 +558,6 @@ public T maxTraceEvents(int maxTraceEvents) {
    * @return this
    * @since 1.19.0
    */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/5113")
   public T proxyDetector(ProxyDetector proxyDetector) {
     throw new UnsupportedOperationException();
   }
@@ -560,10 +594,26 @@ public T proxyDetector(ProxyDetector proxyDetector) {
    *
    * <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.
-   * @return this
    * @since 1.20.0
    */
   @ExperimentalApi("https://github.com/grpc/grpc-java/issues/5189")
@@ -582,6 +632,35 @@ 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.
    *
diff --git a/api/src/main/java/io/grpc/ManagedChannelProvider.java b/api/src/main/java/io/grpc/ManagedChannelProvider.java
index f57340d9ba9..42941dfc809 100644
--- a/api/src/main/java/io/grpc/ManagedChannelProvider.java
+++ b/api/src/main/java/io/grpc/ManagedChannelProvider.java
@@ -17,6 +17,8 @@
 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.
@@ -79,6 +81,11 @@ protected NewChannelBuilderResult newChannelBuilder(String target, ChannelCreden
     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;
diff --git a/api/src/main/java/io/grpc/ManagedChannelRegistry.java b/api/src/main/java/io/grpc/ManagedChannelRegistry.java
index b13d47a90d0..ec47b325ffc 100644
--- a/api/src/main/java/io/grpc/ManagedChannelRegistry.java
+++ b/api/src/main/java/io/grpc/ManagedChannelRegistry.java
@@ -18,14 +18,20 @@
 
 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.ServiceLoader;
 import java.util.logging.Level;
 import java.util.logging.Logger;
-import javax.annotation.concurrent.GuardedBy;
 import javax.annotation.concurrent.ThreadSafe;
 
 /**
@@ -34,7 +40,7 @@
  *
  * @since 1.32.0
  */
-@ExperimentalApi("https://github.com/grpc/grpc-java/issues/7479")
+@Internal
 @ThreadSafe
 public final class ManagedChannelRegistry {
   private static final Logger logger = Logger.getLogger(ManagedChannelRegistry.class.getName());
@@ -95,15 +101,15 @@ public static synchronized ManagedChannelRegistry getDefaultRegistry() {
     if (instance == null) {
       List<ManagedChannelProvider> providerList = ServiceProviders.loadAll(
           ManagedChannelProvider.class,
-          getHardCodedClasses(),
-          ManagedChannelProvider.class.getClassLoader(),
+          ServiceLoader
+            .load(ManagedChannelProvider.class, ManagedChannelProvider.class.getClassLoader())
+            .iterator(),
+          ManagedChannelRegistry::getHardCodedClasses,
           new ManagedChannelPriorityAccessor());
       instance = new ManagedChannelRegistry();
       for (ManagedChannelProvider provider : providerList) {
         logger.fine("Service loader found " + provider);
-        if (provider.isAvailable()) {
-          instance.addProvider(provider);
-        }
+        instance.addProvider(provider);
       }
       instance.refreshProviders();
     }
@@ -140,10 +146,40 @@ static List<Class<?>> getHardCodedClasses() {
     } 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 {
+      String scheme =
+          FeatureFlags.getRfc3986UrisEnabled()
+              ? Uri.parse(target).getScheme()
+              : new URI(target).getScheme();
+      nameResolverProvider = nameResolverRegistry.getProviderForScheme(scheme);
+    } 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. "
@@ -152,6 +188,15 @@ ManagedChannelBuilder<?> newChannelBuilder(String target, ChannelCredentials cre
     }
     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) {
diff --git a/api/src/main/java/io/grpc/Metadata.java b/api/src/main/java/io/grpc/Metadata.java
index e153fd55691..8a958d127df 100644
--- a/api/src/main/java/io/grpc/Metadata.java
+++ b/api/src/main/java/io/grpc/Metadata.java
@@ -16,12 +16,14 @@
 
 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 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;
@@ -32,14 +34,14 @@
 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.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;
@@ -54,6 +56,7 @@
  */
 @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.
@@ -208,8 +211,8 @@ private int len() {
     return size * 2;
   }
 
+  /** checks when {@link #namesAndValues} is null or has no elements. */
   private boolean isEmpty() {
-    /** checks when {@link #namesAndValues} is null or has no elements */
     return size == 0;
   }
 
@@ -322,7 +325,7 @@ public Set<String> keys() {
     if (isEmpty()) {
       return Collections.emptySet();
     }
-    Set<String> ks = new HashSet<>(size);
+    Set<String> ks = Sets.newHashSetWithExpectedSize(size);
     for (int i = 0; i < size; i++) {
       ks.add(new String(name(i), 0 /* hibyte */));
     }
@@ -523,7 +526,7 @@ public void merge(Metadata other) {
   public void merge(Metadata other, Set<Key<?>> keys) {
     Preconditions.checkNotNull(other, "other");
     // Use ByteBuffer for equals and hashCode.
-    Map<ByteBuffer, Key<?>> asciiKeys = new HashMap<>(keys.size());
+    Map<ByteBuffer, Key<?>> asciiKeys = Maps.newHashMapWithExpectedSize(keys.size());
     for (Key<?> key : keys) {
       asciiKeys.put(ByteBuffer.wrap(key.asciiName()), key);
     }
@@ -733,6 +736,15 @@ private static BitSet generateValidTChars() {
     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) {
@@ -822,7 +834,7 @@ public String toString() {
     abstract T parseBytes(byte[] serialized);
 
     /**
-     * @return whether this key will be serialized to bytes lazily.
+     * Returns whether this key will be serialized to bytes lazily.
      */
     boolean serializesToStreams() {
       return false;
@@ -861,7 +873,7 @@ private BinaryKey(String name, BinaryMarshaller<T> marshaller) {
 
     @Override
     byte[] toBytes(T value) {
-      return marshaller.toBytes(value);
+      return Preconditions.checkNotNull(marshaller.toBytes(value), "null marshaller.toBytes()");
     }
 
     @Override
@@ -889,7 +901,7 @@ private LazyStreamBinaryKey(String name, BinaryStreamMarshaller<T> marshaller) {
 
     @Override
     byte[] toBytes(T value) {
-      return streamToBytes(marshaller.toStream(value));
+      return streamToBytes(checkNotNull(marshaller.toStream(value), "null marshaller.toStream()"));
     }
 
     @Override
@@ -920,7 +932,7 @@ static <T> LazyValue<T> create(Key<T> key, T value) {
     }
 
     InputStream toStream() {
-      return marshaller.toStream(value);
+      return checkNotNull(marshaller.toStream(value), "null marshaller.toStream()");
     }
 
     byte[] toBytes() {
@@ -967,7 +979,9 @@ private AsciiKey(String name, boolean pseudo, AsciiMarshaller<T> marshaller) {
 
     @Override
     byte[] toBytes(T value) {
-      return marshaller.toAsciiString(value).getBytes(US_ASCII);
+      String encoded = Preconditions.checkNotNull(
+          marshaller.toAsciiString(value), "null marshaller.toAsciiString()");
+      return encoded.getBytes(US_ASCII);
     }
 
     @Override
@@ -992,7 +1006,8 @@ private TrustedAsciiKey(String name, boolean pseudo, TrustedAsciiMarshaller<T> m
 
     @Override
     byte[] toBytes(T value) {
-      return marshaller.toAsciiString(value);
+      return Preconditions.checkNotNull(
+          marshaller.toAsciiString(value), "null marshaller.toAsciiString()");
     }
 
     @Override
diff --git a/api/src/main/java/io/grpc/MethodDescriptor.java b/api/src/main/java/io/grpc/MethodDescriptor.java
index c1b8a9ed723..a02eb840deb 100644
--- a/api/src/main/java/io/grpc/MethodDescriptor.java
+++ b/api/src/main/java/io/grpc/MethodDescriptor.java
@@ -20,9 +20,9 @@
 
 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.CheckReturnValue;
 import javax.annotation.Nullable;
 import javax.annotation.concurrent.Immutable;
 
@@ -158,7 +158,7 @@ public interface Marshaller<T> {
   }
 
   /**
-   * A marshaller that supports retrieving it's type parameter {@code T} at runtime.
+   * A marshaller that supports retrieving its type parameter {@code T} at runtime.
    *
    * @since 1.1.0
    */
@@ -265,7 +265,7 @@ public String getServiceName() {
   /**
    * A convenience method for {@code extractBareMethodName(getFullMethodName())}.
    *
-   * @since 1.32.0
+   * @since 1.33.0
    */
   @Nullable
   @ExperimentalApi("https://github.com/grpc/grpc-java/issues/5635")
@@ -324,7 +324,6 @@ public InputStream streamResponse(RespT response) {
    *
    * @since 1.1.0
    */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/2592")
   public Marshaller<ReqT> getRequestMarshaller() {
     return requestMarshaller;
   }
@@ -334,7 +333,6 @@ public Marshaller<ReqT> getRequestMarshaller() {
    *
    * @since 1.1.0
    */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/2592")
   public Marshaller<RespT> getResponseMarshaller() {
     return responseMarshaller;
   }
@@ -413,7 +411,7 @@ public static String extractFullServiceName(String fullMethodName) {
    * 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.32.0
+   * @since 1.33.0
    */
   @Nullable
   @ExperimentalApi("https://github.com/grpc/grpc-java/issues/5635")
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
index eb70eae31fd..e44a26309ae 100644
--- a/api/src/main/java/io/grpc/NameResolver.java
+++ b/api/src/main/java/io/grpc/NameResolver.java
@@ -20,18 +20,21 @@
 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.ArrayList;
 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;
 
 /**
@@ -50,7 +53,9 @@
  * <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 Helper#getSynchronizationContext}.
+ * {@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
  */
@@ -70,7 +75,12 @@ public abstract class NameResolver {
   public abstract String getServiceAuthority();
 
   /**
-   * Starts the resolution.
+   * 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
@@ -87,14 +97,26 @@ public void onError(Status error) {
 
           @Override
           public void onResult(ResolutionResult resolutionResult) {
-            listener.onAddresses(resolutionResult.getAddresses(), resolutionResult.getAttributes());
+            StatusOr<List<EquivalentAddressGroup>> addressesOrError =
+                resolutionResult.getAddressesOrError();
+            if (addressesOrError.hasValue()) {
+              listener.onAddresses(addressesOrError.getValue(),
+                  resolutionResult.getAttributes());
+            } else {
+              listener.onError(addressesOrError.getStatus());
+            }
           }
       });
     }
   }
 
   /**
-   * Starts the resolution.
+   * 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
@@ -131,128 +153,51 @@ public void refresh() {}
    */
   @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1770")
   public abstract static class Factory {
-    /**
-     * The port number used in case the target or the underlying naming system doesn't provide a
-     * port number.
-     *
-     * @deprecated this will be deleted along with {@link #newNameResolver(URI, Attributes)} in
-     *             a future release.
-     *
-     * @since 1.0.0
-     */
-    @Deprecated
-    public static final Attributes.Key<Integer> PARAMS_DEFAULT_PORT =
-        Attributes.Key.create("params-default-port");
-
-    /**
-     * If the NameResolver wants to support proxy, it should inquire this {@link ProxyDetector}.
-     * See documentation on {@link ProxyDetector} about how proxies work in gRPC.
-     *
-     * @deprecated this will be deleted along with {@link #newNameResolver(URI, Attributes)} in
-     *             a future release
-     */
-    @ExperimentalApi("https://github.com/grpc/grpc-java/issues/5113")
-    @Deprecated
-    public static final Attributes.Key<ProxyDetector> PARAMS_PROXY_DETECTOR =
-        Attributes.Key.create("params-proxy-detector");
-
-    @Deprecated
-    private static final Attributes.Key<SynchronizationContext> PARAMS_SYNC_CONTEXT =
-        Attributes.Key.create("params-sync-context");
-
-    @Deprecated
-    private static final Attributes.Key<ServiceConfigParser> PARAMS_PARSER =
-        Attributes.Key.create("params-parser");
-
     /**
      * 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}.
+     * <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.
      *
-     * @deprecated Implement {@link #newNameResolver(URI, NameResolver.Helper)} instead.  This is
-     *             going to be deleted in a future release.
+     * @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.0.0
+     * @since 1.21.0
      */
-    @Nullable
-    @Deprecated
-    public NameResolver newNameResolver(URI targetUri, final Attributes params) {
-      Args args = Args.newBuilder()
-          .setDefaultPort(params.get(PARAMS_DEFAULT_PORT))
-          .setProxyDetector(params.get(PARAMS_PROXY_DETECTOR))
-          .setSynchronizationContext(params.get(PARAMS_SYNC_CONTEXT))
-          .setServiceConfigParser(params.get(PARAMS_PARSER))
-          .build();
-      return newNameResolver(targetUri, args);
-    }
+    public abstract NameResolver newNameResolver(URI targetUri, final Args args);
 
     /**
-     * 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.
+     * Creates a {@link NameResolver} for the given target URI.
      *
-     * @param targetUri the target URI to be resolved, whose scheme must not be {@code null}
-     * @param helper utility that may be used by the NameResolver implementation
+     * <p>Implementations return {@code null} if 'targetUri' cannot be resolved by this factory. The
+     * decision should be solely based on the target's scheme.
      *
-     * @since 1.19.0
-     * @deprecated implement {@link #newNameResolver(URI, NameResolver.Args)} instead
-     */
-    @Deprecated
-    @Nullable
-    public NameResolver newNameResolver(URI targetUri, final Helper helper) {
-      return newNameResolver(
-          targetUri,
-          Attributes.newBuilder()
-              .set(PARAMS_DEFAULT_PORT, helper.getDefaultPort())
-              .set(PARAMS_PROXY_DETECTOR, helper.getProxyDetector())
-              .set(PARAMS_SYNC_CONTEXT, helper.getSynchronizationContext())
-              .set(PARAMS_PARSER, new ServiceConfigParser() {
-                  @Override
-                  public ConfigOrError parseServiceConfig(Map<String, ?> rawServiceConfig) {
-                    return helper.parseServiceConfig(rawServiceConfig);
-                  }
-                })
-              .build());
-    }
-
-    /**
-     * 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>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.
      *
-     * @param targetUri the target URI to be resolved, whose scheme must not be {@code null}
-     * @param args other information that may be useful
+     * <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.
      *
-     * @since 1.21.0
+     * @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
      */
-    @SuppressWarnings("deprecation")
-    // TODO(zhangkun83): make it abstract method after all other overrides have been deleted
-    public NameResolver newNameResolver(URI targetUri, final Args args) {
-      return newNameResolver(targetUri, new Helper() {
-          @Override
-          public int getDefaultPort() {
-            return args.getDefaultPort();
-          }
-
-          @Override
-          public ProxyDetector getProxyDetector() {
-            return args.getProxyDetector();
-          }
-
-          @Override
-          public SynchronizationContext getSynchronizationContext() {
-            return args.getSynchronizationContext();
-          }
-
-          @Override
-          public ConfigOrError parseServiceConfig(Map<String, ?> rawServiceConfig) {
-            return args.getServiceConfigParser().parseServiceConfig(rawServiceConfig);
-          }
-        });
+    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);
     }
 
     /**
@@ -310,20 +255,33 @@ void onAddresses(
   @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().setAddresses(servers).setAttributes(attributes).build());
+          ResolutionResult.newBuilder().setAddressesOrError(
+              StatusOr.fromValue(servers)).setAttributes(attributes).build());
     }
 
     /**
      * Handles updates on resolved addresses and attributes.  If
-     * {@link ResolutionResult#getAddresses()} is empty, {@link #onError(Status)} will be called.
+     * {@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
@@ -334,11 +292,31 @@ public final void onAddresses(
      * 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;
+    }
   }
 
   /**
@@ -350,61 +328,20 @@ public final void onAddresses(
   @Documented
   public @interface ResolutionResultAttr {}
 
-  /**
-   * A utility object passed to {@link Factory#newNameResolver(URI, NameResolver.Helper)}.
-   *
-   * @since 1.19.0
-   * @deprecated use {@link Args} instead.
-   */
-  @Deprecated
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1770")
-  public abstract static class Helper {
-    /**
-     * The port number used in case the target or the underlying naming system doesn't provide a
-     * port number.
-     *
-     * @since 1.19.0
-     */
-    public abstract int getDefaultPort();
-
-    /**
-     * 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.19.0
-     */
-    public abstract ProxyDetector getProxyDetector();
-
-    /**
-     * Returns the {@link SynchronizationContext} where {@link #start(Listener2)}, {@link #shutdown}
-     * and {@link #refresh} are run from.
-     *
-     * @since 1.20.0
-     */
-    public SynchronizationContext getSynchronizationContext() {
-      throw new UnsupportedOperationException("Not implemented");
-    }
-
-    /**
-     * 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.20.0
-     */
-    public ConfigOrError parseServiceConfig(Map<String, ?> rawServiceConfig) {
-      throw new UnsupportedOperationException("should have been implemented");
-    }
-  }
+  @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>Note this class doesn't override neither {@code equals()} nor {@code hashCode()}.
+   * <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
    */
@@ -417,22 +354,25 @@ public static final class Args {
     @Nullable private final ScheduledExecutorService scheduledExecutorService;
     @Nullable private final ChannelLogger channelLogger;
     @Nullable private final Executor executor;
-
-    private Args(
-        Integer defaultPort,
-        ProxyDetector proxyDetector,
-        SynchronizationContext syncContext,
-        ServiceConfigParser serviceConfigParser,
-        @Nullable ScheduledExecutorService scheduledExecutorService,
-        @Nullable ChannelLogger channelLogger,
-        @Nullable Executor executor) {
-      this.defaultPort = checkNotNull(defaultPort, "defaultPort not set");
-      this.proxyDetector = checkNotNull(proxyDetector, "proxyDetector not set");
-      this.syncContext = checkNotNull(syncContext, "syncContext not set");
-      this.serviceConfigParser = checkNotNull(serviceConfigParser, "serviceConfigParser not set");
-      this.scheduledExecutorService = scheduledExecutorService;
-      this.channelLogger = channelLogger;
-      this.executor = executor;
+    @Nullable private final String overrideAuthority;
+    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 != null ? builder.metricRecorder
+          : new MetricRecorder() {};
+      this.nameResolverRegistry = builder.nameResolverRegistry;
+      this.customArgs = cloneCustomArgs(builder.customArgs);
     }
 
     /**
@@ -441,6 +381,7 @@ private Args(
      *
      * @since 1.21.0
      */
+    // <p>TODO: Only meaningful for InetSocketAddress producers. Make this a custom arg?
     public int getDefaultPort() {
       return defaultPort;
     }
@@ -493,6 +434,30 @@ 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.
      *
@@ -513,11 +478,43 @@ public ChannelLogger getChannelLogger() {
      * @since 1.25.0
      */
     @Nullable
-    @ExperimentalApi("https://github.com/grpc/grpc-java/issues/6279")
     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.
+     */
+    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)
@@ -525,9 +522,13 @@ public String toString() {
           .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();
     }
 
@@ -545,6 +546,10 @@ public Builder toBuilder() {
       builder.setScheduledExecutorService(scheduledExecutorService);
       builder.setChannelLogger(channelLogger);
       builder.setOffloadExecutor(executor);
+      builder.setOverrideAuthority(overrideAuthority);
+      builder.setMetricRecorder(metricRecorder);
+      builder.setNameResolverRegistry(nameResolverRegistry);
+      builder.customArgs = cloneCustomArgs(customArgs);
       return builder;
     }
 
@@ -570,6 +575,10 @@ public static final class Builder {
       private ScheduledExecutorService scheduledExecutorService;
       private ChannelLogger channelLogger;
       private Executor executor;
+      private String overrideAuthority;
+      private MetricRecorder metricRecorder;
+      private NameResolverRegistry nameResolverRegistry;
+      private IdentityHashMap<Key<?>, Object> customArgs;
 
       Builder() {
       }
@@ -640,22 +649,91 @@ public Builder setChannelLogger(ChannelLogger channelLogger) {
        *
        * @since 1.25.0
        */
-      @ExperimentalApi("https://github.com/grpc/grpc-java/issues/6279")
       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 = checkNotNull(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(
-                defaultPort, proxyDetector, syncContext, serviceConfigParser,
-                scheduledExecutorService, channelLogger, executor);
+        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);
       }
     }
   }
@@ -688,17 +766,17 @@ public abstract static class ServiceConfigParser {
    */
   @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1770")
   public static final class ResolutionResult {
-    private final List<EquivalentAddressGroup> addresses;
+    private final StatusOr<List<EquivalentAddressGroup>> addressesOrError;
     @ResolutionResultAttr
     private final Attributes attributes;
     @Nullable
     private final ConfigOrError serviceConfig;
 
     ResolutionResult(
-        List<EquivalentAddressGroup> addresses,
+        StatusOr<List<EquivalentAddressGroup>> addressesOrError,
         @ResolutionResultAttr Attributes attributes,
         ConfigOrError serviceConfig) {
-      this.addresses = Collections.unmodifiableList(new ArrayList<>(addresses));
+      this.addressesOrError = addressesOrError;
       this.attributes = checkNotNull(attributes, "attributes");
       this.serviceConfig = serviceConfig;
     }
@@ -719,7 +797,7 @@ public static Builder newBuilder() {
      */
     public Builder toBuilder() {
       return newBuilder()
-          .setAddresses(addresses)
+          .setAddressesOrError(addressesOrError)
           .setAttributes(attributes)
           .setServiceConfig(serviceConfig);
     }
@@ -728,9 +806,20 @@ public Builder toBuilder() {
      * Gets the addresses resolved by name resolution.
      *
      * @since 1.21.0
+     * @deprecated Will be superseded by getAddressesOrError
      */
+    @Deprecated
     public List<EquivalentAddressGroup> getAddresses() {
-      return addresses;
+      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;
     }
 
     /**
@@ -745,7 +834,7 @@ public Attributes getAttributes() {
     }
 
     /**
-     * Gets the Service Config parsed by {@link NameResolver.Helper#parseServiceConfig(Map)}.
+     * Gets the Service Config parsed by {@link Args#getServiceConfigParser}.
      *
      * @since 1.21.0
      */
@@ -756,11 +845,11 @@ public ConfigOrError getServiceConfig() {
 
     @Override
     public String toString() {
-      return MoreObjects.toStringHelper(this)
-          .add("addresses", addresses)
-          .add("attributes", attributes)
-          .add("serviceConfig", serviceConfig)
-          .toString();
+      ToStringHelper stringHelper = MoreObjects.toStringHelper(this);
+      stringHelper.add("addressesOrError", addressesOrError.toString());
+      stringHelper.add("attributes", attributes);
+      stringHelper.add("serviceConfigOrError", serviceConfig);
+      return stringHelper.toString();
     }
 
     /**
@@ -772,7 +861,7 @@ public boolean equals(Object obj) {
         return false;
       }
       ResolutionResult that = (ResolutionResult) obj;
-      return Objects.equal(this.addresses, that.addresses)
+      return Objects.equal(this.addressesOrError, that.addressesOrError)
           && Objects.equal(this.attributes, that.attributes)
           && Objects.equal(this.serviceConfig, that.serviceConfig);
     }
@@ -782,7 +871,7 @@ public boolean equals(Object obj) {
      */
     @Override
     public int hashCode() {
-      return Objects.hashCode(addresses, attributes, serviceConfig);
+      return Objects.hashCode(addressesOrError, attributes, serviceConfig);
     }
 
     /**
@@ -792,7 +881,8 @@ public int hashCode() {
      */
     @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1770")
     public static final class Builder {
-      private List<EquivalentAddressGroup> addresses = Collections.emptyList();
+      private StatusOr<List<EquivalentAddressGroup>> addresses =
+          StatusOr.fromValue(Collections.emptyList());
       private Attributes attributes = Attributes.EMPTY;
       @Nullable
       private ConfigOrError serviceConfig;
@@ -804,9 +894,21 @@ public static final class 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) {
-        this.addresses = 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;
       }
 
@@ -822,7 +924,7 @@ public Builder setAttributes(Attributes attributes) {
       }
 
       /**
-       * Sets the Service Config parsed by {@link NameResolver.Helper#parseServiceConfig(Map)}.
+       * Sets the Service Config parsed by {@link Args#getServiceConfigParser}.
        * This field is optional.
        *
        * @since 1.21.0
@@ -929,4 +1031,10 @@ public String 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
index 6cf6e371611..70e22e366d5 100644
--- a/api/src/main/java/io/grpc/NameResolverProvider.java
+++ b/api/src/main/java/io/grpc/NameResolverProvider.java
@@ -16,7 +16,11 @@
 
 package io.grpc;
 
-import java.util.List;
+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.
@@ -33,38 +37,6 @@
  */
 @ExperimentalApi("https://github.com/grpc/grpc-java/issues/4159")
 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.
-   *
-   * @since 1.0.0
-   */
-  @SuppressWarnings("unused") // Avoids outside callers accidentally depending on the super class.
-  @Deprecated
-  public static final Attributes.Key<Integer> PARAMS_DEFAULT_PORT =
-      NameResolver.Factory.PARAMS_DEFAULT_PORT;
-
-  /**
-   * Returns non-{@code null} ClassLoader-wide providers, in preference order.
-   *
-   * @since 1.0.0
-   * @deprecated Has no replacement
-   */
-  @Deprecated
-  public static List<NameResolverProvider> providers() {
-    return NameResolverRegistry.getDefaultRegistry().providers();
-  }
-
-  /**
-   * @since 1.0.0
-   * @deprecated Use NameResolverRegistry.getDefaultRegistry().asFactory()
-   */
-  @Deprecated
-  public static NameResolver.Factory asFactory() {
-    return NameResolverRegistry.getDefaultRegistry().asFactory();
-  }
-
   /**
    * Whether this provider is available for use, taking the current environment into consideration.
    * If {@code false}, no other methods are safe to be called.
@@ -82,4 +54,28 @@ public static NameResolver.Factory asFactory() {
    * @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
index 2e914e2fbc1..c5e9f7467ab 100644
--- a/api/src/main/java/io/grpc/NameResolverRegistry.java
+++ b/api/src/main/java/io/grpc/NameResolverRegistry.java
@@ -19,16 +19,20 @@
 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.Comparator;
+import java.util.HashMap;
 import java.util.LinkedHashSet;
 import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.ServiceLoader;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 import javax.annotation.Nullable;
-import javax.annotation.concurrent.GuardedBy;
 import javax.annotation.concurrent.ThreadSafe;
 
 /**
@@ -44,12 +48,27 @@ public final class NameResolverRegistry {
   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<>();
-  /** Immutable, sorted version of {@code allProviders}. Is replaced instead of mutating. */
+  /** Generated from {@code allProviders}. Is mapping from scheme key to the highest priority
+   * {@link NameResolverProvider}. Is replaced instead of mutating. */
   @GuardedBy("this")
-  private List<NameResolverProvider> effectiveProviders = Collections.emptyList();
+  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.
@@ -81,16 +100,23 @@ public synchronized void deregister(NameResolverProvider provider) {
   }
 
   private synchronized void refreshProviders() {
-    List<NameResolverProvider> 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<NameResolverProvider>() {
-      @Override
-      public int compare(NameResolverProvider o1, NameResolverProvider o2) {
-        return o1.priority() - o2.priority();
+    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 = Collections.unmodifiableList(providers);
+    }
+    effectiveProviders = ImmutableMap.copyOf(refreshedProviders);
+    defaultScheme = refreshedDefaultScheme;
   }
 
   /**
@@ -100,8 +126,10 @@ public static synchronized NameResolverRegistry getDefaultRegistry() {
     if (instance == null) {
       List<NameResolverProvider> providerList = ServiceProviders.loadAll(
           NameResolverProvider.class,
-          getHardCodedClasses(),
-          NameResolverProvider.class.getClassLoader(),
+          ServiceLoader
+            .load(NameResolverProvider.class, NameResolverProvider.class.getClassLoader())
+            .iterator(),
+          NameResolverRegistry::getHardCodedClasses,
           new NameResolverPriorityAccessor());
       if (providerList.isEmpty()) {
         logger.warning("No NameResolverProviders found via ServiceLoader, including for DNS. This "
@@ -110,9 +138,7 @@ public static synchronized NameResolverRegistry getDefaultRegistry() {
       instance = new NameResolverRegistry();
       for (NameResolverProvider provider : providerList) {
         logger.fine("Service loader found " + provider);
-        if (provider.isAvailable()) {
-          instance.addProvider(provider);
-        }
+        instance.addProvider(provider);
       }
       instance.refreshProviders();
     }
@@ -120,10 +146,11 @@ public static synchronized NameResolverRegistry getDefaultRegistry() {
   }
 
   /**
-   * Returns effective providers, in priority order.
+   * Returns effective providers map from scheme to the highest priority NameResolverProvider of
+   * that scheme.
    */
   @VisibleForTesting
-  synchronized List<NameResolverProvider> providers() {
+  synchronized Map<String, NameResolverProvider> providers() {
     return effectiveProviders;
   }
 
@@ -142,6 +169,11 @@ static List<Class<?>> getHardCodedClasses() {
     } 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);
   }
 
@@ -149,23 +181,20 @@ private final class NameResolverFactory extends NameResolver.Factory {
     @Override
     @Nullable
     public NameResolver newNameResolver(URI targetUri, NameResolver.Args args) {
-      List<NameResolverProvider> providers = providers();
-      for (NameResolverProvider provider : providers) {
-        NameResolver resolver = provider.newNameResolver(targetUri, args);
-        if (resolver != null) {
-          return resolver;
-        }
-      }
-      return null;
+      NameResolverProvider provider = getProviderForScheme(targetUri.getScheme());
+      return provider == null ? null : provider.newNameResolver(targetUri, args);
+    }
+
+    @Override
+    @Nullable
+    public NameResolver newNameResolver(io.grpc.Uri targetUri, NameResolver.Args args) {
+      NameResolverProvider provider = getProviderForScheme(targetUri.getScheme());
+      return provider == null ? null : provider.newNameResolver(targetUri, args);
     }
 
     @Override
     public String getDefaultScheme() {
-      List<NameResolverProvider> providers = providers();
-      if (providers.isEmpty()) {
-        return "unknown";
-      }
-      return providers.get(0).getDefaultScheme();
+      return NameResolverRegistry.this.getDefaultScheme();
     }
   }
 
diff --git a/api/src/main/java/io/grpc/PartialForwardingServerCall.java b/api/src/main/java/io/grpc/PartialForwardingServerCall.java
index 8b95d7ae3fe..a313407b23e 100644
--- a/api/src/main/java/io/grpc/PartialForwardingServerCall.java
+++ b/api/src/main/java/io/grpc/PartialForwardingServerCall.java
@@ -20,7 +20,7 @@
 
 /**
  * A {@link ServerCall} which forwards all of it's methods to another {@link ServerCall} which
- * may have a different onMessage() message type.
+ * may have a different sendMessage() message type.
  */
 abstract class PartialForwardingServerCall<ReqT, RespT> extends ServerCall<ReqT, RespT> {
   /**
@@ -54,11 +54,16 @@ public boolean 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/11021")
+  public void setOnReadyThreshold(int numBytes) {
+    delegate().setOnReadyThreshold(numBytes);
+  }
+
   @Override
   @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1704")
   public void setCompression(String compressor) {
@@ -75,6 +80,12 @@ public Attributes getAttributes() {
   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() {
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
index 67d78374376..56b543b5cbd 100644
--- a/api/src/main/java/io/grpc/ProxiedSocketAddress.java
+++ b/api/src/main/java/io/grpc/ProxiedSocketAddress.java
@@ -22,7 +22,6 @@
  * An address that contains the information about making a connection via a proxy.  It is created by
  * a {@link ProxyDetector}.
  */
-@ExperimentalApi("https://github.com/grpc/grpc-java/issues/5279")
 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
index 5202516bca7..1d3686f40eb 100644
--- a/api/src/main/java/io/grpc/ProxyDetector.java
+++ b/api/src/main/java/io/grpc/ProxyDetector.java
@@ -32,7 +32,7 @@
  * underlying transport need to work together.
  *
  * <p>The {@link NameResolver} should invoke the {@link ProxyDetector} retrieved from the {@link
- * NameResolver.Helper#getProxyDetector}, and pass the returned {@link ProxiedSocketAddress} to
+ * 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.
  *
@@ -46,7 +46,6 @@
  * Netty transport and the OkHttp transport currently only support {@link
  * HttpConnectProxiedSocketAddress} which is returned by the default {@code ProxyDetector}.
  */
-@ExperimentalApi("https://github.com/grpc/grpc-java/issues/5279")
 public interface ProxyDetector {
   /**
    * Given a target address, returns a proxied address if a proxy should be used. If no proxy should
diff --git a/api/src/main/java/io/grpc/QueryParams.java b/api/src/main/java/io/grpc/QueryParams.java
new file mode 100644
index 00000000000..31bc2e0e6da
--- /dev/null
+++ b/api/src/main/java/io/grpc/QueryParams.java
@@ -0,0 +1,289 @@
+/*
+ * 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;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.base.Splitter;
+import java.io.UnsupportedEncodingException;
+import java.net.URLDecoder;
+import java.net.URLEncoder;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+import javax.annotation.Nullable;
+
+/**
+ * A parser and mutable container class for {@code application/x-www-form-urlencoded}-style URL
+ * parameters as conceived by <a href="https://datatracker.ietf.org/doc/html/rfc1866#section-8.2.1">
+ * RFC 1866 Section 8.2.1</a>.
+ *
+ * <p>For example, a URI like {@code "http://who?name=John+Doe&role=admin&role=user&active"} has:
+ *
+ * <ul>
+ *   <li>A key {@code name} with value {@code John Doe}
+ *   <li>A key {@code role} with value {@code admin}
+ *   <li>A second key named {@code role} with value {@code user}
+ *   <li>"Lone" key {@code active} without a value.
+ * </ul>
+ *
+ * <p>This class is meant to be used with {@link io.grpc.Uri}. For example:
+ *
+ * <pre>{@code
+ * Uri uri = Uri.parse("http://who?name=John+Doe&role=admin&role=user&active");
+ * QueryParams params = QueryParams.fromRawQuery(uri.getRawQuery());
+ * params.asList().removeIf(e -> "role".equals(e.getKey()) && "admin".equals(e.getValue()));
+ *
+ * Uri modifiedUri = uri.toBuilder().setRawQuery(params.toRawQuery()).build();
+ * }</pre>
+ *
+ * <p>Note that the empty collection is encoded as a null raw query string, which means "absent" to
+ * {@link io.grpc.Uri.Builder#setRawQuery}. An empty string query component (""), on the other hand,
+ * is modeled as an instance of QueryParams containing a single lone (empty) key. It must be this
+ * way if we are to simultaneously 1) support lone keys, 2) have parse/toRawQuery round-trip
+ * transparency, and 3) never fail to parse a valid RFC 3986 query component.
+ *
+ * <p>This container and its {@link Entry} take the same position as {@link io.grpc.Uri} on
+ * equality: raw keys and values must match exactly to be equal. Most callers won't care about how
+ * keys and values are encoded on the wire and will work with the getters for cooked keys and values
+ * instead.
+ *
+ * <p>Instances are not safe for concurrent access by multiple threads, including by way of the
+ * {@link #asList()} view method.
+ */
+@Internal
+public final class QueryParams {
+
+  private static final String UTF_8 = "UTF-8";
+  private final List<Entry> entries = new ArrayList<>();
+
+  /** Creates a new, empty {@code QueryParams} instance. */
+  public QueryParams() {}
+
+  /**
+   * Parses a raw query string into a {@code QueryParams} instance.
+   *
+   * <p>The input is split on {@code '&'} and each parameter is parsed as either a key/value pair
+   * (if it contains an equals sign) or a "lone" key (if it does not).
+   *
+   * <p>No valid RFC 3986 query component will fail to parse. For example, {@code ===} is parsed as
+   * a single parameter with "" as the key and "==" as the value. {@code &&&} is parsed as three
+   * lone keys named "". And so on. If {@code rawQuery} is not a valid RFC 3986 query component, the
+   * behavior is undefined. But if you are starting with a {@link io.grpc.Uri}, passing the value
+   * returned by {@link io.grpc.Uri#getRawQuery()} is always well-defined and will never fail.
+   *
+   * <p>Calling {@link #toRawQuery()} on the returned object is guaranteed to return exactly {@code
+   * rawQuery}.
+   *
+   * @param rawQuery the raw query component to parse, or null to return an empty container
+   * @return a new instance of {@code QueryParams} representing the input
+   */
+  public static QueryParams fromRawQuery(@Nullable String rawQuery) {
+    QueryParams params = new QueryParams();
+    if (rawQuery != null) {
+      for (String part : Splitter.on('&').split(rawQuery)) {
+        int equalsIndex = part.indexOf('=');
+        if (equalsIndex == -1) {
+          params.entries.add(Entry.forRawLoneKey(part));
+        } else {
+          String rawKey = part.substring(0, equalsIndex);
+          String rawValue = part.substring(equalsIndex + 1);
+          params.entries.add(Entry.forRawKeyValue(rawKey, rawValue));
+        }
+      }
+    }
+    return params;
+  }
+
+  /**
+   * Returns a mutable list view of the query parameters.
+   *
+   * @return the mutable list of entries
+   */
+  public List<Entry> asList() {
+    return entries;
+  }
+
+  /**
+   * Returns the "raw" query string representation of these parameters, suitable for passing to the
+   * {@link io.grpc.Uri.Builder#setRawQuery} method.
+   *
+   * @return the raw query string
+   */
+  @Nullable
+  public String toRawQuery() {
+    if (entries.isEmpty()) {
+      return null;
+    }
+    StringBuilder resultBuilder = new StringBuilder();
+    boolean first = true;
+    for (Entry entry : entries) {
+      if (!first) {
+        resultBuilder.append('&');
+      }
+      entry.appendToRawQueryStringBuilder(resultBuilder);
+      first = false;
+    }
+    return resultBuilder.toString();
+  }
+
+  @Override
+  public String toString() {
+    return entries.toString();
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) {
+      return true;
+    }
+    if (!(o instanceof QueryParams)) {
+      return false;
+    }
+    QueryParams other = (QueryParams) o;
+    return entries.equals(other.entries);
+  }
+
+  @Override
+  public int hashCode() {
+    return entries.hashCode();
+  }
+
+  /** A single query parameter entry. */
+  public static final class Entry {
+    private final String rawKey;
+    @Nullable private final String rawValue;
+    private final String key;
+    @Nullable private final String value;
+
+    private Entry(String rawKey, @Nullable String rawValue, String key, @Nullable String value) {
+      this.rawKey = checkNotNull(rawKey, "rawKey");
+      this.rawValue = rawValue;
+      this.key = checkNotNull(key, "key");
+      this.value = value;
+    }
+
+    /**
+     * Returns the key.
+     *
+     * <p>Any characters that needed URL encoding have already been decoded.
+     */
+    public String getKey() {
+      return key;
+    }
+
+    /**
+     * Returns the value, or {@code null} if this is a "lone" key.
+     *
+     * <p>Any characters that needed URL encoding have already been decoded.
+     */
+    @Nullable
+    public String getValue() {
+      return value;
+    }
+
+    /** Returns {@code true} if this entry has a value, {@code false} if it is a "lone" key. */
+    public boolean hasValue() {
+      return value != null;
+    }
+
+    /**
+     * Creates a new key/value pair entry.
+     *
+     * <p>Both key and value can contain any character. They will be URL encoded for you if
+     * necessary.
+     */
+    public static Entry forKeyValue(String key, String value) {
+      checkNotNull(key, "key");
+      checkNotNull(value, "value");
+      return new Entry(encode(key), encode(value), key, value);
+    }
+
+    /**
+     * Creates a new query parameter with a "lone" key.
+     *
+     * <p>'key' can contain any character. It will be URL encoded for you later, as necessary.
+     *
+     * @param key the decoded key, must not be null
+     * @return a new {@code Entry}
+     */
+    public static Entry forLoneKey(String key) {
+      checkNotNull(key, "key");
+      return new Entry(encode(key), null, key, null);
+    }
+
+    static Entry forRawKeyValue(String rawKey, String rawValue) {
+      checkNotNull(rawKey, "rawKey");
+      checkNotNull(rawValue, "rawValue");
+      return new Entry(rawKey, rawValue, decode(rawKey), decode(rawValue));
+    }
+
+    static Entry forRawLoneKey(String rawKey) {
+      checkNotNull(rawKey, "rawKey");
+      return new Entry(rawKey, null, decode(rawKey), null);
+    }
+
+    void appendToRawQueryStringBuilder(StringBuilder sb) {
+      sb.append(rawKey);
+      if (rawValue != null) {
+        sb.append('=').append(rawValue);
+      }
+    }
+
+    @Override
+    public boolean equals(Object o) {
+      if (this == o) {
+        return true;
+      }
+      if (!(o instanceof Entry)) {
+        return false;
+      }
+      Entry entry = (Entry) o;
+      return Objects.equals(rawKey, entry.rawKey) && Objects.equals(rawValue, entry.rawValue);
+    }
+
+    @Override
+    public int hashCode() {
+      return Objects.hash(rawKey, rawValue);
+    }
+
+    @Override
+    public String toString() {
+      StringBuilder sb = new StringBuilder();
+      appendToRawQueryStringBuilder(sb);
+      return sb.toString();
+    }
+  }
+
+  private static String decode(String s) {
+    try {
+      // TODO: Use URLDecoder.decode(String, Charset) when available
+      return URLDecoder.decode(s, UTF_8);
+    } catch (UnsupportedEncodingException impossible) {
+      throw new AssertionError("UTF-8 is not supported", impossible);
+    }
+  }
+
+  private static String encode(String s) {
+    try {
+      // TODO: Use URLEncoder.encode(String, Charset) when available
+      return URLEncoder.encode(s, UTF_8);
+    } catch (UnsupportedEncodingException impossible) {
+      throw new AssertionError("UTF-8 is not supported", impossible);
+    }
+  }
+}
diff --git a/api/src/main/java/io/grpc/Server.java b/api/src/main/java/io/grpc/Server.java
index 781455b18ee..97ea06a81c2 100644
--- a/api/src/main/java/io/grpc/Server.java
+++ b/api/src/main/java/io/grpc/Server.java
@@ -43,7 +43,7 @@ public abstract class Server {
    * listening socket(s).
    *
    * @return {@code this} object
-   * @throws IllegalStateException if already started
+   * @throws IllegalStateException if already started or shut down
    * @throws IOException if unable to bind
    * @since 1.0.0
    */
@@ -71,7 +71,6 @@ public int getPort() {
    * @throws IllegalStateException if the server has not yet been started.
    * @since 1.19.0
    */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/5332")
   public List<? extends SocketAddress> getListenSockets() {
     throw new UnsupportedOperationException();
   }
@@ -119,6 +118,9 @@ public List<ServerServiceDefinition> getMutableServices() {
    * {@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
    */
@@ -130,6 +132,9 @@ public List<ServerServiceDefinition> getMutableServices() {
    * 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
    */
@@ -157,6 +162,9 @@ public List<ServerServiceDefinition> getMutableServices() {
   /**
    * 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;
@@ -164,6 +172,9 @@ public List<ServerServiceDefinition> getMutableServices() {
   /**
    * 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
index 64a63ad2acc..3effe593e57 100644
--- a/api/src/main/java/io/grpc/ServerBuilder.java
+++ b/api/src/main/java/io/grpc/ServerBuilder.java
@@ -16,9 +16,12 @@
 
 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;
@@ -71,6 +74,27 @@ public static ServerBuilder<?> forPort(int port) {
    */
   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.
    *
@@ -89,6 +113,24 @@ public static ServerBuilder<?> forPort(int port) {
    */
   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
@@ -99,7 +141,6 @@ public static ServerBuilder<?> forPort(int port) {
    * @return this
    * @since 1.5.0
    */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/3117")
   public T intercept(ServerInterceptor interceptor) {
     throw new UnsupportedOperationException();
   }
@@ -191,18 +232,142 @@ public T useTransportSecurity(InputStream certChain, InputStream privateKey) {
 
   /**
    * Sets the permitted time for new connections to complete negotiation handshakes before being
-   * killed.
+   * killed. The default value is 2 minutes.
    *
    * @return this
    * @throws IllegalArgumentException if timeout is negative
    * @throws UnsupportedOperationException if unsupported
    * @since 1.8.0
    */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/3706")
   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
@@ -270,6 +435,17 @@ public T setBinaryLog(BinaryLog binaryLog) {
    */
   public abstract Server build();
 
+  /**
+   * Adds a metric sink to the server.
+   *
+   * @param metricSink the metric sink to add.
+   * @return this
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/12693")
+  public T addMetricSink(MetricSink metricSink) {
+    return thisT();
+  }
+
   /**
    * Returns the correctly typed version of the builder.
    */
diff --git a/api/src/main/java/io/grpc/ServerCall.java b/api/src/main/java/io/grpc/ServerCall.java
index d391cb5c79a..3db8ac30e83 100644
--- a/api/src/main/java/io/grpc/ServerCall.java
+++ b/api/src/main/java/io/grpc/ServerCall.java
@@ -16,6 +16,8 @@
 
 package io.grpc;
 
+import static com.google.common.base.Preconditions.checkArgument;
+
 import javax.annotation.Nullable;
 
 /**
@@ -189,16 +191,15 @@ public boolean isReady() {
    * 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.
+   * 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.
@@ -206,11 +207,38 @@ public void setMessageCompression(boolean enabled) {
    * @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
   }
 
+  /**
+   * 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.
    *
@@ -229,7 +257,6 @@ public Attributes getAttributes() {
    *
    * @return the authority string. {@code null} if not available.
    */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/2924")
   @Nullable
   public String getAuthority() {
     return null;
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
index 13d0b4128f0..fdfa9997957 100644
--- a/api/src/main/java/io/grpc/ServerCallHandler.java
+++ b/api/src/main/java/io/grpc/ServerCallHandler.java
@@ -25,17 +25,26 @@
 @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.
+   * Starts asynchronous processing of an incoming call.
    *
-   * <p>Since {@link Metadata} is not thread-safe, the caller must not access (read or write) {@code
-   * headers} after this point.
+   * <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>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.
+   * <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(
diff --git a/api/src/main/java/io/grpc/ServerCredentials.java b/api/src/main/java/io/grpc/ServerCredentials.java
index ccdaee38ab3..2b648aaeb7c 100644
--- a/api/src/main/java/io/grpc/ServerCredentials.java
+++ b/api/src/main/java/io/grpc/ServerCredentials.java
@@ -33,5 +33,4 @@
  * would only be used after {@code instanceof} checks (which must consider
  * {@code ChoiceServerCredentials}!).
  */
-@ExperimentalApi("https://github.com/grpc/grpc-java/issues/7621")
 public abstract class ServerCredentials {}
diff --git a/api/src/main/java/io/grpc/ServerInterceptor.java b/api/src/main/java/io/grpc/ServerInterceptor.java
index 272b10636cd..9b2e76ef608 100644
--- a/api/src/main/java/io/grpc/ServerInterceptor.java
+++ b/api/src/main/java/io/grpc/ServerInterceptor.java
@@ -19,7 +19,7 @@
 import javax.annotation.concurrent.ThreadSafe;
 
 /**
- * Interface for intercepting incoming calls before that are dispatched by
+ * 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
diff --git a/api/src/main/java/io/grpc/ServerInterceptors.java b/api/src/main/java/io/grpc/ServerInterceptors.java
index 153c7b4068e..6626c8e5810 100644
--- a/api/src/main/java/io/grpc/ServerInterceptors.java
+++ b/api/src/main/java/io/grpc/ServerInterceptors.java
@@ -184,6 +184,31 @@ private static final class KnownLengthBufferedInputStream extends BufferedInputS
   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 =
@@ -191,8 +216,8 @@ public static <T> ServerServiceDefinition useMarshalledMessages(
     // Wrap the descriptors
     for (final ServerMethodDefinition<?, ?> definition : serviceDef.getMethods()) {
       final MethodDescriptor<?, ?> originalMethodDescriptor = definition.getMethodDescriptor();
-      final MethodDescriptor<T, T> wrappedMethodDescriptor =
-          originalMethodDescriptor.toBuilder(marshaller, marshaller).build();
+      final MethodDescriptor<ReqT, RespT> wrappedMethodDescriptor =
+          originalMethodDescriptor.toBuilder(requestMarshaller, responseMarshaller).build();
       wrappedDescriptors.add(wrappedMethodDescriptor);
       wrappedMethods.add(wrapMethod(definition, wrappedMethodDescriptor));
     }
@@ -266,23 +291,23 @@ public ServerCall.Listener<WReqT> startCall(
           final Metadata headers) {
         final ServerCall<OReqT, ORespT> unwrappedCall =
             new PartialForwardingServerCall<OReqT, ORespT>() {
-          @Override
-          protected ServerCall<WReqT, WRespT> delegate() {
-            return call;
-          }
+              @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 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;
-          }
-        };
+              @Override
+              public MethodDescriptor<OReqT, ORespT> getMethodDescriptor() {
+                return originalMethod;
+              }
+            };
 
         final ServerCall.Listener<OReqT> originalListener = originalHandler
             .startCall(unwrappedCall, headers);
diff --git a/api/src/main/java/io/grpc/ServerRegistry.java b/api/src/main/java/io/grpc/ServerRegistry.java
index f267797e3f3..1ec7030b82b 100644
--- a/api/src/main/java/io/grpc/ServerRegistry.java
+++ b/api/src/main/java/io/grpc/ServerRegistry.java
@@ -18,20 +18,22 @@
 
 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.ServiceLoader;
+import java.util.logging.Level;
 import java.util.logging.Logger;
-import javax.annotation.concurrent.GuardedBy;
 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.
  */
-@ExperimentalApi("https://github.com/grpc/grpc-java/issues/7621")
+@Internal
 @ThreadSafe
 public final class ServerRegistry {
   private static final Logger logger = Logger.getLogger(ServerRegistry.class.getName());
@@ -92,15 +94,14 @@ public static synchronized ServerRegistry getDefaultRegistry() {
     if (instance == null) {
       List<ServerProvider> providerList = ServiceProviders.loadAll(
           ServerProvider.class,
-          Collections.<Class<?>>emptyList(),
-          ServerProvider.class.getClassLoader(),
+          ServiceLoader.load(ServerProvider.class, ServerProvider.class.getClassLoader())
+            .iterator(),
+          ServerRegistry::getHardCodedClasses,
           new ServerPriorityAccessor());
       instance = new ServerRegistry();
       for (ServerProvider provider : providerList) {
         logger.fine("Service loader found " + provider);
-        if (provider.isAvailable()) {
-          instance.addProvider(provider);
-        }
+        instance.addProvider(provider);
       }
       instance.refreshProviders();
     }
@@ -121,11 +122,26 @@ ServerProvider provider() {
     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 or grpc-netty-shaded artifact");
+          + "Try adding a dependency on the grpc-netty, grpc-netty-shaded, or grpc-okhttp "
+          + "artifact");
     }
     StringBuilder error = new StringBuilder();
     for (ServerProvider provider : providers()) {
diff --git a/api/src/main/java/io/grpc/ServiceProviders.java b/api/src/main/java/io/grpc/ServiceProviders.java
index 08837bcf5cc..861688be9fb 100644
--- a/api/src/main/java/io/grpc/ServiceProviders.java
+++ b/api/src/main/java/io/grpc/ServiceProviders.java
@@ -17,10 +17,13 @@
 package io.grpc;
 
 import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Supplier;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Comparator;
+import java.util.Iterator;
 import java.util.List;
+import java.util.ListIterator;
 import java.util.ServiceConfigurationError;
 import java.util.ServiceLoader;
 
@@ -29,42 +32,44 @@ 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.
+   *
+   * <p>{@code serviceLoader} should be created with {@code ServiceLoader.load(MyClass.class,
+   * MyClass.class.getClassLoader()).iterator()} in order to be detected by R8 so that R8 full mode
+   * will keep the constructors for the provider classes.
    */
   public static <T> List<T> loadAll(
       Class<T> klass,
-      Iterable<Class<?>> hardcoded,
-      ClassLoader cl,
+      Iterator<T> serviceLoader,
+      Supplier<Iterable<Class<?>>> hardcoded,
       final PriorityAccessor<T> priorityAccessor) {
-    Iterable<T> candidates;
-    if (isAndroid(cl)) {
-      candidates = getCandidatesViaHardCoded(klass, hardcoded);
+    Iterator<T> candidates;
+    if (serviceLoader instanceof ListIterator) {
+      // A rewriting tool has replaced the ServiceLoader with a List of some sort (R8 uses
+      // ArrayList, AppReduce uses singletonList). We prefer to use such iterators on Android as
+      // they won't need reflection like the hard-coded list does. In addition, the provider
+      // instances will have already been created, so it seems we should use them.
+      //
+      // R8: https://r8.googlesource.com/r8/+/490bc53d9310d4cc2a5084c05df4aadaec8c885d/src/main/java/com/android/tools/r8/ir/optimize/ServiceLoaderRewriter.java
+      // AppReduce: service_loader_pass.cc
+      candidates = serviceLoader;
+    } else if (isAndroid(klass.getClassLoader())) {
+      // Avoid getResource() on Android, which must read from a zip which uses a lot of memory
+      candidates = getCandidatesViaHardCoded(klass, hardcoded.get()).iterator();
+    } else if (!serviceLoader.hasNext()) {
+      // 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.
+      candidates = ServiceLoader.load(klass).iterator();
     } else {
-      candidates = getCandidatesViaServiceLoader(klass, cl);
+      candidates = serviceLoader;
     }
     List<T> list = new ArrayList<>();
-    for (T current: candidates) {
+    while (candidates.hasNext()) {
+      T current = candidates.next();
       if (!priorityAccessor.isAvailable(current)) {
         continue;
       }
@@ -101,15 +106,14 @@ static boolean isAndroid(ClassLoader cl) {
   }
 
   /**
-   * Loads service providers for the {@code klass} service using {@link ServiceLoader}.
+   * For testing only: Loads service providers for the {@code klass} service using {@link
+   * ServiceLoader}. Does not support spi-fly and related tricks.
    */
   @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 null;
     }
     return i;
   }
@@ -122,15 +126,26 @@ public static <T> Iterable<T> getCandidatesViaServiceLoader(Class<T> klass, Clas
   static <T> Iterable<T> getCandidatesViaHardCoded(Class<T> klass, Iterable<Class<?>> hardcoded) {
     List<T> list = new ArrayList<>();
     for (Class<?> candidate : hardcoded) {
-      list.add(create(klass, candidate));
+      T t = createForHardCoded(klass, candidate);
+      if (t == null) {
+        continue;
+      }
+      list.add(t);
     }
     return list;
   }
 
-  @VisibleForTesting
-  static <T> T create(Class<T> klass, Class<?> rawClass) {
+  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);
diff --git a/api/src/main/java/io/grpc/Status.java b/api/src/main/java/io/grpc/Status.java
index 963a001d9cd..38cd9581f8e 100644
--- a/api/src/main/java/io/grpc/Status.java
+++ b/api/src/main/java/io/grpc/Status.java
@@ -16,13 +16,14 @@
 
 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;
@@ -30,11 +31,9 @@
 import java.util.Collections;
 import java.util.List;
 import java.util.TreeMap;
-import javax.annotation.CheckReturnValue;
 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
@@ -50,6 +49,10 @@
  *
  * <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
@@ -230,10 +233,6 @@ private byte[] valueAscii() {
     }
   }
 
-  private static final String TEST_EQUALS_FAILURE_PROPERTY = "io.grpc.Status.failOnEqualsForTest";
-  private static final boolean FAIL_ON_EQUALS_FOR_TEST =
-      Boolean.parseBoolean(System.getProperty(TEST_EQUALS_FAILURE_PROPERTY, "false"));
-  
   // Create the canonical list of Status instances indexed by their code values.
   private static final List<Status> STATUS_LIST = buildStatusList();
 
@@ -303,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);
@@ -414,7 +413,6 @@ public static Status fromThrowable(Throwable t) {
    * @return the trailers or {@code null} if not found.
    */
   @Nullable
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/4683")
   public static Metadata trailersFromThrowable(Throwable t) {
     Throwable cause = checkNotNull(t, "t");
     while (cause != null) {
@@ -530,7 +528,6 @@ public StatusRuntimeException asRuntimeException() {
    * Same as {@link #asRuntimeException()} but includes the provided trailers in the returned
    * exception.
    */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/4683")
   public StatusRuntimeException asRuntimeException(@Nullable Metadata trailers) {
     return new StatusRuntimeException(this, trailers);
   }
@@ -546,7 +543,6 @@ public StatusException asException() {
   /**
    * Same as {@link #asException()} but includes the provided trailers in the returned exception.
    */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/4683")
   public StatusException asException(@Nullable Metadata trailers) {
     return new StatusException(this, trailers);
   }
@@ -596,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.
      */
@@ -659,8 +657,6 @@ private static String parseAsciiStringSlow(byte[] value) {
    */
   @Override
   public boolean equals(Object obj) {
-    assert !FAIL_ON_EQUALS_FOR_TEST
-        : "Status.equals called; disable this by setting " + TEST_EQUALS_FAILURE_PROPERTY;
     return super.equals(obj);
   }
 
diff --git a/api/src/main/java/io/grpc/StatusException.java b/api/src/main/java/io/grpc/StatusException.java
index e89ac16dc6c..c0a67a375b2 100644
--- a/api/src/main/java/io/grpc/StatusException.java
+++ b/api/src/main/java/io/grpc/StatusException.java
@@ -25,9 +25,10 @@
  */
 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;
-  private final boolean fillInStackTrace;
 
   /**
    * Constructs an exception with both a status.  See also {@link Status#asException()}.
@@ -45,25 +46,9 @@ public StatusException(Status status) {
    * @since 1.0.0
    */
   public StatusException(Status status, @Nullable Metadata trailers) {
-    this(status, trailers, /*fillInStackTrace=*/ true);
-  }
-
-  StatusException(Status status, @Nullable Metadata trailers, boolean fillInStackTrace) {
     super(Status.formatThrowableMessage(status), status.getCause());
     this.status = status;
     this.trailers = trailers;
-    this.fillInStackTrace = fillInStackTrace;
-    fillInStackTrace();
-  }
-
-  @Override
-  public synchronized Throwable fillInStackTrace() {
-    // Let's observe final variables in two states!  This works because Throwable will invoke this
-    // method before fillInStackTrace is set, thus doing nothing.  After the constructor has set
-    // fillInStackTrace, this method will properly fill it in.  Additionally, sub classes may call
-    // this normally, because fillInStackTrace will either be set, or this method will be
-    // overriden.
-    return fillInStackTrace ? super.fillInStackTrace() : this;
   }
 
   /**
@@ -80,6 +65,7 @@ public final Status getStatus() {
    *
    * @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
index e3e0555fb09..ebcc2f0d671 100644
--- a/api/src/main/java/io/grpc/StatusRuntimeException.java
+++ b/api/src/main/java/io/grpc/StatusRuntimeException.java
@@ -26,13 +26,13 @@
 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;
 
-  private final boolean fillInStackTrace;
-
   /**
-   * Constructs the exception with both a status.  See also {@link Status#asException()}.
+   * Constructs the exception with a status. See also {@link Status#asRuntimeException()}.
    *
    * @since 1.0.0
    */
@@ -41,31 +41,15 @@ public StatusRuntimeException(Status status) {
   }
 
   /**
-   * Constructs the exception with both a status and trailers.  See also
-   * {@link Status#asException(Metadata)}.
+   * 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) {
-    this(status, trailers, /*fillInStackTrace=*/ true);
-  }
-
-  StatusRuntimeException(Status status, @Nullable Metadata trailers, boolean fillInStackTrace) {
     super(Status.formatThrowableMessage(status), status.getCause());
     this.status = status;
     this.trailers = trailers;
-    this.fillInStackTrace = fillInStackTrace;
-    fillInStackTrace();
-  }
-
-  @Override
-  public synchronized Throwable fillInStackTrace() {
-    // Let's observe final variables in two states!  This works because Throwable will invoke this
-    // method before fillInStackTrace is set, thus doing nothing.  After the constructor has set
-    // fillInStackTrace, this method will properly fill it in.  Additionally, sub classes may call
-    // this normally, because fillInStackTrace will either be set, or this method will be
-    // overriden.
-    return fillInStackTrace ? super.fillInStackTrace() : this;
   }
 
   /**
diff --git a/api/src/main/java/io/grpc/SynchronizationContext.java b/api/src/main/java/io/grpc/SynchronizationContext.java
index 03d26b55f0a..94916a1b473 100644
--- a/api/src/main/java/io/grpc/SynchronizationContext.java
+++ b/api/src/main/java/io/grpc/SynchronizationContext.java
@@ -18,8 +18,10 @@
 
 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;
@@ -57,7 +59,6 @@
  * @since 1.17.0
  */
 @ThreadSafe
-@ExperimentalApi("https://github.com/grpc/grpc-java/issues/4984")
 public final class SynchronizationContext implements Executor {
   private final UncaughtExceptionHandler uncaughtExceptionHandler;
 
@@ -163,6 +164,52 @@ public String toString() {
     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;
@@ -215,4 +262,4 @@ 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
index 2d3751f80c4..b58048be0b2 100644
--- a/api/src/main/java/io/grpc/TlsChannelCredentials.java
+++ b/api/src/main/java/io/grpc/TlsChannelCredentials.java
@@ -36,7 +36,6 @@
  * incomprehensible()} method. Unless overridden by a {@code Feature}, server verification should
  * use customary default root certificates.
  */
-@ExperimentalApi("https://github.com/grpc/grpc-java/issues/7479")
 public final class TlsChannelCredentials extends ChannelCredentials {
   /** Use TLS with its defaults. */
   public static ChannelCredentials create() {
@@ -221,7 +220,6 @@ public static Builder newBuilder() {
   }
 
   /** Builder for {@link TlsChannelCredentials}. */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/7479")
   public static final class Builder {
     private boolean fakeFeature;
     private byte[] certificateChain;
diff --git a/api/src/main/java/io/grpc/TlsServerCredentials.java b/api/src/main/java/io/grpc/TlsServerCredentials.java
index 8ed1482c409..ef20149eef6 100644
--- a/api/src/main/java/io/grpc/TlsServerCredentials.java
+++ b/api/src/main/java/io/grpc/TlsServerCredentials.java
@@ -37,7 +37,6 @@
  * method. Unless overridden by a {@code Feature}, server identity is provided via {@link
  * #getCertificateChain}, {@link #getPrivateKey}, and {@link #getPrivateKeyPassword}.
  */
-@ExperimentalApi("https://github.com/grpc/grpc-java/issues/7621")
 public final class TlsServerCredentials extends ServerCredentials {
   /**
    * Creates an instance using provided certificate chain and private key. Generally they should be
@@ -239,7 +238,6 @@ public static Builder newBuilder() {
   }
 
   /** Builder for {@link TlsServerCredentials}. */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/7621")
   public static final class Builder {
     private boolean fakeFeature;
     private byte[] certificateChain;
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..a88bb6138d8
--- /dev/null
+++ b/api/src/main/java/io/grpc/Uri.java
@@ -0,0 +1,1184 @@
+/*
+ * 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}.
+ *
+ * <p>Some URI components, e.g. scheme, are required while others may or may not be present, e.g.
+ * authority. {@link Uri} is careful to preserve the distinction between an absent string component
+ * (getter returns null) and one with an empty value (getter returns ""). {@link java.net.URI} makes
+ * this distinction too, *except* when it comes to the authority and host components: {@link
+ * java.net.URI#getAuthority()} and {@link java.net.URI#getHost()} return null when an authority is
+ * absent, e.g. <code>file:/path</code> as expected. But these methods surprisingly also return null
+ * when the authority is the empty string, e.g.<code>file:///path</code>. {@link Uri}'s getters
+ * correctly return null and "" in these cases, respectively, as one would expect.
+ */
+@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;
+        }
+      }
+      builder.setRawAuthority(s.substring(authorityStart, i));
+    }
+
+    // 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's decoding is lossy -- It only exists for compatibility with {@link
+   * java.net.URI}. Prefer {@link #getRawAuthority()} or work instead with authority in terms of its
+   * individual components ({@link #getUserInfo()}, {@link #getHost()} and {@link #getPort()}). The
+   * problem with getAuthority() is that it returns the delimited concatenation of the percent-
+   * decoded userinfo, host and port components. But both userinfo and host can contain the '@'
+   * character, which becomes indistinguishable from the userinfo/host delimiter after decoding. For
+   * example, URIs <code>scheme://x@y%40z</code> and <code>scheme://x%40y@z</code> have different
+   * userinfo and host components but getAuthority() returns "x@y@z" for both of them.
+   *
+   * <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 empty or not present. */
+  public int getPort() {
+    return port != null && !port.isEmpty() ? 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 query component of this URI in its originally parsed, possibly percent-encoded
+   * form, without any leading '?' character, or null if not present.
+   *
+   * <p>The query component can only be read in its raw form. That’s because virtually everyone uses
+   * query as a container for structured data, with some additional layer of encoding not present in
+   * RFC-3986. Like 'application/x-www-form-urlencoded', which encodes key/value pairs like so:
+   * <code>?k1=v1&k2=v+2</code>. The encoding of these containers always has characters that take on
+   * a special delimiter meaning when not percent-encoded and a literal meaning when they are (like
+   * '&', '=' and '+' above). Since it matters whether a character was percent encoded or not,
+   * offering a '#getQuery()' method that percent-decodes everything like we do for other components
+   * would be error-prone.
+   */
+  @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.
+   *
+   * <p>NB: Choose carefully between this method and {@link #getRawFragment()}. Many URI schemes
+   * embed further structure inside the fragment that isn't part of the RFC 3986 generic syntax. For
+   * example, Android uses the fragment to encode the many fields of an Intent, like {@code
+   * intent:#Intent;S.key=val;end;}. And the URI of a JSON resource may use RFC 6901 in its fragment
+   * to point at a particular node, e.g. {@code
+   * file:/etc/config/service.json#/methodConfig/0/retryPolicy/maxBackoff}.
+   *
+   * <p>When percent-encoding is used to escape internal delimiters, like a literal ';' and '=' in
+   * an `intent:`, call {@link #getRawFragment()} to preserve that percent-encoding, or risk
+   * corruption. Conversely, use *this* method when percent-decoding is needed *before* any further
+   * interpretation, like with a JSON pointer, which must be percent-encoded in a URI fragment but
+   * uses a completely different method of escaping literal '/' characters.
+   */
+  @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.
+   *
+   * <p>NB: Choose carefully between this method and {@link #getFragment()}. See that Javadoc for
+   * details.
+   */
+  @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, possibly percent-encoded, exactly as it will
+     * appear in the string form of the built URI.
+     *
+     * <p>'query' must only contain codepoints from RFC 3986's "query" character class. Any other
+     * characters must be percent-encoded using UTF-8. Do not include the leading '?' delimiter.
+     *
+     * <p>The query component can only be provided in its raw form. That’s because virtually
+     * everyone uses query as a container for structured data, with some additional layer of
+     * encoding not present in RFC-3986. Like 'application/x-www-form-urlencoded', which encodes
+     * key/value pairs like so: <code>?k1=v1&k2=v+2</code>. The encoding of these containers always
+     * has characters that take on a special delimiter meaning when not percent-encoded and a
+     * literal meaning when they are (like '&', '=' and '+' above). Since 'query' must have already
+     * been carefully percent-encoded externally, a '#setQuery(String)' method that percent-encodes
+     * an assumed-cooked string would be error-prone.
+     *
+     * <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 setRawQuery(@Nullable String query) {
+      if (query != null) {
+        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>NB: Choose carefully between this method and {@link #setRawFragment(String)}. Many URI
+     * schemes embed further structure in the fragment that isn't part of the RFC 3986 generic
+     * syntax. These schemes often use internal delimiters that must be carefully percent-encoded in
+     * ways that this method doesn't understand. See {@link #getFragment()} for an example. In that
+     * case, callers should percent-encode externally then call {@link #setRawFragment(String)}
+     * instead.
+     *
+     * <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;
+    }
+
+    /**
+     * Specifies the fragment component of the new URI, already percent-encoded, exactly as it will
+     * appear after the '#' delimiter in the string form of the built URI.
+     *
+     * <p>NB: Choose carefully between this method and {@link #setFragment(String)}. {@code
+     * fragment} must only contain codepoints from RFC 3986's "fragment" character class. Use
+     * percent-encoding and UTF-8 to represent anything else. In certain cases, you can use {@link
+     * #setFragment(String)} to have the fragment percent-encoded for you instead, but see that
+     * method's Javadoc for its limitations.
+     *
+     * <p>This field is optional.
+     *
+     * @param fragment the new fragment component, or null to clear this field
+     * @return this, for fluent building
+     * @throws IllegalArgumentException if 'fragment' contains forbidden characters
+     */
+    @CanIgnoreReturnValue
+    public Builder setRawFragment(@Nullable String fragment) {
+      if (fragment != null) {
+        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) {
+      if (port != null && !port.isEmpty()) {
+        try {
+          Integer.parseInt(port); // Result unused.
+        } catch (NumberFormatException e) {
+          throw new IllegalArgumentException("Invalid port", e);
+        }
+      }
+      this.port = port;
+      return this;
+    }
+
+    /**
+     * Specifies the userinfo, host and port URI components all at once using a single string.
+     *
+     * <p>This setter is "raw" in the sense that special characters in userinfo and host must be
+     * passed in percent-encoded. See <a
+     * href="https://datatracker.ietf.org/doc/html/rfc3986#section-3.2">RFC 3986 3.2</a> for the set
+     * of characters allowed in each component of an authority.
+     *
+     * <p>There's no "cooked" method to set authority like for other URI components because
+     * authority is a *compound* URI component whose userinfo, host and port components are
+     * delimited with special characters '@' and ':'. But the first two of those components can
+     * themselves contain these delimiters so we need percent-encoding to parse them unambiguously.
+     *
+     * @param authority an RFC 3986 authority string that will be used to set userinfo, host and
+     *     port, or null to clear all three of those components
+     */
+    @CanIgnoreReturnValue
+    public Builder setRawAuthority(@Nullable String authority) {
+      if (authority == null) {
+        setUserInfo(null);
+        setHost((String) null);
+        setPort(-1);
+      } else {
+        // UserInfo. Easy because '@' cannot appear unencoded inside userinfo or host.
+        int userInfoEnd = authority.indexOf('@');
+        if (userInfoEnd >= 0) {
+          setRawUserInfo(authority.substring(0, userInfoEnd));
+        } else {
+          setUserInfo(null);
+        }
+
+        // Host/Port.
+        int hostStart = userInfoEnd >= 0 ? userInfoEnd + 1 : 0;
+        int portStartColon = findPortStartColon(authority, hostStart);
+        if (portStartColon < 0) {
+          setRawHost(authority.substring(hostStart));
+          setPort(-1);
+        } else {
+          setRawHost(authority.substring(hostStart, portStartColon));
+          setRawPort(authority.substring(portStartColon + 1));
+        }
+      }
+      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/test/java/io/grpc/CallOptionsTest.java b/api/src/test/java/io/grpc/CallOptionsTest.java
index 31861306891..65fb7ff3bf2 100644
--- a/api/src/test/java/io/grpc/CallOptionsTest.java
+++ b/api/src/test/java/io/grpc/CallOptionsTest.java
@@ -30,9 +30,10 @@
 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 java.util.concurrent.TimeUnit;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
@@ -81,6 +82,16 @@ public void withAndWithoutWaitForReady() {
         .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);
@@ -140,6 +151,15 @@ public void withDeadlineAfter() {
     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
@@ -148,6 +168,7 @@ public void toStringMatches_noDeadline_default() {
         .withCallCredentials(null)
         .withMaxInboundMessageSize(44)
         .withMaxOutboundMessageSize(55)
+        .withOnReadyThreshold(1024)
         .toString();
 
     assertThat(actual).contains("deadline=null");
@@ -159,6 +180,7 @@ public void toStringMatches_noDeadline_default() {
     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]");
   }
 
@@ -258,17 +280,6 @@ private static class FakeTicker extends Deadline.Ticker {
     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);
-    }
   }
 
   private static class FakeTracerFactory extends ClientStreamTracer.Factory {
@@ -279,8 +290,7 @@ private static class FakeTracerFactory extends ClientStreamTracer.Factory {
     }
 
     @Override
-    public ClientStreamTracer newClientStreamTracer(
-        ClientStreamTracer.StreamInfo info, Metadata headers) {
+    public ClientStreamTracer newClientStreamTracer(StreamInfo info, Metadata headers) {
       return new ClientStreamTracer() {};
     }
 
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
index 4e606c41668..e4647a0b38f 100644
--- a/api/src/test/java/io/grpc/CompositeCallCredentialsTest.java
+++ b/api/src/test/java/io/grpc/CompositeCallCredentialsTest.java
@@ -109,7 +109,5 @@ public FakeCallCredentials(Status status) {
         applier.fail(status);
       }
     }
-
-    @Override public void thisUsesUnstableApi() {}
   }
 }
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/context/src/test/java/io/grpc/ContextTest.java b/api/src/test/java/io/grpc/ContextTest.java
similarity index 97%
rename from context/src/test/java/io/grpc/ContextTest.java
rename to api/src/test/java/io/grpc/ContextTest.java
index 5171d4839a9..7f24ff4461d 100644
--- a/context/src/test/java/io/grpc/ContextTest.java
+++ b/api/src/test/java/io/grpc/ContextTest.java
@@ -16,6 +16,7 @@
 
 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;
@@ -705,7 +706,7 @@ public void relativeDeadlineTriggersAndPropagates() throws Exception {
 
   @Test
   public void innerDeadlineCompletesBeforeOuter() throws Exception {
-    Context base = Context.current().withDeadline(Deadline.after(2, TimeUnit.SECONDS), scheduler);
+    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());
@@ -718,7 +719,7 @@ public void innerDeadlineCompletesBeforeOuter() throws Exception {
 
     deadlineLatch = new CountDownLatch(1);
     base.addListener(cancellationListener, MoreExecutors.directExecutor());
-    assertTrue(deadlineLatch.await(2, TimeUnit.SECONDS));
+    assertTrue(deadlineLatch.await(4, TimeUnit.SECONDS));
     assertTrue(base.isCancelled());
     assertTrue(base.cancellationCause() instanceof TimeoutException);
     assertNotSame(base.cancellationCause(), child.cancellationCause());
@@ -872,6 +873,20 @@ public String call() {
 
   @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()));
diff --git a/api/src/test/java/io/grpc/ContextsTest.java b/api/src/test/java/io/grpc/ContextsTest.java
index cfcfa7d4981..ec9dc3929a2 100644
--- a/api/src/test/java/io/grpc/ContextsTest.java
+++ b/api/src/test/java/io/grpc/ContextsTest.java
@@ -28,7 +28,6 @@
 import static org.junit.Assert.fail;
 
 import com.google.common.util.concurrent.testing.TestingExecutors;
-import io.grpc.internal.NoopServerCall;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
diff --git a/context/src/test/java/io/grpc/DeadlineTest.java b/api/src/test/java/io/grpc/DeadlineTest.java
similarity index 100%
rename from context/src/test/java/io/grpc/DeadlineTest.java
rename to api/src/test/java/io/grpc/DeadlineTest.java
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
index 5ebfef5fb7c..8ea99929f4f 100644
--- a/api/src/test/java/io/grpc/ForwardingChannelBuilderTest.java
+++ b/api/src/test/java/io/grpc/ForwardingChannelBuilderTest.java
@@ -39,6 +39,7 @@ public class ForwardingChannelBuilderTest {
 
   private final class TestBuilder extends ForwardingChannelBuilder<TestBuilder> {
     @Override
+    @SuppressWarnings("deprecation")
     protected ManagedChannelBuilder<?> delegate() {
       return mockDelegate;
     }
diff --git a/api/src/test/java/io/grpc/ForwardingServerBuilderTest.java b/api/src/test/java/io/grpc/ForwardingServerBuilderTest.java
index 6a8c1c115a9..d77eeb30d57 100644
--- a/api/src/test/java/io/grpc/ForwardingServerBuilderTest.java
+++ b/api/src/test/java/io/grpc/ForwardingServerBuilderTest.java
@@ -55,7 +55,9 @@ public void allMethodsForwarded() throws Exception {
   @Test
   public void allBuilderMethodsReturnThis() throws Exception {
     for (Method method : ServerBuilder.class.getDeclaredMethods()) {
-      if (Modifier.isStatic(method.getModifiers()) || Modifier.isPrivate(method.getModifiers())) {
+      if (Modifier.isStatic(method.getModifiers())
+          || Modifier.isPrivate(method.getModifiers())
+          || Modifier.isFinal(method.getModifiers())) {
         continue;
       }
       if (method.getName().equals("build")) {
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/LoadBalancerRegistryTest.java b/api/src/test/java/io/grpc/LoadBalancerRegistryTest.java
index e8588e5e8d8..690db6622e0 100644
--- a/api/src/test/java/io/grpc/LoadBalancerRegistryTest.java
+++ b/api/src/test/java/io/grpc/LoadBalancerRegistryTest.java
@@ -19,7 +19,6 @@
 import static com.google.common.truth.Truth.assertThat;
 import static org.junit.Assert.fail;
 
-import io.grpc.grpclb.GrpclbLoadBalancerProvider;
 import io.grpc.internal.PickFirstLoadBalancerProvider;
 import java.util.List;
 import org.junit.Test;
@@ -41,7 +40,7 @@ public void getClassesViaHardcoded_classesPresent() throws Exception {
   @Test
   public void stockProviders() {
     LoadBalancerRegistry defaultRegistry = LoadBalancerRegistry.getDefaultRegistry();
-    assertThat(defaultRegistry.providers()).hasSize(3);
+    assertThat(defaultRegistry.providers()).hasSize(4);
 
     LoadBalancerProvider pickFirst = defaultRegistry.getProvider("pick_first");
     assertThat(pickFirst).isInstanceOf(PickFirstLoadBalancerProvider.class);
@@ -52,9 +51,17 @@ public void stockProviders() {
         "io.grpc.util.SecretRoundRobinLoadBalancerProvider$Provider");
     assertThat(roundRobin.getPriority()).isEqualTo(5);
 
-    LoadBalancerProvider grpclb = defaultRegistry.getProvider("grpclb");
-    assertThat(grpclb).isInstanceOf(GrpclbLoadBalancerProvider.class);
-    assertThat(grpclb.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
diff --git a/api/src/test/java/io/grpc/LoadBalancerTest.java b/api/src/test/java/io/grpc/LoadBalancerTest.java
index be3d10ba2ae..22fdc220081 100644
--- a/api/src/test/java/io/grpc/LoadBalancerTest.java
+++ b/api/src/test/java/io/grpc/LoadBalancerTest.java
@@ -64,6 +64,26 @@ public void pickResult_withSubchannelAndTracer() {
     assertThat(result.isDrop()).isFalse();
   }
 
+  @Test
+  public void pickResult_withSubchannelReplacement() {
+    PickResult result = PickResult.withSubchannel(subchannel, tracerFactory)
+        .copyWithSubchannel(subchannel2);
+    assertThat(result.getSubchannel()).isSameInstanceAs(subchannel2);
+    assertThat(result.getStatus()).isSameInstanceAs(Status.OK);
+    assertThat(result.getStreamTracerFactory()).isSameInstanceAs(tracerFactory);
+    assertThat(result.isDrop()).isFalse();
+  }
+
+  @Test
+  public void pickResult_withStreamTracerFactory() {
+    PickResult result = PickResult.withSubchannel(subchannel)
+        .copyWithStreamTracerFactory(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();
@@ -235,13 +255,14 @@ public void createSubchannelArgs_toString() {
 
   @Deprecated
   @Test
-  public void handleResolvedAddressGroups_delegatesToHandleResolvedAddresses() {
+  public void handleResolvedAddresses_delegatesToAcceptResolvedAddresses() {
     final AtomicReference<ResolvedAddresses> resultCapture = new AtomicReference<>();
 
     LoadBalancer balancer = new LoadBalancer() {
         @Override
-        public void handleResolvedAddresses(ResolvedAddresses resolvedAddresses) {
+        public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
           resultCapture.set(resolvedAddresses);
+          return Status.OK;
         }
 
         @Override
@@ -260,23 +281,22 @@ public void shutdown() {
     List<EquivalentAddressGroup> servers = Arrays.asList(
         new EquivalentAddressGroup(new SocketAddress(){}),
         new EquivalentAddressGroup(new SocketAddress(){}));
-    balancer.handleResolvedAddressGroups(servers, attrs);
+    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 handleResolvedAddresses_delegatesToHandleResolvedAddressGroups() {
-    final AtomicReference<List<EquivalentAddressGroup>> serversCapture = new AtomicReference<>();
-    final AtomicReference<Attributes> attrsCapture = new AtomicReference<>();
+  public void acceptResolvedAddresses_delegatesToHandleResolvedAddressGroups() {
+    final AtomicReference<ResolvedAddresses> addressesCapture = new AtomicReference<>();
 
     LoadBalancer balancer = new LoadBalancer() {
         @Override
-        public void handleResolvedAddressGroups(
-            List<EquivalentAddressGroup> servers, Attributes attrs) {
-          serversCapture.set(servers);
-          attrsCapture.set(attrs);
+        public void handleResolvedAddresses(ResolvedAddresses addresses) {
+          addressesCapture.set(addresses);
         }
 
         @Override
@@ -295,25 +315,23 @@ public void shutdown() {
     List<EquivalentAddressGroup> servers = Arrays.asList(
         new EquivalentAddressGroup(new SocketAddress(){}),
         new EquivalentAddressGroup(new SocketAddress(){}));
-    balancer.handleResolvedAddresses(
-        ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(attrs).build());
-    assertThat(serversCapture.get()).isEqualTo(servers);
-    assertThat(attrsCapture.get()).isEqualTo(attrs);
+    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 handleResolvedAddresses_noInfiniteLoop() {
-    final List<List<EquivalentAddressGroup>> serversCapture = new ArrayList<>();
-    final List<Attributes> attrsCapture = new ArrayList<>();
+  public void acceptResolvedAddresses_noInfiniteLoop() {
+    final List<ResolvedAddresses> addressesCapture = new ArrayList<>();
 
     LoadBalancer balancer = new LoadBalancer() {
       @Override
-      public void handleResolvedAddressGroups(
-          List<EquivalentAddressGroup> servers, Attributes attrs) {
-        serversCapture.add(servers);
-        attrsCapture.add(attrs);
-        super.handleResolvedAddressGroups(servers, attrs);
+      public void handleResolvedAddresses(ResolvedAddresses addresses) {
+        addressesCapture.add(addresses);
+        super.handleResolvedAddresses(addresses);
       }
 
       @Override
@@ -328,12 +346,12 @@ public void shutdown() {
     List<EquivalentAddressGroup> servers = Arrays.asList(
         new EquivalentAddressGroup(new SocketAddress(){}),
         new EquivalentAddressGroup(new SocketAddress(){}));
-    balancer.handleResolvedAddresses(
-        ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(attrs).build());
-    assertThat(serversCapture).hasSize(1);
-    assertThat(attrsCapture).hasSize(1);
-    assertThat(serversCapture.get(0)).isEqualTo(servers);
-    assertThat(attrsCapture.get(0)).isEqualTo(attrs);
+    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 {
diff --git a/api/src/test/java/io/grpc/ManagedChannelRegistryTest.java b/api/src/test/java/io/grpc/ManagedChannelRegistryTest.java
index 6f25f620576..2479e339791 100644
--- a/api/src/test/java/io/grpc/ManagedChannelRegistryTest.java
+++ b/api/src/test/java/io/grpc/ManagedChannelRegistryTest.java
@@ -19,12 +19,24 @@
 import static com.google.common.truth.Truth.assertThat;
 import static org.junit.Assert.fail;
 
+import com.google.common.collect.ImmutableSet;
+import io.grpc.FlagResetRule;
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+import java.net.URI;
+import java.util.Arrays;
+import java.util.Collection;
+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.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
 
 /** Unit tests for {@link ManagedChannelRegistry}. */
-@RunWith(JUnit4.class)
+@RunWith(Parameterized.class)
 public class ManagedChannelRegistryTest {
   private String target = "testing123";
   private ChannelCredentials creds = new ChannelCredentials() {
@@ -34,6 +46,20 @@ public ChannelCredentials withoutBearerTokens() {
     }
   };
 
+  @Rule public final FlagResetRule flagResetRule = new FlagResetRule();
+
+  @Parameters(name = "enableRfc3986UrisParam={0}")
+  public static Iterable<Object[]> data() {
+    return Arrays.asList(new Object[][] {{true}, {false}});
+  }
+
+  @Parameter public boolean enableRfc3986UrisParam;
+
+  @Before
+  public void setUp() {
+    flagResetRule.setFlagForTest(FeatureFlags::setRfc3986UrisEnabled, enableRfc3986UrisParam);
+  }
+
   @Test
   public void register_unavailableProviderThrows() {
     ManagedChannelRegistry reg = new ManagedChannelRegistry();
@@ -119,7 +145,7 @@ public NewChannelBuilderResult newChannelBuilder(
         return NewChannelBuilderResult.error("dodging");
       }
     });
-    class MockChannelBuilder extends ForwardingChannelBuilder<MockChannelBuilder> {
+    class MockChannelBuilder extends ForwardingChannelBuilder2<MockChannelBuilder> {
       @Override public ManagedChannelBuilder<?> delegate() {
         throw new UnsupportedOperationException();
       }
@@ -156,6 +182,251 @@ public void newChannelBuilder_noProvider() {
     }
   }
 
+  @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;
@@ -184,5 +455,10 @@ protected ManagedChannelBuilder<?> builderForAddress(String name, int port) {
     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
index 51aecc638e7..a858fff5e5a 100644
--- a/api/src/test/java/io/grpc/MetadataTest.java
+++ b/api/src/test/java/io/grpc/MetadataTest.java
@@ -16,20 +16,22 @@
 
 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.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.assertNotEquals;
 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;
@@ -37,9 +39,7 @@
 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;
 
@@ -49,23 +49,20 @@
 @RunWith(JUnit4.class)
 public class MetadataTest {
 
-  @SuppressWarnings("deprecation") // https://github.com/grpc/grpc-java/issues/7467
-  @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 class FishStreamMarsaller implements Metadata.BinaryStreamMarshaller<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));
@@ -82,7 +79,7 @@ public Fish parseStream(InputStream stream) {
   }
 
   private static final Metadata.BinaryStreamMarshaller<Fish> FISH_STREAM_MARSHALLER =
-      new FishStreamMarsaller();
+      new FishStreamMarshaller();
 
   /** A pattern commonly used to avoid unnecessary serialization of immutable objects. */
   private static final class FakeFishStream extends InputStream {
@@ -100,16 +97,16 @@ public int read() throws IOException {
 
   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 InputStream toStream(Fish fish) {
+          return new FakeFishStream(fish);
+        }
 
-    @Override
-    public Fish parseStream(InputStream stream) {
-      return ((FakeFishStream) stream).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);
@@ -121,10 +118,9 @@ public Fish parseStream(InputStream stream) {
 
   @Test
   public void noPseudoHeaders() {
-    thrown.expect(IllegalArgumentException.class);
-    thrown.expectMessage("Invalid character");
-
-    Metadata.Key.of(":test-bin", FISH_MARSHALLER);
+    IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
+        () -> Metadata.Key.of(":test-bin", FISH_MARSHALLER));
+    assertThat(e).hasMessageThat().isEqualTo("Invalid character ':' in key name ':test-bin'");
   }
 
   @Test
@@ -186,8 +182,7 @@ public void testGetAllNoRemove() {
     Iterator<Fish> i = metadata.getAll(KEY).iterator();
     assertEquals(lance, i.next());
 
-    thrown.expect(UnsupportedOperationException.class);
-    i.remove();
+    assertThrows(UnsupportedOperationException.class, i::remove);
   }
 
   @Test
@@ -271,17 +266,15 @@ public void mergeExpands() {
 
   @Test
   public void shortBinaryKeyName() {
-    thrown.expect(IllegalArgumentException.class);
-
-    Metadata.Key.of("-bin", FISH_MARSHALLER);
+    assertThrows(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);
+    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
@@ -313,6 +306,7 @@ public void verifyToString_usingBinary() {
   }
 
   @Test
+  @SuppressWarnings("StringCaseLocaleUsage")  // System locale is exactly what we're testing.
   public void testKeyCaseHandling() {
     Locale originalLocale = Locale.getDefault();
     Locale.setDefault(new Locale("tr", "TR"));
@@ -367,14 +361,12 @@ public void removeAllIgnoresMissingValue() {
   @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);
-    assertEquals(k1, k1);
-    assertNotEquals(k1, null);
-    assertNotEquals(k1, new Object(){});
-    assertEquals(k1, k2);
 
-    assertEquals(k1.hashCode(), k2.hashCode());
+    new EqualsTester()
+        .addEqualityGroup(k1, k2)
+        .addEqualityGroup(new Object(){})
+        .testEquals();
     // Check that the casing is preserved.
     assertEquals("CASE", k2.originalName());
     assertEquals("case", k2.name());
@@ -416,7 +408,7 @@ public void streamedValueDifferentMarshaller() {
     h.put(KEY_STREAMED, salmon);
 
     // Get using a different marshaller instance.
-    Fish fish = h.get(copyKey(KEY_STREAMED, new FishStreamMarsaller()));
+    Fish fish = h.get(copyKey(KEY_STREAMED, new FishStreamMarshaller()));
     assertEquals(salmon, fish);
   }
 
diff --git a/api/src/test/java/io/grpc/MethodDescriptorTest.java b/api/src/test/java/io/grpc/MethodDescriptorTest.java
index 5e742fb47ed..e068e0c1108 100644
--- a/api/src/test/java/io/grpc/MethodDescriptorTest.java
+++ b/api/src/test/java/io/grpc/MethodDescriptorTest.java
@@ -26,9 +26,7 @@
 import io.grpc.MethodDescriptor.Marshaller;
 import io.grpc.MethodDescriptor.MethodType;
 import io.grpc.testing.TestMethodDescriptors;
-import org.junit.Rule;
 import org.junit.Test;
-import org.junit.rules.ExpectedException;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 
@@ -37,10 +35,6 @@
  */
 @RunWith(JUnit4.class)
 public class MethodDescriptorTest {
-  @SuppressWarnings("deprecation") // https://github.com/grpc/grpc-java/issues/7467
-  @Rule
-  public final ExpectedException thrown = ExpectedException.none();
-
   @Test
   public void createMethodDescriptor() {
     MethodDescriptor<String, String> descriptor = MethodDescriptor.<String, String>newBuilder()
@@ -67,7 +61,7 @@ public void idempotent() {
 
     assertFalse(descriptor.isIdempotent());
 
-    // Create a new desriptor by setting idempotent to true
+    // Create a new descriptor by setting idempotent to true
     MethodDescriptor<String, String> newDescriptor =
         descriptor.toBuilder().setIdempotent(true).build();
     assertTrue(newDescriptor.isIdempotent());
@@ -86,7 +80,7 @@ public void safe() {
         .build();
     assertFalse(descriptor.isSafe());
 
-    // Create a new desriptor by setting safe to true
+    // 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
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
index 6002dcdaf57..76976c3b59b 100644
--- a/api/src/test/java/io/grpc/NameResolverRegistryTest.java
+++ b/api/src/test/java/io/grpc/NameResolverRegistryTest.java
@@ -25,6 +25,7 @@
 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;
@@ -32,7 +33,8 @@
 /** Unit tests for {@link NameResolverRegistry}. */
 @RunWith(JUnit4.class)
 public class NameResolverRegistryTest {
-  private final URI uri = URI.create("dns:///localhost");
+  private final URI javaNetUri = URI.create("dns:///localhost");
+  private final Uri ioGrpcUri = Uri.create("dns:///localhost");
   private final NameResolver.Args args = NameResolver.Args.newBuilder()
       .setDefaultPort(8080)
       .setProxyDetector(mock(ProxyDetector.class))
@@ -59,12 +61,16 @@ public void deregister() {
     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()).containsExactly(p1, p2, p3).inOrder();
+    assertThat(reg.providers().get(sameScheme)).isSameInstanceAs(p1);
     reg.deregister(p2);
-    assertThat(reg.providers()).containsExactly(p1, p3).inOrder();
+    assertThat(reg.providers().get(sameScheme)).isSameInstanceAs(p1);
+    reg.deregister(p1);
+    assertThat(reg.providers().get(sameScheme)).isSameInstanceAs(p3);
+
   }
 
   @Test
@@ -75,12 +81,13 @@ public void provider_sorted() {
     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()).containsExactly(p3, p5, p1, p2, p4).inOrder();
+    assertThat(reg.providers().get(sameScheme)).isSameInstanceAs(p3);
   }
 
   @Test
@@ -90,75 +97,173 @@ public void getDefaultScheme_noProvider() {
   }
 
   @Test
-  public void newNameResolver_providerReturnsNull() {
+  public void newNameResolver_providerReturnsNull_ioGrpcUri() {
     NameResolverRegistry registry = new NameResolverRegistry();
     registry.register(
-        new BaseProvider(true, 5) {
+        new BaseProvider(true, 5, ioGrpcUri.getScheme()) {
           @Override
-          public NameResolver newNameResolver(URI passedUri, NameResolver.Args passedArgs) {
-            assertThat(passedUri).isSameInstanceAs(uri);
+          public NameResolver newNameResolver(Uri passedUri, NameResolver.Args passedArgs) {
+            assertThat(passedUri).isSameInstanceAs(ioGrpcUri);
             assertThat(passedArgs).isSameInstanceAs(args);
             return null;
           }
         });
-    assertThat(registry.asFactory().newNameResolver(uri, args)).isNull();
+    assertThat(registry.asFactory().newNameResolver(ioGrpcUri, args)).isNull();
+    assertThat(registry.asFactory().getDefaultScheme()).isEqualTo(ioGrpcUri.getScheme());
   }
 
   @Test
-  public void newNameResolver_providerReturnsNonNull() {
+  public void newNameResolver_providerReturnsNull_javaNetUri() {
     NameResolverRegistry registry = new NameResolverRegistry();
-    registry.register(new BaseProvider(true, 5) {
-      @Override
-      public NameResolver newNameResolver(URI passedUri, NameResolver.Args passedArgs) {
-        return null;
-      }
-    });
-    final NameResolver nr = new NameResolver() {
-      @Override public String getServiceAuthority() {
-        throw new UnsupportedOperationException();
-      }
+    registry.register(
+        new BaseProvider(true, 5, javaNetUri.getScheme()) {
+          @Override
+          public NameResolver newNameResolver(URI passedUri, NameResolver.Args passedArgs) {
+            assertThat(passedUri).isSameInstanceAs(javaNetUri);
+            assertThat(passedArgs).isSameInstanceAs(args);
+            return null;
+          }
+        });
+    assertThat(registry.asFactory().newNameResolver(javaNetUri, args)).isNull();
+    assertThat(registry.asFactory().getDefaultScheme()).isEqualTo(javaNetUri.getScheme());
+  }
 
-      @Override public void start(Listener2 listener) {
-        throw new UnsupportedOperationException();
-      }
+  @Test
+  public void newNameResolver_providerReturnsNonNull_ioGrpcUri() {
+    NameResolverRegistry registry = new NameResolverRegistry();
+    Uri uri = ioGrpcUri;
+    registry.register(
+        new BaseProvider(true, 5, uri.getScheme()) {
+          @Override
+          public NameResolver newNameResolver(Uri passedUri, NameResolver.Args passedArgs) {
+            return null;
+          }
+        });
+    final NameResolver nr = new DummyNameResolver();
+    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());
+  }
 
-      @Override public void shutdown() {
-        throw new UnsupportedOperationException();
-      }
-    };
+  @Test
+  public void newNameResolver_providerReturnsNonNull_javaNetUri() {
+    NameResolverRegistry registry = new NameResolverRegistry();
+    URI uri = javaNetUri;
     registry.register(
-        new BaseProvider(true, 4) {
+        new BaseProvider(true, 5, uri.getScheme()) {
+          @Override
+          public NameResolver newNameResolver(URI passedUri, NameResolver.Args passedArgs) {
+            return null;
+          }
+        });
+    final NameResolver nr = new DummyNameResolver();
+    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) {
+        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)).isSameInstanceAs(nr);
+    assertThat(registry.asFactory().newNameResolver(uri, args)).isNull();
+    assertThat(registry.asFactory().getDefaultScheme()).isEqualTo(uri.getScheme());
+  }
+
+  @Test
+  public void newNameResolver_multipleScheme_ioGrpcUri() {
+    NameResolverRegistry registry = new NameResolverRegistry();
+    Uri uri = ioGrpcUri;
+    registry.register(
+        new BaseProvider(true, 5, uri.getScheme()) {
+          @Override
+          public NameResolver newNameResolver(Uri passedUri, NameResolver.Args passedArgs) {
+            return null;
+          }
+        });
+    final NameResolver nr = new DummyNameResolver();
+    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("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_multipleScheme_javaNetUri() {
+    NameResolverRegistry registry = new NameResolverRegistry();
+    URI uri = javaNetUri;
+    registry.register(
+        new BaseProvider(true, 5, uri.getScheme()) {
+          @Override
+          public NameResolver newNameResolver(URI passedUri, NameResolver.Args passedArgs) {
+            return null;
+          }
+        });
+    final NameResolver nr = new DummyNameResolver();
+    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.newNameResolver(javaNetUri, args)).isNull();
+    assertThat(factory.newNameResolver(ioGrpcUri, args)).isNull();
+    assertThat(factory.getDefaultScheme()).isEqualTo("unknown");
   }
 
   @Test
   public void baseProviders() {
-    List<NameResolverProvider> providers = NameResolverRegistry.getDefaultRegistry().providers();
-    assertThat(providers).hasSize(2);
-    // 2 name resolvers from grpclb and core, ordered with decreasing priorities.
-    assertThat(providers.get(0).getClass().getName())
-        .isEqualTo("io.grpc.grpclb.SecretGrpclbNameResolverProvider$Provider");
-    assertThat(providers.get(1).getClass().getName())
-        .isEqualTo("io.grpc.internal.DnsNameResolverProvider");
+    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");
   }
@@ -184,10 +289,18 @@ NameResolverProvider.class, getClass().getClassLoader())) {
   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
@@ -205,9 +318,31 @@ public NameResolver newNameResolver(URI targetUri, NameResolver.Args args) {
       throw new UnsupportedOperationException();
     }
 
+    @Override
+    public NameResolver newNameResolver(Uri targetUri, NameResolver.Args args) {
+      throw new UnsupportedOperationException();
+    }
+
     @Override
     public String getDefaultScheme() {
-      return "scheme" + getClass().getSimpleName();
+      return scheme == null ? "scheme" + getClass().getSimpleName() : scheme;
+    }
+  }
+
+  private static class DummyNameResolver extends NameResolver {
+    @Override
+    public String getServiceAuthority() {
+      throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public void start(Listener2 listener) {
+      throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public void shutdown() {
+      throw new UnsupportedOperationException();
     }
   }
 }
diff --git a/api/src/test/java/io/grpc/NameResolverTest.java b/api/src/test/java/io/grpc/NameResolverTest.java
index 0924002fd28..82abe5c7505 100644
--- a/api/src/test/java/io/grpc/NameResolverTest.java
+++ b/api/src/test/java/io/grpc/NameResolverTest.java
@@ -17,30 +17,47 @@
 package io.grpc;
 
 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.same;
 import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
 
+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.URI;
+import java.net.SocketAddress;
 import java.util.Collections;
-import java.util.Map;
+import java.util.List;
 import java.util.concurrent.Executor;
 import java.util.concurrent.Executors;
 import java.util.concurrent.ScheduledExecutorService;
-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.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 =
@@ -50,13 +67,10 @@ public class NameResolverTest {
       mock(ScheduledExecutorService.class);
   private final ChannelLogger channelLogger = mock(ChannelLogger.class);
   private final Executor executor = Executors.newSingleThreadExecutor();
-  private URI uri;
-  private final NameResolver nameResolver = mock(NameResolver.class);
-
-  @Before
-  public void setUp() throws Exception {
-    uri = new URI("fake://service");
-  }
+  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() {
@@ -68,6 +82,10 @@ public void args() {
     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);
@@ -77,191 +95,163 @@ public void args() {
     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);
   }
 
-  @Deprecated
-  @Test
-  public void newNameResolver_Api2DelegatesToApi1() {
-    final AtomicReference<Attributes> paramsCapture = new AtomicReference<>();
-    NameResolver.Factory factory = new NameResolver.Factory() {
-        @Deprecated
-        @Override
-        public NameResolver newNameResolver(URI targetUri, Attributes params) {
-          assertThat(targetUri).isSameInstanceAs(uri);
-          paramsCapture.set(params);
-          return nameResolver;
-        }
-
-        @Override
-        public String getDefaultScheme() {
-          throw new AssertionError();
-        }
-      };
-    assertThat(factory.newNameResolver(uri, new NameResolver.Helper() {
-        @Override
-        public int getDefaultPort() {
-          return defaultPort;
-        }
-
-        @Override
-        public ProxyDetector getProxyDetector() {
-          return proxyDetector;
-        }
-
-        @Override
-        public SynchronizationContext getSynchronizationContext() {
-          return syncContext;
-        }
-      })).isSameInstanceAs(nameResolver);
-    Attributes params = paramsCapture.get();
-    assertThat(params.get(NameResolver.Factory.PARAMS_DEFAULT_PORT)).isEqualTo(defaultPort);
-    assertThat(params.get(NameResolver.Factory.PARAMS_PROXY_DETECTOR))
-        .isSameInstanceAs(proxyDetector);
+  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();
   }
 
-  @Deprecated
-  @SuppressWarnings("unchecked")
   @Test
-  public void newNameResolver_Api3DelegatesToApi2() {
-    final AtomicReference<NameResolver.Helper> helperCapture = new AtomicReference<>();
-    NameResolver.Factory factory = new NameResolver.Factory() {
-        @Deprecated
-        @Override
-        public NameResolver newNameResolver(URI targetUri, NameResolver.Helper helper) {
-          assertThat(targetUri).isSameInstanceAs(uri);
-          helperCapture.set(helper);
-          return nameResolver;
-        }
-
-        @Override
-        public String getDefaultScheme() {
-          return "fake";
-        }
-      };
-    assertThat(factory.newNameResolver(uri, createArgs())).isSameInstanceAs(nameResolver);
-    NameResolver.Helper helper = helperCapture.get();
-    assertThat(helper.getDefaultPort()).isEqualTo(defaultPort);
-    assertThat(helper.getProxyDetector()).isSameInstanceAs(proxyDetector);
-    assertThat(helper.getSynchronizationContext()).isSameInstanceAs(syncContext);
-
-    // Test service config parsing
-    ConfigOrError coe = ConfigOrError.fromConfig("A config");
-    when(parser.parseServiceConfig(any(Map.class))).thenReturn(coe);
-    Map<String, ?> rawConfig = Collections.singletonMap("Key", "value");
-    assertThat(helper.parseServiceConfig(rawConfig)).isSameInstanceAs(coe);
-    verify(parser).parseServiceConfig(same(rawConfig));
+  @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);
   }
 
-  // Tests that a forwarding factory on API1 can correctly delegate to a factory already migrated
-  // to API3 without losing information.
-  @Deprecated
-  @SuppressWarnings("unchecked")
   @Test
-  public void newNameResolver_forwardingFactory1DelegatesToApi3() {
-    final AtomicReference<NameResolver.Args> argsCapture = new AtomicReference<>();
-    final NameResolver.Factory delegate = new NameResolver.Factory() {
-        @Override
-        public NameResolver newNameResolver(URI targetUri, NameResolver.Args args) {
-          assertThat(targetUri).isSameInstanceAs(uri);
-          argsCapture.set(args);
-          return nameResolver;
-        }
-
-        @Override
-        public String getDefaultScheme() {
-          throw new AssertionError();
-        }
-      };
-
-    NameResolver.Factory forwarding = new NameResolver.Factory() {
-        @Deprecated
-        public NameResolver newNameResolver(URI targetUri, Attributes attrs) {
-          return delegate.newNameResolver(targetUri, attrs);
-        }
-
-        @Override
-        public String getDefaultScheme() {
-          throw new AssertionError();
-        }
-      };
-
-    // gRPC channel is calling forwarding with API3.
-    assertThat(forwarding.newNameResolver(uri, createArgs())).isSameInstanceAs(nameResolver);
-
-    NameResolver.Args args = argsCapture.get();
-    assertThat(args.getDefaultPort()).isEqualTo(defaultPort);
-    assertThat(args.getProxyDetector()).isSameInstanceAs(proxyDetector);
-    assertThat(args.getSynchronizationContext()).isSameInstanceAs(syncContext);
+  @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;
+      }
 
-    ServiceConfigParser passedParser = args.getServiceConfigParser();
-    ConfigOrError coe = ConfigOrError.fromConfig("A config");
-    when(parser.parseServiceConfig(any(Map.class))).thenReturn(coe);
-    Map<String, ?> rawConfig = Collections.singletonMap("Key", "value");
-    assertThat(passedParser.parseServiceConfig(rawConfig)).isSameInstanceAs(coe);
-    verify(parser).parseServiceConfig(same(rawConfig));
+      @Override
+      public void onError(Status error) {}
+    };
+
+    listener2.onAddresses(ADDRESSES, ATTRIBUTES);
+
+    assertThat(resolutionResult[0].getAddressesOrError().getValue()).isEqualTo(ADDRESSES);
+    assertThat(resolutionResult[0].getAttributes()).isEqualTo(ATTRIBUTES);
   }
 
-  // Tests that a forwarding factory on API2 can correctly delegate to a factory already migrated
-  // to API3 without losing information.
-  @Deprecated
-  @SuppressWarnings("unchecked")
   @Test
-  public void newNameResolver_forwardingFactory2DelegatesToApi3() {
-    final AtomicReference<NameResolver.Args> argsCapture = new AtomicReference<>();
-    final NameResolver.Factory delegate = new NameResolver.Factory() {
-        @Override
-        public NameResolver newNameResolver(URI targetUri, NameResolver.Args args) {
-          assertThat(targetUri).isSameInstanceAs(uri);
-          argsCapture.set(args);
-          return nameResolver;
-        }
-
-        @Override
-        public String getDefaultScheme() {
-          throw new AssertionError();
-        }
-      };
-
-    NameResolver.Factory forwarding = new NameResolver.Factory() {
-        @Deprecated
-        public NameResolver newNameResolver(URI targetUri, NameResolver.Helper helper) {
-          return delegate.newNameResolver(targetUri, helper);
-        }
-
-        @Override
-        public String getDefaultScheme() {
-          throw new AssertionError();
-        }
-      };
-
-    // gRPC channel is calling forwarding with API3.
-    assertThat(forwarding.newNameResolver(uri, createArgs())).isSameInstanceAs(nameResolver);
-
-    NameResolver.Args args = argsCapture.get();
-    assertThat(args.getDefaultPort()).isEqualTo(defaultPort);
-    assertThat(args.getProxyDetector()).isSameInstanceAs(proxyDetector);
-    assertThat(args.getSynchronizationContext()).isSameInstanceAs(syncContext);
+  public void resolutionResult_toString_addressesAttributesAndConfig() {
+    ResolutionResult resolutionResult = ResolutionResult.newBuilder()
+        .setAddressesOrError(StatusOr.fromValue(ADDRESSES))
+        .setAttributes(ATTRIBUTES)
+        .setServiceConfig(CONFIG)
+        .build();
 
-    ServiceConfigParser passedParser = args.getServiceConfigParser();
-    ConfigOrError coe = ConfigOrError.fromConfig("A config");
-    when(parser.parseServiceConfig(any(Map.class))).thenReturn(coe);
-    Map<String, ?> rawConfig = Collections.singletonMap("Key", "value");
-    assertThat(passedParser.parseServiceConfig(rawConfig)).isSameInstanceAs(coe);
-    verify(parser).parseServiceConfig(same(rawConfig));
+    assertThat(resolutionResult.toString()).isEqualTo(
+        "ResolutionResult{addressesOrError=StatusOr{value="
+            + "[[[FakeSocketAddress-fake-address-1]/{}]]}, attributes={yolo=To be, or not to be?}, "
+            + "serviceConfigOrError=ConfigOrError{config=foo}}");
   }
 
-  private NameResolver.Args createArgs() {
-    return NameResolver.Args.newBuilder()
-        .setDefaultPort(defaultPort)
-        .setProxyDetector(proxyDetector)
-        .setSynchronizationContext(syncContext)
-        .setServiceConfigParser(parser)
-        .setScheduledExecutorService(scheduledExecutorService)
-        .setChannelLogger(channelLogger)
-        .setOffloadExecutor(executor)
+  @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/context/src/test/java/io/grpc/PersistentHashArrayMappedTrieTest.java b/api/src/test/java/io/grpc/PersistentHashArrayMappedTrieTest.java
similarity index 95%
rename from context/src/test/java/io/grpc/PersistentHashArrayMappedTrieTest.java
rename to api/src/test/java/io/grpc/PersistentHashArrayMappedTrieTest.java
index f02c2916e36..aeac2f51a5b 100644
--- a/context/src/test/java/io/grpc/PersistentHashArrayMappedTrieTest.java
+++ b/api/src/test/java/io/grpc/PersistentHashArrayMappedTrieTest.java
@@ -84,15 +84,25 @@ public void leaf_insert() {
     assertEquals(2, ret.size());
   }
 
-  @Test(expected = AssertionError.class)
+  @SuppressWarnings("CheckReturnValue")
+  @Test
   public void collisionLeaf_assertKeysDifferent() {
     Key key1 = new Key(0);
-    new CollisionLeaf<>(key1, new Object(), key1, new Object());
+    try {
+      new CollisionLeaf<>(key1, new Object(), key1, new Object());
+      throw new Error();
+    } catch (AssertionError expected) {
+    }
   }
 
-  @Test(expected = AssertionError.class)
+  @SuppressWarnings("CheckReturnValue")
+  @Test
   public void collisionLeaf_assertHashesSame() {
-    new CollisionLeaf<>(new Key(0), new Object(), new Key(1), new Object());
+    try {
+      new CollisionLeaf<>(new Key(0), new Object(), new Key(1), new Object());
+      throw new Error();
+    } catch (AssertionError expected) {
+    }
   }
 
   @Test
diff --git a/api/src/test/java/io/grpc/QueryParamsTest.java b/api/src/test/java/io/grpc/QueryParamsTest.java
new file mode 100644
index 00000000000..2def165a170
--- /dev/null
+++ b/api/src/test/java/io/grpc/QueryParamsTest.java
@@ -0,0 +1,274 @@
+/*
+ * 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;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertThrows;
+
+import io.grpc.QueryParams.Entry;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link QueryParams}. */
+@RunWith(JUnit4.class)
+public class QueryParamsTest {
+
+  @Test
+  public void emptyInstance() {
+    QueryParams params = new QueryParams();
+    assertThat(params.asList()).isEmpty();
+    assertThat(params.toRawQuery()).isNull();
+  }
+
+  @Test
+  public void parseNull_yieldsEmptyInstance() {
+    QueryParams params = QueryParams.fromRawQuery(null);
+    assertThat(params.asList()).isEmpty();
+    assertThat(params.toRawQuery()).isNull();
+  }
+
+  @Test
+  public void parseEmptyString_yieldsSingleLoneKey() {
+    QueryParams params = QueryParams.fromRawQuery("");
+    assertThat(params.toRawQuery()).isEmpty();
+    assertThat(params.asList()).isNotEmpty();
+    Entry entry = params.asList().get(0);
+    assertThat(entry).isNotNull();
+    assertThat(entry.getKey()).isEmpty();
+    assertThat(entry.hasValue()).isFalse();
+    assertThat(entry.getValue()).isNull();
+  }
+
+  @Test
+  public void parseNormalPairs() {
+    QueryParams params = QueryParams.fromRawQuery("a=b&c=d");
+    assertThat(params.toRawQuery()).isEqualTo("a=b&c=d");
+
+    QueryParams.Entry a = params.asList().get(0);
+    assertThat(a.getKey()).isEqualTo("a");
+    assertThat(a.hasValue()).isTrue();
+    assertThat(a.getValue()).isEqualTo("b");
+
+    QueryParams.Entry c = params.asList().get(1);
+    assertThat(c.getKey()).isEqualTo("c");
+    assertThat(c.getValue()).isEqualTo("d");
+  }
+
+  @Test
+  public void parseLoneKey() {
+    QueryParams params = QueryParams.fromRawQuery("a&b");
+    assertThat(params.toRawQuery()).isEqualTo("a&b");
+
+    QueryParams.Entry a = params.asList().get(0);
+    assertThat(a.getKey()).isEqualTo("a");
+    assertThat(a.hasValue()).isFalse();
+
+    QueryParams.Entry b = params.asList().get(1);
+    assertThat(b.getKey()).isEqualTo("b");
+    assertThat(b.hasValue()).isFalse();
+  }
+
+  @Test
+  public void parseEmptyKeysAndValues() {
+    QueryParams params = QueryParams.fromRawQuery("=&=");
+    assertThat(params.toRawQuery()).isEqualTo("=&=");
+
+    assertThat(params.asList()).hasSize(2);
+    assertThat(params.asList().get(0).getKey()).isEmpty();
+    assertThat(params.asList().get(0).hasValue()).isTrue();
+    assertThat(params.asList().get(0).getValue()).isEmpty();
+    assertThat(params.asList().get(1).getKey()).isEmpty();
+    assertThat(params.asList().get(1).hasValue()).isTrue();
+    assertThat(params.asList().get(1).getValue()).isEmpty();
+  }
+
+  @Test
+  public void roundTripPreservesEncodingOfSpaces() {
+    // Spaces can be encoded as + or %20.
+    QueryParams params = QueryParams.fromRawQuery("a+b=c%20d");
+    assertThat(params.asList().get(0).getKey()).isEqualTo("a b");
+    assertThat(params.asList().get(0).getValue()).isEqualTo("c d");
+    assertThat(params.toRawQuery()).isEqualTo("a+b=c%20d");
+  }
+
+  @Test
+  public void roundTripPreservesCaseOfHexDigits() {
+    // Percent encoding can use upper or lower case.
+    QueryParams params = QueryParams.fromRawQuery("%4A%4a=%4B%4b");
+    assertThat(params.asList().get(0).getKey()).isEqualTo("JJ");
+    assertThat(params.asList().get(0).getValue()).isEqualTo("KK");
+    assertThat(params.toRawQuery()).isEqualTo("%4A%4a=%4B%4b");
+  }
+
+  @Test
+  public void asListMethod() {
+    QueryParams params = new QueryParams();
+    params.asList().add(QueryParams.Entry.forKeyValue("a b", "c d"));
+    params.asList().add(QueryParams.Entry.forLoneKey("e f"));
+
+    // URLEncoder encodes spaces as +
+    assertThat(params.toRawQuery()).isEqualTo("a+b=c+d&e+f");
+  }
+
+  @Test
+  public void parseInvalidPercentEncodingThrows() {
+    assertThrows(IllegalArgumentException.class, () -> QueryParams.fromRawQuery("a=%GH"));
+  }
+
+  @Test
+  public void parseInvalidKeyValueEncodingSucceeds() {
+    QueryParams params = QueryParams.fromRawQuery("====");
+    assertThat(params.asList())
+        .containsExactly(Entry.forRawKeyValue("", "==="))
+        .inOrder();
+    assertThat(params.toRawQuery()).isEqualTo("====");
+  }
+
+  @Test
+  public void uriIntegration_canBuild() {
+    QueryParams params = new QueryParams();
+    params.asList().add(Entry.forKeyValue("a", "b"));
+    params.asList().add(Entry.forKeyValue("c", "d"));
+
+    Uri uri =
+        Uri.newBuilder()
+            .setScheme("http")
+            .setHost("example.com")
+            .setRawQuery(params.toRawQuery())
+            .build();
+
+    assertThat(uri.toString()).isEqualTo("http://example.com?a=b&c=d");
+    assertThat(uri.getRawQuery()).isEqualTo("a=b&c=d");
+  }
+
+  @Test
+  public void uriIntegration_canBuildEmpty() {
+    QueryParams params = new QueryParams();
+    Uri uri =
+        Uri.newBuilder()
+            .setScheme("http")
+            .setHost("example.com")
+            .setRawQuery(params.toRawQuery())
+            .build();
+
+    assertThat(uri.toString()).isEqualTo("http://example.com");
+    assertThat(uri.getRawQuery()).isNull();
+  }
+
+  @Test
+  public void uriIntegration_canParse() {
+    Uri uri = Uri.create("http://example.com?a=b&c=d&e");
+    QueryParams params = QueryParams.fromRawQuery(uri.getRawQuery());
+
+    assertThat(params.asList())
+        .containsExactly(
+            Entry.forKeyValue("a", "b"), Entry.forKeyValue("c", "d"), Entry.forLoneKey("e"))
+        .inOrder();
+  }
+
+  @Test
+  public void keysAndValuesWithCharactersNeedingUrlEncoding() {
+    QueryParams params = new QueryParams();
+    params.asList().add(Entry.forKeyValue("a=b", "c&d"));
+    params.asList().add(Entry.forKeyValue("e+f", "g h"));
+
+    assertThat(params.toRawQuery()).isEqualTo("a%3Db=c%26d&e%2Bf=g+h");
+
+    QueryParams roundTripped = QueryParams.fromRawQuery(params.toRawQuery());
+    assertThat(roundTripped).isEqualTo(params);
+  }
+
+  @Test
+  public void keysAndValuesWithCodePointsOutsideAsciiRange() {
+    QueryParams params = new QueryParams();
+    params.asList().add(Entry.forKeyValue("€", "𐐷"));
+
+    assertThat(params.toRawQuery()).isEqualTo("%E2%82%AC=%F0%90%90%B7");
+
+    QueryParams roundTripped = QueryParams.fromRawQuery(params.toRawQuery());
+    assertThat(roundTripped).isEqualTo(params);
+  }
+
+  @Test
+  public void toStringMethod() {
+    QueryParams params = new QueryParams();
+    assertThat(params.toString()).isEqualTo("[]");
+
+    params.asList().add(Entry.forKeyValue("a", "b"));
+    assertThat(params.toString()).isEqualTo("[a=b]");
+
+    params.asList().add(Entry.forLoneKey("c"));
+    assertThat(params.toString()).isEqualTo("[a=b, c]");
+
+    params.asList().add(Entry.forKeyValue("d=e", "f&g"));
+    assertThat(params.toString()).isEqualTo("[a=b, c, d%3De=f%26g]");
+  }
+
+  @Test
+  public void entryProperties() {
+    Entry keyValue = Entry.forKeyValue("key", "val");
+    assertThat(keyValue.getKey()).isEqualTo("key");
+    assertThat(keyValue.getValue()).isEqualTo("val");
+    assertThat(keyValue.hasValue()).isTrue();
+
+    Entry loneKey = Entry.forLoneKey("key");
+    assertThat(loneKey.getKey()).isEqualTo("key");
+    assertThat(loneKey.getValue()).isNull();
+    assertThat(loneKey.hasValue()).isFalse();
+  }
+
+  @Test
+  public void equalsAndHashCode_container() {
+    QueryParams params1 = new QueryParams();
+    QueryParams params2 = new QueryParams();
+
+    // Empty instances are equal
+    assertThat(params1).isEqualTo(params2);
+    assertThat(params1.hashCode()).isEqualTo(params2.hashCode());
+
+    params1.asList().add(Entry.forKeyValue("a", "b"));
+    params1.asList().add(Entry.forLoneKey("c"));
+
+    params2.asList().add(Entry.forKeyValue("a", "b"));
+    params2.asList().add(Entry.forLoneKey("c"));
+
+    // Identical parameters in identical order are equal
+    assertThat(params1).isEqualTo(params2);
+    assertThat(params1.hashCode()).isEqualTo(params2.hashCode());
+
+    // Order matters.
+    QueryParams params3 = new QueryParams();
+    params3.asList().add(Entry.forLoneKey("c"));
+    params3.asList().add(Entry.forKeyValue("a", "b"));
+    assertThat(params1).isNotEqualTo(params3);
+  }
+
+  @Test
+  public void equalsAndHashCode_entry() {
+    // Raw matches are equal.
+    assertThat(Entry.forRawKeyValue("a+b", "c")).isEqualTo(Entry.forRawKeyValue("a+b", "c"));
+    assertThat(Entry.forRawKeyValue("a+b", "c").hashCode())
+        .isEqualTo(Entry.forRawKeyValue("a+b", "c").hashCode());
+
+    // Spaces encoding matters. + and %20 are not equal.
+    assertThat(Entry.forRawKeyValue("a+b", "c")).isNotEqualTo(Entry.forRawKeyValue("a%20b", "c"));
+
+    // Case of hex digits matter: %4A vs %4a are not equal raw keys.
+    assertThat(Entry.forRawKeyValue("a", "%4A")).isNotEqualTo(Entry.forRawKeyValue("a", "%4a"));
+  }
+}
diff --git a/api/src/test/java/io/grpc/ServerInterceptorsTest.java b/api/src/test/java/io/grpc/ServerInterceptorsTest.java
index fa4e7e747a2..b84b3838afa 100644
--- a/api/src/test/java/io/grpc/ServerInterceptorsTest.java
+++ b/api/src/test/java/io/grpc/ServerInterceptorsTest.java
@@ -19,6 +19,7 @@
 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.AdditionalAnswers.delegatesTo;
 import static org.mockito.ArgumentMatchers.same;
@@ -31,7 +32,6 @@
 import io.grpc.MethodDescriptor.Marshaller;
 import io.grpc.MethodDescriptor.MethodType;
 import io.grpc.ServerCall.Listener;
-import io.grpc.internal.NoopServerCall;
 import java.io.ByteArrayInputStream;
 import java.io.InputStream;
 import java.util.ArrayList;
@@ -41,7 +41,6 @@
 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.ArgumentMatchers;
@@ -56,10 +55,6 @@ public class ServerInterceptorsTest {
   @Rule
   public final MockitoRule mocks = MockitoJUnit.rule();
 
-  @SuppressWarnings("deprecation") // https://github.com/grpc/grpc-java/issues/7467
-  @Rule
-  public final ExpectedException thrown = ExpectedException.none();
-
   @Mock
   private Marshaller<String> requestMarshaller;
 
@@ -112,21 +107,21 @@ public void makeSureExpectedMocksUnused() {
   public void npeForNullServiceDefinition() {
     ServerServiceDefinition serviceDef = null;
     List<ServerInterceptor> interceptors = Arrays.asList();
-    thrown.expect(NullPointerException.class);
-    ServerInterceptors.intercept(serviceDef, interceptors);
+    assertThrows(NullPointerException.class,
+        () -> ServerInterceptors.intercept(serviceDef, interceptors));
   }
 
   @Test
   public void npeForNullInterceptorList() {
-    thrown.expect(NullPointerException.class);
-    ServerInterceptors.intercept(serviceDefinition, (List<ServerInterceptor>) null);
+    assertThrows(NullPointerException.class,
+        () -> ServerInterceptors.intercept(serviceDefinition, (List<ServerInterceptor>) null));
   }
 
   @Test
   public void npeForNullInterceptor() {
     List<ServerInterceptor> interceptors = Arrays.asList((ServerInterceptor) null);
-    thrown.expect(NullPointerException.class);
-    ServerInterceptors.intercept(serviceDefinition, interceptors);
+    assertThrows(NullPointerException.class,
+        () -> ServerInterceptors.intercept(serviceDefinition, interceptors));
   }
 
   @Test
@@ -425,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) {
diff --git a/api/src/test/java/io/grpc/ServerServiceDefinitionTest.java b/api/src/test/java/io/grpc/ServerServiceDefinitionTest.java
index 6a84d640d78..9e43302e210 100644
--- a/api/src/test/java/io/grpc/ServerServiceDefinitionTest.java
+++ b/api/src/test/java/io/grpc/ServerServiceDefinitionTest.java
@@ -18,14 +18,13 @@
 
 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.Rule;
 import org.junit.Test;
-import org.junit.rules.ExpectedException;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 
@@ -52,9 +51,6 @@ public class ServerServiceDefinitionTest {
         = ServerMethodDefinition.create(method1, methodHandler1);
   private ServerMethodDefinition<String, Integer> methodDef2
         = ServerMethodDefinition.create(method2, methodHandler2);
-  @SuppressWarnings("deprecation") // https://github.com/grpc/grpc-java/issues/7467
-  @Rule
-  public ExpectedException thrown = ExpectedException.none();
 
   @Test
   public void noMethods() {
@@ -91,9 +87,7 @@ 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();
+    assertThrows(IllegalStateException.class, () -> ssd.addMethod(diffMethod1, methodHandler2));
   }
 
   @Test
@@ -101,8 +95,7 @@ public void buildMisaligned_extraMethod() {
     ServiceDescriptor sd = new ServiceDescriptor(serviceName);
     ServerServiceDefinition.Builder ssd = ServerServiceDefinition.builder(sd)
         .addMethod(methodDef1);
-    thrown.expect(IllegalStateException.class);
-    ssd.build();
+    assertThrows(IllegalStateException.class, ssd::build);
   }
 
   @Test
@@ -110,16 +103,14 @@ 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();
+    assertThrows(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();
+    assertThrows(IllegalStateException.class, ssd::build);
   }
 
   @Test
diff --git a/api/src/test/java/io/grpc/ServiceDescriptorTest.java b/api/src/test/java/io/grpc/ServiceDescriptorTest.java
index a05858680d5..89bdead3632 100644
--- a/api/src/test/java/io/grpc/ServiceDescriptorTest.java
+++ b/api/src/test/java/io/grpc/ServiceDescriptorTest.java
@@ -16,17 +16,18 @@
 
 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.Rule;
 import org.junit.Test;
-import org.junit.rules.ExpectedException;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 
@@ -36,32 +37,27 @@
 @RunWith(JUnit4.class)
 public class ServiceDescriptorTest {
 
-  @SuppressWarnings("deprecation") // https://github.com/grpc/grpc-java/issues/7467
-  @Rule
-  public final ExpectedException thrown = ExpectedException.none();
-
   @Test
   public void failsOnNullName() {
-    thrown.expect(NullPointerException.class);
-    thrown.expectMessage("name");
-
-    new ServiceDescriptor(null, Collections.<MethodDescriptor<?, ?>>emptyList());
+    List<MethodDescriptor<?, ?>> methods = Collections.emptyList();
+    NullPointerException e = assertThrows(NullPointerException.class,
+        () -> new ServiceDescriptor(null, methods));
+    assertThat(e).hasMessageThat().isEqualTo("name");
   }
 
   @Test
   public void failsOnNullMethods() {
-    thrown.expect(NullPointerException.class);
-    thrown.expectMessage("methods");
-
-    new ServiceDescriptor("name", (Collection<MethodDescriptor<?, ?>>) null);
+    NullPointerException e = assertThrows(NullPointerException.class,
+        () -> new ServiceDescriptor("name", (Collection<MethodDescriptor<?, ?>>) null));
+    assertThat(e).hasMessageThat().isEqualTo("methods");
   }
 
   @Test
   public void failsOnNullMethod() {
-    thrown.expect(NullPointerException.class);
-    thrown.expectMessage("method");
-
-    new ServiceDescriptor("name", Collections.<MethodDescriptor<?, ?>>singletonList(null));
+    List<MethodDescriptor<?, ?>> methods = Collections.singletonList(null);
+    NullPointerException e = assertThrows(NullPointerException.class,
+        () -> new ServiceDescriptor("name", methods));
+    assertThat(e).hasMessageThat().isEqualTo("method");
   }
 
   @Test
@@ -69,15 +65,17 @@ public void failsOnNonMatchingNames() {
     List<MethodDescriptor<?, ?>> descriptors = Collections.<MethodDescriptor<?, ?>>singletonList(
         MethodDescriptor.<Void, Void>newBuilder()
           .setType(MethodType.UNARY)
-          .setFullMethodName(MethodDescriptor.generateFullMethodName("wrongservice", "method"))
+          .setFullMethodName(MethodDescriptor.generateFullMethodName("wrongService", "method"))
           .setRequestMarshaller(TestMethodDescriptors.voidMarshaller())
           .setResponseMarshaller(TestMethodDescriptors.voidMarshaller())
           .build());
 
-    thrown.expect(IllegalArgumentException.class);
-    thrown.expectMessage("service names");
-
-    new ServiceDescriptor("name", descriptors);
+    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
@@ -96,10 +94,9 @@ public void failsOnNonDuplicateNames() {
           .setResponseMarshaller(TestMethodDescriptors.voidMarshaller())
           .build());
 
-    thrown.expect(IllegalArgumentException.class);
-    thrown.expectMessage("duplicate");
-
-    new ServiceDescriptor("name", descriptors);
+    IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
+        () -> new ServiceDescriptor("name", descriptors));
+    assertThat(e).hasMessageThat().isEqualTo("duplicate name name/method");
   }
 
   @Test
diff --git a/api/src/test/java/io/grpc/ServiceProvidersTest.java b/api/src/test/java/io/grpc/ServiceProvidersTest.java
index 4bbfe2117be..f971ed42646 100644
--- a/api/src/test/java/io/grpc/ServiceProvidersTest.java
+++ b/api/src/test/java/io/grpc/ServiceProvidersTest.java
@@ -16,6 +16,7 @@
 
 package io.grpc;
 
+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;
@@ -23,12 +24,15 @@
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 
+import com.google.common.base.Supplier;
 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 java.util.ServiceLoader;
+import org.junit.After;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
@@ -36,7 +40,6 @@
 /** 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
@@ -51,6 +54,19 @@ public int getPriority(ServiceProvidersTestAbstractProvider provider) {
       };
   private final String serviceFile =
       "META-INF/services/io.grpc.ServiceProvidersTestAbstractProvider";
+  private boolean failingHardCodedAccessed;
+  private final Supplier<Iterable<Class<?>>> failingHardCoded = new Supplier<Iterable<Class<?>>>() {
+    @Override
+    public Iterable<Class<?>> get() {
+      failingHardCodedAccessed = true;
+      throw new AssertionError();
+    }
+  };
+
+  @After
+  public void tearDown() {
+    assertThat(failingHardCodedAccessed).isFalse();
+  }
 
   @Test
   public void contextClassLoaderProvider() {
@@ -69,8 +85,8 @@ public void contextClassLoaderProvider() {
       Thread.currentThread().setContextClassLoader(rcll);
       assertEquals(
           Available7Provider.class,
-          ServiceProviders.load(
-              ServiceProvidersTestAbstractProvider.class, NO_HARDCODED, cl, ACCESSOR).getClass());
+          load(ServiceProvidersTestAbstractProvider.class, failingHardCoded, cl, ACCESSOR)
+            .getClass());
     } finally {
       Thread.currentThread().setContextClassLoader(ccl);
     }
@@ -85,8 +101,7 @@ public void noProvider() {
           serviceFile,
           "io/grpc/ServiceProvidersTestAbstractProvider-doesNotExist.txt");
       Thread.currentThread().setContextClassLoader(cl);
-      assertNull(ServiceProviders.load(
-          ServiceProvidersTestAbstractProvider.class, NO_HARDCODED, cl, ACCESSOR));
+      assertNull(load(ServiceProvidersTestAbstractProvider.class, failingHardCoded, cl, ACCESSOR));
     } finally {
       Thread.currentThread().setContextClassLoader(ccl);
     }
@@ -98,11 +113,11 @@ public void multipleProvider() throws Exception {
         "io/grpc/ServiceProvidersTestAbstractProvider-multipleProvider.txt");
     assertSame(
         Available7Provider.class,
-        ServiceProviders.load(
-            ServiceProvidersTestAbstractProvider.class, NO_HARDCODED, cl, ACCESSOR).getClass());
+        load(ServiceProvidersTestAbstractProvider.class, failingHardCoded, cl, ACCESSOR)
+          .getClass());
 
-    List<ServiceProvidersTestAbstractProvider> providers = ServiceProviders.loadAll(
-        ServiceProvidersTestAbstractProvider.class, NO_HARDCODED, cl, ACCESSOR);
+    List<ServiceProvidersTestAbstractProvider> providers = loadAll(
+        ServiceProvidersTestAbstractProvider.class, failingHardCoded, cl, ACCESSOR);
     assertEquals(3, providers.size());
     assertEquals(Available7Provider.class, providers.get(0).getClass());
     assertEquals(Available5Provider.class, providers.get(1).getClass());
@@ -116,8 +131,8 @@ public void unavailableProvider() {
         "io/grpc/ServiceProvidersTestAbstractProvider-unavailableProvider.txt");
     assertEquals(
         Available7Provider.class,
-        ServiceProviders.load(
-            ServiceProvidersTestAbstractProvider.class, NO_HARDCODED, cl, ACCESSOR).getClass());
+        load(ServiceProvidersTestAbstractProvider.class, failingHardCoded, cl, ACCESSOR)
+          .getClass());
   }
 
   @Test
@@ -125,8 +140,7 @@ public void unknownClassProvider() {
     ClassLoader cl = new ReplacingClassLoader(getClass().getClassLoader(), serviceFile,
         "io/grpc/ServiceProvidersTestAbstractProvider-unknownClassProvider.txt");
     try {
-      ServiceProviders.load(
-          ServiceProvidersTestAbstractProvider.class, NO_HARDCODED, cl, ACCESSOR);
+      loadAll(ServiceProvidersTestAbstractProvider.class, failingHardCoded, cl, ACCESSOR);
       fail("Exception expected");
     } catch (ServiceConfigurationError e) {
       // noop
@@ -140,8 +154,7 @@ public void exceptionSurfacedToCaller_failAtInit() {
     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);
+      loadAll(ServiceProvidersTestAbstractProvider.class, failingHardCoded, cl, ACCESSOR);
       fail("Expected exception");
     } catch (ServiceConfigurationError expected) {
       // noop
@@ -154,8 +167,7 @@ public void exceptionSurfacedToCaller_failAtPriority() {
         "io/grpc/ServiceProvidersTestAbstractProvider-failAtPriorityProvider.txt");
     try {
       // The exception should be surfaced to the caller
-      ServiceProviders.load(
-          ServiceProvidersTestAbstractProvider.class, NO_HARDCODED, cl, ACCESSOR);
+      loadAll(ServiceProvidersTestAbstractProvider.class, failingHardCoded, cl, ACCESSOR);
       fail("Expected exception");
     } catch (FailAtPriorityProvider.PriorityException expected) {
       // noop
@@ -168,8 +180,7 @@ public void exceptionSurfacedToCaller_failAtAvailable() {
         "io/grpc/ServiceProvidersTestAbstractProvider-failAtAvailableProvider.txt");
     try {
       // The exception should be surfaced to the caller
-      ServiceProviders.load(
-          ServiceProvidersTestAbstractProvider.class, NO_HARDCODED, cl, ACCESSOR);
+      loadAll(ServiceProvidersTestAbstractProvider.class, failingHardCoded, cl, ACCESSOR);
       fail("Expected exception");
     } catch (FailAtAvailableProvider.AvailableException expected) {
       // noop
@@ -215,17 +226,57 @@ public void getCandidatesViaHardCoded_failAtInit_moreCandidates() throws Excepti
   }
 
   @Test
-  public void create_throwsErrorOnMisconfiguration() throws Exception {
-    class PrivateClass {}
+  public void getCandidatesViaHardCoded_throwsErrorOnMisconfiguration() throws Exception {
+    class PrivateClass extends BaseProvider {
+      private PrivateClass() {
+        super(true, 5);
+      }
+    }
 
     try {
-      ServiceProviders.create(
-          ServiceProvidersTestAbstractProvider.class, PrivateClass.class);
+      ServiceProviders.getCandidatesViaHardCoded(
+          ServiceProvidersTestAbstractProvider.class,
+          Collections.<Class<?>>singletonList(PrivateClass.class));
       fail("Expected exception");
     } catch (ServiceConfigurationError expected) {
-      assertTrue("Expected ClassCastException cause: " + expected.getCause(),
-          expected.getCause() instanceof ClassCastException);
+      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 <T> T load(
+      Class<T> klass,
+      Supplier<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);
+  }
+
+  private static <T> List<T> loadAll(
+      Class<T> klass,
+      Supplier<Iterable<Class<?>>> hardCoded,
+      ClassLoader classLoader,
+      PriorityAccessor<T> priorityAccessor) {
+    return ServiceProviders.loadAll(
+        klass,
+        ServiceLoader.load(klass, classLoader).iterator(),
+        hardCoded,
+        priorityAccessor);
   }
 
   private static class BaseProvider extends ServiceProvidersTestAbstractProvider {
diff --git a/api/src/test/java/io/grpc/StatusExceptionTest.java b/api/src/test/java/io/grpc/StatusExceptionTest.java
index dd0d12dccda..410cfb2289a 100644
--- a/api/src/test/java/io/grpc/StatusExceptionTest.java
+++ b/api/src/test/java/io/grpc/StatusExceptionTest.java
@@ -28,14 +28,6 @@
 @RunWith(JUnit4.class)
 public class StatusExceptionTest {
 
-  @Test
-  public void internalCtorRemovesStack() {
-    StackTraceElement[] trace =
-        new StatusException(Status.CANCELLED, null, false) {}.getStackTrace();
-
-    assertThat(trace).isEmpty();
-  }
-
   @Test
   public void normalCtorKeepsStack() {
     StackTraceElement[] trace =
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
index 2c3bf7e9c81..d965ed86253 100644
--- a/api/src/test/java/io/grpc/StatusRuntimeExceptionTest.java
+++ b/api/src/test/java/io/grpc/StatusRuntimeExceptionTest.java
@@ -31,7 +31,7 @@ public class StatusRuntimeExceptionTest {
   @Test
   public void internalCtorRemovesStack() {
     StackTraceElement[] trace =
-        new StatusRuntimeException(Status.CANCELLED, null, false) {}.getStackTrace();
+        new InternalStatusRuntimeException(Status.CANCELLED, null) {}.getStackTrace();
 
     assertThat(trace).isEmpty();
   }
@@ -54,15 +54,13 @@ public void extendPreservesStack() {
   @Test
   public void extendAndOverridePreservesStack() {
     final StackTraceElement element = new StackTraceElement("a", "b", "c", 4);
-    StatusRuntimeException exception =
-        new StatusRuntimeException(Status.CANCELLED, new Metadata()) {
-
+    StatusRuntimeException error = new StatusRuntimeException(Status.CANCELLED, new Metadata()) {
       @Override
       public synchronized Throwable fillInStackTrace() {
         setStackTrace(new StackTraceElement[]{element});
         return this;
       }
     };
-    assertThat(exception.getStackTrace()).asList().containsExactly(element);
+    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
index 9abeba436f7..5c8a1b2ae86 100644
--- a/api/src/test/java/io/grpc/StatusTest.java
+++ b/api/src/test/java/io/grpc/StatusTest.java
@@ -43,6 +43,7 @@ public void verifyExceptionMessage() {
   @Test
   public void impossibleCodeValue() {
     assertEquals(Code.UNKNOWN, Status.fromCodeValue(-1).getCode());
+    assertEquals(Code.UNKNOWN, Status.fromCodeValue(17).getCode());
   }
 
   @Test
diff --git a/api/src/test/java/io/grpc/SynchronizationContextTest.java b/api/src/test/java/io/grpc/SynchronizationContextTest.java
index 3d5e7fa42b9..668f5ae4d6d 100644
--- a/api/src/test/java/io/grpc/SynchronizationContextTest.java
+++ b/api/src/test/java/io/grpc/SynchronizationContextTest.java
@@ -27,6 +27,7 @@
 
 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;
@@ -72,7 +73,7 @@ public void uncaughtException(Thread t, Throwable e) {
 
   @Mock
   private Runnable task3;
-  
+
   @After public void tearDown() {
     assertThat(uncaughtErrors).isEmpty();
   }
@@ -246,6 +247,43 @@ public void schedule() {
     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();
@@ -357,5 +395,13 @@ static class MockScheduledExecutorService extends ForwardingScheduledExecutorSer
       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/context/src/test/java/io/grpc/ThreadLocalContextStorageTest.java b/api/src/test/java/io/grpc/ThreadLocalContextStorageTest.java
similarity index 100%
rename from context/src/test/java/io/grpc/ThreadLocalContextStorageTest.java
rename to api/src/test/java/io/grpc/ThreadLocalContextStorageTest.java
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/UriTest.java b/api/src/test/java/io/grpc/UriTest.java
new file mode 100644
index 00000000000..0de7ef0fc10
--- /dev/null
+++ b/api/src/test/java/io/grpc/UriTest.java
@@ -0,0 +1,828 @@
+/*
+ * 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.getRawQuery()).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.getRawQuery()).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.getRawQuery()).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.getRawQuery()).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.getRawQuery()).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.getRawQuery()).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.getRawQuery()).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_emptyQuery() {
+    Uri uri = Uri.create("scheme:?");
+    assertThat(uri.getScheme()).isEqualTo("scheme");
+    assertThat(uri.getRawQuery()).isEmpty();
+  }
+
+  @Test
+  public void parse_emptyFragment() {
+    Uri uri = Uri.create("scheme:#");
+    assertThat(uri.getScheme()).isEqualTo("scheme");
+    assertThat(uri.getFragment()).isEmpty();
+  }
+
+  @Test
+  public void parse_emptyUserInfo() {
+    Uri uri = Uri.create("scheme://@host");
+    assertThat(uri.getScheme()).isEqualTo("scheme");
+    assertThat(uri.getAuthority()).isEqualTo("@host");
+    assertThat(uri.getHost()).isEqualTo("host");
+    assertThat(uri.getUserInfo()).isEmpty();
+    assertThat(uri.toString()).isEqualTo("scheme://@host");
+  }
+
+  @Test
+  public void parse_emptyPort() {
+    Uri uri = Uri.create("scheme://host:");
+    assertThat(uri.getScheme()).isEqualTo("scheme");
+    assertThat(uri.getAuthority()).isEqualTo("host:");
+    assertThat(uri.getRawAuthority()).isEqualTo("host:");
+    assertThat(uri.getHost()).isEqualTo("host");
+    assertThat(uri.getPort()).isEqualTo(-1);
+    assertThat(uri.getRawPort()).isEqualTo("");
+    assertThat(uri.toString()).isEqualTo("scheme://host:");
+  }
+
+  @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_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.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#f%25ragment");
+    assertThat(uri.getPath()).isEqualTo("/p%20ath");
+    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")
+            .setRawQuery("q%20uery")
+            .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.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.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:/@")
+            .setRawQuery("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
+            .setRawQuery("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)
+            .setRawQuery(null)
+            .setFragment(null)
+            .build();
+    assertThat(uri.toString()).isEqualTo("http:");
+  }
+
+  @Test
+  public void builder_setRawQuery() {
+    Uri uri = Uri.newBuilder().setScheme("http").setHost("host").setRawQuery("%61=b&c=%64").build();
+    assertThat(uri.getRawQuery()).isEqualTo("%61=b&c=%64");
+    assertThat(uri.toString()).isEqualTo("http://host?%61=b&c=%64");
+  }
+
+  @Test
+  public void builder_setRawQuery_null() {
+    Uri uri =
+        Uri.newBuilder()
+            .setScheme("http")
+            .setHost("host")
+            .setRawQuery("a=b")
+            .setRawQuery(null)
+            .build();
+    assertThat(uri.getRawQuery()).isNull();
+    assertThat(uri.toString()).isEqualTo("http://host");
+  }
+
+  @Test
+  public void builder_setRawFragment() {
+    Uri uri = Uri.newBuilder().setScheme("http").setHost("host").setRawFragment("a%20b").build();
+    assertThat(uri.getRawFragment()).isEqualTo("a%20b");
+    assertThat(uri.getFragment()).isEqualTo("a b");
+    assertThat(uri.toString()).isEqualTo("http://host#a%20b");
+  }
+
+  @Test
+  public void builder_setRawFragment_null() {
+    Uri uri =
+        Uri.newBuilder()
+            .setScheme("http")
+            .setHost("host")
+            .setRawFragment("a%20b")
+            .setRawFragment(null)
+            .build();
+    assertThat(uri.getRawFragment()).isNull();
+    assertThat(uri.getFragment()).isNull();
+    assertThat(uri.toString()).isEqualTo("http://host");
+  }
+
+  @Test
+  public void builder_setRawFragment_invalidCharacters_throws() {
+    IllegalArgumentException e =
+        assertThrows(
+            IllegalArgumentException.class,
+            () -> Uri.newBuilder().setRawFragment("f[]rag"));
+    assertThat(e).hasMessageThat().contains("Invalid character in fragment");
+  }
+
+  @Test
+  public void builder_setRawFragment_invalidPercentEncoding_throws() {
+    IllegalArgumentException e =
+        assertThrows(
+            IllegalArgumentException.class,
+            () -> Uri.newBuilder().setRawFragment("f%XXragment"));
+    assertThat(e).hasMessageThat().contains("Invalid");
+  }
+
+  @Test
+  public void builder_canClearAuthorityComponents() {
+    Uri uri = Uri.create("s://user@host:80/path").toBuilder().setRawAuthority(null).build();
+    assertThat(uri.toString()).isEqualTo("s:/path");
+  }
+
+  @Test
+  public void builder_canSetEmptyAuthority() {
+    Uri uri = Uri.create("s://user@host:80/path").toBuilder().setRawAuthority("").build();
+    assertThat(uri.toString()).isEqualTo("s:///path");
+  }
+
+  @Test
+  public void builder_canSetRawAuthority() {
+    Uri uri = Uri.newBuilder().setScheme("http").setRawAuthority("user@host:1234").build();
+    assertThat(uri.getUserInfo()).isEqualTo("user");
+    assertThat(uri.getHost()).isEqualTo("host");
+    assertThat(uri.getPort()).isEqualTo(1234);
+  }
+
+  @Test
+  public void builder_setRawAuthorityPercentDecodes() {
+    Uri uri =
+        Uri.newBuilder()
+            .setScheme("http")
+            .setRawAuthority("user:user%40user@host%40host%3Ahost")
+            .build();
+    assertThat(uri.getUserInfo()).isEqualTo("user:user@user");
+    assertThat(uri.getHost()).isEqualTo("host@host:host");
+    assertThat(uri.getPort()).isEqualTo(-1);
+  }
+
+  @Test
+  public void builder_setRawAuthorityReplacesAllComponents() {
+    Uri uri =
+        Uri.newBuilder()
+            .setScheme("http")
+            .setUserInfo("user")
+            .setHost("host")
+            .setPort(1234)
+            .setRawAuthority("other")
+            .build();
+    assertThat(uri.getUserInfo()).isNull();
+    assertThat(uri.getHost()).isEqualTo("other");
+    assertThat(uri.getPort()).isEqualTo(-1);
+  }
+
+  @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")
+            .setRawQuery("q%25uery")
+            .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/testFixtures/java/io/grpc/FlagResetRule.java b/api/src/testFixtures/java/io/grpc/FlagResetRule.java
new file mode 100644
index 00000000000..08ce7ce82f2
--- /dev/null
+++ b/api/src/testFixtures/java/io/grpc/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;
+
+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/api/src/test/java/io/grpc/ForwardingTestUtil.java b/api/src/testFixtures/java/io/grpc/ForwardingTestUtil.java
similarity index 99%
rename from api/src/test/java/io/grpc/ForwardingTestUtil.java
rename to api/src/testFixtures/java/io/grpc/ForwardingTestUtil.java
index 3c77e9078b6..b7c91caee03 100644
--- a/api/src/test/java/io/grpc/ForwardingTestUtil.java
+++ b/api/src/testFixtures/java/io/grpc/ForwardingTestUtil.java
@@ -83,6 +83,7 @@ public static <T> void testMethodsForwarded(
     for (Method method : delegateClass.getDeclaredMethods()) {
       if (Modifier.isStatic(method.getModifiers())
           || Modifier.isPrivate(method.getModifiers())
+          || Modifier.isFinal(method.getModifiers())
           || skippedMethods.contains(method)) {
         continue;
       }
diff --git a/api/src/test/java/io/grpc/IntegerMarshaller.java b/api/src/testFixtures/java/io/grpc/IntegerMarshaller.java
similarity index 100%
rename from api/src/test/java/io/grpc/IntegerMarshaller.java
rename to api/src/testFixtures/java/io/grpc/IntegerMarshaller.java
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/test/java/io/grpc/ManagedChannelRegistryAccessor.java b/api/src/testFixtures/java/io/grpc/ManagedChannelRegistryAccessor.java
similarity index 100%
rename from api/src/test/java/io/grpc/ManagedChannelRegistryAccessor.java
rename to api/src/testFixtures/java/io/grpc/ManagedChannelRegistryAccessor.java
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/testing/src/main/java/io/grpc/internal/NoopClientCall.java b/api/src/testFixtures/java/io/grpc/NoopClientCall.java
similarity index 95%
rename from testing/src/main/java/io/grpc/internal/NoopClientCall.java
rename to api/src/testFixtures/java/io/grpc/NoopClientCall.java
index a81fdaeeb19..0b2b0fbadad 100644
--- a/testing/src/main/java/io/grpc/internal/NoopClientCall.java
+++ b/api/src/testFixtures/java/io/grpc/NoopClientCall.java
@@ -14,10 +14,7 @@
  * limitations under the License.
  */
 
-package io.grpc.internal;
-
-import io.grpc.ClientCall;
-import io.grpc.Metadata;
+package io.grpc;
 
 /**
  * {@link NoopClientCall} is a class that is designed for use in tests.  It is designed to be used
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/testing/src/main/java/io/grpc/internal/NoopServerCall.java b/api/src/testFixtures/java/io/grpc/NoopServerCall.java
similarity index 92%
rename from testing/src/main/java/io/grpc/internal/NoopServerCall.java
rename to api/src/testFixtures/java/io/grpc/NoopServerCall.java
index 45038198fa9..f4010851630 100644
--- a/testing/src/main/java/io/grpc/internal/NoopServerCall.java
+++ b/api/src/testFixtures/java/io/grpc/NoopServerCall.java
@@ -14,12 +14,7 @@
  * limitations under the License.
  */
 
-package io.grpc.internal;
-
-import io.grpc.Metadata;
-import io.grpc.MethodDescriptor;
-import io.grpc.ServerCall;
-import io.grpc.Status;
+package io.grpc;
 
 /**
  * {@link NoopServerCall} is a class that is designed for use in tests.  It is designed to be used
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/context/src/test/java/io/grpc/StaticTestingClassLoader.java b/api/src/testFixtures/java/io/grpc/StaticTestingClassLoader.java
similarity index 100%
rename from context/src/test/java/io/grpc/StaticTestingClassLoader.java
rename to api/src/testFixtures/java/io/grpc/StaticTestingClassLoader.java
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..08e9fffb013
--- /dev/null
+++ b/api/src/testFixtures/java/io/grpc/StatusMatcher.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;
+
+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, 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 final ArgumentMatcher<Throwable> causeMatcher;
+
+  private StatusMatcher(
+      ArgumentMatcher<Status.Code> codeMatcher,
+      ArgumentMatcher<String> descriptionMatcher,
+      ArgumentMatcher<Throwable> causeMatcher) {
+    this.codeMatcher = checkNotNull(codeMatcher, "codeMatcher");
+    this.descriptionMatcher = descriptionMatcher;
+    this.causeMatcher = causeMatcher;
+  }
+
+  public StatusMatcher andDescription(ArgumentMatcher<String> descriptionMatcher) {
+    checkState(this.descriptionMatcher == null, "Already has a description matcher");
+    return new StatusMatcher(codeMatcher, descriptionMatcher, causeMatcher);
+  }
+
+  public StatusMatcher andDescription(String description) {
+    return andDescription(new EqualsMatcher<>(description));
+  }
+
+  public StatusMatcher andDescriptionContains(String substring) {
+    return andDescription(new StringContainsMatcher(substring));
+  }
+
+  public StatusMatcher andCause(ArgumentMatcher<Throwable> causeMatcher) {
+    checkState(this.causeMatcher == null, "Already has a cause matcher");
+    return new StatusMatcher(codeMatcher, descriptionMatcher, causeMatcher);
+  }
+
+  public StatusMatcher andCause(Throwable cause) {
+    return andCause(new EqualsMatcher<>(cause));
+  }
+
+  @Override
+  public boolean matches(Status status) {
+    return status != null
+        && codeMatcher.matches(status.getCode())
+        && (descriptionMatcher == null || descriptionMatcher.matches(status.getDescription()))
+        && (causeMatcher == null || causeMatcher.matches(status.getCause()));
+  }
+
+  @Override
+  public String toString() {
+    StringBuilder sb = new StringBuilder();
+    sb.append("{code=");
+    sb.append(codeMatcher);
+    if (descriptionMatcher != null) {
+      sb.append(", description=");
+      sb.append(descriptionMatcher);
+    }
+    if (causeMatcher != null) {
+      sb.append(", cause=");
+      sb.append(causeMatcher);
+    }
+    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/StatusSubject.java b/api/src/testFixtures/java/io/grpc/StatusSubject.java
new file mode 100644
index 00000000000..0b00df96140
--- /dev/null
+++ b/api/src/testFixtures/java/io/grpc/StatusSubject.java
@@ -0,0 +1,68 @@
+/*
+ * 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;
+
+import static com.google.common.truth.Fact.fact;
+
+import com.google.common.truth.FailureMetadata;
+import com.google.common.truth.Subject;
+import javax.annotation.Nullable;
+
+/** Propositions for {@link Status} subjects. */
+public final class StatusSubject extends Subject {
+
+  private static final Subject.Factory<StatusSubject, Status> statusFactory = new Factory();
+
+  public static Subject.Factory<StatusSubject, Status> status() {
+    return statusFactory;
+  }
+
+  private final Status actual;
+
+  private StatusSubject(FailureMetadata metadata, @Nullable Status subject) {
+    super(metadata, subject);
+    this.actual = subject;
+  }
+
+  /** Fails if the subject is not OK. */
+  public void isOk() {
+    if (actual == null) {
+      failWithActual("expected to be OK but was", "null");
+    } else if (!actual.isOk()) {
+      failWithoutActual(
+          fact("expected to be OK but was", actual.getCode()),
+          fact("description", actual.getDescription()),
+          fact("cause", actual.getCause()));
+    }
+  }
+
+  /** Fails if the subject does not have the given code. */
+  public void hasCode(Status.Code expectedCode) {
+    if (actual == null) {
+      failWithActual("expected to have code " + expectedCode + " but was", "null");
+    } else {
+      check("getCode()").that(actual.getCode()).isEqualTo(expectedCode);
+    }
+  }
+
+  private static final class Factory implements Subject.Factory<StatusSubject, Status> {
+    @Override
+    public StatusSubject createSubject(FailureMetadata metadata, @Nullable Status that) {
+      return new StatusSubject(metadata, that);
+    }
+  }
+}
diff --git a/api/src/test/java/io/grpc/StringMarshaller.java b/api/src/testFixtures/java/io/grpc/StringMarshaller.java
similarity index 95%
rename from api/src/test/java/io/grpc/StringMarshaller.java
rename to api/src/testFixtures/java/io/grpc/StringMarshaller.java
index af53d420e2b..e8358b76333 100644
--- a/api/src/test/java/io/grpc/StringMarshaller.java
+++ b/api/src/testFixtures/java/io/grpc/StringMarshaller.java
@@ -16,7 +16,7 @@
 
 package io.grpc;
 
-import static com.google.common.base.Charsets.UTF_8;
+import static java.nio.charset.StandardCharsets.UTF_8;
 
 import com.google.common.io.ByteStreams;
 import java.io.ByteArrayInputStream;
diff --git a/context/src/test/java/io/grpc/testing/DeadlineSubject.java b/api/src/testFixtures/java/io/grpc/testing/DeadlineSubject.java
similarity index 87%
rename from context/src/test/java/io/grpc/testing/DeadlineSubject.java
rename to api/src/testFixtures/java/io/grpc/testing/DeadlineSubject.java
index 820f91248a1..c2b4d8412a7 100644
--- a/context/src/test/java/io/grpc/testing/DeadlineSubject.java
+++ b/api/src/testFixtures/java/io/grpc/testing/DeadlineSubject.java
@@ -19,19 +19,20 @@
 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.math.BigInteger;
 import java.util.concurrent.TimeUnit;
-import javax.annotation.CheckReturnValue;
 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();
 
@@ -60,14 +61,14 @@ public void of(Deadline expected) {
         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) {
+        long actualNanos = actual.timeRemaining(NANOSECONDS);
+        long expectedNanos = expected.timeRemaining(NANOSECONDS);
+        long deltaNanos = timeUnit.toNanos(delta) ;
+        if (Math.abs(actualNanos - expectedNanos) > deltaNanos) {
           failWithoutActual(
-              fact("expected", expected),
-              fact("but was", actual),
-              fact("outside tolerance in ns", deltaNanos));
+              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));
         }
       }
     };
diff --git a/auth/BUILD.bazel b/auth/BUILD.bazel
index cc923dce2b5..da44243e583 100644
--- a/auth/BUILD.bazel
+++ b/auth/BUILD.bazel
@@ -1,3 +1,6 @@
+load("@rules_java//java:defs.bzl", "java_library")
+load("@rules_jvm_external//:defs.bzl", "artifact")
+
 java_library(
     name = "auth",
     srcs = glob([
@@ -6,9 +9,8 @@ java_library(
     visibility = ["//visibility:public"],
     deps = [
         "//api",
-        "@com_google_auth_google_auth_library_credentials//jar",
-        "@com_google_code_findbugs_jsr305//jar",
-        "@com_google_guava_guava//jar",
-        "@com_google_j2objc_j2objc_annotations//jar",
+        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 1f5e4b41953..d56802c14ca 100644
--- a/auth/build.gradle
+++ b/auth/build.gradle
@@ -7,12 +7,29 @@ plugins {
 }
 
 description = "gRPC: Auth"
+
+tasks.named("jar").configure {
+    manifest {
+        attributes('Automatic-Module-Name': 'io.grpc.auth')
+    }
+}
+
 dependencies {
     api project(':grpc-api'),
-            libraries.google_auth_credentials
-    guavaDependency 'implementation'
-    testImplementation project(':grpc-testing')
-    googleOauth2Dependency 'testImplementation'
-    signature "org.codehaus.mojo.signature:java17:1.0@signature"
-    signature "net.sf.androidscents.signature:android-api-level-14:4.0_r4@signature"
+            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/GoogleAuthLibraryCallCredentials.java b/auth/src/main/java/io/grpc/auth/GoogleAuthLibraryCallCredentials.java
index 852fba73b20..b4b7f5b89e4 100644
--- a/auth/src/main/java/io/grpc/auth/GoogleAuthLibraryCallCredentials.java
+++ b/auth/src/main/java/io/grpc/auth/GoogleAuthLibraryCallCredentials.java
@@ -20,14 +20,15 @@
 
 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.InternalMayRequireSpecificExecutor;
 import io.grpc.Metadata;
 import io.grpc.MethodDescriptor;
 import io.grpc.SecurityLevel;
 import io.grpc.Status;
 import io.grpc.StatusException;
-import java.io.IOException;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.net.URI;
@@ -42,17 +43,18 @@
 import javax.annotation.Nullable;
 
 /**
- * Wraps {@link Credentials} as a {@link CallCredentials}.
+ * Wraps {@link Credentials} as a {@link io.grpc.CallCredentials}.
  */
-// TODO(zhangkun83): remove the suppression after we change the base class to CallCredential
-@SuppressWarnings("deprecation")
-final class GoogleAuthLibraryCallCredentials extends io.grpc.CallCredentials2 {
+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> googleCredentialsClass
+  private static final Class<? extends Credentials> GOOGLE_CREDENTIALS_CLASS
       = loadGoogleCredentialsClass();
+  private static final Class<?> APP_ENGINE_CREDENTIALS_CLASS
+      = loadAppEngineCredentials();
 
   private final boolean requirePrivacy;
   @VisibleForTesting
@@ -61,6 +63,8 @@ final class GoogleAuthLibraryCallCredentials extends io.grpc.CallCredentials2 {
   private Metadata lastHeaders;
   private Map<String, List<String>> lastMetadata;
 
+  private final boolean requiresSpecificExecutor;
+
   public GoogleAuthLibraryCallCredentials(Credentials creds) {
     this(creds, jwtHelper);
   }
@@ -69,22 +73,26 @@ public GoogleAuthLibraryCallCredentials(Credentials creds) {
   GoogleAuthLibraryCallCredentials(Credentials creds, JwtHelper jwtHelper) {
     checkNotNull(creds, "creds");
     boolean requirePrivacy = false;
-    if (googleCredentialsClass != null) {
+    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 = googleCredentialsClass.isInstance(creds);
+      requirePrivacy = GOOGLE_CREDENTIALS_CLASS.isInstance(creds);
     }
     if (jwtHelper != null) {
       creds = jwtHelper.tryServiceAccountToJwt(creds);
     }
     this.requirePrivacy = requirePrivacy;
     this.creds = creds;
-  }
 
-  @Override
-  public void thisUsesUnstableApi() {}
+    // 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(
@@ -135,8 +143,8 @@ public void onSuccess(Map<String, List<String>> metadata) {
 
       @Override
       public void onFailure(Throwable e) {
-        if (e instanceof IOException) {
-          // Since it's an I/O failure, let the call be retried with UNAVAILABLE.
+        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));
@@ -244,6 +252,16 @@ private static Class<? extends Credentials> loadGoogleCredentialsClass() {
     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;
@@ -300,6 +318,11 @@ public JwtHelper(Class<?> rawServiceAccountClass, ClassLoader loader)
         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));
+      }
     }
 
     /**
@@ -350,4 +373,15 @@ public Credentials tryServiceAccountToJwt(Credentials creds) {
       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/test/java/io/grpc/auth/GoogleAuthLibraryCallCredentialsTest.java b/auth/src/test/java/io/grpc/auth/GoogleAuthLibraryCallCredentialsTest.java
index 634cc1e46de..75026fd7c18 100644
--- a/auth/src/test/java/io/grpc/auth/GoogleAuthLibraryCallCredentialsTest.java
+++ b/auth/src/test/java/io/grpc/auth/GoogleAuthLibraryCallCredentialsTest.java
@@ -16,7 +16,7 @@
 
 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;
@@ -30,6 +30,7 @@
 
 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;
@@ -49,10 +50,12 @@
 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.Date;
 import java.util.List;
@@ -191,8 +194,9 @@ public void invalidBase64() throws Exception {
   }
 
   @Test
-  public void credentialsFailsWithIoException() throws Exception {
-    Exception 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 =
@@ -206,6 +210,23 @@ public void credentialsFailsWithIoException() throws Exception {
     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");
@@ -323,7 +344,10 @@ public void serviceUri() throws Exception {
 
   @Test
   public void serviceAccountToJwt() throws Exception {
-    KeyPair pair = KeyPairGenerator.getInstance("RSA").generateKeyPair();
+    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());
@@ -331,7 +355,7 @@ public void serviceAccountToJwt() throws Exception {
     ServiceAccountCredentials credentials =
         ServiceAccountCredentials.newBuilder()
             .setClientEmail("test-email@example.com")
-            .setPrivateKey(pair.getPrivate())
+            .setPrivateKey(privateKey)
             .setPrivateKeyId("test-private-key-id")
             .setHttpTransportFactory(factory)
             .build();
@@ -371,14 +395,18 @@ public void oauthClassesNotInClassPath() throws Exception {
 
   @Test
   public void jwtAccessCredentialsInRequestMetadata() throws Exception {
-    KeyPair pair = KeyPairGenerator.getInstance("RSA").generateKeyPair();
+    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(pair.getPrivate())
+            .setPrivateKey(privateKey)
             .setPrivateKeyId("test-private-key-id")
+            .setQuotaProjectId("test-quota-project-id")
             .build();
     GoogleAuthLibraryCallCredentials callCredentials =
         new GoogleAuthLibraryCallCredentials(credentials);
@@ -394,9 +422,17 @@ public void jwtAccessCredentialsInRequestMetadata() throws Exception {
     Map<?, ?> header = (Map<?, ?>) JsonParser.parse(jsonHeader);
     assertEquals("test-private-key-id", header.get("kid"));
     Map<?, ?> payload = (Map<?, ?>) JsonParser.parse(jsonPayload);
-    assertEquals("https://example.com:123/a.service", payload.get("aud"));
+    // 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() {
@@ -449,4 +485,21 @@ 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/build.gradle b/benchmarks/build.gradle
index ec071137e0c..88b26397e78 100644
--- a/benchmarks/build.gradle
+++ b/benchmarks/build.gradle
@@ -4,43 +4,54 @@ plugins {
     id "maven-publish"
 
     id "com.google.protobuf"
-    id "me.champeau.gradle.jmh"
+    id "me.champeau.jmh"
+    id "ru.vyarus.animalsniffer"
 }
 
 description = "grpc Benchmarks"
 
-startScripts.enabled = false
-run.enabled = false
-
-jmh {
-    jvmArgs = "-server -Xms2g -Xmx2g"
+tasks.named("jmh").configure {
+    jvmArgs = ["-server", "-Xms2g", "-Xmx2g"]
 }
 
-configurations {
-    alpnagent
+tasks.named("jar").configure {
+    manifest {
+        attributes('Automatic-Module-Name': 'io.grpc.benchmarks')
+    }
 }
 
 dependencies {
     implementation project(':grpc-core'),
+            project(':grpc-inprocess'),
             project(':grpc-netty'),
             project(':grpc-okhttp'),
             project(':grpc-stub'),
             project(':grpc-protobuf'),
             project(':grpc-testing'),
+            project(path: ':grpc-xds', configuration: 'shadow'),
             libraries.hdrhistogram,
-            libraries.netty_tcnative,
-            libraries.netty_epoll,
-            libraries.math
-    compileOnly libraries.javax_annotation
-    alpnagent libraries.jetty_alpn_agent
+            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
+            libraries.mockito.core
+
+    signature (libraries.signature.java) {
+        artifact {
+            extension = "signature"
+        }
+    }
 }
 
 import net.ltgt.gradle.errorprone.CheckSeverity
 
-compileJava {
+tasks.named("compileJava").configure {
     // The Control.Void protobuf clashes
     options.errorprone.check("JavaLangClash", CheckSeverity.OFF)
 }
@@ -54,43 +65,55 @@ def vmArgs = [
     "-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 = 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 = 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"
     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 = 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)
+        }
+    }
 }
 
 publishing {
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 0a26dddce0d..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
@@ -4,14 +4,12 @@
 
 /**
  */
-@javax.annotation.Generated(
-    value = "by gRPC proto compiler",
-    comments = "Source: grpc/testing/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.
   private static volatile io.grpc.MethodDescriptor<io.grpc.benchmarks.proto.Messages.SimpleRequest,
@@ -183,6 +181,21 @@ public BenchmarkServiceStub newStub(io.grpc.Channel channel, io.grpc.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);
+  }
+
   /**
    * Creates a new blocking-style stub that supports unary and streaming output calls on the service
    */
@@ -215,7 +228,7 @@ public BenchmarkServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallO
 
   /**
    */
-  public static abstract class BenchmarkServiceImplBase implements io.grpc.BindableService {
+  public interface AsyncService {
 
     /**
      * <pre>
@@ -223,7 +236,7 @@ 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) {
       io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getUnaryCallMethod(), responseObserver);
     }
@@ -235,7 +248,7 @@ public void unaryCall(io.grpc.benchmarks.proto.Messages.SimpleRequest request,
      * 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 io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall(getStreamingCallMethod(), responseObserver);
     }
@@ -246,7 +259,7 @@ public io.grpc.stub.StreamObserver<io.grpc.benchmarks.proto.Messages.SimpleReque
      * 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(
+    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);
     }
@@ -257,7 +270,7 @@ public io.grpc.stub.StreamObserver<io.grpc.benchmarks.proto.Messages.SimpleReque
      * The server repeatedly returns the client payload as-is
      * </pre>
      */
-    public void streamingFromServer(io.grpc.benchmarks.proto.Messages.SimpleRequest request,
+    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);
     }
@@ -268,55 +281,28 @@ public void streamingFromServer(io.grpc.benchmarks.proto.Messages.SimpleRequest
      * 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(
+    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 abstract class BenchmarkServiceImplBase
+      implements io.grpc.BindableService, AsyncService {
 
     @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
-      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>(
-                  this, METHODID_UNARY_CALL)))
-          .addMethod(
-            getStreamingCallMethod(),
-            io.grpc.stub.ServerCalls.asyncBidiStreamingCall(
-              new MethodHandlers<
-                io.grpc.benchmarks.proto.Messages.SimpleRequest,
-                io.grpc.benchmarks.proto.Messages.SimpleResponse>(
-                  this, METHODID_STREAMING_CALL)))
-          .addMethod(
-            getStreamingFromClientMethod(),
-            io.grpc.stub.ServerCalls.asyncClientStreamingCall(
-              new MethodHandlers<
-                io.grpc.benchmarks.proto.Messages.SimpleRequest,
-                io.grpc.benchmarks.proto.Messages.SimpleResponse>(
-                  this, 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>(
-                  this, 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>(
-                  this, METHODID_STREAMING_BOTH_WAYS)))
-          .build();
+      return BenchmarkServiceGrpc.bindService(this);
     }
   }
 
   /**
+   * A stub to allow clients to do asynchronous rpc calls to service BenchmarkService.
    */
-  public static final class BenchmarkServiceStub extends io.grpc.stub.AbstractAsyncStub<BenchmarkServiceStub> {
+  public static final class BenchmarkServiceStub
+      extends io.grpc.stub.AbstractAsyncStub<BenchmarkServiceStub> {
     private BenchmarkServiceStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -391,8 +377,91 @@ public io.grpc.stub.StreamObserver<io.grpc.benchmarks.proto.Messages.SimpleReque
   }
 
   /**
+   * A stub to allow clients to do synchronous rpc calls to service BenchmarkService.
    */
-  public static final class BenchmarkServiceBlockingStub extends io.grpc.stub.AbstractBlockingStub<BenchmarkServiceBlockingStub> {
+  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);
+    }
+
+    /**
+     * <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);
@@ -429,8 +498,10 @@ public java.util.Iterator<io.grpc.benchmarks.proto.Messages.SimpleResponse> stre
   }
 
   /**
+   * A stub to allow clients to do ListenableFuture-style rpc calls to service BenchmarkService.
    */
-  public static final class BenchmarkServiceFutureStub extends io.grpc.stub.AbstractFutureStub<BenchmarkServiceFutureStub> {
+  public static final class BenchmarkServiceFutureStub
+      extends io.grpc.stub.AbstractFutureStub<BenchmarkServiceFutureStub> {
     private BenchmarkServiceFutureStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -466,10 +537,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 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;
     }
@@ -511,6 +582,46 @@ public io.grpc.stub.StreamObserver<Req> invoke(
     }
   }
 
+  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() {}
@@ -534,9 +645,9 @@ private static final class BenchmarkServiceFileDescriptorSupplier
   private static final class BenchmarkServiceMethodDescriptorSupplier
       extends BenchmarkServiceBaseDescriptorSupplier
       implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
-    private final String methodName;
+    private final java.lang.String methodName;
 
-    BenchmarkServiceMethodDescriptorSupplier(String methodName) {
+    BenchmarkServiceMethodDescriptorSupplier(java.lang.String methodName) {
       this.methodName = methodName;
     }
 
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
index d62c590c380..c5064875bb6 100644
--- a/benchmarks/src/generated/main/grpc/io/grpc/benchmarks/proto/ReportQpsScenarioServiceGrpc.java
+++ b/benchmarks/src/generated/main/grpc/io/grpc/benchmarks/proto/ReportQpsScenarioServiceGrpc.java
@@ -4,14 +4,12 @@
 
 /**
  */
-@javax.annotation.Generated(
-    value = "by gRPC proto compiler",
-    comments = "Source: grpc/testing/services.proto")
+@io.grpc.stub.annotations.GrpcGenerated
 public final class ReportQpsScenarioServiceGrpc {
 
   private ReportQpsScenarioServiceGrpc() {}
 
-  public static final String SERVICE_NAME = "grpc.testing.ReportQpsScenarioService";
+  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,
@@ -59,6 +57,21 @@ public ReportQpsScenarioServiceStub newStub(io.grpc.Channel channel, io.grpc.Cal
     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
    */
@@ -91,34 +104,35 @@ public ReportQpsScenarioServiceFutureStub newStub(io.grpc.Channel channel, io.gr
 
   /**
    */
-  public static abstract class ReportQpsScenarioServiceImplBase implements io.grpc.BindableService {
+  public interface AsyncService {
 
     /**
      * <pre>
      * Report results of a QPS test benchmark scenario.
      * </pre>
      */
-    public void reportScenario(io.grpc.benchmarks.proto.Control.ScenarioResult request,
+    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 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>(
-                  this, METHODID_REPORT_SCENARIO)))
-          .build();
+      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> {
+  public static final class ReportQpsScenarioServiceStub
+      extends io.grpc.stub.AbstractAsyncStub<ReportQpsScenarioServiceStub> {
     private ReportQpsScenarioServiceStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -143,8 +157,37 @@ public void reportScenario(io.grpc.benchmarks.proto.Control.ScenarioResult reque
   }
 
   /**
+   * 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> {
+  public static final class ReportQpsScenarioServiceBlockingStub
+      extends io.grpc.stub.AbstractBlockingStub<ReportQpsScenarioServiceBlockingStub> {
     private ReportQpsScenarioServiceBlockingStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -168,8 +211,10 @@ public io.grpc.benchmarks.proto.Control.Void reportScenario(io.grpc.benchmarks.p
   }
 
   /**
+   * 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> {
+  public static final class ReportQpsScenarioServiceFutureStub
+      extends io.grpc.stub.AbstractFutureStub<ReportQpsScenarioServiceFutureStub> {
     private ReportQpsScenarioServiceFutureStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -200,10 +245,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 ReportQpsScenarioServiceImplBase serviceImpl;
+    private final AsyncService serviceImpl;
     private final int methodId;
 
-    MethodHandlers(ReportQpsScenarioServiceImplBase serviceImpl, int methodId) {
+    MethodHandlers(AsyncService serviceImpl, int methodId) {
       this.serviceImpl = serviceImpl;
       this.methodId = methodId;
     }
@@ -232,6 +277,18 @@ public io.grpc.stub.StreamObserver<Req> invoke(
     }
   }
 
+  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() {}
@@ -255,9 +312,9 @@ private static final class ReportQpsScenarioServiceFileDescriptorSupplier
   private static final class ReportQpsScenarioServiceMethodDescriptorSupplier
       extends ReportQpsScenarioServiceBaseDescriptorSupplier
       implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
-    private final String methodName;
+    private final java.lang.String methodName;
 
-    ReportQpsScenarioServiceMethodDescriptorSupplier(String methodName) {
+    ReportQpsScenarioServiceMethodDescriptorSupplier(java.lang.String methodName) {
       this.methodName = methodName;
     }
 
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 e5c08145090..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
@@ -4,14 +4,12 @@
 
 /**
  */
-@javax.annotation.Generated(
-    value = "by gRPC proto compiler",
-    comments = "Source: grpc/testing/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.
   private static volatile io.grpc.MethodDescriptor<io.grpc.benchmarks.proto.Control.ServerArgs,
@@ -152,6 +150,21 @@ public WorkerServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions ca
     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);
+  }
+
   /**
    * Creates a new blocking-style stub that supports unary and streaming output calls on the service
    */
@@ -184,7 +197,7 @@ public WorkerServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOpti
 
   /**
    */
-  public static abstract class WorkerServiceImplBase implements io.grpc.BindableService {
+  public interface AsyncService {
 
     /**
      * <pre>
@@ -196,7 +209,7 @@ 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 io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall(getRunServerMethod(), responseObserver);
     }
@@ -211,7 +224,7 @@ 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 io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall(getRunClientMethod(), responseObserver);
     }
@@ -221,7 +234,7 @@ 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) {
       io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getCoreCountMethod(), responseObserver);
     }
@@ -231,48 +244,28 @@ 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) {
       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(
-            getRunServerMethod(),
-            io.grpc.stub.ServerCalls.asyncBidiStreamingCall(
-              new MethodHandlers<
-                io.grpc.benchmarks.proto.Control.ServerArgs,
-                io.grpc.benchmarks.proto.Control.ServerStatus>(
-                  this, METHODID_RUN_SERVER)))
-          .addMethod(
-            getRunClientMethod(),
-            io.grpc.stub.ServerCalls.asyncBidiStreamingCall(
-              new MethodHandlers<
-                io.grpc.benchmarks.proto.Control.ClientArgs,
-                io.grpc.benchmarks.proto.Control.ClientStatus>(
-                  this, METHODID_RUN_CLIENT)))
-          .addMethod(
-            getCoreCountMethod(),
-            io.grpc.stub.ServerCalls.asyncUnaryCall(
-              new MethodHandlers<
-                io.grpc.benchmarks.proto.Control.CoreRequest,
-                io.grpc.benchmarks.proto.Control.CoreResponse>(
-                  this, METHODID_CORE_COUNT)))
-          .addMethod(
-            getQuitWorkerMethod(),
-            io.grpc.stub.ServerCalls.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.AbstractAsyncStub<WorkerServiceStub> {
+  public static final class WorkerServiceStub
+      extends io.grpc.stub.AbstractAsyncStub<WorkerServiceStub> {
     private WorkerServiceStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -340,8 +333,81 @@ public void quitWorker(io.grpc.benchmarks.proto.Control.Void request,
   }
 
   /**
+   * A stub to allow clients to do synchronous rpc calls to service WorkerService.
    */
-  public static final class WorkerServiceBlockingStub extends io.grpc.stub.AbstractBlockingStub<WorkerServiceBlockingStub> {
+  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);
+    }
+
+    /**
+     * <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);
@@ -375,8 +441,10 @@ public io.grpc.benchmarks.proto.Control.Void quitWorker(io.grpc.benchmarks.proto
   }
 
   /**
+   * A stub to allow clients to do ListenableFuture-style rpc calls to service WorkerService.
    */
-  public static final class WorkerServiceFutureStub extends io.grpc.stub.AbstractFutureStub<WorkerServiceFutureStub> {
+  public static final class WorkerServiceFutureStub
+      extends io.grpc.stub.AbstractFutureStub<WorkerServiceFutureStub> {
     private WorkerServiceFutureStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -421,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;
     }
@@ -463,6 +531,39 @@ public io.grpc.stub.StreamObserver<Req> invoke(
     }
   }
 
+  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() {}
@@ -486,9 +587,9 @@ private static final class WorkerServiceFileDescriptorSupplier
   private static final class WorkerServiceMethodDescriptorSupplier
       extends WorkerServiceBaseDescriptorSupplier
       implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
-    private final String methodName;
+    private final java.lang.String methodName;
 
-    WorkerServiceMethodDescriptorSupplier(String methodName) {
+    WorkerServiceMethodDescriptorSupplier(java.lang.String methodName) {
       this.methodName = methodName;
     }
 
diff --git a/benchmarks/src/jmh/java/io/grpc/benchmarks/TransportBenchmark.java b/benchmarks/src/jmh/java/io/grpc/benchmarks/TransportBenchmark.java
index 1af821be837..d0de1571a59 100644
--- a/benchmarks/src/jmh/java/io/grpc/benchmarks/TransportBenchmark.java
+++ b/benchmarks/src/jmh/java/io/grpc/benchmarks/TransportBenchmark.java
@@ -87,23 +87,20 @@ public void setUp() throws Exception {
     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, 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);
         EventLoopGroup group = new DefaultEventLoopGroup();
@@ -113,13 +110,12 @@ public void setUp() throws Exception {
             .channelType(LocalServerChannel.class);
         channelBuilder = NettyChannelBuilder.forAddress(address)
             .eventLoopGroup(group)
-            .channelType(LocalChannel.class)
+            .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.
@@ -138,13 +134,12 @@ public void setUp() throws Exception {
               .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, serverCreds);
@@ -219,6 +214,7 @@ public SimpleResponse unaryCallsByteThroughput() {
     return stub.unaryCall(BYTE_THROUGHPUT_REQUEST);
   }
 
+  @SuppressWarnings("StaticAssignmentOfThrowable")
   private static final Throwable OK_THROWABLE = new RuntimeException("OK");
 
   @State(Scope.Thread)
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 3edc92ac02a..6d8a9ec8a8e 100644
--- a/benchmarks/src/jmh/java/io/grpc/benchmarks/netty/AbstractBenchmark.java
+++ b/benchmarks/src/jmh/java/io/grpc/benchmarks/netty/AbstractBenchmark.java
@@ -78,6 +78,7 @@ public enum MessageSize {
     SMALL(10), MEDIUM(1024), LARGE(65536), JUMBO(1048576);
 
     private final int bytes;
+
     MessageSize(int bytes) {
       this.bytes = bytes;
     }
@@ -94,6 +95,7 @@ public enum FlowWindowSize {
     SMALL(16383), MEDIUM(65535), LARGE(1048575), JUMBO(8388607);
 
     private final int bytes;
+
     FlowWindowSize(int bytes) {
       this.bytes = bytes;
     }
@@ -205,7 +207,7 @@ public void setup(ExecutorType clientExecutor,
       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.
@@ -214,7 +216,8 @@ public void setup(ExecutorType clientExecutor,
       sock.close();
       serverBuilder = NettyServerBuilder.forAddress(address, serverCreds)
           .channelType(NioServerSocketChannel.class);
-      channelBuilder = NettyChannelBuilder.forAddress(address).channelType(NioSocketChannel.class);
+      channelBuilder = NettyChannelBuilder.forAddress(address).channelType(NioSocketChannel.class,
+          InetSocketAddress.class);
     }
 
     if (serverExecutor == ExecutorType.DIRECT) {
diff --git a/benchmarks/src/main/java/io/grpc/benchmarks/SocketAddressValidator.java b/benchmarks/src/main/java/io/grpc/benchmarks/SocketAddressValidator.java
index 6c6d597cd5e..c35cc7e5c38 100644
--- a/benchmarks/src/main/java/io/grpc/benchmarks/SocketAddressValidator.java
+++ b/benchmarks/src/main/java/io/grpc/benchmarks/SocketAddressValidator.java
@@ -33,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://");
+    }
   };
 
   /**
@@ -43,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 0097bd9dd20..fa21e03b6b8 100644
--- a/benchmarks/src/main/java/io/grpc/benchmarks/Transport.java
+++ b/benchmarks/src/main/java/io/grpc/benchmarks/Transport.java
@@ -16,7 +16,7 @@
 
 package io.grpc.benchmarks;
 
-import java.net.SocketAddress;
+import java.util.Locale;
 
 /**
  * All of the supported transports.
@@ -49,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);
@@ -66,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 9a3d1f6bc24..c4ba99e1639 100644
--- a/benchmarks/src/main/java/io/grpc/benchmarks/Utils.java
+++ b/benchmarks/src/main/java/io/grpc/benchmarks/Utils.java
@@ -18,20 +18,22 @@
 
 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.testing.TestUtils;
-import io.grpc.netty.GrpcSslContexts;
 import io.grpc.netty.NettyChannelBuilder;
 import io.grpc.okhttp.OkHttpChannelBuilder;
-import io.grpc.okhttp.internal.Platform;
+import io.grpc.testing.TlsTesting;
 import io.netty.channel.epoll.EpollDomainSocketChannel;
 import io.netty.channel.epoll.EpollEventLoopGroup;
 import io.netty.channel.epoll.EpollSocketChannel;
@@ -79,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.
@@ -96,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);
@@ -111,57 +107,44 @@ public static SocketAddress parseSocketAddress(String value) {
     }
   }
 
-  private static OkHttpChannelBuilder newOkHttpClientChannel(
-      SocketAddress address, boolean tls, boolean testca) {
-    InetSocketAddress addr = (InetSocketAddress) address;
-    OkHttpChannelBuilder builder =
-        OkHttpChannelBuilder.forAddress(addr.getHostName(), addr.getPort());
-    if (!tls) {
-      builder.usePlaintext();
-    } else if (testca) {
-      try {
-        builder.sslSocketFactory(TestUtils.newSslSocketFactoryForCa(
-            Platform.get().getProvider(),
-            TestUtils.loadCert("ca.pem")));
-      } catch (Exception e) {
-        throw new RuntimeException(e);
-      }
+  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)
-      throws IOException {
-    NettyChannelBuilder builder =
-        NettyChannelBuilder.forAddress(address).flowControlWindow(flowControlWindow);
-    if (!tls) {
-      builder.usePlaintext();
-    } else if (testca) {
-      File cert = TestUtils.loadCert("ca.pem");
-      builder.sslContext(GrpcSslContexts.forClient().trustManager(cert).build());
-    }
-
+  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:
@@ -194,17 +177,38 @@ public ForkJoinWorkerThread newThread(ForkJoinPool pool) {
   /**
    * Create a {@link ManagedChannel} for the given parameters.
    */
-  public static ManagedChannel newClientChannel(Transport transport, SocketAddress address,
+  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);
+      builder = OkHttpChannelBuilder.forTarget(target, credentials)
+          .flowControlWindow(flowControlWindow);
     } else {
-      try {
-        builder = newNettyClientChannel(transport, address, tls, testca, flowControlWindow);
-      } 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 c25fb38fdec..6b37718a49b 100644
--- a/benchmarks/src/main/java/io/grpc/benchmarks/driver/LoadClient.java
+++ b/benchmarks/src/main/java/io/grpc/benchmarks/driver/LoadClient.java
@@ -82,7 +82,7 @@ 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()
@@ -245,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
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 f07d6400292..ed91135e6c3 100644
--- a/benchmarks/src/main/java/io/grpc/benchmarks/driver/LoadServer.java
+++ b/benchmarks/src/main/java/io/grpc/benchmarks/driver/LoadServer.java
@@ -36,10 +36,10 @@
 import io.grpc.benchmarks.proto.Control;
 import io.grpc.benchmarks.proto.Stats;
 import io.grpc.benchmarks.qps.AsyncServer;
-import io.grpc.internal.testing.TestUtils;
+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;
@@ -115,8 +115,8 @@ 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 AsyncServer.BenchmarkServiceImpl();
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 fc74b1706e7..1606b194d39 100644
--- a/benchmarks/src/main/java/io/grpc/benchmarks/qps/AbstractConfigurationBuilder.java
+++ b/benchmarks/src/main/java/io/grpc/benchmarks/qps/AbstractConfigurationBuilder.java
@@ -147,6 +147,7 @@ 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;
@@ -210,6 +211,7 @@ private static String commandLineFlag(Param param) {
     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;
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 cd165c74988..7f61e15f783 100644
--- a/benchmarks/src/main/java/io/grpc/benchmarks/qps/AsyncServer.java
+++ b/benchmarks/src/main/java/io/grpc/benchmarks/qps/AsyncServer.java
@@ -23,19 +23,17 @@
 import io.grpc.benchmarks.Utils;
 import io.grpc.benchmarks.proto.BenchmarkServiceGrpc;
 import io.grpc.benchmarks.proto.Messages;
-import io.grpc.internal.testing.TestUtils;
 import io.grpc.netty.NettyServerBuilder;
 import io.grpc.stub.ServerCallStreamObserver;
 import io.grpc.stub.StreamObserver;
-import io.grpc.stub.StreamObservers;
+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.util.concurrent.DefaultThreadFactory;
-import java.io.File;
 import java.io.IOException;
-import java.util.Iterator;
+import java.io.InputStream;
 import java.util.concurrent.ForkJoinPool;
 import java.util.concurrent.ForkJoinPool.ForkJoinWorkerThreadFactory;
 import java.util.concurrent.ForkJoinWorkerThread;
@@ -164,8 +162,8 @@ static Server newServer(ServerConfiguration config) throws IOException {
       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");
+      InputStream cert = TlsTesting.loadCert("server1.pem");
+      InputStream key = TlsTesting.loadCert("server1.key");
       builder.useTransportSecurity(cert, key);
     }
     if (config.directExecutor) {
@@ -289,26 +287,17 @@ public void streamingFromServer(
       final Messages.SimpleResponse response = Utils.makeResponse(request);
       final ServerCallStreamObserver<Messages.SimpleResponse> responseObserver =
           (ServerCallStreamObserver<Messages.SimpleResponse>) observer;
-      // If the client cancels, copyWithFlowControl takes care of calling
-      // responseObserver.onCompleted() for us
-      StreamObservers.copyWithFlowControl(
-          new Iterator<Messages.SimpleResponse>() {
-            @Override
-            public boolean hasNext() {
-              return !shutdown.get() && !responseObserver.isCancelled();
-            }
-
-            @Override
-            public Messages.SimpleResponse next() {
-              return response;
-            }
-
-            @Override
-            public void remove() {
-              throw new UnsupportedOperationException();
-            }
-          },
-          responseObserver);
+      Runnable onReady = () -> {
+        if (shutdown.get()) {
+          responseObserver.onCompleted();
+          return;
+        }
+        while (responseObserver.isReady() && !responseObserver.isCancelled()) {
+          responseObserver.onNext(response);
+        }
+      };
+      responseObserver.setOnReadyHandler(onReady);
+      onReady.run();
     }
 
     @Override
@@ -317,28 +306,17 @@ public StreamObserver<Messages.SimpleRequest> streamingBothWays(
       // receive data forever and send data forever until client cancels or we shut down.
       final ServerCallStreamObserver<Messages.SimpleResponse> responseObserver =
           (ServerCallStreamObserver<Messages.SimpleResponse>) observer;
-      // If the client cancels, copyWithFlowControl takes care of calling
-      // responseObserver.onCompleted() for us
-      StreamObservers.copyWithFlowControl(
-          new Iterator<Messages.SimpleResponse>() {
-            @Override
-            public boolean hasNext() {
-              return !shutdown.get() && !responseObserver.isCancelled();
-            }
-
-            @Override
-            public Messages.SimpleResponse next() {
-              return BIDI_RESPONSE;
-            }
-
-            @Override
-            public void remove() {
-              throw new UnsupportedOperationException();
-            }
-          },
-          responseObserver
-      );
-
+      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) {
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 f15779bdabc..45061ffec49 100644
--- a/benchmarks/src/main/java/io/grpc/benchmarks/qps/ClientConfiguration.java
+++ b/benchmarks/src/main/java/io/grpc/benchmarks/qps/ClientConfiguration.java
@@ -28,11 +28,10 @@
 import io.grpc.benchmarks.proto.Messages.PayloadType;
 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;
 
 /**
@@ -47,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;
@@ -66,7 +65,7 @@ private ClientConfiguration() {
   }
 
   public ManagedChannel newChannel() throws IOException {
-    return Utils.newClientChannel(transport, address, tls, testca, authorityOverride,
+    return Utils.newClientChannel(transport, target, tls, testca, authorityOverride,
         flowControlWindow, directExecutor);
   }
 
@@ -104,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;
     }
@@ -136,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) {
@@ -176,10 +167,10 @@ protected void setClientValue(ClientConfiguration config, String value) {
         config.testca = 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) {
@@ -246,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/OpenLoopClient.java b/benchmarks/src/main/java/io/grpc/benchmarks/qps/OpenLoopClient.java
index f366bc344ff..c44d7b67892 100644
--- a/benchmarks/src/main/java/io/grpc/benchmarks/qps/OpenLoopClient.java
+++ b/benchmarks/src/main/java/io/grpc/benchmarks/qps/OpenLoopClient.java
@@ -202,7 +202,7 @@ public void onCompleted() {
 
     private void waitForRpcsToComplete(int duration) {
       long now = System.nanoTime();
-      long end = now + duration * 1000 * 1000 * 1000;
+      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 a8a097303f1..eb0b45c85e0 100644
--- a/benchmarks/src/main/java/io/grpc/benchmarks/qps/ServerConfiguration.java
+++ b/benchmarks/src/main/java/io/grpc/benchmarks/qps/ServerConfiguration.java
@@ -29,6 +29,7 @@
 import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
+import java.util.Locale;
 
 /**
  * Configuration options for benchmark servers.
@@ -69,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.
@@ -109,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.
      *
@@ -128,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;
@@ -142,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();
@@ -158,10 +164,10 @@ protected void setServerValue(ServerConfiguration config, String value) {
         config.tls = 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 "
@@ -197,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/test/java/io/grpc/benchmarks/driver/LoadClientTest.java b/benchmarks/src/test/java/io/grpc/benchmarks/driver/LoadClientTest.java
index e8c6b929909..2ad8668b9fa 100644
--- a/benchmarks/src/test/java/io/grpc/benchmarks/driver/LoadClientTest.java
+++ b/benchmarks/src/test/java/io/grpc/benchmarks/driver/LoadClientTest.java
@@ -21,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;
@@ -30,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 {
@@ -48,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);
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 2f8b7a0ea27..d4669325aac 100644
--- a/benchmarks/src/test/java/io/grpc/benchmarks/driver/LoadWorkerTest.java
+++ b/benchmarks/src/test/java/io/grpc/benchmarks/driver/LoadWorkerTest.java
@@ -16,9 +16,10 @@
 
 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;
@@ -26,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();
@@ -51,6 +51,7 @@ 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 {
@@ -62,6 +63,18 @@ public void setup() throws Exception {
     marksQueue = new LinkedBlockingQueue<>();
   }
 
+  @After
+  public void tearDown() {
+    if (serverLifetime != null) {
+      serverLifetime.onCompleted();
+    }
+    try {
+      WorkerServiceGrpc.newBlockingStub(channel).quitWorker(Control.Void.getDefaultInstance());
+    } finally {
+      channel.shutdownNow();
+    }
+  }
+
   @Test
   public void runUnaryBlockingClosedLoop() throws Exception {
     Control.ServerArgs.Builder serverArgsBuilder = Control.ServerArgs.newBuilder();
@@ -181,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);
@@ -194,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());
             }
@@ -217,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..7e7d4810e98
--- /dev/null
+++ b/binder/build.gradle
@@ -0,0 +1,171 @@
+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 23
+        targetSdkVersion 33
+        versionCode 1
+        versionName "1.0"
+        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+    }
+    lintOptions { abortOnError = false }
+    buildTypes {
+        debug {
+            testCoverageEnabled true // For robolectric unit tests.
+            enableUnitTestCoverage true // For tests that run on an emulator.
+        }
+    }
+
+    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'))
+    testImplementation testFixtures(project(':grpc-api'))
+
+    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() }
+}
+
+tasks.withType(Test) {
+    // Robolectric modifies classes in memory at runtime, so they lack a java.security.CodeSource
+    // URL to their on-disk location. By default, JaCoCo ignores classes without this property.
+    // Overriding this allows Robolectric tests to be instrumented.
+    jacoco.includeNoLocationClasses = true
+    // Don't instrument certain JDK internals protected from modification by JEP 403's "strong
+    // encapsulation." Avoids IllegalAccessError, InvalidClassException and similar at runtime.
+    jacoco.excludes = ["jdk.internal.**"]
+}
+
+// Android projects don't automatically get a coverage report task. We must
+// register one manually here and wire it up to AGP's test tasks.
+tasks.register("jacocoTestReport", JacocoReport) {
+    dependsOn "testDebugUnitTest"
+
+    reports {
+        // For codecov.io and coveralls.
+        xml.required = true
+        // Use the same output location as the other subprojects.
+        html.outputLocation = layout.buildDirectory.dir("reports/jacoco/test/html")
+    }
+
+    sourceDirectories.from = android.sourceSets.main.java.srcDirs
+    classDirectories.from = fileTree(dir: layout.buildDirectory.dir("intermediates/javac/debug/classes"),
+            excludes: ['**/R.class', '**/R$*.class', '**/BuildConfig.class', '**/Manifest*.*', '**/*Test*.*', 'android/**/*.*'])
+    executionData.from = tasks.named("testDebugUnitTest").map { it.jacoco.destinationFile }
+}
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/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..5f0885883a5
--- /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, metricRecorder) -> {
+              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..58e7d7e2b31
--- /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..f913775fcbe
--- /dev/null
+++ b/binder/src/main/java/io/grpc/binder/internal/BinderServer.java
@@ -0,0 +1,316 @@
+/*
+ * 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;
+  private final OneWayBinderProxy.Decorator clientBinderDecorator;
+
+  @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;
+    this.clientBinderDecorator = builder.clientBinderDecorator;
+    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,
+                  clientBinderDecorator,
+                  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;
+    OneWayBinderProxy.Decorator clientBinderDecorator = OneWayBinderProxy.IDENTITY_DECORATOR;
+
+    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;
+    }
+
+    /**
+     * Sets the {@link OneWayBinderProxy.Decorator} to be applied to this server's "client Binders".
+     *
+     * <p>Tests can use this to capture post-setup transactions from server to client. The specified
+     * decorator will be applied every time a client connects. The decorated result will be used for
+     * all subsequent transactions to this client from the new ServerTransport.
+     *
+     * <p>Optional, {@link OneWayBinderProxy#IDENTITY_DECORATOR} is the default.
+     */
+    public Builder setClientBinderDecorator(OneWayBinderProxy.Decorator clientBinderDecorator) {
+      this.clientBinderDecorator = checkNotNull(clientBinderDecorator);
+      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..784d833bdf5
--- /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..30b8735ac68
--- /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..985e465ab4b
--- /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.
+   */
+  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..83fc8273d6f
--- /dev/null
+++ b/binder/src/main/java/io/grpc/binder/internal/Inbound.java
@@ -0,0 +1,735 @@
+/*
+ * 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, T extends BinderTransport>
+    implements StreamListener.MessageProducer {
+
+  protected final T 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(T 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();
+      if (numBytes > parcel.dataAvail()) {
+        throw Status.INTERNAL
+            .withDescription(
+                "Message size is larger than remaining parcel size: "
+                + numBytes + " > " + parcel.dataAvail())
+            .asException();
+      }
+      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, BinderClientTransport> {
+
+    private final boolean countsForInUse;
+
+    @Nullable
+    @GuardedBy("this")
+    private Status closeStatus;
+
+    @Nullable
+    @GuardedBy("this")
+    private Metadata trailers;
+
+    ClientInbound(
+        BinderClientTransport 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, BinderServerTransport> {
+    ServerInbound(BinderServerTransport transport, Attributes attributes, int callId) {
+      super(transport, attributes, callId);
+    }
+
+    @GuardedBy("this")
+    @Override
+    protected void handlePrefix(int flags, Parcel parcel) throws StatusException {
+      String methodName = parcel.readString();
+      Metadata headers = MetadataHelper.readMetadata(parcel, attributes);
+
+      StatsTraceContext statsTraceContext = transport.createStatsTraceContext(methodName, headers);
+      Outbound.ServerOutbound outbound =
+          new Outbound.ServerOutbound(transport, 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 = transport.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..63c47bf4f19
--- /dev/null
+++ b/binder/src/test/java/io/grpc/binder/internal/RobolectricBinderTransportTest.java
@@ -0,0 +1,698 @@
+/*
+ * 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.assertAbout;
+import static com.google.common.truth.Truth.assertThat;
+import static com.google.common.util.concurrent.MoreExecutors.directExecutor;
+import static io.grpc.StatusSubject.status;
+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.CallOptions;
+import io.grpc.InternalChannelz.SocketStats;
+import io.grpc.Metadata;
+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.OneWayBinderProxies.*;
+import io.grpc.binder.internal.SettableAsyncSecurityPolicy.AuthRequest;
+import io.grpc.internal.AbstractTransportTest;
+import io.grpc.internal.ClientStream;
+import io.grpc.internal.ClientStreamListenerBase;
+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.io.InputStream;
+import java.util.List;
+import java.util.concurrent.BlockingQueue;
+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;
+  private BlockingBinderDecorator<OneWayBinderProxy> blockingDecorator =
+      new BlockingBinderDecorator<>();
+
+  @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);
+  }
+
+  BinderServer.Builder newServerBuilder() {
+    AndroidComponentAddress listenAddr =
+        AndroidComponentAddress.forBindIntent(
+            new Intent()
+                .setClassName(serviceInfo.packageName, serviceInfo.name)
+                .setAction("io.grpc.action.BIND." + nextServerAddress++));
+
+    return new BinderServer.Builder()
+        .setListenAddress(listenAddr)
+        .setExecutorPool(serverExecutorPool)
+        .setExecutorServicePool(executorServicePool)
+        .setStreamTracerFactories(List.of());
+  }
+
+  void registerServerWithRobolectric(BinderServer server) {
+    AndroidComponentAddress listenAddr = (AndroidComponentAddress) server.getListenSocketAddress();
+    shadowOf(application.getPackageManager()).addServiceIfNotPresent(listenAddr.getComponent());
+    shadowOf(application)
+        .setComponentNameAndServiceForBindServiceForIntent(
+            listenAddr.asBindIntent(), listenAddr.getComponent(), server.getHostBinder());
+  }
+
+  @Override
+  protected InternalServer newServer(List<ServerStreamTracer.Factory> streamTracerFactories) {
+    BinderServer server =
+        newServerBuilder().setStreamTracerFactories(streamTracerFactories).build();
+    registerServerWithRobolectric(server);
+    return server;
+  }
+
+  @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() {}
+
+  @Test
+  public void singleTxnMsgsDeliveredToServerOutOfOrder() throws Exception {
+    server.start(serverListener);
+    client =
+        newClientTransportBuilder()
+            .setFactory(
+                newClientTransportFactoryBuilder()
+                    .setBinderDecorator(blockingDecorator)
+                    .buildClientTransportFactory())
+            .build();
+    runIfNotNull(client.start(mockClientTransportListener));
+    blockingDecorator.putNextResult(takeNextBinder(blockingDecorator)); // Endpoint binder.
+    QueueingOneWayBinderProxy queueingServerProxy =
+        new QueueingOneWayBinderProxy(takeNextBinder(blockingDecorator)); // Server binder.
+    blockingDecorator.putNextResult(queueingServerProxy);
+
+    verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportReady();
+
+    ClientStream stream =
+        client.newStream(methodDescriptor, new Metadata(), CallOptions.DEFAULT, noopTracers);
+    ClientStreamListenerBase clientStreamListener = new ClientStreamListenerBase();
+    stream.start(clientStreamListener);
+    stream.writeMessage(methodDescriptor.streamRequest("one"));
+    stream.writeMessage(methodDescriptor.streamRequest("two"));
+    stream.halfClose();
+
+    // Expect one transaction for headers, one for each message, and one for half-close.
+    QueueingOneWayBinderProxy.Transaction txHeaders = takeNextTransaction(queueingServerProxy);
+    QueueingOneWayBinderProxy.Transaction tx1 = takeNextTransaction(queueingServerProxy);
+    QueueingOneWayBinderProxy.Transaction tx2 = takeNextTransaction(queueingServerProxy);
+    QueueingOneWayBinderProxy.Transaction txHalfClose = takeNextTransaction(queueingServerProxy);
+
+    // Deliver messages out of order!
+    queueingServerProxy.deliver(txHeaders);
+    queueingServerProxy.deliver(tx2);
+    queueingServerProxy.deliver(tx1);
+    queueingServerProxy.deliver(txHalfClose);
+
+    MockServerTransportListener serverTransportListener =
+        serverListener.takeListenerOrFail(TIMEOUT_MS, MILLISECONDS);
+    MockServerTransportListener.StreamCreation serverStreamCreation =
+        serverTransportListener.takeStreamOrFail(TIMEOUT_MS, MILLISECONDS);
+    serverStreamCreation.stream.request(2);
+
+    // Expect the server to deliver the messages in the order they were originally sent.
+    InputStream msg1 = takeNextMessage(serverStreamCreation.listener.messageQueue);
+    assertThat(methodDescriptor.parseResponse(msg1)).isEqualTo("one");
+
+    InputStream msg2 = takeNextMessage(serverStreamCreation.listener.messageQueue);
+    assertThat(methodDescriptor.parseResponse(msg2)).isEqualTo("two");
+
+    assertThat(serverStreamCreation.listener.awaitHalfClosed(TIMEOUT_MS, MILLISECONDS)).isTrue();
+    serverStreamCreation.stream.close(Status.OK, new Metadata());
+
+    assertAbout(status()).that(clientStreamListener.awaitClose(TIMEOUT_MS, MILLISECONDS)).isOk();
+    assertAbout(status())
+        .that(serverStreamCreation.listener.awaitClose(TIMEOUT_MS, MILLISECONDS))
+        .isOk();
+  }
+
+  @Test
+  public void msgFragmentsDeliveredToServerOutOfOrder() throws Exception {
+    server.start(serverListener);
+    client =
+        newClientTransportBuilder()
+            .setFactory(
+                newClientTransportFactoryBuilder()
+                    .setBinderDecorator(blockingDecorator)
+                    .buildClientTransportFactory())
+            .build();
+    runIfNotNull(client.start(mockClientTransportListener));
+    blockingDecorator.putNextResult(takeNextBinder(blockingDecorator)); // Endpoint binder.
+    QueueingOneWayBinderProxy queueingServerProxy =
+        new QueueingOneWayBinderProxy(takeNextBinder(blockingDecorator)); // Server binder.
+    blockingDecorator.putNextResult(queueingServerProxy);
+
+    verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportReady();
+
+    ClientStream stream =
+        client.newStream(methodDescriptor, new Metadata(), CallOptions.DEFAULT, noopTracers);
+    ClientStreamListenerBase clientStreamListener = new ClientStreamListenerBase();
+    stream.start(clientStreamListener);
+
+    String largeMessage = newStringOfLength(BlockPool.BLOCK_SIZE + 1);
+    stream.writeMessage(methodDescriptor.streamRequest(largeMessage));
+    stream.halfClose();
+
+    // Expect the client to split largeMessage into two transactions, plus headers and half-close.
+    QueueingOneWayBinderProxy.Transaction txHeaders = takeNextTransaction(queueingServerProxy);
+    QueueingOneWayBinderProxy.Transaction tx1 = takeNextTransaction(queueingServerProxy);
+    QueueingOneWayBinderProxy.Transaction tx2 = takeNextTransaction(queueingServerProxy);
+    QueueingOneWayBinderProxy.Transaction txHalfClose = takeNextTransaction(queueingServerProxy);
+
+    // Deliver fragments out of order!
+    queueingServerProxy.deliver(txHeaders);
+    queueingServerProxy.deliver(tx2);
+    queueingServerProxy.deliver(tx1);
+    queueingServerProxy.deliver(txHalfClose);
+
+    // Verify that the server reassembles the transactions correctly.
+    MockServerTransportListener serverTransportListener =
+        serverListener.takeListenerOrFail(TIMEOUT_MS, MILLISECONDS);
+    MockServerTransportListener.StreamCreation serverStreamCreation =
+        serverTransportListener.takeStreamOrFail(TIMEOUT_MS, MILLISECONDS);
+    serverStreamCreation.stream.request(1);
+    InputStream msg = takeNextMessage(serverStreamCreation.listener.messageQueue);
+    assertThat(methodDescriptor.parseResponse(msg)).isEqualTo(largeMessage);
+
+    assertThat(serverStreamCreation.listener.awaitHalfClosed(TIMEOUT_MS, MILLISECONDS)).isTrue();
+    serverStreamCreation.stream.close(Status.OK, new Metadata());
+
+    assertAbout(status()).that(clientStreamListener.awaitClose(TIMEOUT_MS, MILLISECONDS)).isOk();
+    assertAbout(status())
+        .that(serverStreamCreation.listener.awaitClose(TIMEOUT_MS, MILLISECONDS))
+        .isOk();
+  }
+
+  @Test
+  public void singleTxnMsgsDeliveredToClientOutOfOrder() throws Exception {
+    server = newServerBuilder().setClientBinderDecorator(blockingDecorator).build();
+    registerServerWithRobolectric((BinderServer) server);
+    server.start(serverListener);
+
+    client = newClientTransport(server);
+    runIfNotNull(client.start(mockClientTransportListener));
+
+    QueueingOneWayBinderProxy queueingClientProxy =
+        new QueueingOneWayBinderProxy(takeNextBinder(blockingDecorator));
+    blockingDecorator.putNextResult(queueingClientProxy);
+
+    // Deliver the setup transaction without interference.
+    queueingClientProxy.deliver(takeNextTransaction(queueingClientProxy));
+    verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportReady();
+
+    ClientStreamListenerBase clientStreamListener = new ClientStreamListenerBase();
+    ClientStream stream =
+        client.newStream(methodDescriptor, new Metadata(), CallOptions.DEFAULT, noopTracers);
+    stream.start(clientStreamListener);
+    stream.halfClose();
+    stream.request(2);
+
+    MockServerTransportListener serverTransportListener =
+        serverListener.takeListenerOrFail(TIMEOUT_MS, MILLISECONDS);
+    MockServerTransportListener.StreamCreation serverStreamCreation =
+        serverTransportListener.takeStreamOrFail(TIMEOUT_MS, MILLISECONDS);
+
+    serverStreamCreation.stream.writeMessage(methodDescriptor.streamResponse("one"));
+    serverStreamCreation.stream.writeMessage(methodDescriptor.streamResponse("two"));
+    serverStreamCreation.stream.close(Status.OK, new Metadata());
+
+    // Expect one transaction from the server for each message.
+    QueueingOneWayBinderProxy.Transaction tx1 = takeNextTransaction(queueingClientProxy);
+    QueueingOneWayBinderProxy.Transaction tx2 = takeNextTransaction(queueingClientProxy);
+    QueueingOneWayBinderProxy.Transaction txClose = takeNextTransaction(queueingClientProxy);
+
+    // Deliver messages to the client out of order!
+    queueingClientProxy.deliver(tx2);
+    queueingClientProxy.deliver(tx1);
+    queueingClientProxy.deliver(txClose);
+
+    // Client should deliver messages to the application in the order sent.
+    InputStream msg1 = takeNextMessage(clientStreamListener.messageQueue);
+    assertThat(methodDescriptor.parseResponse(msg1)).isEqualTo("one");
+    InputStream msg2 = takeNextMessage(clientStreamListener.messageQueue);
+    assertThat(methodDescriptor.parseResponse(msg2)).isEqualTo("two");
+
+    assertAbout(status()).that(clientStreamListener.awaitClose(TIMEOUT_MS, MILLISECONDS)).isOk();
+    assertAbout(status())
+        .that(serverStreamCreation.listener.awaitClose(TIMEOUT_MS, MILLISECONDS))
+        .isOk();
+  }
+
+  @Test
+  public void msgFragmentsDeliveredToClientOutOfOrder() throws Exception {
+    server = newServerBuilder().setClientBinderDecorator(blockingDecorator).build();
+    registerServerWithRobolectric((BinderServer) server);
+    server.start(serverListener);
+
+    client = newClientTransport(server);
+    runIfNotNull(client.start(mockClientTransportListener));
+
+    QueueingOneWayBinderProxy queueingClientProxy =
+        new QueueingOneWayBinderProxy(takeNextBinder(blockingDecorator));
+    blockingDecorator.putNextResult(queueingClientProxy);
+
+    // Deliver the setup transaction without interference.
+    queueingClientProxy.deliver(takeNextTransaction(queueingClientProxy));
+    verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportReady();
+
+    ClientStreamListenerBase clientStreamListener = new ClientStreamListenerBase();
+    ClientStream stream =
+        client.newStream(methodDescriptor, new Metadata(), CallOptions.DEFAULT, noopTracers);
+    stream.start(clientStreamListener);
+    stream.request(1);
+
+    MockServerTransportListener serverTransportListener =
+        serverListener.takeListenerOrFail(TIMEOUT_MS, MILLISECONDS);
+    MockServerTransportListener.StreamCreation serverStreamCreation =
+        serverTransportListener.takeStreamOrFail(TIMEOUT_MS, MILLISECONDS);
+
+    String largeMessage = newStringOfLength(BlockPool.BLOCK_SIZE + 1);
+    serverStreamCreation.stream.writeMessage(methodDescriptor.streamResponse(largeMessage));
+    serverStreamCreation.stream.flush();
+
+    // Expect the client to split largeMessage into two transactions.
+    QueueingOneWayBinderProxy.Transaction tx1 = takeNextTransaction(queueingClientProxy);
+    QueueingOneWayBinderProxy.Transaction tx2 = takeNextTransaction(queueingClientProxy);
+
+    // Deliver them to the client out of order!
+    queueingClientProxy.deliver(tx2);
+    queueingClientProxy.deliver(tx1);
+
+    // Client should reassemble the message correctly.
+    InputStream msg = takeNextMessage(clientStreamListener.messageQueue);
+    assertThat(methodDescriptor.parseResponse(msg)).isEqualTo(largeMessage);
+  }
+
+  private static OneWayBinderProxy takeNextBinder(
+      BlockingBinderDecorator<OneWayBinderProxy> decorator) throws InterruptedException {
+    OneWayBinderProxy proxy = decorator.takeNextRequest(TIMEOUT_MS, MILLISECONDS);
+    assertThat(proxy).isNotNull();
+    return proxy;
+  }
+
+  private static QueueingOneWayBinderProxy.Transaction takeNextTransaction(
+      QueueingOneWayBinderProxy proxy) throws InterruptedException {
+    QueueingOneWayBinderProxy.Transaction tx = proxy.pollNextTransaction(TIMEOUT_MS, MILLISECONDS);
+    assertThat(tx).isNotNull();
+    return tx;
+  }
+
+  private static InputStream takeNextMessage(BlockingQueue<InputStream> messageQueue)
+      throws InterruptedException {
+    InputStream msg = messageQueue.poll(TIMEOUT_MS, MILLISECONDS);
+    assertThat(msg).isNotNull();
+    return msg;
+  }
+
+  private static String newStringOfLength(int numChars) {
+    char[] chars = new char[numChars];
+    java.util.Arrays.fill(chars, 'x');
+    return new String(chars);
+  }
+}
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/OneWayBinderProxies.java b/binder/src/testFixtures/java/io/grpc/binder/internal/OneWayBinderProxies.java
new file mode 100644
index 00000000000..c7eee06e73a
--- /dev/null
+++ b/binder/src/testFixtures/java/io/grpc/binder/internal/OneWayBinderProxies.java
@@ -0,0 +1,181 @@
+/*
+ * 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 java.util.concurrent.TimeUnit;
+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();
+    }
+
+    /**
+     * Returns the next {@link OneWayBinderProxy} that needs decorating, blocking for up to the
+     * specified timeout 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(long timeout, TimeUnit unit)
+        throws InterruptedException {
+      return requests.poll(timeout, unit);
+    }
+
+    /** 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);
+      }
+    }
+  }
+
+  /** A {@link OneWayBinderProxy} that queues transactions for a test to deliver manually later. */
+  public static final class QueueingOneWayBinderProxy extends OneWayBinderProxy {
+    public static final class Transaction {
+      public final int code;
+      private final ParcelHolder parcel;
+
+      public Transaction(int code, ParcelHolder parcel) {
+        this.code = code;
+        this.parcel = parcel;
+      }
+    }
+
+    private final BlockingQueue<Transaction> queue = new LinkedBlockingQueue<>();
+    private final OneWayBinderProxy wrapped;
+
+    public QueueingOneWayBinderProxy(OneWayBinderProxy wrapped) {
+      super(wrapped.getDelegate());
+      this.wrapped = wrapped;
+    }
+
+    @Override
+    public void transact(int code, ParcelHolder data) throws RemoteException {
+      queue.add(new Transaction(code, new ParcelHolder(data.release())));
+    }
+
+    /**
+     * Returns the next transaction that was queued in order, waiting up to the specified timeout.
+     */
+    public Transaction pollNextTransaction(long timeout, TimeUnit unit)
+        throws InterruptedException {
+      return queue.poll(timeout, unit);
+    }
+
+    /**
+     * Delivers a previously queued transaction to its original destination.
+     *
+     * @throws IllegalStateException if transaction was already delivered once before
+     */
+    public void deliver(Transaction transaction) throws RemoteException {
+      wrapped.transact(transaction.code, transaction.parcel);
+    }
+  }
+
+  // Cannot be instantiated.
+  private OneWayBinderProxies() {}
+  ;
+}
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
index 43668511e3b..f7f3918372f 100644
--- a/bom/build.gradle
+++ b/bom/build.gradle
@@ -1,31 +1,32 @@
 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) {
-      // remove all other artifacts since BOM doesn't generates any Jar
-      artifacts = []
-
+      from components.javaPlatform
       pom.withXml {
-        // Generate bom using subprojects
-        def internalProjects = [project.name, 'grpc-gae-interop-testing-jdk8', 'grpc-compiler']
-
-        def dependencyManagement = asNode().appendNode('dependencyManagement')
-        def dependencies = dependencyManagement.appendNode('dependencies')
-        rootProject.subprojects.each { subproject ->
-          if (internalProjects.contains(subproject.name)) {
-            return
-          }
-          def dependencyNode = dependencies.appendNode('dependency')
-          dependencyNode.appendNode('groupId', subproject.group)
-          dependencyNode.appendNode('artifactId', subproject.name)
-          dependencyNode.appendNode('version', subproject.version)
-        }
+        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')
diff --git a/build.gradle b/build.gradle
index 5c605dcab37..e65261b0cc4 100644
--- a/build.gradle
+++ b/build.gradle
@@ -1,11 +1,14 @@
 plugins {
-    id "com.android.application" apply false // Necessary for Android plugin to find its classes
-    id "com.android.library" apply false
+    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 {
@@ -18,16 +21,31 @@ subprojects {
     apply plugin: "net.ltgt.errorprone"
 
     group = "io.grpc"
-    version = "1.37.0-SNAPSHOT" // CURRENT_GRPC_VERSION
+    version = "1.82.0-SNAPSHOT" // CURRENT_GRPC_VERSION
 
     repositories {
         maven { // The google mirror is less flaky than mavenCentral()
-            url "https://maven-central.storage-download.googleapis.com/maven2/" }
-        mavenCentral()
-        mavenLocal()
+            url = "https://maven-central.storage-download.googleapis.com/maven2/"
+            metadataSources {
+                mavenPom()
+                ignoreGradleMetadataRedirection()
+            }
+        }
+        mavenCentral() {
+            metadataSources {
+                mavenPom()
+                ignoreGradleMetadataRedirection()
+            }
+        }
+        mavenLocal() {
+            metadataSources {
+                mavenPom()
+                ignoreGradleMetadataRedirection()
+            }
+        }
     }
 
-    tasks.withType(JavaCompile) {
+    tasks.withType(JavaCompile).configureEach {
         it.options.compilerArgs += [
             "-Xlint:all",
             "-Xlint:-options",
@@ -35,12 +53,15 @@ subprojects {
             "-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"]
         }
     }
 
-    tasks.withType(GenerateModuleMetadata) {
+    tasks.withType(GenerateModuleMetadata).configureEach {
         // Module metadata, introduced in Gradle 6.0, conflicts with our publishing task for
         // grpc-alts and grpc-compiler.
         enabled = false
@@ -54,14 +75,6 @@ subprojects {
         protocPluginBaseName = 'protoc-gen-grpc-java'
         javaPluginPath = "$rootDir/compiler/build/exe/java_plugin/$protocPluginBaseName$exeSuffix"
 
-        nettyVersion = '4.1.52.Final'
-        guavaVersion = '30.0-android'
-        googleauthVersion = '0.22.2'
-        protobufVersion = '3.12.0'
-        protocVersion = protobufVersion
-        opencensusVersion = '0.28.0'
-        autovalueVersion = '1.7.4'
-
         configureProtoCompilation = {
             String generatedSourcePath = "${projectDir}/src/generated"
             project.protobuf {
@@ -69,14 +82,11 @@ subprojects {
                     if (project.hasProperty('protoc')) {
                         path = project.protoc
                     } else {
-                        artifact = "com.google.protobuf:protoc:${protocVersion}"
+                        artifact = libs.protobuf.protoc.get()
                     }
                 }
                 generateProtoTasks {
                     all().each { task ->
-                        // 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"
                         if (isAndroid) {
                             task.builtins {
                                 java { option 'lite' }
@@ -88,26 +98,31 @@ subprojects {
             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.
-                task syncGeneratedSources { }
+                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 "$buildDir/generated/source/proto/${variantOrSourceSet}/grpc"
-                                into "$generatedSourcePath/${variantOrSourceSet}/grpc"
+                                from task
+                                into "$generatedSourcePath/$variantOrSourceSet"
+                                include "grpc/"
                             }
-                            syncGeneratedSources.dependsOn syncTask
-
-                            task.dependsOn ':grpc-compiler:java_pluginExecutable'
-                            // Recompile protos when the codegen has been changed
-                            task.inputs.file javaPluginPath
-                            task.plugins { grpc { option 'noversion' } }
-                            if (isAndroid) {
-                                task.plugins {
-                                    grpc {
-                                        option 'lite'
+                            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'
+                                        }
                                     }
                                 }
                             }
@@ -115,7 +130,9 @@ subprojects {
                     }
                 }
                 // Re-sync as part of a normal build, to avoid forgetting to run the sync
-                assemble.dependsOn syncGeneratedSources
+                tasks.named("assemble").configure {
+                    dependsOn syncGeneratedSources
+                }
             } else {
                 // Otherwise, we just use the checked-in generated code.
                 if (isAndroid) {
@@ -124,142 +141,22 @@ subprojects {
                         release { java { srcDir "${generatedSourcePath}/release/grpc" } }
                     }
                 } else {
-                    project.sourceSets {
-                        main { java { srcDir "${generatedSourcePath}/main/grpc" } }
-                        test { java { srcDir "${generatedSourcePath}/test/grpc" } }
+                    project.sourceSets.each() { sourceSet ->
+                        sourceSet.java { srcDir "${generatedSourcePath}/${sourceSet.name}/grpc" }
                     }
                 }
             }
 
-            tasks.withType(JavaCompile) {
+            tasks.withType(JavaCompile).configureEach {
                 appendToProperty(
                     it.options.errorprone.excludedPaths,
                     ".*/src/generated/[^/]+/java/.*" +
-                        "|.*/build/generated/source/proto/[^/]+/java/.*",
+                        "|.*/build/generated/sources/proto/[^/]+/java/.*",
                     "|")
             }
         }
 
-        libraries = [
-            android_annotations: "com.google.android:annotations:4.1.1.4",
-            animalsniffer_annotations: "org.codehaus.mojo:animal-sniffer-annotations:1.19",
-            autovalue: "com.google.auto.value:auto-value:${autovalueVersion}",
-            autovalue_annotation: "com.google.auto.value:auto-value-annotations:${autovalueVersion}",
-            errorprone: "com.google.errorprone:error_prone_annotations:2.4.0",
-            cronet_api: 'org.chromium.net:cronet-api:76.3809.111',
-            cronet_embedded: 'org.chromium.net:cronet-embedded:66.3359.158',
-            gson: "com.google.code.gson:gson:2.8.6",
-            guava: "com.google.guava:guava:${guavaVersion}",
-            javax_annotation: 'org.apache.tomcat:annotations-api:6.0.53',
-            jsr305: 'com.google.code.findbugs:jsr305:3.0.2',
-            google_api_protos: 'com.google.api.grpc:proto-google-common-protos:2.0.1',
-            google_auth_credentials: "com.google.auth:google-auth-library-credentials:${googleauthVersion}",
-            google_auth_oauth2_http: "com.google.auth:google-auth-library-oauth2-http:${googleauthVersion}",
-            okhttp: 'com.squareup.okhttp:okhttp:2.7.4',
-            okio: 'com.squareup.okio:okio:1.17.5',
-            opencensus_api: "io.opencensus:opencensus-api:${opencensusVersion}",
-            opencensus_contrib_grpc_metrics: "io.opencensus:opencensus-contrib-grpc-metrics:${opencensusVersion}",
-            opencensus_impl: "io.opencensus:opencensus-impl:${opencensusVersion}",
-            opencensus_impl_lite: "io.opencensus:opencensus-impl-lite:${opencensusVersion}",
-            opencensus_proto: "io.opencensus:opencensus-proto:0.2.0",
-            instrumentation_api: 'com.google.instrumentation:instrumentation-api:0.4.3',
-            perfmark: 'io.perfmark:perfmark-api:0.23.0',
-            protobuf: "com.google.protobuf:protobuf-java:${protobufVersion}",
-            protobuf_lite: "com.google.protobuf:protobuf-javalite:${protobufVersion}",
-            protobuf_util: "com.google.protobuf:protobuf-java-util:${protobufVersion}",
-
-            netty: "io.netty:netty-codec-http2:[${nettyVersion}]",
-            netty_epoll: "io.netty:netty-transport-native-epoll:${nettyVersion}:linux-x86_64",
-            netty_proxy_handler: "io.netty:netty-handler-proxy:${nettyVersion}",
-
-            // Keep the following references of tcnative version in sync whenever it's updated
-            // SECURITY.md (multiple occurrences)
-            // examples/example-tls/build.gradle
-            // examples/example-tls/pom.xml
-            netty_tcnative: 'io.netty:netty-tcnative-boringssl-static:2.0.34.Final',
-
-            conscrypt: 'org.conscrypt:conscrypt-openjdk-uber:2.5.1',
-            re2j: 'com.google.re2j:re2j:1.5',
-
-            bouncycastle: 'org.bouncycastle:bcpkix-jdk15on:1.67',
-
-            // Test dependencies.
-            junit: 'junit:junit:4.12',
-            mockito: 'org.mockito:mockito-core:3.3.3',
-            truth: 'com.google.truth:truth:1.0.1',
-            guava_testlib: "com.google.guava:guava-testlib:${guavaVersion}",
-            androidx_test: "androidx.test:core:1.3.0",
-            robolectric: "org.robolectric:robolectric:4.3.1",
-
-            // Benchmark dependencies
-            hdrhistogram: 'org.hdrhistogram:HdrHistogram:2.1.12',
-            math: 'org.apache.commons:commons-math3:3.6.1',
-
-            // Jetty ALPN dependencies
-            jetty_alpn_agent: 'org.mortbay.jetty.alpn:jetty-alpn-agent:2.0.10'
-        ]
-
-        // A util function to config guava dependency with transitive dependencies
-        // properly resolved for the failOnVersionConflict strategy.
-        guavaDependency = { configurationName ->
-            dependencies."$configurationName"(libraries.guava) {
-                exclude group: 'com.google.code.findbugs', module: 'jsr305'
-                exclude group: 'com.google.errorprone', module: 'error_prone_annotations'
-                exclude group: 'org.codehaus.mojo', module: 'animal-sniffer-annotations'
-            }
-            dependencies."$configurationName" libraries.errorprone
-            dependencies.runtimeOnly libraries.animalsniffer_annotations
-            dependencies.runtimeOnly libraries.jsr305
-        }
-
-        // A util function to config opencensus_api dependency with transitive
-        // dependencies properly resolved for the failOnVersionConflict strategy.
-        censusApiDependency = { configurationName ->
-            dependencies."$configurationName"(libraries.opencensus_api) {
-                exclude group: 'com.google.code.findbugs', module: 'jsr305'
-                exclude group: 'com.google.guava', module: 'guava'
-                // we'll always be more up-to-date
-                exclude group: 'io.grpc', module: 'grpc-context'
-            }
-            dependencies.runtimeOnly project(':grpc-context')
-            dependencies.runtimeOnly libraries.jsr305
-            guavaDependency 'runtimeOnly'
-        }
-
-        // A util function to config opencensus_contrib_grpc_metrics dependency
-        // with transitive dependencies properly resolved for the failOnVersionConflict
-        // strategy.
-        censusGrpcMetricDependency = { configurationName ->
-            dependencies."$configurationName"(libraries.opencensus_contrib_grpc_metrics) {
-                exclude group: 'com.google.code.findbugs', module: 'jsr305'
-                exclude group: 'com.google.guava', module: 'guava'
-                // we'll always be more up-to-date
-                exclude group: 'io.grpc', module: 'grpc-context'
-            }
-            dependencies.runtimeOnly project(':grpc-context')
-            dependencies.runtimeOnly libraries.jsr305
-            guavaDependency 'runtimeOnly'
-        }
-
-        googleOauth2Dependency = { configurationName ->
-            dependencies."$configurationName"(libraries.google_auth_oauth2_http) {
-                exclude group: 'com.google.guava', module: 'guava'
-                exclude group: 'io.grpc', module: 'grpc-context'
-                exclude group: 'io.opencensus', module: 'opencensus-api'
-            }
-            dependencies.runtimeOnly project(':grpc-context')
-            censusApiDependency 'runtimeOnly'
-            guavaDependency 'runtimeOnly'
-        }
-
-        // A util function to config perfmark dependency with transitive
-        // dependencies properly resolved for the failOnVersionConflict strategy.
-        perfmarkDependency = { configurationName ->
-            dependencies."$configurationName"(libraries.perfmark) {
-                exclude group: 'com.google.errorprone', module: 'error_prone_annotations'
-            }
-            dependencies.runtimeOnly libraries.errorprone
-        }
+        libraries = libs
 
         appendToProperty = { Property<String> property, String value, String separator ->
             if (property.present) {
@@ -270,144 +167,169 @@ subprojects {
         }
     }
 
-    configurations {
-        // Detect Maven Enforcer's dependencyConvergence failures. We only
-        // care for artifacts used as libraries by others.
-        if (isAndroid && !(project.name in ['grpc-android-interop-testing'])) {
-            releaseRuntimeClasspath {
-                resolutionStrategy.failOnVersionConflict()
-            }
-        }
-        if (!isAndroid && !(project.name in [
-                'grpc-benchmarks',
-                'grpc-interop-testing',
-                'grpc-gae-interop-testing-jdk8',
-        ])) {
-            runtimeClasspath {
-                resolutionStrategy.failOnVersionConflict()
-            }
-        }
-    }
-
     // Disable JavaDoc doclint on Java 8. It's annoying.
     if (JavaVersion.current().isJava8Compatible()) {
         allprojects {
-            tasks.withType(Javadoc) {
+            tasks.withType(Javadoc).configureEach {
                 options.addStringOption('Xdoclint:none', '-quiet')
             }
         }
     }
 
-    jacoco { toolVersion = "0.8.2" }
-
     checkstyle {
         configDirectory = file("$rootDir/buildscripts")
-        toolVersion = "6.17"
+        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()
         }
     }
 
-    if (rootProject.properties.get('errorProne', true)) {
+    if (!project.hasProperty('errorProne') || errorProne.toBoolean()) {
         dependencies {
-            errorprone 'com.google.errorprone:error_prone_core:2.4.0'
-            errorproneJavac 'com.google.errorprone:javac:9+181-r4173-1'
+            errorprone JavaVersion.current().isJava11Compatible() ? libs.errorprone.core : libs.errorprone.corejava8
         }
     } else {
         // Disable Error Prone
-        allprojects {
-            afterEvaluate { project ->
-                project.tasks.withType(JavaCompile) {
-                    options.errorprone.enabled = false
+        tasks.withType(JavaCompile).configureEach {
+            options.errorprone.enabled = false
+        }
+    }
+
+    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"]
+            }
+        }
     }
 
     plugins.withId("java") {
-        sourceCompatibility = 1.7
-        targetCompatibility = 1.7
-
         dependencies {
             testImplementation libraries.junit,
-                    libraries.mockito,
+                    libraries.mockito.core,
                     libraries.truth
         }
 
-        compileTestJava {
+        tasks.named("compileTestJava").configure {
             // serialVersionUID is basically guaranteed to be useless in our tests
             options.compilerArgs += [
                 "-Xlint:-serial"
             ]
         }
 
-        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)
+        tasks.named("jar").configure {
+            manifest {
+                attributes('Implementation-Title': name,
+                        'Implementation-Version': project.version)
+            }
         }
 
-        javadoc.options {
-            encoding = 'UTF-8'
-            use = true
-            links 'https://docs.oracle.com/javase/8/docs/api/'
-            source = "8"
+        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"
+            }
         }
 
-        checkstyleMain {
+        tasks.named("checkstyleMain").configure {
             source = fileTree(dir: "$projectDir/src/main", include: "**/*.java")
         }
 
-        checkstyleTest {
+        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.
-        test {
+        tasks.withType(Test).configureEach {
             testLogging {
                 exceptionFormat = 'full'
-                showExceptions true
-                showCauses true
-                showStackTraces true
+                showExceptions = true
+                showCauses = true
+                showStackTraces = true
             }
             maxHeapSize = '1500m'
         }
 
-        if (rootProject.properties.get('errorProne', true)) {
+        if (!project.hasProperty('errorProne') || errorProne.toBoolean()) {
             dependencies {
-                annotationProcessor 'com.google.guava:guava-beta-checker:1.0'
+                annotationProcessor libs.guava.betaChecker
             }
         }
 
-        compileJava {
-            // This project targets Java 7 (no method references)
-            options.errorprone.check("UnnecessaryAnonymousClass", CheckSeverity.OFF)
+        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)
         }
-        compileTestJava {
+        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("UnnecessaryAnonymousClass", 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
+            }
         }
     }
 
-    plugins.withId("me.champeau.gradle.jmh") {
-        dependencies {
-            jmh 'org.openjdk.jmh:jmh-core:1.19',
-                    'org.openjdk.jmh:jmh-generator-bytecode:1.19'
+    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')
         }
+    }
+
+    plugins.withId("me.champeau.jmh") {
         // invoke jmh on a single benchmark class like so:
         //   ./gradlew -PjmhIncludeSingleClass=StatsTraceContextBenchmark clean :grpc-core:jmh
-        jmh {
+        tasks.named("jmh").configure {
             warmupIterations = 10
             iterations = 10
             fork = 1
@@ -416,13 +338,31 @@ subprojects {
             // depends on core; core's testCompile depends on testing)
             includeTests = false
             if (project.hasProperty('jmhIncludeSingleClass')) {
-                include = [
+                includes = [
                     project.property('jmhIncludeSingleClass')
                 ]
             }
         }
     }
 
+    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")
+                    }
+                }
+            })
+        }
+    }
+
     plugins.withId("maven-publish") {
         publishing {
             publications {
@@ -459,21 +399,6 @@ subprojects {
                                 organizationUrl = "https://www.google.com"
                             }
                         }
-
-                        withXml {
-                            if (!(project.name in
-                            [
-                                "grpc-stub",
-                                "grpc-protobuf",
-                                "grpc-protobuf-lite",
-                            ])) {
-                                asNode().dependencies.'*'.findAll() { dep ->
-                                    dep.artifactId.text() in ['grpc-api', 'grpc-core']
-                                }.each() { core ->
-                                    core.version*.value = "[" + core.version.text() + "]"
-                                }
-                            }
-                        }
                     }
                 }
             }
@@ -483,11 +408,11 @@ subprojects {
                         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 = 'https://oss.sonatype.org/service/local/staging/deployByRepositoryId/' +
-                                    rootProject.repositoryId
+                            stagingUrl = "${baseUrl}/staging/deployByRepositoryId/" + rootProject.repositoryId
                         } else {
-                            stagingUrl = 'https://oss.sonatype.org/service/local/staging/deploy/maven2/'
+                            stagingUrl = "${baseUrl}/staging/deploy/maven2/"
                         }
                         credentials {
                             if (rootProject.hasProperty('ossrhUsername') && rootProject.hasProperty('ossrhPassword')) {
@@ -496,7 +421,7 @@ subprojects {
                             }
                         }
                         def releaseUrl = stagingUrl
-                        def snapshotUrl = 'https://oss.sonatype.org/content/repositories/snapshots/'
+                        def snapshotUrl = 'https://central.sonatype.com/repository/maven-snapshots/'
                         url = version.endsWith('SNAPSHOT') ? snapshotUrl : releaseUrl
                     }
                 }
@@ -504,7 +429,7 @@ subprojects {
         }
 
         signing {
-            required false
+            required = false
             sign publishing.publications.maven
         }
 
@@ -531,30 +456,25 @@ subprojects {
         def baselineGrpcVersion = '1.6.1'
 
         // Get the baseline version's jar for this subproject
-        File baselineArtifact = null
-        // Use a detached configuration, otherwise the current version's jar will take precedence
-        // over the baseline jar.
+        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'
-            String depModule = "io.grpc:${project.name}:${baselineGrpcVersion}@jar"
-            String depJar = "${project.name}-${baselineGrpcVersion}.jar"
-            Configuration configuration = configurations.detachedConfiguration(
-                    dependencies.create(depModule)
-                    )
-            baselineArtifact = files(configuration.files).filter {
-                it.name.equals(depJar)
-            }.singleFile
+            dependencies {
+                baselineArtifact "io.grpc:${project.name}:${baselineGrpcVersion}@jar"
+            }
         } finally {
             project.group = oldGroup
         }
 
         // Add a japicmp task that compares the current .jar with baseline .jar
-        task japicmp(type: me.champeau.gradle.japicmp.JapicmpTask, dependsOn: jar) {
-            oldClasspath = files(baselineArtifact)
-            newClasspath = files(jar.archivePath)
+        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
@@ -567,12 +487,51 @@ subprojects {
 
             // Also break on source incompatible changes, not just binary.
             // Eg adding abstract method to public class.
-            // TODO(zpencer): enable after japicmp-gradle-plugin/pull/14
-            // breakOnSourceIncompatibility = true
+            failOnSourceIncompatibility = true
 
             // Ignore any classes or methods marked @ExperimentalApi
-            // TODO(zpencer): enable after japicmp-gradle-plugin/pull/15
-            // annotationExcludes = ['@io.grpc.ExperimentalApi']
+            annotationExcludes = ['@io.grpc.ExperimentalApi']
         }
     }
 }
+
+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_docker.sh b/buildscripts/build_docker.sh
index ce89d348ca0..b34f9a6e542 100755
--- a/buildscripts/build_docker.sh
+++ b/buildscripts/build_docker.sh
@@ -2,4 +2,7 @@
 set -eu -o pipefail
 
 readonly buildscripts_dir="$(dirname "$(readlink -f "$0")")"
-docker build -t grpc-java-artifacts "$buildscripts_dir"/grpc-java-artifacts
+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.xml b/buildscripts/checkstyle.xml
index 52b564201c8..0ec8ecc79ce 100644
--- a/buildscripts/checkstyle.xml
+++ b/buildscripts/checkstyle.xml
@@ -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
index 5bab7bf29fb..54c595cd960 100644
--- a/buildscripts/grpc-java-artifacts/Dockerfile
+++ b/buildscripts/grpc-java-artifacts/Dockerfile
@@ -1,25 +1,37 @@
-FROM centos:7.9.2009
+FROM almalinux:8
 
 RUN yum install -y \
             autoconf \
             automake \
+            diffutils \
             gcc-c++ \
-            gcc-c++.i686 \
             glibc-devel \
             glibc-devel.i686 \
-            java-1.8.0-openjdk-devel \
+            java-11-openjdk-devel \
             libstdc++-devel \
             libstdc++-devel.i686 \
-            libstdc++-static \
-            libstdc++-static.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 http://apache.cs.utah.edu/maven/maven-3/3.3.9/binaries/apache-maven-3.3.9-bin.tar.gz | \
+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/apache-maven-3.3.9/bin:$PATH
+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..6b670994677
--- /dev/null
+++ b/buildscripts/grpc-java-artifacts/Dockerfile.multiarch.base
@@ -0,0 +1,23 @@
+FROM ubuntu:24.04
+
+# Redirect to the internal mirror to bypass the Kokoro network block
+RUN sed -i 's|http://archive.ubuntu.com/ubuntu/|http://mirror.bazel.build/archive.ubuntu.com/ubuntu/|g' /etc/apt/sources.list
+
+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-11-jdk \
+        pkgconf \
+        && \
+    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/grpc-java-linux-arm64-tests/Dockerfile b/buildscripts/grpc-java-linux-arm64-tests/Dockerfile
deleted file mode 100644
index 47cbd18ebc0..00000000000
--- a/buildscripts/grpc-java-linux-arm64-tests/Dockerfile
+++ /dev/null
@@ -1,10 +0,0 @@
-# This docker image uses magic to seamlessly run its contents using qemu ARM emulator on x86 host.
-# See https://ownyourbits.com/2018/06/27/running-and-building-arm-docker-containers-in-x86/
-
-# We want to test on arm64v8
-FROM arm64v8/debian:buster
-
-# Make the host's qemu-arm-static emulator available from inside the docker container.
-COPY qemu-arm-static /usr/bin
-
-RUN apt-get update && apt-get install -y --no-install-recommends openjdk-11-jdk-headless && apt-get clean
diff --git a/buildscripts/kokoro/android-interop.sh b/buildscripts/kokoro/android-interop.sh
index 5d9774bb12f..877311daca5 100755
--- a/buildscripts/kokoro/android-interop.sh
+++ b/buildscripts/kokoro/android-interop.sh
@@ -1,40 +1,56 @@
 #!/bin/bash
 
 set -exu -o pipefail
-if [[ -f /VERSION ]]; then
-  cat /VERSION
-fi
-
-# Install gRPC and codegen for the Android interop app
-# (a composite gradle build can't find protoc-gen-grpc-java)
 
 cd github/grpc-java
 
-export GRADLE_OPTS=-Xmx512m
-export LDFLAGS=-L/tmp/protobuf/lib
-export CXXFLAGS=-I/tmp/protobuf/include
-export LD_LIBRARY_PATH=/tmp/protobuf/lib
-export OS_NAME=$(uname)
+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
 
-echo y | ${ANDROID_HOME}/tools/bin/sdkmanager "build-tools;28.0.3"
+GRADLE_FLAGS="-Pandroid.useAndroidX=true -Dorg.gradle.jvmargs=-Xmx1024m -PskipCodegen=true"
 
-# Proto deps
-buildscripts/make_dependencies.sh
+./gradlew $GRADLE_FLAGS :grpc-android-interop-testing:assembleDebug
+./gradlew $GRADLE_FLAGS :grpc-android-interop-testing:assembleDebugAndroidTest
+./gradlew $GRADLE_FLAGS :grpc-binder:assembleDebugAndroidTest
 
-# Build and run interop instrumentation tests on Firebase Test Lab
-cd android-interop-testing
-../gradlew assembleDebug
-../gradlew 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 build/outputs/apk/debug/grpc-android-interop-testing-debug.apk \
-  --test build/outputs/apk/androidTest/debug/grpc-android-interop-testing-debug-androidTest.apk \
+  --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=Nexus6P,version=27,locale=en,orientation=portrait \
-  --device model=Nexus6P,version=26,locale=en,orientation=portrait \
+  --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 \
-  --device model=Nexus6P,version=23,locale=en,orientation=portrait \
-  --device model=Nexus6,version=22,locale=en,orientation=portrait \
-  --device model=Nexus6,version=21,locale=en,orientation=portrait
diff --git a/buildscripts/kokoro/android.sh b/buildscripts/kokoro/android.sh
index 50337ef878b..677825ae66b 100755
--- a/buildscripts/kokoro/android.sh
+++ b/buildscripts/kokoro/android.sh
@@ -1,7 +1,6 @@
 #!/bin/bash
 
 set -exu -o pipefail
-cat /VERSION
 
 BASE_DIR="$(pwd)"
 
@@ -10,28 +9,51 @@ BASE_DIR="$(pwd)"
 
 cd "$BASE_DIR/github/grpc-java"
 
-export LDFLAGS=-L/tmp/protobuf/lib
-export CXXFLAGS=-I/tmp/protobuf/include
-export LD_LIBRARY_PATH=/tmp/protobuf/lib
 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
-org.gradle.jvmargs=-Xmx512m -XX:MaxMetaspaceSize=512m
+# 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
 
-echo y | ${ANDROID_HOME}/tools/bin/sdkmanager "build-tools;28.0.3"
-
+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 \
-    publishToMavenLocal
+    :grpc-binder:build \
+    assembleAndroidTest \
+    publishToMavenLocal \
+    $GRADLE_FLAGS
 
 if [[ ! -z $(git status --porcelain) ]]; then
   git status
@@ -42,13 +64,13 @@ fi
 # Build examples
 
 cd ./examples/android/clientcache
-../../gradlew build
+../../gradlew build $GRADLE_FLAGS
 cd ../routeguide
-../../gradlew build
+../../gradlew build $GRADLE_FLAGS
 cd ../helloworld
-../../gradlew build
+../../gradlew build $GRADLE_FLAGS
 cd ../strictmode
-../../gradlew build
+../../gradlew build $GRADLE_FLAGS
 
 # Skip APK size and dex count comparisons for non-PR builds
 
@@ -57,22 +79,18 @@ if [[ -z "${KOKORO_GITHUB_PULL_REQUEST_COMMIT:-}" ]]; then
     exit 0
 fi
 
-# Save a copy of set_github_status.py (it may differ from the base commit)
-
-SET_GITHUB_STATUS="$TMPDIR/set_github_status.py"
-cp "$BASE_DIR/github/grpc-java/buildscripts/set_github_status.py" "$SET_GITHUB_STATUS"
-
-
 # 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}/tools/bin/apkanalyzer" dex references \
+  <("${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}/tools/bin/apkanalyzer" dex packages \
+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
@@ -81,20 +99,20 @@ new_apk_size="$(stat --printf=%s $HELLO_WORLD_OUTPUT_DIR/apk/release/app-release
 
 
 # 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
-./gradlew publishToMavenLocal
+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
+../../gradlew build $GRADLE_FLAGS
 
 read -r ignored old_dex_count < \
-  <("${ANDROID_HOME}/tools/bin/apkanalyzer" dex references app/build/outputs/apk/release/app-release-unsigned.apk)
+  <("${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}/tools/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`
+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)"
@@ -114,16 +132,19 @@ fi
 
 # Update the statuses with the deltas
 
+set +x
 gsutil cp gs://grpc-testing-secrets/github_credentials/oauth_token.txt ~/
 
-"$SET_GITHUB_STATUS" \
-  --sha1 "$KOKORO_GITHUB_PULL_REQUEST_COMMIT" \
-  --state success \
-  --description "New DEX reference count: $(printf "%'d" "$new_dex_count") (delta: $(printf "%'d" "$dex_count_delta"))" \
-  --context android/dex_diff --oauth_file ~/oauth_token.txt
-
-"$SET_GITHUB_STATUS" \
-  --sha1 "$KOKORO_GITHUB_PULL_REQUEST_COMMIT" \
-  --state success \
-  --description "New APK size in bytes: $(printf "%'d" "$new_apk_size") (delta: $(printf "%'d" "$apk_size_delta"))" \
-  --context android/apk_diff --oauth_file ~/oauth_token.txt
+desc="New DEX reference count: $(printf "%'d" "$new_dex_count") (delta: $(printf "%'d" "$dex_count_delta"))"
+echo "Setting status: $desc"
+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"))"
+echo "Setting status: $desc"
+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/bazel.cfg b/buildscripts/kokoro/bazel.cfg
deleted file mode 100644
index ae7cb261caf..00000000000
--- a/buildscripts/kokoro/bazel.cfg
+++ /dev/null
@@ -1,5 +0,0 @@
-# Config file for internal CI
-
-# Location of the continuous shell script in repository.
-build_file: "grpc-java/buildscripts/kokoro/bazel.sh"
-timeout_mins: 45
diff --git a/buildscripts/kokoro/bazel.sh b/buildscripts/kokoro/bazel.sh
deleted file mode 100755
index f63c05f300b..00000000000
--- a/buildscripts/kokoro/bazel.sh
+++ /dev/null
@@ -1,14 +0,0 @@
-#!/bin/bash
-
-set -exu -o pipefail
-cat /VERSION
-
-use_bazel.sh 1.0.1
-bazel version
-
-cd github/grpc-java
-bazel build ...
-
-cd examples
-bazel clean
-bazel build ...
diff --git a/buildscripts/kokoro/gae-interop.sh b/buildscripts/kokoro/gae-interop.sh
deleted file mode 100755
index b3973031d85..00000000000
--- a/buildscripts/kokoro/gae-interop.sh
+++ /dev/null
@@ -1,54 +0,0 @@
-#!/bin/bash
-
-set -exu -o pipefail
-if [[ -f /VERSION ]]; then
-  cat /VERSION
-fi
-
-KOKORO_GAE_SERVICE="java-gae-interop-test"
-
-# We deploy as different versions of a single service, this way any stale
-# lingering deploys can be easily cleaned up by purging all running versions
-# of this service.
-KOKORO_GAE_APP_VERSION=$(hostname)
-
-# A dummy version that can be the recipient of all traffic, so that the kokoro test version can be
-# set to 0 traffic. This is a requirement in order to delete it.
-DUMMY_DEFAULT_VERSION='dummy-default'
-
-function cleanup() {
-  echo "Performing cleanup now."
-  gcloud app services delete $KOKORO_GAE_SERVICE --version $KOKORO_GAE_APP_VERSION --quiet
-}
-trap cleanup SIGHUP SIGINT SIGTERM EXIT
-
-readonly GRPC_JAVA_DIR="$(cd "$(dirname "$0")"/../.. && pwd)"
-cd "$GRPC_JAVA_DIR"
-
-##
-## Deploy the dummy 'default' version of the service
-##
-GRADLE_FLAGS="--stacktrace -DgaeStopPreviousVersion=false -PskipCodegen=true -PskipAndroid=true"
-
-# Deploy the dummy 'default' version. We only require that it exists when cleanup() is called.
-# It ok if we race with another run and fail here, because the end result is idempotent.
-set +e
-if ! gcloud app versions describe "$DUMMY_DEFAULT_VERSION" --service="$KOKORO_GAE_SERVICE"; then
-  ./gradlew $GRADLE_FLAGS -DgaeDeployVersion="$DUMMY_DEFAULT_VERSION" -DgaePromote=true :grpc-gae-interop-testing-jdk8:appengineDeploy
-else
-  echo "default version already exists: $DUMMY_DEFAULT_VERSION"
-fi
-set -e
-
-# Deploy and test the real app (jdk8)
-./gradlew $GRADLE_FLAGS -DgaeDeployVersion="$KOKORO_GAE_APP_VERSION" :grpc-gae-interop-testing-jdk8:runInteropTestRemote
-
-set +e
-echo "Cleaning out stale deploys from previous runs, it is ok if this part fails"
-
-# Sometimes the trap based cleanup fails.
-# 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' AND version.createTime<'-p1h'" | xargs -i gcloud app services delete "$KOKORO_GAE_SERVICE" --version {} --quiet
-exit 0
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
index 0938e4bff2e..8691b5ff356 100644
--- a/buildscripts/kokoro/linux_artifacts.cfg
+++ b/buildscripts/kokoro/linux_artifacts.cfg
@@ -6,6 +6,7 @@ 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
index 17402fe89b3..49d9932dfa0 100755
--- a/buildscripts/kokoro/linux_artifacts.sh
+++ b/buildscripts/kokoro/linux_artifacts.sh
@@ -7,31 +7,17 @@ fi
 
 readonly GRPC_JAVA_DIR="$(cd "$(dirname "$0")"/../.. && pwd)"
 
-"$GRPC_JAVA_DIR"/buildscripts/build_docker.sh
-"$GRPC_JAVA_DIR"/buildscripts/run_in_docker.sh /grpc-java/buildscripts/build_artifacts_in_docker.sh
-
-# grpc-android and grpc-cronet require the Android SDK, so build outside of Docker and
-# use --include-build for its grpc-core dependency
-echo y | ${ANDROID_HOME}/tools/bin/sdkmanager "build-tools;28.0.3"
-LOCAL_MVN_TEMP=$(mktemp -d)
-pushd "$GRPC_JAVA_DIR/android"
-../gradlew publish \
-  -Dorg.gradle.parallel=false \
-  -PskipCodegen=true \
-  -PrepositoryDir="$LOCAL_MVN_TEMP"
-popd
+. "$GRPC_JAVA_DIR"/buildscripts/kokoro/kokoro.sh
+trap spongify_logs EXIT
 
-pushd "$GRPC_JAVA_DIR/cronet"
-../gradlew publish \
-  -Dorg.gradle.parallel=false \
-  -PskipCodegen=true \
-  -PrepositoryDir="$LOCAL_MVN_TEMP"
-popd
-
-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"/
+"$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
 
-# for aarch64 platform
-sudo apt-get install -y g++-aarch64-linux-gnu
-SKIP_TESTS=true ARCH=aarch_64 "$GRPC_JAVA_DIR"/buildscripts/kokoro/unix.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
index 310e1130416..4c79743692e 100644
--- a/buildscripts/kokoro/macos.cfg
+++ b/buildscripts/kokoro/macos.cfg
@@ -1,20 +1,13 @@
 # Config file for internal CI
 
 # Location of the continuous shell script in repository.
-build_file: "grpc-java/buildscripts/kokoro/unix.sh"
-timeout_mins: 45
-
-# We had problems with random tests timing out because it took seconds to do
-# trivial (ns) operations. The Mac machines have 2 cores with 4 logical
-# threads, so Gradle should be using 4 workers by default.
-env_vars {
-  key: "GRADLE_FLAGS"
-  value: "--max-workers=2"
-}
+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/unix.sh b/buildscripts/kokoro/unix.sh
index 5a720295c64..693768a0270 100755
--- a/buildscripts/kokoro/unix.sh
+++ b/buildscripts/kokoro/unix.sh
@@ -9,6 +9,10 @@
 #  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
@@ -16,38 +20,48 @@ 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)"
 
-if [[ -f /VERSION ]]; then
-  cat /VERSION
-fi
-
 # cd to the root dir of grpc-java
 cd $(dirname $0)/../..
 
-# TODO(zpencer): always make sure we are using Oracle jdk8
-
 # 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+=" -PskipAndroid=true"
 GRADLE_FLAGS+=" -Dorg.gradle.parallel=true"
-export GRADLE_OPTS="-Xmx512m"
+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 LD_LIBRARY_PATH=/tmp/protobuf/lib
-export LDFLAGS=-L/tmp/protobuf/lib
-export CXXFLAGS="-I/tmp/protobuf/include"
+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 clean $GRADLE_FLAGS
-# Ensure dependency convergence
-./gradlew :grpc-all:dependencies $GRADLE_FLAGS
+./gradlew grpc-compiler:clean $GRADLE_FLAGS
 
 if [[ -z "${SKIP_TESTS:-}" ]]; then
   # Ensure all *.proto changes include *.java generated code
@@ -59,35 +73,29 @@ if [[ -z "${SKIP_TESTS:-}" ]]; then
     exit 1
   fi
   # Run tests
-  ./gradlew build $GRADLE_FLAGS
+  ./gradlew build :grpc-all:jacocoTestReport $GRADLE_FLAGS
   pushd examples
-  ./gradlew clean $GRADLE_FLAGS
   ./gradlew build $GRADLE_FLAGS
   # --batch-mode reduces log spam
   mvn verify --batch-mode
   popd
-  pushd examples/example-hostname
-  ../gradlew build $GRADLE_FLAGS
-  mvn verify --batch-mode
-  popd
-  pushd examples/example-tls
-  ../gradlew build $GRADLE_FLAGS
-  mvn verify --batch-mode
-  popd
-  pushd examples/example-jwt-auth
-  ../gradlew build $GRADLE_FLAGS
-  mvn verify --batch-mode
-  popd
-  pushd examples/example-xds
-  ../gradlew build $GRADLE_FLAGS
-  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" ]]; 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"
diff --git a/buildscripts/kokoro/upload_artifacts.sh b/buildscripts/kokoro/upload_artifacts.sh
index 8d7f2f5b365..39e27eff522 100644
--- a/buildscripts/kokoro/upload_artifacts.sh
+++ b/buildscripts/kokoro/upload_artifacts.sh
@@ -24,6 +24,9 @@ LOCAL_OTHER_ARTIFACTS="$KOKORO_GFILE_DIR"/github/grpc-java/artifacts/
 # 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' ]]
@@ -31,8 +34,16 @@ LOCAL_OTHER_ARTIFACTS="$KOKORO_GFILE_DIR"/github/grpc-java/artifacts/
 # 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' ]]
diff --git a/buildscripts/kokoro/windows.bat b/buildscripts/kokoro/windows.bat
index 709b61c9886..b5852cdd971 100644
--- a/buildscripts/kokoro/windows.bat
+++ b/buildscripts/kokoro/windows.bat
@@ -11,12 +11,10 @@ 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
 
 
-@rem Clear JAVA_HOME to prevent a different Java version from being used
-set JAVA_HOME=
-set PATH=C:\Program Files\java\jdk1.8.0_152\bin;%PATH%
-
 cmd.exe /C "%WORKSPACE%\buildscripts\kokoro\windows32.bat" || exit /b 1
 cmd.exe /C "%WORKSPACE%\buildscripts\kokoro\windows64.bat" || exit /b 1
 
diff --git a/buildscripts/kokoro/windows.cfg b/buildscripts/kokoro/windows.cfg
index 6b2703f99c9..ec0a3c9ae34 100644
--- a/buildscripts/kokoro/windows.cfg
+++ b/buildscripts/kokoro/windows.cfg
@@ -2,12 +2,12 @@
 
 # Location of the continuous shell script in repository.
 build_file: "grpc-java/buildscripts/kokoro/windows.bat"
-timeout_mins: 45
+timeout_mins: 90 
 
 # We always build mvn artifacts.
 action {
   define_artifacts {
-    regex: "**/build/test-results/**/*.xml"
+    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
index 5a87b779da3..d51beba82f9 100644
--- a/buildscripts/kokoro/windows32.bat
+++ b/buildscripts/kokoro/windows32.bat
@@ -15,20 +15,23 @@ set ESCWORKSPACE=%WORKSPACE:\=\\%
 
 @rem Clear JAVA_HOME to prevent a different Java version from being used
 set JAVA_HOME=
-set PATH=C:\Program Files\java\jdk1.8.0_152\bin;%PATH%
 
 mkdir grpc-java-helper32
 cd grpc-java-helper32
-call "%VS140COMNTOOLS%\vsvars32.bat" || exit /b 1
+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 VC_PROTOBUF_LIBS=%ESCWORKSPACE%\\grpc-java-helper32\\protobuf-%PROTOBUF_VER%\\cmake\\build\\Release
-SET VC_PROTOBUF_INCLUDE=%ESCWORKSPACE%\\grpc-java-helper32\\protobuf-%PROTOBUF_VER%\\cmake\\build\\include
+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%
@@ -49,3 +52,34 @@ IF NOT %GRADLEEXIT% == 0 (
 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
index edcb421fe7d..180025d5e82 100644
--- a/buildscripts/kokoro/windows64.bat
+++ b/buildscripts/kokoro/windows64.bat
@@ -14,22 +14,56 @@ set ESCWORKSPACE=%WORKSPACE:\=\\%
 
 @rem Clear JAVA_HOME to prevent a different Java version from being used
 set JAVA_HOME=
-set PATH=C:\Program Files\java\jdk1.8.0_152\bin;%PATH%
 
 mkdir grpc-java-helper64
 cd grpc-java-helper64
-call "%VS140COMNTOOLS%\..\..\VC\bin\amd64\vcvars64.bat" || exit /b 1
+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 VC_PROTOBUF_LIBS=%ESCWORKSPACE%\\grpc-java-helper64\\protobuf-%PROTOBUF_VER%\\cmake\\build\\Release
-SET VC_PROTOBUF_INCLUDE=%ESCWORKSPACE%\\grpc-java-helper64\\protobuf-%PROTOBUF_VER%\\cmake\\build\\include
+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 clean grpc-compiler:build grpc-compiler:publish" || exit /b 1
+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-install-test-driver.sh b/buildscripts/kokoro/xds-k8s-install-test-driver.sh
deleted file mode 100755
index fba84daea21..00000000000
--- a/buildscripts/kokoro/xds-k8s-install-test-driver.sh
+++ /dev/null
@@ -1,342 +0,0 @@
-#!/usr/bin/env bash
-# TODO(sergiitk): move to grpc/grpc when implementing support of other languages
-set -eo pipefail
-
-# Constants
-readonly PYTHON_VERSION="3.6"
-# Test driver
-readonly TEST_DRIVER_REPO_NAME="grpc"
-readonly TEST_DRIVER_REPO_URL="https://github.com/grpc/grpc.git"
-readonly TEST_DRIVER_BRANCH="${TEST_DRIVER_BRANCH:-master}"
-readonly TEST_DRIVER_PATH="tools/run_tests/xds_k8s_test_driver"
-readonly TEST_DRIVER_PROTOS_PATH="src/proto/grpc/testing"
-
-#######################################
-# Run command end report its exit code. Doesn't exit on non-zero exit code.
-# Globals:
-#   None
-# Arguments:
-#   Command to execute
-# Outputs:
-#   Writes the output of given command to stdout, stderr
-#######################################
-run_ignore_exit_code() {
-  local exit_code=-1
-  "$@" || exit_code=$?
-  echo "Exit code: ${exit_code}"
-}
-
-#######################################
-# Parses information about git repository at given path to global variables.
-# Globals:
-#   GIT_ORIGIN_URL: Populated with the origin URL of git repo used for the build
-#   GIT_COMMIT: Populated with the SHA-1 of git commit being built
-#   GIT_COMMIT_SHORT: Populated with the short SHA-1 of git commit being built
-# Arguments:
-#   Git source dir
-#######################################
-parse_src_repo_git_info() {
-  local src_dir="${SRC_DIR:?SRC_DIR must be set}"
-  readonly GIT_ORIGIN_URL=$(git -C "${src_dir}" remote get-url origin)
-  readonly GIT_COMMIT=$(git -C "${src_dir}" rev-parse HEAD)
-  readonly GIT_COMMIT_SHORT=$(git -C "${src_dir}" rev-parse --short HEAD)
-}
-
-#######################################
-# List GCR image tags matching given tag name.
-# Arguments:
-#   Image name
-#   Tag name
-# Outputs:
-#   Writes the table with the list of found tags to stdout.
-#   If no tags found, the output is an empty string.
-#######################################
-gcloud_gcr_list_image_tags() {
-  gcloud container images list-tags --format="table[box](tags,digest,timestamp.date())" --filter="tags:$2" "$1"
-}
-
-#######################################
-# A helper to execute `gcloud -q components update`.
-# Arguments:
-#   None
-# Outputs:
-#   Writes the output of `gcloud` command to stdout, stderr
-#######################################
-gcloud_update() {
-  echo "Update gcloud components:"
-  gcloud -q components update
-}
-
-#######################################
-# Create kube context authenticated with GKE cluster, saves context name.
-# to KUBE_CONTEXT
-# Globals:
-#   GKE_CLUSTER_NAME
-#   GKE_CLUSTER_ZONE
-#   KUBE_CONTEXT: Populated with name of kubectl context with GKE cluster access
-# Arguments:
-#   None
-# Outputs:
-#   Writes the output of `gcloud` command to stdout, stderr
-#   Writes authorization info $HOME/.kube/config
-#######################################
-gcloud_get_cluster_credentials() {
-  gcloud container clusters get-credentials "${GKE_CLUSTER_NAME}" --zone "${GKE_CLUSTER_ZONE}"
-  readonly KUBE_CONTEXT="$(kubectl config current-context)"
-}
-
-#######################################
-# Clone the source code of the test driver to $TEST_DRIVER_REPO_DIR, unless
-# given folder exists.
-# Globals:
-#   TEST_DRIVER_REPO_URL
-#   TEST_DRIVER_BRANCH
-#   TEST_DRIVER_REPO_DIR: path to the repo containing the test driver
-#   TEST_DRIVER_REPO_DIR_USE_EXISTING: set non-empty value to use exiting
-#      clone of the driver repo located at $TEST_DRIVER_REPO_DIR.
-#      Useful for debugging the build script locally.
-# Arguments:
-#   None
-# Outputs:
-#   Writes the output of `git` command to stdout, stderr
-#   Writes driver source code to $TEST_DRIVER_REPO_DIR
-#######################################
-test_driver_get_source() {
-  if [[ -n "${TEST_DRIVER_REPO_DIR_USE_EXISTING}" && -d "${TEST_DRIVER_REPO_DIR}" ]]; then
-    echo "Using exiting driver directory: ${TEST_DRIVER_REPO_DIR}."
-  else
-    echo "Cloning driver to ${TEST_DRIVER_REPO_URL} branch ${TEST_DRIVER_BRANCH} to ${TEST_DRIVER_REPO_DIR}"
-    git clone -b "${TEST_DRIVER_BRANCH}" --depth=1 "${TEST_DRIVER_REPO_URL}" "${TEST_DRIVER_REPO_DIR}"
-  fi
-}
-
-#######################################
-# Install Python modules from required in $TEST_DRIVER_FULL_DIR/requirements.txt
-# to Python virtual environment. Creates and activates Python venv if necessary.
-# Globals:
-#   TEST_DRIVER_FULL_DIR
-#   PYTHON_VERSION
-# Arguments:
-#   None
-# Outputs:
-#   Writes the output of `python`, `pip` commands to stdout, stderr
-#   Writes the list of installed modules to stdout
-#######################################
-test_driver_pip_install() {
-  echo "Install python dependencies"
-  cd "${TEST_DRIVER_FULL_DIR}"
-
-  # Create and activate virtual environment unless already using one
-  if [[ -z "${VIRTUAL_ENV}" ]]; then
-    local venv_dir="${TEST_DRIVER_FULL_DIR}/venv"
-    if [[ -d "${venv_dir}" ]]; then
-      echo "Found python virtual environment directory: ${venv_dir}"
-    else
-      echo "Creating python virtual environment: ${venv_dir}"
-      "python${PYTHON_VERSION} -m venv ${venv_dir}"
-    fi
-    # Intentional: No need to check python venv activate script.
-    # shellcheck source=/dev/null
-    source "${venv_dir}/bin/activate"
-  fi
-
-  pip install -r requirements.txt
-  echo "Installed Python packages:"
-  pip list
-}
-
-#######################################
-# Compile proto-files needed for the test driver
-# Globals:
-#   TEST_DRIVER_REPO_DIR
-#   TEST_DRIVER_FULL_DIR
-#   TEST_DRIVER_PROTOS_PATH
-# Arguments:
-#   None
-# Outputs:
-#   Writes the output of `python -m grpc_tools.protoc` to stdout, stderr
-#   Writes the list if compiled python code to stdout
-#   Writes compiled python code with proto messages and grpc services to
-#   $TEST_DRIVER_FULL_DIR/src/proto
-#######################################
-test_driver_compile_protos() {
-  declare -a protos
-  protos=(
-    "${TEST_DRIVER_PROTOS_PATH}/test.proto"
-    "${TEST_DRIVER_PROTOS_PATH}/messages.proto"
-    "${TEST_DRIVER_PROTOS_PATH}/empty.proto"
-  )
-  echo "Generate python code from grpc.testing protos: ${protos[*]}"
-  cd "${TEST_DRIVER_REPO_DIR}"
-  python -m grpc_tools.protoc \
-    --proto_path=. \
-    --python_out="${TEST_DRIVER_FULL_DIR}" \
-    --grpc_python_out="${TEST_DRIVER_FULL_DIR}" \
-    "${protos[@]}"
-  local protos_out_dir="${TEST_DRIVER_FULL_DIR}/${TEST_DRIVER_PROTOS_PATH}"
-  echo "Generated files ${protos_out_dir}:"
-  ls -Fl "${protos_out_dir}"
-}
-
-#######################################
-# Installs the test driver and it's requirements.
-# https://github.com/grpc/grpc/tree/master/tools/run_tests/xds_k8s_test_driver#installation
-# Globals:
-#   TEST_DRIVER_REPO_DIR: Populated with the path to the repo containing
-#                         the test driver
-#   TEST_DRIVER_FULL_DIR: Populated with the path to the test driver source code
-# Arguments:
-#   The directory for test driver's source code
-# Outputs:
-#   Writes the output to stdout, stderr
-#######################################
-test_driver_install() {
-  readonly TEST_DRIVER_REPO_DIR="${1:?Usage test_driver_install TEST_DRIVER_REPO_DIR}"
-  readonly TEST_DRIVER_FULL_DIR="${TEST_DRIVER_REPO_DIR}/${TEST_DRIVER_PATH}"
-  test_driver_get_source
-  test_driver_pip_install
-  test_driver_compile_protos
-}
-
-#######################################
-# Outputs Kokoro image version and Ubuntu's lsb_release
-# Arguments:
-#   None
-# Outputs:
-#   Writes the output to stdout
-#######################################
-kokoro_print_version() {
-  echo "Kokoro VM version:"
-  if [[ -f /VERSION ]]; then
-    cat /VERSION
-  fi
-  run_ignore_exit_code lsb_release -a
-}
-
-#######################################
-# Report extra information about the job via sponge properties.
-# Globals:
-#   KOKORO_ARTIFACTS_DIR
-#   GIT_ORIGIN_URL
-#   GIT_COMMIT_SHORT
-#   TESTGRID_EXCLUDE
-# Arguments:
-#   None
-# Outputs:
-#   Writes the output to stdout
-#   Writes job properties to $KOKORO_ARTIFACTS_DIR/custom_sponge_config.csv
-#######################################
-kokoro_write_sponge_properties() {
-  # CSV format: "property_name","property_value"
-  # Bump TESTS_FORMAT_VERSION when reported test name changed enough to when it
-  # makes more sense to discard previous test results from a testgrid board.
-  # Use GIT_ORIGIN_URL to exclude test runs executed against repo forks from
-  # testgrid reports.
-  cat >"${KOKORO_ARTIFACTS_DIR}/custom_sponge_config.csv" <<EOF
-TESTS_FORMAT_VERSION,2
-TESTGRID_EXCLUDE,${TESTGRID_EXCLUDE:-0}
-GIT_ORIGIN_URL,${GIT_ORIGIN_URL:?GIT_ORIGIN_URL must be set}
-GIT_COMMIT_SHORT,${GIT_COMMIT_SHORT:?GIT_COMMIT_SHORT must be set}
-EOF
-  echo "Sponge properties:"
-  cat "${KOKORO_ARTIFACTS_DIR}/custom_sponge_config.csv"
-}
-
-#######################################
-# Configure Python virtual environment on Kokoro VM.
-# Arguments:
-#   None
-# Outputs:
-#   Writes the output of `pyenv` commands to stdout
-#######################################
-kokoro_setup_python_virtual_environment() {
-  # Kokoro provides pyenv, so use it instead of `python -m venv`
-  echo "Setup pyenv environment"
-  eval "$(pyenv init -)"
-  eval "$(pyenv virtualenv-init -)"
-  py_latest_patch="$(pyenv versions --bare --skip-aliases | grep -E "^${PYTHON_VERSION}\.[0-9]{1,2}$" | sort --version-sort | tail -n 1)"
-  echo "Activating python ${py_latest_patch} virtual environment"
-  pyenv virtualenv "${py_latest_patch}" k8s_xds_test_runner
-  pyenv local k8s_xds_test_runner
-  pyenv activate k8s_xds_test_runner
-}
-
-#######################################
-# Installs and configures the test driver on Kokoro VM.
-# Globals:
-#   KOKORO_ARTIFACTS_DIR
-#   TEST_DRIVER_REPO_NAME
-#   SRC_DIR: Populated with absolute path to the source repo on Kokoro VM
-#   TEST_DRIVER_REPO_DIR: Populated with the path to the repo containing
-#                         the test driver
-#   TEST_DRIVER_FULL_DIR: Populated with the path to the test driver source code
-#   TEST_DRIVER_FLAGFILE: Populated with relative path to test driver flagfile
-#   TEST_XML_OUTPUT_DIR: Populated with the path to test xUnit XML report
-#   KUBE_CONTEXT: Populated with name of kubectl context with GKE cluster access
-#   GIT_ORIGIN_URL: Populated with the origin URL of git repo used for the build
-#   GIT_COMMIT: Populated with the SHA-1 of git commit being built
-#   GIT_COMMIT_SHORT: Populated with the short SHA-1 of git commit being built
-# Arguments:
-#   The name of github repository being built
-# Outputs:
-#   Writes the output to stdout, stderr, files
-#######################################
-kokoro_setup_test_driver() {
-  local src_repository_name="${1:?Usage kokoro_setup_test_driver GITHUB_REPOSITORY_NAME}"
-  # Capture Kokoro VM version info in the log.
-  kokoro_print_version
-
-  # Kokoro clones repo to ${KOKORO_ARTIFACTS_DIR}/github/${GITHUB_REPOSITORY}
-  local github_root="${KOKORO_ARTIFACTS_DIR}/github"
-  readonly SRC_DIR="${github_root}/${src_repository_name}"
-  local test_driver_repo_dir="${github_root}/${TEST_DRIVER_REPO_NAME}"
-  parse_src_repo_git_info SRC_DIR
-  kokoro_write_sponge_properties
-  kokoro_setup_python_virtual_environment
-
-  # gcloud requires python, so this should be executed after pyenv setup
-  gcloud_update
-  gcloud_get_cluster_credentials
-  test_driver_install "${test_driver_repo_dir}"
-  # shellcheck disable=SC2034  # Used in the main script
-  readonly TEST_DRIVER_FLAGFILE="config/grpc-testing.cfg"
-  # Test artifacts dir: xml reports, logs, etc.
-  local artifacts_dir="${KOKORO_ARTIFACTS_DIR}/artifacts"
-  # Folders after $artifacts_dir reported as target name
-  readonly TEST_XML_OUTPUT_DIR="${artifacts_dir}/${KOKORO_JOB_NAME}"
-  mkdir -p "${artifacts_dir}" "${TEST_XML_OUTPUT_DIR}"
-}
-
-#######################################
-# Installs and configures the test driver for testing build script locally.
-# Globals:
-#   TEST_DRIVER_REPO_NAME
-#   TEST_DRIVER_REPO_DIR: Unless provided, populated with a temporary dir with
-#                         the path to the test driver repo
-#   SRC_DIR: Populated with absolute path to the source repo
-#   TEST_DRIVER_FULL_DIR: Populated with the path to the test driver source code
-#   TEST_DRIVER_FLAGFILE: Populated with relative path to test driver flagfile
-#   TEST_XML_OUTPUT_DIR: Populated with the path to test xUnit XML report
-#   GIT_ORIGIN_URL: Populated with the origin URL of git repo used for the build
-#   GIT_COMMIT: Populated with the SHA-1 of git commit being built
-#   GIT_COMMIT_SHORT: Populated with the short SHA-1 of git commit being built
-#   KUBE_CONTEXT: Populated with name of kubectl context with GKE cluster access
-# Arguments:
-#   The path to the folder containing the build script
-# Outputs:
-#   Writes the output to stdout, stderr, files
-#######################################
-local_setup_test_driver() {
-  local script_dir="${1:?Usage: local_setup_test_driver SCRIPT_DIR}"
-  readonly SRC_DIR="$(git -C "${script_dir}" rev-parse --show-toplevel)"
-  parse_src_repo_git_info SRC_DIR
-  readonly KUBE_CONTEXT="${KUBE_CONTEXT:-$(kubectl config current-context)}"
-  local test_driver_repo_dir
-  test_driver_repo_dir="${TEST_DRIVER_REPO_DIR:-$(mktemp -d)/${TEST_DRIVER_REPO_NAME}}"
-  test_driver_install "${test_driver_repo_dir}"
-  # shellcheck disable=SC2034  # Used in the main script
-  readonly TEST_DRIVER_FLAGFILE="config/local-dev.cfg"
-  # Test out
-  readonly TEST_XML_OUTPUT_DIR="${TEST_DRIVER_FULL_DIR}/out"
-  mkdir -p "${TEST_XML_OUTPUT_DIR}"
-}
diff --git a/buildscripts/kokoro/xds-k8s.cfg b/buildscripts/kokoro/xds-k8s.cfg
deleted file mode 100644
index 61fe825d8ad..00000000000
--- a/buildscripts/kokoro/xds-k8s.cfg
+++ /dev/null
@@ -1,13 +0,0 @@
-# Config file for internal CI
-
-# Location of the continuous shell script in repository.
-build_file: "grpc-java/buildscripts/kokoro/xds-k8s.sh"
-timeout_mins: 90
-
-action {
-  define_artifacts {
-    regex: "artifacts/**/*sponge_log.xml"
-    regex: "artifacts/**/*sponge_log.log"
-    strip_prefix: "artifacts"
-  }
-}
diff --git a/buildscripts/kokoro/xds-k8s.sh b/buildscripts/kokoro/xds-k8s.sh
deleted file mode 100755
index 8b5bf72f0f7..00000000000
--- a/buildscripts/kokoro/xds-k8s.sh
+++ /dev/null
@@ -1,164 +0,0 @@
-#!/usr/bin/env bash
-set -eo pipefail
-
-# Constants
-readonly GITHUB_REPOSITORY_NAME="grpc-java"
-# GKE Cluster
-readonly GKE_CLUSTER_NAME="interop-test-psm-sec1-us-central1"
-readonly GKE_CLUSTER_ZONE="us-central1-a"
-## xDS test server/client Docker images
-readonly SERVER_IMAGE_NAME="gcr.io/grpc-testing/xds-interop/java-server"
-readonly CLIENT_IMAGE_NAME="gcr.io/grpc-testing/xds-interop/java-client"
-readonly FORCE_IMAGE_BUILD="${FORCE_IMAGE_BUILD:-0}"
-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
-#   BUILD_APP_PATH
-# Arguments:
-#   None
-# Outputs:
-#   Writes the output of xds-test-client and xds-test-server --help to stderr
-#######################################
-build_java_test_app() {
-  echo "Building Java test app"
-  cd "${SRC_DIR}"
-  ./gradlew --no-daemon grpc-interop-testing:installDist -x test \
-    -PskipCodegen=true -PskipAndroid=true --console=plain
-
-  # Test-run binaries
-  run_ignore_exit_code "${SRC_DIR}/${BUILD_APP_PATH}/bin/xds-test-client" --help
-  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
-# Arguments:
-#   None
-# Outputs:
-#   Writes the output of `gcloud builds submit` to stdout, stderr
-#######################################
-build_test_app_docker_images() {
-  echo "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}"
-  # Run Google Cloud Build
-  gcloud builds submit "${build_dir}" \
-    --config "${docker_dir}/cloudbuild.yaml" \
-    --substitutions "_SERVER_IMAGE_NAME=${SERVER_IMAGE_NAME},_CLIENT_IMAGE_NAME=${CLIENT_IMAGE_NAME},COMMIT_SHA=${GIT_COMMIT}"
-  # TODO(sergiitk): extra "cosmetic" tags for versioned branches, e.g. v1.34.x
-  # TODO(sergiitk): do this when adding support for custom configs per version
-}
-
-#######################################
-# Builds test app and its docker images unless they already exist
-# Globals:
-#   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
-#   FORCE_IMAGE_BUILD
-# Arguments:
-#   None
-# Outputs:
-#   Writes the output to stdout, stderr
-#######################################
-build_docker_images_if_needed() {
-  # Check if images already exist
-  server_tags="$(gcloud_gcr_list_image_tags "${SERVER_IMAGE_NAME}" "${GIT_COMMIT}")"
-  printf "Server image: %s:%s\n" "${SERVER_IMAGE_NAME}" "${GIT_COMMIT}"
-  echo "${server_tags:-Server image not found}"
-
-  client_tags="$(gcloud_gcr_list_image_tags "${CLIENT_IMAGE_NAME}" "${GIT_COMMIT}")"
-  printf "Client image: %s:%s\n" "${CLIENT_IMAGE_NAME}" "${GIT_COMMIT}"
-  echo "${client_tags:-Client image not found}"
-
-  # Build if any of the images are missing, or FORCE_IMAGE_BUILD=1
-  if [[ "${FORCE_IMAGE_BUILD}" == "1" || -z "${server_tags}" || -z "${client_tags}" ]]; then
-    build_java_test_app
-    build_test_app_docker_images
-  else
-    echo "Skipping Java test app build"
-  fi
-}
-
-#######################################
-# Executes the test case
-# Globals:
-#   TEST_DRIVER_FLAGFILE: Relative path to test driver flagfile
-#   KUBE_CONTEXT: The name of kubectl context with GKE cluster access
-#   TEST_XML_OUTPUT_DIR: Output directory for the test xUnit XML report
-#   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
-# Arguments:
-#   Test case name
-# Outputs:
-#   Writes the output of test execution to stdout, stderr
-#   Test xUnit report to ${TEST_XML_OUTPUT_DIR}/${test_name}/sponge_log.xml
-#######################################
-run_test() {
-  # Test driver usage:
-  # https://github.com/grpc/grpc/tree/master/tools/run_tests/xds_k8s_test_driver#basic-usage
-  local test_name="${1:?Usage: run_test test_name}"
-  set -x
-  python -m "tests.${test_name}" \
-    --flagfile="${TEST_DRIVER_FLAGFILE}" \
-    --kube_context="${KUBE_CONTEXT}" \
-    --server_image="${SERVER_IMAGE_NAME}:${GIT_COMMIT}" \
-    --client_image="${CLIENT_IMAGE_NAME}:${GIT_COMMIT}" \
-    --xml_output_file="${TEST_XML_OUTPUT_DIR}/${test_name}/sponge_log.xml" \
-    --force_cleanup
-  set +x
-}
-
-#######################################
-# Main function: provision software necessary to execute tests, and run them
-# Globals:
-#   KOKORO_ARTIFACTS_DIR
-#   GITHUB_REPOSITORY_NAME
-#   SRC_DIR: Populated with absolute path to the source repo
-#   TEST_DRIVER_REPO_DIR: Populated with the path to the repo containing
-#                         the test driver
-#   TEST_DRIVER_FULL_DIR: Populated with the path to the test driver source code
-#   TEST_DRIVER_FLAGFILE: Populated with relative path to test driver flagfile
-#   TEST_XML_OUTPUT_DIR: Populated with the path to test xUnit XML report
-#   GIT_ORIGIN_URL: Populated with the origin URL of git repo used for the build
-#   GIT_COMMIT: Populated with the SHA-1 of git commit being built
-#   GIT_COMMIT_SHORT: Populated with the short SHA-1 of git commit being built
-#   KUBE_CONTEXT: Populated with name of kubectl context with GKE cluster access
-# Arguments:
-#   None
-# Outputs:
-#   Writes the output of test execution to stdout, stderr
-#######################################
-main() {
-  local script_dir
-  script_dir="$(dirname "$0")"
-  # shellcheck source=buildscripts/kokoro/xds-k8s-install-test-driver.sh
-  source "${script_dir}/xds-k8s-install-test-driver.sh"
-  set -x
-  if [[ -n "${KOKORO_ARTIFACTS_DIR}" ]]; then
-    kokoro_setup_test_driver "${GITHUB_REPOSITORY_NAME}"
-  else
-    local_setup_test_driver "${script_dir}"
-  fi
-  build_docker_images_if_needed
-  # Run tests
-  cd "${TEST_DRIVER_FULL_DIR}"
-  run_test baseline_test
-  run_test security_test
-}
-
-main "$@"
diff --git a/buildscripts/kokoro/xds.cfg b/buildscripts/kokoro/xds.cfg
deleted file mode 100644
index d6ca02c0583..00000000000
--- a/buildscripts/kokoro/xds.cfg
+++ /dev/null
@@ -1,11 +0,0 @@
-# Config file for internal CI
-
-# Location of the continuous shell script in repository.
-build_file: "grpc-java/buildscripts/kokoro/xds.sh"
-timeout_mins: 120
-action {
-  define_artifacts {
-    regex: "**/*sponge_log.*"
-    regex: "github/grpc/reports/**"
-  }
-}
diff --git a/buildscripts/kokoro/xds.sh b/buildscripts/kokoro/xds.sh
deleted file mode 100755
index fa727734522..00000000000
--- a/buildscripts/kokoro/xds.sh
+++ /dev/null
@@ -1,44 +0,0 @@
-#!/bin/bash
-
-set -exu -o pipefail
-if [[ -f /VERSION ]]; then
-  cat /VERSION
-fi
-
-cd github
-
-pushd grpc-java/interop-testing
-branch=$(git branch --all --no-color --contains "${KOKORO_GITHUB_COMMIT}" \
-      | grep -v HEAD | head -1)
-shopt -s extglob
-branch="${branch//[[:space:]]}"
-branch="${branch##remotes/origin/}"
-shopt -u extglob
-../gradlew installDist -x test -PskipCodegen=true -PskipAndroid=true
-popd
-
-git clone -b "${branch}" --single-branch --depth=1 https://github.com/grpc/grpc.git
-
-grpc/tools/run_tests/helper_scripts/prep_xds.sh
-
-# Test cases "path_matching" and "header_matching" are not included in "all",
-# because not all interop clients in all languages support these new tests.
-#
-# TODO(ericgribkoff): remove "path_matching" and "header_matching" from
-# --test_case after they are added into "all".
-JAVA_OPTS=-Djava.util.logging.config.file=grpc-java/buildscripts/xds_logging.properties \
-  python3 grpc/tools/run_tests/run_xds_tests.py \
-    --test_case="all,path_matching,header_matching,circuit_breaking,timeout" \
-    --project_id=grpc-testing \
-    --project_num=830293263384 \
-    --source_image=projects/grpc-testing/global/images/xds-test-server-4 \
-    --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_OPT-} \
-    --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/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
index 10aadda3145..fc2fe34e064 100644
--- a/buildscripts/kokoro/xds_v3.cfg
+++ b/buildscripts/kokoro/xds_v3.cfg
@@ -2,7 +2,7 @@
 
 # Location of the continuous shell script in repository.
 build_file: "grpc-java/buildscripts/kokoro/xds_v3.sh"
-timeout_mins: 120
+timeout_mins: 360
 action {
   define_artifacts {
     regex: "**/*sponge_log.*"
diff --git a/buildscripts/kokoro/xds_v3.sh b/buildscripts/kokoro/xds_v3.sh
index 73eb50d248a..8c879e1095b 100755
--- a/buildscripts/kokoro/xds_v3.sh
+++ b/buildscripts/kokoro/xds_v3.sh
@@ -1,3 +1,34 @@
 #!/bin/bash
 
-XDS_V3_OPT="--xds_v3_support" `dirname $0`/xds.sh
+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 c9ff2a63a43..a11f84d998e 100644
--- a/buildscripts/make_dependencies.bat
+++ b/buildscripts/make_dependencies.bat
@@ -1,12 +1,16 @@
-set PROTOBUF_VER=3.12.0
-set CMAKE_NAME=cmake-3.3.2-win32-x86
+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
 
-if not exist "protobuf-%PROTOBUF_VER%\cmake\build\Release\" (
+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
 
 
@@ -20,24 +24,34 @@ if not exist "%CMAKE_NAME%" (
 set PATH=%PATH%;%cd%\%CMAKE_NAME%\bin
 :hasCmake
 @rem GitHub requires TLSv1.2, and for whatever reason our powershell doesn't have it enabled
-powershell -command "$ErrorActionPreference = 'stop'; & { [Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12 ; iwr https://github.com/google/protobuf/archive/v%PROTOBUF_VER%.zip -OutFile protobuf.zip }" || exit /b 1
+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
+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
-if "%PLATFORM%" == "X64" (
-  @rem Note the space
-  SET CMAKE_VSARCH= Win64
+@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=
 )
-cmake -Dprotobuf_BUILD_TESTS=OFF -G "Visual Studio %VisualStudioVersion:~0,2%%CMAKE_VSARCH%" .. || exit /b 1
-msbuild /maxcpucount /p:Configuration=Release /verbosity:minimal libprotoc.vcxproj || exit /b 1
-call extract_includes.bat || exit /b 1
+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
 
@@ -48,3 +62,4 @@ powershell -command "$ErrorActionPreference = 'stop'; & { iwr https://cmake.org/
 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 3c3cc23c6a9..8cbefddd2eb 100755
--- a/buildscripts/make_dependencies.sh
+++ b/buildscripts/make_dependencies.sh
@@ -3,13 +3,63 @@
 # Build protoc
 set -evux -o pipefail
 
-PROTOBUF_VERSION=3.12.0
+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-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
@@ -19,6 +69,7 @@ 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.
@@ -26,22 +77,24 @@ 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
-  if [[ ! -d "$DOWNLOAD_DIR"/protobuf-"${PROTOBUF_VERSION}" ]]; then
-    curl -Ls https://github.com/google/protobuf/releases/download/v${PROTOBUF_VERSION}/protobuf-all-${PROTOBUF_VERSION}.tar.gz | tar xz -C $DOWNLOAD_DIR
-  fi
-  pushd $DOWNLOAD_DIR/protobuf-${PROTOBUF_VERSION}
-  # install here so we don't need sudo
-  if [[ "$ARCH" == x86* ]]; then
-    ./configure CFLAGS=-m${ARCH#*_} CXXFLAGS=-m${ARCH#*_} --disable-shared \
-      --prefix="$INSTALL_DIR"
-  elif [[ "$ARCH" == aarch* ]]; then
-    ./configure --disable-shared --host=aarch64-linux-gnu --prefix="$INSTALL_DIR"
+  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
-  make clean
-  make V=0 -j$NUM_CPU
-  make install
+  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.
@@ -54,7 +107,9 @@ ln -s "$INSTALL_DIR" /tmp/protobuf
 cat <<EOF
 To compile with the build dependencies:
 
-export LDFLAGS=-L/tmp/protobuf/lib
-export CXXFLAGS=-I/tmp/protobuf/include
+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_arm64_tests_in_docker.sh b/buildscripts/run_arm64_tests_in_docker.sh
deleted file mode 100755
index f6f8c14cbb4..00000000000
--- a/buildscripts/run_arm64_tests_in_docker.sh
+++ /dev/null
@@ -1,26 +0,0 @@
-#!/bin/bash
-set -ex
-
-readonly grpc_java_dir="$(dirname "$(readlink -f "$0")")/.."
-
-# Build magic docker image that can run on x86 host, but looks like an ARM machine
-# from the inside (qemu-user-static is used for emulation)
-# Run "sudo apt install qemu-user-static binfmt-support" install the emulator
-# on the host machine.
-# Also see https://ownyourbits.com/2018/06/27/running-and-building-arm-docker-containers-in-x86/
-cp /usr/bin/qemu-arm-static "${grpc_java_dir}/buildscripts/grpc-java-linux-arm64-tests"
-docker build -t grpc-java-linux-arm64-tests "${grpc_java_dir}/buildscripts/grpc-java-linux-arm64-tests"
-
-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
-
-# - run docker container under current user's UID to avoid polluting the workspace
-# - set the user.home property to avoid creating a "?" directory under grpc-java
-exec docker run $DOCKER_ARGS --rm=true -v "${grpc_java_dir}":/grpc-java -w /grpc-java \
-  --user "$(id -u):$(id -g)" -e "JAVA_OPTS=-Duser.home=/grpc-java/.current-user-home" \
-  grpc-java-linux-arm64-tests \
-  bash -c "./gradlew build -PskipAndroid=true -PskipCodegen=true"
diff --git a/buildscripts/run_in_docker.sh b/buildscripts/run_in_docker.sh
index 3963368f895..60af68f3bec 100755
--- a/buildscripts/run_in_docker.sh
+++ b/buildscripts/run_in_docker.sh
@@ -10,6 +10,8 @@ quote() {
   done
 }
 
+readonly docker_image=$1; shift
+
 readonly grpc_java_dir="$(dirname "$(readlink -f "$0")")/.."
 if [[ -t 0 ]]; then
   DOCKER_ARGS="-it"
@@ -21,5 +23,5 @@ fi
 # 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 \
-  grpc-java-artifacts \
+  $docker_image \
   bash -c "function fixFiles() { chown -R $(id -u):$(id -g) /grpc-java; }; trap fixFiles EXIT; $(quote "$@")"
diff --git a/buildscripts/set_github_status.py b/buildscripts/set_github_status.py
deleted file mode 100755
index 09b2ad2ace6..00000000000
--- a/buildscripts/set_github_status.py
+++ /dev/null
@@ -1,64 +0,0 @@
-#!/usr/bin/env python2.7
-#
-# 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.
-
-import argparse
-import json
-import urllib2
-
-
-def run():
-  argp = argparse.ArgumentParser(description='Set status on pull request')
-
-  argp.add_argument(
-      '--sha1', type=str, help='SHA1 of the commit', required=True)
-  argp.add_argument(
-      '--state',
-      type=str,
-      choices=('error', 'failure', 'pending', 'success'),
-      help='State to set',
-      required=True)
-  argp.add_argument(
-      '--description', type=str, help='Status description', required=True)
-  argp.add_argument('--context', type=str, help='Status context', required=True)
-  argp.add_argument(
-      '--oauth_file', type=str, help='File with OAuth token', required=True)
-
-  args = argp.parse_args()
-  sha1 = args.sha1
-  state = args.state
-  description = args.description
-  context = args.context
-  oauth_file = args.oauth_file
-
-  with open(oauth_file, 'r') as oauth_file_reader:
-    oauth_token = oauth_file_reader.read().replace('\n', '')
-
-  req = urllib2.Request(
-      url='https://api.github.com/repos/grpc/grpc-java/statuses/%s' % sha1,
-      data=json.dumps({
-          'state': state,
-          'description': description,
-          'context': context,
-      }),
-      headers={
-          'Authorization': 'token %s' % oauth_token,
-          'Content-Type': 'application/json',
-      })
-  print urllib2.urlopen(req).read()
-
-
-if __name__ == '__main__':
-  run()
diff --git a/buildscripts/sonatype-upload.sh b/buildscripts/sonatype-upload.sh
index 236212dfd76..4baa4e46ca0 100755
--- a/buildscripts/sonatype-upload.sh
+++ b/buildscripts/sonatype-upload.sh
@@ -59,7 +59,7 @@ if [ -z "$USERNAME" -o -z "$PASSWORD" ]; then
   exit 1
 fi
 
-STAGING_URL="https://oss.sonatype.org/service/local/staging"
+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
@@ -85,7 +85,7 @@ REPOID="$(
       <description>Release upload</description>
     </data>
   </promoteRequest>"
-  curl -s -X POST -d "$XML" -u "$USERPASS" -H "Content-Type: application/xml" \
+  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/'
@@ -94,7 +94,7 @@ echo "Repository id: $REPOID"
 
 for X in $(cd "$DIR" && find -type f | cut -b 3-); do
   echo "Uploading $X"
-  curl -T "$DIR/$X" -u "$USERPASS" -H "Content-Type: application/octet-stream" \
+  curl --fail-with-body -T "$DIR/$X" -u "$USERPASS" -H "Content-Type: application/octet-stream" \
     "$STAGING_URL/deployByRepositoryId/$REPOID/$X"
 done
 
@@ -106,5 +106,20 @@ XML="
     <description>Auto-close via upload script</description>
   </data>
 </promoteRequest>"
-curl -X POST -d "$XML" -u "$USERPASS" -H "Content-Type: application/xml" \
+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
index 968147ccac1..5f01be2e5c9 100755
--- a/buildscripts/sync-protos.sh
+++ b/buildscripts/sync-protos.sh
@@ -8,7 +8,7 @@ curl -Ls https://github.com/grpc/grpc-proto/archive/master.tar.gz | tar xz -C "$
 base="$tmpdir/grpc-proto-master"
 
 # Copy protos in 'src/main/proto' from grpc-proto for these projects
-for project in alts grpclb services rls; do
+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"
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
index 03c57489214..ad4e8049e22 100644
--- a/buildscripts/xds-k8s/cloudbuild.yaml
+++ b/buildscripts/xds-k8s/cloudbuild.yaml
@@ -3,6 +3,7 @@ steps:
   args:
     - 'build'
     - '--tag=${_SERVER_IMAGE_NAME}:${COMMIT_SHA}'
+    - '--tag=${_SERVER_IMAGE_NAME}:${BRANCH_NAME}'
     - '--file=test-server.Dockerfile'
     - '.'
 
@@ -10,13 +11,16 @@ steps:
   args:
     - 'build'
     - '--tag=${_CLIENT_IMAGE_NAME}:${COMMIT_SHA}'
+    - '--tag=${_CLIENT_IMAGE_NAME}:${BRANCH_NAME}'
     - '--file=test-client.Dockerfile'
     - '.'
 
 substitutions:
-  _SERVER_IMAGE_NAME: gcr.io/grpc-testing/xds-interop/java-server
-  _CLIENT_IMAGE_NAME: gcr.io/grpc-testing/xds-interop/java-client
+  _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/test-client.Dockerfile b/buildscripts/xds-k8s/test-client.Dockerfile
index 220ca038bbc..67fadb1302a 100644
--- a/buildscripts/xds-k8s/test-client.Dockerfile
+++ b/buildscripts/xds-k8s/test-client.Dockerfile
@@ -1,5 +1,5 @@
 # Build runtime image.
-FROM openjdk:11.0.9.1-jdk
+FROM eclipse-temurin:11-jre
 
 ENV APP_DIR=/usr/src/app
 WORKDIR $APP_DIR
@@ -11,5 +11,12 @@ COPY grpc-interop-testing/ $APP_DIR/
 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
index 86f84348458..e717b7dc526 100644
--- a/buildscripts/xds-k8s/test-server.Dockerfile
+++ b/buildscripts/xds-k8s/test-server.Dockerfile
@@ -1,5 +1,5 @@
 # Build runtime image.
-FROM openjdk:11.0.9.1-jdk
+FROM eclipse-temurin:11-jre
 
 ENV APP_DIR=/usr/src/app
 WORKDIR $APP_DIR
@@ -11,5 +11,12 @@ COPY grpc-interop-testing/ $APP_DIR/
 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/census/BUILD.bazel b/census/BUILD.bazel
index c0bf29b3f37..f017eeaf8bd 100644
--- a/census/BUILD.bazel
+++ b/census/BUILD.bazel
@@ -1,3 +1,6 @@
+load("@rules_java//java:defs.bzl", "java_library")
+load("@rules_jvm_external//:defs.bzl", "artifact")
+
 java_library(
     name = "census",
     srcs = glob([
@@ -5,11 +8,12 @@ java_library(
     ]),
     visibility = ["//visibility:public"],
     deps = [
-            "//api",
-            "//context",
-            "@com_google_code_findbugs_jsr305//jar",
-            "@com_google_guava_guava//jar",
-            "@io_opencensus_opencensus_api//jar",
-            "@io_opencensus_opencensus_contrib_grpc_metrics//jar",
+        "//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
index af5445a218c..c7cb02c15a0 100644
--- a/census/build.gradle
+++ b/census/build.gradle
@@ -1,27 +1,46 @@
 plugins {
     id "java-library"
     id "maven-publish"
+
+    id "ru.vyarus.animalsniffer"
 }
 
 description = 'gRPC: Census'
 
-evaluationDependsOn(project(':grpc-api').path)
+tasks.named("jar").configure {
+    manifest {
+        attributes('Automatic-Module-Name': 'io.grpc.census')
+    }
+}
 
 dependencies {
     api project(':grpc-api')
-    guavaDependency 'implementation'
-    censusApiDependency 'implementation'
-    censusGrpcMetricDependency 'implementation'
+    // 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 project(':grpc-api').sourceSets.test.output,
-            project(':grpc-context').sourceSets.test.output,
-            project(':grpc-core').sourceSets.test.output,
+    testImplementation testFixtures(project(':grpc-api')),
+            testFixtures(project(':grpc-core')),
             project(':grpc-testing'),
-            libraries.opencensus_impl
+            libraries.opencensus.impl
+
+    signature (libraries.signature.java) {
+        artifact {
+            extension = "signature"
+        }
+    }
+    signature (libraries.signature.android) {
+        artifact {
+            extension = "signature"
+        }
+    }
 }
 
-javadoc {
-    failOnError false  // no public or protected classes found to document
+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
index d625a6f5c6f..8f571ceb627 100644
--- a/census/src/main/java/io/grpc/census/CensusStatsModule.java
+++ b/census/src/main/java/io/grpc/census/CensusStatsModule.java
@@ -17,26 +17,32 @@
 package io.grpc.census;
 
 import static com.google.common.base.Preconditions.checkNotNull;
-import static com.google.common.base.Preconditions.checkState;
+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;
@@ -50,9 +56,10 @@
 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.concurrent.atomic.AtomicReferenceFieldUpdater;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 import javax.annotation.Nullable;
@@ -60,9 +67,10 @@
 /**
  * Provides factories for {@link StreamTracer} that records stats 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 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
@@ -81,19 +89,21 @@ final class CensusStatsModule {
   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 recordRealTimeMetrics, boolean recordRetryMetrics) {
     this(
         Tags.getTagger(),
         Tags.getTagPropagationComponent().getBinarySerializer(),
         Stats.getStatsRecorder(),
         stopwatchSupplier,
-        propagateTags, recordStartedRpcs, recordFinishedRpcs, recordRealTimeMetrics);
+        propagateTags, recordStartedRpcs, recordFinishedRpcs, recordRealTimeMetrics,
+        recordRetryMetrics);
   }
 
   /**
@@ -104,7 +114,7 @@ final class CensusStatsModule {
       final TagContextBinarySerializer tagCtxSerializer,
       StatsRecorder statsRecorder, Supplier<Stopwatch> stopwatchSupplier,
       boolean propagateTags, boolean recordStartedRpcs, boolean recordFinishedRpcs,
-      boolean recordRealTimeMetrics) {
+      boolean recordRealTimeMetrics, boolean recordRetryMetrics) {
     this.tagger = checkNotNull(tagger, "tagger");
     this.statsRecorder = checkNotNull(statsRecorder, "statsRecorder");
     checkNotNull(tagCtxSerializer, "tagCtxSerializer");
@@ -113,6 +123,7 @@ final class CensusStatsModule {
     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
@@ -138,15 +149,6 @@ public TagContext parseBytes(byte[] serialized) {
           });
   }
 
-  /**
-   * Creates a {@link ClientCallTracer} for a new call.
-   */
-  @VisibleForTesting
-  ClientCallTracer newClientCallTracer(
-      TagContext parentCtx, String fullMethodName) {
-    return new ClientCallTracer(this, parentCtx, fullMethodName);
-  }
-
   /**
    * Returns the server tracer factory.
    */
@@ -176,7 +178,6 @@ private void recordRealTimeMetric(TagContext ctx, MeasureLong measure, long valu
   }
 
   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;
@@ -188,7 +189,7 @@ private static final class ClientTracer extends ClientStreamTracer {
     @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.
@@ -230,23 +231,45 @@ private static final class ClientTracer extends ClientStreamTracer {
       inboundUncompressedSizeUpdater = tmpInboundUncompressedSizeUpdater;
     }
 
-    private final CensusStatsModule module;
-    private final TagContext startCtx;
-
+    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();
+    }
 
-    ClientTracer(CensusStatsModule module, TagContext startCtx) {
-      this.module = checkNotNull(module, "module");
-      this.startCtx = checkNotNull(startCtx, "startCtx");
+    @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")
+    @SuppressWarnings({"NonAtomicVolatileUpdate", "NonAtomicOperationOnVolatileField"})
     public void outboundWireSize(long bytes) {
       if (outboundWireSizeUpdater != null) {
         outboundWireSizeUpdater.getAndAdd(this, bytes);
@@ -254,7 +277,7 @@ public void outboundWireSize(long bytes) {
         outboundWireSize += bytes;
       }
       module.recordRealTimeMetric(
-          startCtx, RpcMeasureConstants.GRPC_CLIENT_SENT_BYTES_PER_METHOD, bytes);
+          startCtx, RpcMeasureConstants.GRPC_CLIENT_SENT_BYTES_PER_METHOD, (double) bytes);
     }
 
     @Override
@@ -266,7 +289,7 @@ public void inboundWireSize(long bytes) {
         inboundWireSize += bytes;
       }
       module.recordRealTimeMetric(
-          startCtx, RpcMeasureConstants.GRPC_CLIENT_RECEIVED_BYTES_PER_METHOD, bytes);
+          startCtx, RpcMeasureConstants.GRPC_CLIENT_RECEIVED_BYTES_PER_METHOD, (double) bytes);
     }
 
     @Override
@@ -292,6 +315,11 @@ public void inboundUncompressedSize(long 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 {
@@ -312,137 +340,221 @@ public void outboundMessage(int seqNo) {
       module.recordRealTimeMetric(
           startCtx, RpcMeasureConstants.GRPC_CLIENT_SENT_MESSAGES_PER_METHOD, 1);
     }
-  }
-
-  @VisibleForTesting
-  static final class ClientCallTracer extends ClientStreamTracer.Factory {
-    @Nullable
-    private static final AtomicReferenceFieldUpdater<ClientCallTracer, ClientTracer>
-        streamTracerUpdater;
 
-    @Nullable private static final AtomicIntegerFieldUpdater<ClientCallTracer> callEndedUpdater;
+    @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.
+    }
 
-    /**
-     * 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 {
-      AtomicReferenceFieldUpdater<ClientCallTracer, ClientTracer> tmpStreamTracerUpdater;
-      AtomicIntegerFieldUpdater<ClientCallTracer> tmpCallEndedUpdater;
-      try {
-        tmpStreamTracerUpdater =
-            AtomicReferenceFieldUpdater.newUpdater(
-                ClientCallTracer.class, ClientTracer.class, "streamTracer");
-        tmpCallEndedUpdater =
-            AtomicIntegerFieldUpdater.newUpdater(ClientCallTracer.class, "callEnded");
-      } catch (Throwable t) {
-        logger.log(Level.SEVERE, "Creating atomic field updaters failed", t);
-        tmpStreamTracerUpdater = null;
-        tmpCallEndedUpdater = null;
+    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);
       }
-      streamTracerUpdater = tmpStreamTracerUpdater;
-      callEndedUpdater = tmpCallEndedUpdater;
+      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 volatile ClientTracer streamTracer;
-    private volatile int callEnded;
+    private final Stopwatch callStopwatch;
+    @GuardedBy("lock")
+    private boolean callEnded;
     private final TagContext parentCtx;
     private final TagContext startCtx;
-
-    ClientCallTracer(CensusStatsModule module, TagContext parentCtx, String fullMethodName) {
-      this.module = checkNotNull(module);
-      this.parentCtx = checkNotNull(parentCtx);
+    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);
-      this.startCtx = module.tagger.toBuilder(parentCtx)
+      startCtx = module.tagger.toBuilder(parentCtx)
           .putLocal(RpcMeasureConstants.GRPC_CLIENT_METHOD, methodTag)
           .build();
-      this.stopwatch = module.stopwatchSupplier.get().start();
       if (module.recordStartedRpcs) {
+        // Record here in case newClientStreamTracer() would never be called.
         module.statsRecorder.newMeasureMap()
-            .put(DeprecatedCensusConstants.RPC_CLIENT_STARTED_COUNT, 1)
+            .put(RpcMeasureConstants.GRPC_CLIENT_STARTED_RPCS, 1)
             .record(startCtx);
       }
     }
 
     @Override
-    public ClientStreamTracer newClientStreamTracer(
-        ClientStreamTracer.StreamInfo info, Metadata headers) {
-      ClientTracer tracer = new ClientTracer(module, startCtx);
-      // TODO(zhangkun83): Once retry or hedging is implemented, a ClientCall may start more than
-      // one streams.  We will need to update this file to support them.
-      if (streamTracerUpdater != null) {
-        checkState(
-            streamTracerUpdater.compareAndSet(this, null, tracer),
-            "Are you creating multiple streams per call? This class doesn't yet support this case");
+    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 {
-        checkState(
-            streamTracer == null,
-            "Are you creating multiple streams per call? This class doesn't yet support this case");
-        streamTracer = tracer;
+        attemptsPerCall.incrementAndGet();
       }
-      if (module.propagateTags) {
-        headers.discardAll(module.statsHeader);
-        if (!module.tagger.empty().equals(parentCtx)) {
-          headers.put(module.statsHeader, parentCtx);
+      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;
+          }
         }
       }
-      return tracer;
+      if (shouldRecordFinishedCall) {
+        recordFinishedCall();
+      }
     }
 
-    /**
-     * 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(Status status) {
-      if (callEndedUpdater != null) {
-        if (callEndedUpdater.getAndSet(this, 1) != 0) {
+      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;
         }
-      } else {
-        if (callEnded != 0) {
-          return;
+        callEnded = true;
+        if (activeStreams == 0 && !finishedCallToBeRecorded) {
+          shouldRecordFinishedCall = true;
+          finishedCallToBeRecorded = true;
         }
-        callEnded = 1;
       }
-      if (!module.recordFinishedRpcs) {
+      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;
       }
-      stopwatch.stop();
-      long roundtripNanos = stopwatch.elapsed(TimeUnit.NANOSECONDS);
-      ClientTracer tracer = streamTracer;
-      if (tracer == null) {
-        tracer = new ClientTracer(module, startCtx);
+      long retriesPerCall = 0;
+      long attempts = attemptsPerCall.get();
+      if (attempts > 0) {
+        retriesPerCall = attempts - 1;
       }
+      callLatencyNanos = callStopwatch.elapsed(TimeUnit.NANOSECONDS);
       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(
-              DeprecatedCensusConstants.RPC_CLIENT_ROUNDTRIP_LATENCY,
-              roundtripNanos / NANOS_PER_MILLI)
-          .put(DeprecatedCensusConstants.RPC_CLIENT_REQUEST_COUNT, tracer.outboundMessageCount)
-          .put(DeprecatedCensusConstants.RPC_CLIENT_RESPONSE_COUNT, tracer.inboundMessageCount)
-          .put(DeprecatedCensusConstants.RPC_CLIENT_REQUEST_BYTES, tracer.outboundWireSize)
-          .put(DeprecatedCensusConstants.RPC_CLIENT_RESPONSE_BYTES, tracer.inboundWireSize)
-          .put(
-              DeprecatedCensusConstants.RPC_CLIENT_UNCOMPRESSED_REQUEST_BYTES,
-              tracer.outboundUncompressedSize)
-          .put(
-              DeprecatedCensusConstants.RPC_CLIENT_UNCOMPRESSED_RESPONSE_BYTES,
-              tracer.inboundUncompressedSize);
-      if (!status.isOk()) {
-        measureMap.put(DeprecatedCensusConstants.RPC_CLIENT_ERROR_COUNT, 1);
-      }
+          .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(startCtx)
+          module.tagger
+              .toBuilder(parentCtx)
+              .putLocal(RpcMeasureConstants.GRPC_CLIENT_METHOD, methodTag)
               .putLocal(RpcMeasureConstants.GRPC_CLIENT_STATUS, statusTag)
               .build());
     }
@@ -461,7 +573,7 @@ private static final class ServerTracer extends ServerStreamTracer {
     @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.
@@ -527,7 +639,7 @@ private static final class ServerTracer extends ServerStreamTracer {
       this.stopwatch = module.stopwatchSupplier.get().start();
       if (module.recordStartedRpcs) {
         module.statsRecorder.newMeasureMap()
-            .put(DeprecatedCensusConstants.RPC_SERVER_STARTED_COUNT, 1)
+            .put(RpcMeasureConstants.GRPC_SERVER_STARTED_RPCS, 1)
             .record(parentCtx);
       }
     }
@@ -541,7 +653,7 @@ public void outboundWireSize(long bytes) {
         outboundWireSize += bytes;
       }
       module.recordRealTimeMetric(
-          parentCtx, RpcMeasureConstants.GRPC_SERVER_SENT_BYTES_PER_METHOD, bytes);
+          parentCtx, RpcMeasureConstants.GRPC_SERVER_SENT_BYTES_PER_METHOD, (double) bytes);
     }
 
     @Override
@@ -553,7 +665,7 @@ public void inboundWireSize(long bytes) {
         inboundWireSize += bytes;
       }
       module.recordRealTimeMetric(
-          parentCtx, RpcMeasureConstants.GRPC_SERVER_RECEIVED_BYTES_PER_METHOD, bytes);
+          parentCtx, RpcMeasureConstants.GRPC_SERVER_RECEIVED_BYTES_PER_METHOD, (double) bytes);
     }
 
     @Override
@@ -623,23 +735,27 @@ public void streamClosed(Status status) {
       }
       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(
-              DeprecatedCensusConstants.RPC_SERVER_SERVER_LATENCY,
-              elapsedTimeNanos / NANOS_PER_MILLI)
-          .put(DeprecatedCensusConstants.RPC_SERVER_RESPONSE_COUNT, outboundMessageCount)
-          .put(DeprecatedCensusConstants.RPC_SERVER_REQUEST_COUNT, inboundMessageCount)
-          .put(DeprecatedCensusConstants.RPC_SERVER_RESPONSE_BYTES, outboundWireSize)
-          .put(DeprecatedCensusConstants.RPC_SERVER_REQUEST_BYTES, inboundWireSize)
-          .put(
-              DeprecatedCensusConstants.RPC_SERVER_UNCOMPRESSED_RESPONSE_BYTES,
-              outboundUncompressedSize)
-          .put(
-              DeprecatedCensusConstants.RPC_SERVER_UNCOMPRESSED_REQUEST_BYTES,
-              inboundUncompressedSize);
+      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);
       }
@@ -654,10 +770,7 @@ public void streamClosed(Status status) {
 
     @Override
     public Context filterContext(Context context) {
-      if (!module.tagger.empty().equals(parentCtx)) {
-        return ContextUtils.withValue(context, parentCtx);
-      }
-      return context;
+      return ContextUtils.withValue(context, parentCtx);
     }
   }
 
@@ -686,8 +799,8 @@ 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 ClientCallTracer tracerFactory =
-          newClientCallTracer(parentCtx, method.getFullMethodName());
+      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) {
diff --git a/census/src/main/java/io/grpc/census/CensusTracingModule.java b/census/src/main/java/io/grpc/census/CensusTracingModule.java
index fc35d89db55..68ec8b61eda 100644
--- a/census/src/main/java/io/grpc/census/CensusTracingModule.java
+++ b/census/src/main/java/io/grpc/census/CensusTracingModule.java
@@ -17,8 +17,11 @@
 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;
@@ -31,6 +34,7 @@
 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;
@@ -39,7 +43,9 @@
 import io.opencensus.trace.Status;
 import io.opencensus.trace.Tracer;
 import io.opencensus.trace.propagation.BinaryFormat;
-import io.opencensus.trace.unsafe.ContextUtils;
+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;
@@ -59,21 +65,22 @@
 final class CensusTracingModule {
   private static final Logger logger = Logger.getLogger(CensusTracingModule.class.getName());
 
-  @Nullable private static final AtomicIntegerFieldUpdater<ClientCallTracer> callEndedUpdater;
+  @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<ClientCallTracer> tmpCallEndedUpdater;
+    AtomicIntegerFieldUpdater<CallAttemptsTracerFactory> tmpCallEndedUpdater;
     AtomicIntegerFieldUpdater<ServerTracer> tmpStreamClosedUpdater;
     try {
       tmpCallEndedUpdater =
-          AtomicIntegerFieldUpdater.newUpdater(ClientCallTracer.class, "callEnded");
+          AtomicIntegerFieldUpdater.newUpdater(CallAttemptsTracerFactory.class, "callEnded");
       tmpStreamClosedUpdater =
           AtomicIntegerFieldUpdater.newUpdater(ServerTracer.class, "streamClosed");
     } catch (Throwable t) {
@@ -115,11 +122,12 @@ public SpanContext parseBytes(byte[] serialized) {
   }
 
   /**
-   * Creates a {@link ClientCallTracer} for a new call.
+   * Creates a {@link CallAttemptsTracerFactory} for a new call.
    */
   @VisibleForTesting
-  ClientCallTracer newClientCallTracer(@Nullable Span parentSpan, MethodDescriptor<?, ?> method) {
-    return new ClientCallTracer(parentSpan, method);
+  CallAttemptsTracerFactory newClientCallTracer(
+      @Nullable Span clientSpan, MethodDescriptor<?, ?> method) {
+    return new CallAttemptsTracerFactory(clientSpan, method);
   }
 
   /**
@@ -208,7 +216,7 @@ private static EndSpanOptions createEndSpanOptions(
         .build();
   }
 
-  private static void recordMessageEvent(
+  private void recordMessageEvent(
       Span span, MessageEvent.Type type,
       int seqNo, long optionalWireSize, long optionalUncompressedSize) {
     MessageEvent.Builder eventBuilder = MessageEvent.builder(type, seqNo);
@@ -221,33 +229,51 @@ private static void recordMessageEvent(
     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 ClientCallTracer extends ClientStreamTracer.Factory {
+  final class CallAttemptsTracerFactory extends ClientStreamTracer.Factory {
     volatile int callEnded;
 
     private final boolean isSampledToLocalTracing;
     private final Span span;
+    private final String fullMethodName;
 
-    ClientCallTracer(@Nullable Span parentSpan, MethodDescriptor<?, ?> method) {
+    CallAttemptsTracerFactory(@Nullable Span clientSpan, MethodDescriptor<?, ?> method) {
       checkNotNull(method, "method");
       this.isSampledToLocalTracing = method.isSampledToLocalTracing();
-      this.span =
-          censusTracer
-              .spanBuilderWithExplicitParent(
-                  generateTraceSpanName(false, method.getFullMethodName()),
-                  parentSpan)
-              .setRecordEvents(true)
-              .startSpan();
+      this.fullMethodName = method.getFullMethodName();
+      this.span = clientSpan;
     }
 
     @Override
     public ClientStreamTracer newClientStreamTracer(
         ClientStreamTracer.StreamInfo info, Metadata headers) {
-      if (span != BlankSpan.INSTANCE) {
-        headers.discardAll(tracingHeader);
-        headers.put(tracingHeader, span.getContext());
+      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(span);
+      return new ClientTracer(attemptSpan, span, tracingHeader, isSampledToLocalTracing);
     }
 
     /**
@@ -271,11 +297,37 @@ void callEnded(io.grpc.Status status) {
     }
   }
 
-  private static final class ClientTracer extends ClientStreamTracer {
+  private final class ClientTracer extends ClientStreamTracer {
     private final Span span;
-
-    ClientTracer(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
@@ -288,8 +340,24 @@ public void outboundMessageSent(
     @Override
     public void inboundMessageRead(
         int seqNo, long optionalWireSize, long optionalUncompressedSize) {
-      recordMessageEvent(
-          span, MessageEvent.Type.RECEIVED, seqNo, optionalWireSize, 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));
     }
   }
 
@@ -298,6 +366,7 @@ 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");
@@ -336,12 +405,18 @@ public void streamClosed(io.grpc.Status status) {
       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 ContextUtils.withValue(context, span);
+      return io.opencensus.trace.unsafe.ContextUtils.withValue(context, span);
     }
 
     @Override
@@ -354,8 +429,19 @@ public void outboundMessageSent(
     @Override
     public void inboundMessageRead(
         int seqNo, long optionalWireSize, long optionalUncompressedSize) {
-      recordMessageEvent(
-          span, MessageEvent.Type.RECEIVED, seqNo, optionalWireSize, 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);
     }
   }
 
@@ -374,6 +460,8 @@ public ServerStreamTracer newServerStreamTracer(String fullMethodName, Metadata
 
   @VisibleForTesting
   final class TracingClientInterceptor implements ClientInterceptor {
+
+    @SuppressWarnings("deprecation")
     @Override
     public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
         MethodDescriptor<ReqT, RespT> method, CallOptions callOptions, Channel next) {
@@ -381,12 +469,20 @@ public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
       // 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.
-      final ClientCallTracer tracerFactory =
-          newClientCallTracer(ContextUtils.getValue(Context.current()), method);
+      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));
+              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) {
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
index 96be3258dff..3bbbb7dd0e0 100644
--- a/census/src/main/java/io/grpc/census/InternalCensusStatsAccessor.java
+++ b/census/src/main/java/io/grpc/census/InternalCensusStatsAccessor.java
@@ -49,14 +49,16 @@ private InternalCensusStatsAccessor() {
   public static ClientInterceptor getClientInterceptor(
       boolean recordStartedRpcs,
       boolean recordFinishedRpcs,
-      boolean recordRealTimeMetrics) {
+      boolean recordRealTimeMetrics,
+      boolean recordRetryMetrics) {
     CensusStatsModule censusStats =
         new CensusStatsModule(
             STOPWATCH_SUPPLIER,
             true, /* propagateTags */
             recordStartedRpcs,
             recordFinishedRpcs,
-            recordRealTimeMetrics);
+            recordRealTimeMetrics,
+            recordRetryMetrics);
     return censusStats.getClientInterceptor();
   }
 
@@ -71,11 +73,13 @@ public static ClientInterceptor getClientInterceptor(
       boolean propagateTags,
       boolean recordStartedRpcs,
       boolean recordFinishedRpcs,
-      boolean recordRealTimeMetrics) {
+      boolean recordRealTimeMetrics,
+      boolean recordRetryMetrics) {
     CensusStatsModule censusStats =
         new CensusStatsModule(
             tagger, tagCtxSerializer, statsRecorder, stopwatchSupplier,
-            propagateTags, recordStartedRpcs, recordFinishedRpcs, recordRealTimeMetrics);
+            propagateTags, recordStartedRpcs, recordFinishedRpcs, recordRealTimeMetrics,
+            recordRetryMetrics);
     return censusStats.getClientInterceptor();
   }
 
@@ -92,7 +96,8 @@ public static ServerStreamTracer.Factory getServerStreamTracerFactory(
             true, /* propagateTags */
             recordStartedRpcs,
             recordFinishedRpcs,
-            recordRealTimeMetrics);
+            recordRealTimeMetrics,
+            false);
     return censusStats.getServerTracerFactory();
   }
 
@@ -111,7 +116,7 @@ public static ServerStreamTracer.Factory getServerStreamTracerFactory(
     CensusStatsModule censusStats =
         new CensusStatsModule(
             tagger, tagCtxSerializer, statsRecorder, stopwatchSupplier,
-            propagateTags, recordStartedRpcs, recordFinishedRpcs, recordRealTimeMetrics);
+            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
index 2df6c5fb4bd..3a4c8bfd196 100644
--- a/census/src/main/java/io/grpc/census/InternalCensusTracingAccessor.java
+++ b/census/src/main/java/io/grpc/census/InternalCensusTracingAccessor.java
@@ -44,7 +44,7 @@ public static ClientInterceptor getClientInterceptor() {
   }
 
   /**
-   * Returns a {@link ServerStreamTracer.Factory} with default stats implementation.
+   * Returns a {@link ServerStreamTracer.Factory} with default tracing implementation.
    */
   public static ServerStreamTracer.Factory getServerStreamTracerFactory() {
     CensusTracingModule censusTracing =
diff --git a/census/src/main/java/io/grpc/census/internal/DeprecatedCensusConstants.java b/census/src/main/java/io/grpc/census/internal/DeprecatedCensusConstants.java
index 2b0a4763a28..7470bc81b15 100644
--- a/census/src/main/java/io/grpc/census/internal/DeprecatedCensusConstants.java
+++ b/census/src/main/java/io/grpc/census/internal/DeprecatedCensusConstants.java
@@ -27,49 +27,23 @@
 public final class DeprecatedCensusConstants {
   public static final MeasureLong RPC_CLIENT_ERROR_COUNT =
       RpcMeasureConstants.RPC_CLIENT_ERROR_COUNT;
-  public static final MeasureDouble RPC_CLIENT_REQUEST_BYTES =
-      RpcMeasureConstants.RPC_CLIENT_REQUEST_BYTES;
-  public static final MeasureDouble RPC_CLIENT_RESPONSE_BYTES =
-      RpcMeasureConstants.RPC_CLIENT_RESPONSE_BYTES;
-  public static final MeasureDouble RPC_CLIENT_ROUNDTRIP_LATENCY =
-      RpcMeasureConstants.RPC_CLIENT_ROUNDTRIP_LATENCY;
-  public static final MeasureDouble RPC_CLIENT_SERVER_ELAPSED_TIME =
-      RpcMeasureConstants.RPC_CLIENT_SERVER_ELAPSED_TIME;
   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_STARTED_COUNT =
-      RpcMeasureConstants.RPC_CLIENT_STARTED_COUNT;
   public static final MeasureLong RPC_CLIENT_FINISHED_COUNT =
       RpcMeasureConstants.RPC_CLIENT_FINISHED_COUNT;
-  public static final MeasureLong RPC_CLIENT_REQUEST_COUNT =
-      RpcMeasureConstants.RPC_CLIENT_REQUEST_COUNT;
-  public static final MeasureLong RPC_CLIENT_RESPONSE_COUNT =
-      RpcMeasureConstants.RPC_CLIENT_RESPONSE_COUNT;
 
   public static final MeasureLong RPC_SERVER_ERROR_COUNT =
       RpcMeasureConstants.RPC_SERVER_ERROR_COUNT;
-  public static final MeasureDouble RPC_SERVER_REQUEST_BYTES =
-      RpcMeasureConstants.RPC_SERVER_REQUEST_BYTES;
-  public static final MeasureDouble RPC_SERVER_RESPONSE_BYTES =
-      RpcMeasureConstants.RPC_SERVER_RESPONSE_BYTES;
   public static final MeasureDouble RPC_SERVER_SERVER_ELAPSED_TIME =
       RpcMeasureConstants.RPC_SERVER_SERVER_ELAPSED_TIME;
-  public static final MeasureDouble RPC_SERVER_SERVER_LATENCY =
-      RpcMeasureConstants.RPC_SERVER_SERVER_LATENCY;
   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_STARTED_COUNT =
-      RpcMeasureConstants.RPC_SERVER_STARTED_COUNT;
   public static final MeasureLong RPC_SERVER_FINISHED_COUNT =
       RpcMeasureConstants.RPC_SERVER_FINISHED_COUNT;
-  public static final MeasureLong RPC_SERVER_REQUEST_COUNT =
-      RpcMeasureConstants.RPC_SERVER_REQUEST_COUNT;
-  public static final MeasureLong RPC_SERVER_RESPONSE_COUNT =
-      RpcMeasureConstants.RPC_SERVER_RESPONSE_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
index fbbcd44150c..9e0b4d935d3 100644
--- a/census/src/test/java/io/grpc/census/CensusModulesTest.java
+++ b/census/src/test/java/io/grpc/census/CensusModulesTest.java
@@ -18,6 +18,12 @@
 
 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;
@@ -50,6 +56,7 @@
 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;
@@ -58,7 +65,9 @@
 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;
@@ -81,6 +90,7 @@
 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;
@@ -90,10 +100,11 @@
 import io.opencensus.trace.Tracer;
 import io.opencensus.trace.propagation.BinaryFormat;
 import io.opencensus.trace.propagation.SpanContextParseException;
-import io.opencensus.trace.unsafe.ContextUtils;
+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;
@@ -117,14 +128,17 @@
  */
 @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().build();
+      ClientStreamTracer.StreamInfo.newBuilder()
+          .setCallOptions(CallOptions.DEFAULT.withOption(NAME_RESOLUTION_DELAYED, 10L)).build();
 
-  private static class StringInputStream extends InputStream {
+  private static class StringInputStream extends InputStream implements KnownLength {
     final String string;
 
     StringInputStream(String string) {
@@ -137,6 +151,11 @@ public int read() {
       // 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 =
@@ -173,10 +192,12 @@ public String parse(InputStream stream) {
   private final Random random = new Random(1234);
   private final Span fakeClientParentSpan = MockableSpan.generateRandomSpan(random);
   private final Span spyClientSpan = spy(MockableSpan.generateRandomSpan(random));
-  private final SpanContext fakeClientSpanContext = spyClientSpan.getContext();
+  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
@@ -194,6 +215,8 @@ public String parse(InputStream stream) {
   private ArgumentCaptor<Status> statusCaptor;
   @Captor
   private ArgumentCaptor<MessageEvent> messageEventCaptor;
+  @Captor
+  private ArgumentCaptor<Map<String, AttributeValue>> annotationAttributesCaptor;
 
   private CensusStatsModule censusStats;
   private CensusTracingModule censusTracing;
@@ -201,19 +224,24 @@ public String parse(InputStream stream) {
   @Before
   public void setUp() throws Exception {
     when(spyClientSpanBuilder.startSpan()).thenReturn(spyClientSpan);
-    when(tracer.spanBuilderWithExplicitParent(anyString(), ArgumentMatchers.<Span>any()))
+    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(fakeClientSpanContext);
+        .thenReturn(fakeAttemptSpanContext);
     censusStats =
         new CensusStatsModule(
             tagger, tagCtxSerializer, statsRecorder, fakeClock.getStopwatchSupplier(),
-            true, true, true, false /* real-time */);
+            true, true, true, false /* real-time */, true);
     censusTracing = new CensusTracingModule(tracer, mockTracingPropagationHandler);
   }
 
@@ -235,6 +263,7 @@ public void clientInterceptorCustomTag() {
   // 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(
@@ -272,7 +301,7 @@ public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
                   .emptyBuilder()
                   .putLocal(StatsTestUtils.EXTRA_TAG, TagValue.create("extra value"))
                   .build());
-      ctx = ContextUtils.withValue(ctx, fakeClientParentSpan);
+      ctx =  io.opencensus.trace.unsafe.ContextUtils.withValue(ctx, fakeClientParentSpan);
       Context origCtx = ctx.attach();
       try {
         call = interceptedChannel.newCall(method, CALL_OPTIONS);
@@ -283,7 +312,8 @@ public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
       assertEquals(
           io.opencensus.tags.unsafe.ContextUtils.getValue(Context.ROOT),
           io.opencensus.tags.unsafe.ContextUtils.getValue(Context.current()));
-      assertEquals(ContextUtils.getValue(Context.current()), BlankSpan.INSTANCE);
+      assertEquals(io.opencensus.trace.unsafe.ContextUtils.getValue(Context.current()),
+          BlankSpan.INSTANCE);
       call = interceptedChannel.newCall(method, CALL_OPTIONS);
     }
 
@@ -292,10 +322,14 @@ public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
     assertEquals(2, capturedCallOptions.get().getStreamTracerFactories().size());
     assertTrue(
         capturedCallOptions.get().getStreamTracerFactories().get(0)
-        instanceof CensusTracingModule.ClientCallTracer);
+        instanceof CallAttemptsTracerFactory);
     assertTrue(
         capturedCallOptions.get().getStreamTracerFactories().get(1)
-        instanceof CensusStatsModule.ClientCallTracer);
+        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();
@@ -355,6 +389,7 @@ record = statsRecorder.pollRecord();
             .setSampleToLocalSpanStore(false)
             .build());
     verify(spyClientSpan, never()).end();
+    assertPerCallMetrics(0D);
   }
 
   @Test
@@ -387,12 +422,13 @@ private void subtestClientBasicStatsDefaultContext(
     CensusStatsModule localCensusStats =
         new CensusStatsModule(
             tagger, tagCtxSerializer, statsRecorder, fakeClock.getStopwatchSupplier(),
-            true, recordStarts, recordFinishes, recordRealTime);
-    CensusStatsModule.ClientCallTracer callTracer =
-        localCensusStats.newClientCallTracer(
-            tagger.empty(), method.getFullMethodName());
+            true, recordStarts, recordFinishes, recordRealTime, true);
+    CensusStatsModule.CallAttemptsTracerFactory callAttemptsTracerFactory =
+        new CensusStatsModule.CallAttemptsTracerFactory(
+            localCensusStats, tagger.empty(), method.getFullMethodName());
     Metadata headers = new Metadata();
-    ClientStreamTracer tracer = callTracer.newClientStreamTracer(STREAM_INFO, headers);
+    ClientStreamTracer tracer =
+        callAttemptsTracerFactory.newClientStreamTracer(STREAM_INFO, headers);
 
     if (recordStarts) {
       StatsTestUtils.MetricsRecord record = statsRecorder.pollRecord();
@@ -401,8 +437,7 @@ private void subtestClientBasicStatsDefaultContext(
       assertEquals(1, record.tags.size());
       TagValue methodTag = record.tags.get(RpcMeasureConstants.GRPC_CLIENT_METHOD);
       assertEquals(method.getFullMethodName(), methodTag.asString());
-      assertEquals(
-          1, record.getMetricAsLongOrFail(DeprecatedCensusConstants.RPC_CLIENT_STARTED_COUNT));
+      assertEquals(1, record.getMetricAsLongOrFail(RpcMeasureConstants.GRPC_CLIENT_STARTED_RPCS));
     } else {
       assertNull(statsRecorder.pollRecord());
     }
@@ -455,7 +490,7 @@ private void subtestClientBasicStatsDefaultContext(
 
     tracer.inboundUncompressedSize(552);
     tracer.streamClosed(Status.OK);
-    callTracer.callEnded(Status.OK);
+    callAttemptsTracerFactory.callEnded(Status.OK);
 
     if (recordFinishes) {
       StatsTestUtils.MetricsRecord record = statsRecorder.pollRecord();
@@ -469,30 +504,218 @@ private void subtestClientBasicStatsDefaultContext(
           1, record.getMetricAsLongOrFail(DeprecatedCensusConstants.RPC_CLIENT_FINISHED_COUNT));
       assertNull(record.getMetric(DeprecatedCensusConstants.RPC_CLIENT_ERROR_COUNT));
       assertEquals(
-          2, record.getMetricAsLongOrFail(DeprecatedCensusConstants.RPC_CLIENT_REQUEST_COUNT));
+          2, record.getMetricAsLongOrFail(RpcMeasureConstants.GRPC_CLIENT_SENT_MESSAGES_PER_RPC));
       assertEquals(
           1028 + 99,
-          record.getMetricAsLongOrFail(DeprecatedCensusConstants.RPC_CLIENT_REQUEST_BYTES));
+          record.getMetricAsLongOrFail(RpcMeasureConstants.GRPC_CLIENT_SENT_BYTES_PER_RPC));
       assertEquals(
           1128 + 865,
           record.getMetricAsLongOrFail(
               DeprecatedCensusConstants.RPC_CLIENT_UNCOMPRESSED_REQUEST_BYTES));
       assertEquals(
-          2, record.getMetricAsLongOrFail(DeprecatedCensusConstants.RPC_CLIENT_RESPONSE_COUNT));
+          2,
+          record.getMetricAsLongOrFail(RpcMeasureConstants.GRPC_CLIENT_RECEIVED_MESSAGES_PER_RPC));
       assertEquals(
           33 + 154,
-          record.getMetricAsLongOrFail(DeprecatedCensusConstants.RPC_CLIENT_RESPONSE_BYTES));
+          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(DeprecatedCensusConstants.RPC_CLIENT_ROUNDTRIP_LATENCY));
+          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();
@@ -516,15 +739,28 @@ private void assertRealTimeMetric(
     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() {
-    CensusTracingModule.ClientCallTracer callTracer =
-        censusTracing.newClientCallTracer(null, method);
+    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("Sent.package1.service2.method3"), ArgumentMatchers.<Span>isNull());
+        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);
@@ -536,8 +772,14 @@ public void clientBasicTracingDefaultSpan() {
     clientStreamTracer.streamClosed(Status.OK);
     callTracer.callEnded(Status.OK);
 
-    InOrder inOrder = inOrder(spyClientSpan);
-    inOrder.verify(spyClientSpan, times(3)).addMessageEvent(messageEventCaptor.capture());
+    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(),
@@ -545,25 +787,32 @@ public void clientBasicTracingDefaultSpan() {
     assertEquals(
         MessageEvent.builder(MessageEvent.Type.SENT, 1).setUncompressedMessageSize(27).build(),
         events.get(1));
-    assertEquals(
-        MessageEvent.builder(MessageEvent.Type.RECEIVED, 0)
-            .setCompressedMessageSize(255)
-            .setUncompressedMessageSize(90)
-            .build(),
-        events.get(2));
+    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());
-    verifyNoMoreInteractions(spyClientSpan);
+    inOrder.verifyNoMoreInteractions();
     verifyNoMoreInteractions(tracer);
   }
 
   @Test
   public void clientTracingSampledToLocalSpanStore() {
-    CensusTracingModule.ClientCallTracer callTracer =
-        censusTracing.newClientCallTracer(null, sampledMethod);
+    CallAttemptsTracerFactory callTracer =
+        censusTracing.newClientCallTracer(spyClientSpan, sampledMethod);
     callTracer.callEnded(Status.OK);
 
     verify(spyClientSpan).end(
@@ -575,11 +824,15 @@ public void clientTracingSampledToLocalSpanStore() {
 
   @Test
   public void clientStreamNeverCreatedStillRecordStats() {
-    CensusStatsModule.ClientCallTracer callTracer =
-        censusStats.newClientCallTracer(tagger.empty(), method.getFullMethodName());
-
+    CensusStatsModule.CallAttemptsTracerFactory callAttemptsTracerFactory =
+        new CensusStatsModule.CallAttemptsTracerFactory(
+            censusStats, tagger.empty(), method.getFullMethodName());
+    ClientStreamTracer streamTracer =
+        callAttemptsTracerFactory.newClientStreamTracer(STREAM_INFO, new Metadata());
     fakeClock.forwardTime(3000, MILLISECONDS);
-    callTracer.callEnded(Status.DEADLINE_EXCEEDED.withDescription("3 seconds"));
+    Status status = Status.DEADLINE_EXCEEDED.withDescription("3 seconds");
+    streamTracer.streamClosed(status);
+    callAttemptsTracerFactory.callEnded(status);
 
     // Upstart record
     StatsTestUtils.MetricsRecord record = statsRecorder.pollRecord();
@@ -588,9 +841,7 @@ public void clientStreamNeverCreatedStillRecordStats() {
     assertEquals(1, record.tags.size());
     TagValue methodTag = record.tags.get(RpcMeasureConstants.GRPC_CLIENT_METHOD);
     assertEquals(method.getFullMethodName(), methodTag.asString());
-    assertEquals(
-        1,
-        record.getMetricAsLongOrFail(DeprecatedCensusConstants.RPC_CLIENT_STARTED_COUNT));
+    assertEquals(1, record.getMetricAsLongOrFail(RpcMeasureConstants.GRPC_CLIENT_STARTED_RPCS));
 
     // Completion record
     record = statsRecorder.pollRecord();
@@ -607,33 +858,31 @@ record = statsRecorder.pollRecord();
         1,
         record.getMetricAsLongOrFail(DeprecatedCensusConstants.RPC_CLIENT_ERROR_COUNT));
     assertEquals(
-        0, record.getMetricAsLongOrFail(DeprecatedCensusConstants.RPC_CLIENT_REQUEST_COUNT));
+        0, record.getMetricAsLongOrFail(RpcMeasureConstants.GRPC_CLIENT_SENT_MESSAGES_PER_RPC));
     assertEquals(
-        0, record.getMetricAsLongOrFail(DeprecatedCensusConstants.RPC_CLIENT_REQUEST_BYTES));
+        0, record.getMetricAsLongOrFail(RpcMeasureConstants.GRPC_CLIENT_SENT_BYTES_PER_RPC));
     assertEquals(
         0,
         record.getMetricAsLongOrFail(
             DeprecatedCensusConstants.RPC_CLIENT_UNCOMPRESSED_REQUEST_BYTES));
     assertEquals(
-        0, record.getMetricAsLongOrFail(DeprecatedCensusConstants.RPC_CLIENT_RESPONSE_COUNT));
+        0, record.getMetricAsLongOrFail(RpcMeasureConstants.GRPC_CLIENT_RECEIVED_MESSAGES_PER_RPC));
     assertEquals(
-        0, record.getMetricAsLongOrFail(DeprecatedCensusConstants.RPC_CLIENT_RESPONSE_BYTES));
+        0, record.getMetricAsLongOrFail(RpcMeasureConstants.GRPC_CLIENT_RECEIVED_BYTES_PER_RPC));
     assertEquals(0,
         record.getMetricAsLongOrFail(
             DeprecatedCensusConstants.RPC_CLIENT_UNCOMPRESSED_RESPONSE_BYTES));
     assertEquals(
         3000,
-        record.getMetricAsLongOrFail(DeprecatedCensusConstants.RPC_CLIENT_ROUNDTRIP_LATENCY));
-    assertNull(record.getMetric(DeprecatedCensusConstants.RPC_CLIENT_SERVER_ELAPSED_TIME));
+        record.getMetricAsLongOrFail(RpcMeasureConstants.GRPC_CLIENT_ROUNDTRIP_LATENCY));
+    assertNull(record.getMetric(RpcMeasureConstants.GRPC_CLIENT_SERVER_LATENCY));
+    assertPerCallMetrics(3000D);
   }
 
   @Test
   public void clientStreamNeverCreatedStillRecordTracing() {
-    CensusTracingModule.ClientCallTracer callTracer =
-        censusTracing.newClientCallTracer(fakeClientParentSpan, method);
-    verify(tracer).spanBuilderWithExplicitParent(
-        eq("Sent.package1.service2.method3"), same(fakeClientParentSpan));
-    verify(spyClientSpanBuilder).setRecordEvents(eq(true));
+    CallAttemptsTracerFactory callTracer =
+        censusTracing.newClientCallTracer(spyClientSpan, method);
 
     callTracer.callEnded(Status.DEADLINE_EXCEEDED.withDescription("3 seconds"));
     verify(spyClientSpan).end(
@@ -678,12 +927,15 @@ private void subtestStatsHeadersPropagateTags(boolean propagate, boolean recordS
             tagCtxSerializer,
             statsRecorder,
             fakeClock.getStopwatchSupplier(),
-            propagate, recordStats, recordStats, recordStats);
+            propagate, recordStats, recordStats, recordStats, recordStats);
     Metadata headers = new Metadata();
-    CensusStatsModule.ClientCallTracer callTracer =
-        census.newClientCallTracer(clientCtx, method.getFullMethodName());
+    CensusStatsModule.CallAttemptsTracerFactory callAttemptsTracerFactory =
+        new CensusStatsModule.CallAttemptsTracerFactory(
+            census, clientCtx, method.getFullMethodName());
     // This propagates clientCtx to headers if propagates==true
-    callTracer.newClientStreamTracer(STREAM_INFO, headers);
+    ClientStreamTracer streamTracer =
+        callAttemptsTracerFactory.newClientStreamTracer(STREAM_INFO, headers);
+    streamTracer.streamCreated(Attributes.EMPTY, headers);
     if (recordStats) {
       // Client upstart record
       StatsTestUtils.MetricsRecord clientRecord = statsRecorder.pollRecord();
@@ -746,7 +998,8 @@ private void subtestStatsHeadersPropagateTags(boolean propagate, boolean recordS
 
     // Verifies that the client tracer factory uses clientCtx, which includes the custom tags, to
     // record stats.
-    callTracer.callEnded(Status.OK);
+    streamTracer.streamClosed(Status.OK);
+    callAttemptsTracerFactory.callEnded(Status.OK);
 
     if (recordStats) {
       // Client completion record
@@ -760,6 +1013,7 @@ private void subtestStatsHeadersPropagateTags(boolean propagate, boolean recordS
       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) {
@@ -769,10 +1023,12 @@ private void subtestStatsHeadersPropagateTags(boolean propagate, boolean recordS
 
   @Test
   public void statsHeadersNotPropagateDefaultContext() {
-    CensusStatsModule.ClientCallTracer callTracer =
-        censusStats.newClientCallTracer(tagger.empty(), method.getFullMethodName());
+    CensusStatsModule.CallAttemptsTracerFactory callAttemptsTracerFactory =
+        new CensusStatsModule.CallAttemptsTracerFactory(
+            censusStats, tagger.empty(), method.getFullMethodName());
     Metadata headers = new Metadata();
-    callTracer.newClientStreamTracer(STREAM_INFO, headers);
+    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();
@@ -798,18 +1054,19 @@ public void statsHeaderMalformed() {
     assertSame(tagger.empty(), headers.get(censusStats.statsHeader));
   }
 
+  @SuppressWarnings("deprecation")
   @Test
   public void traceHeadersPropagateSpanContext() throws Exception {
-    CensusTracingModule.ClientCallTracer callTracer =
-        censusTracing.newClientCallTracer(fakeClientParentSpan, method);
+    CallAttemptsTracerFactory callTracer =
+        censusTracing.newClientCallTracer(spyClientSpan, method);
     Metadata headers = new Metadata();
-    callTracer.newClientStreamTracer(STREAM_INFO, headers);
+    ClientStreamTracer streamTracer = callTracer.newClientStreamTracer(STREAM_INFO, headers);
+    streamTracer.streamCreated(Attributes.EMPTY, headers);
 
-    verify(mockTracingPropagationHandler).toByteArray(same(fakeClientSpanContext));
+    verify(mockTracingPropagationHandler).toByteArray(same(fakeAttemptSpanContext));
     verifyNoMoreInteractions(mockTracingPropagationHandler);
     verify(tracer).spanBuilderWithExplicitParent(
-        eq("Sent.package1.service2.method3"), same(fakeClientParentSpan));
-    verify(spyClientSpanBuilder).setRecordEvents(eq(true));
+        eq("Attempt.package1.service2.method3"), same(spyClientSpan));
     verifyNoMoreInteractions(tracer);
     assertTrue(headers.containsKey(censusTracing.tracingHeader));
 
@@ -818,20 +1075,21 @@ public void traceHeadersPropagateSpanContext() throws Exception {
             method.getFullMethodName(), headers);
     verify(mockTracingPropagationHandler).fromByteArray(same(binarySpanContext));
     verify(tracer).spanBuilderWithRemoteParent(
-        eq("Recv.package1.service2.method3"), same(spyClientSpan.getContext()));
+        eq("Recv.package1.service2.method3"), same(spyAttemptSpan.getContext()));
     verify(spyServerSpanBuilder).setRecordEvents(eq(true));
 
     Context filteredContext = serverTracer.filterContext(Context.ROOT);
-    assertSame(spyServerSpan, ContextUtils.getValue(filteredContext));
+    assertSame(spyServerSpan, io.opencensus.trace.unsafe.ContextUtils.getValue(filteredContext));
   }
 
   @Test
   public void traceHeaders_propagateSpanContext() throws Exception {
-    CensusTracingModule.ClientCallTracer callTracer =
+    CallAttemptsTracerFactory callTracer =
         censusTracing.newClientCallTracer(fakeClientParentSpan, method);
     Metadata headers = new Metadata();
 
-    callTracer.newClientStreamTracer(STREAM_INFO, headers);
+    ClientStreamTracer streamTracer = callTracer.newClientStreamTracer(STREAM_INFO, headers);
+    streamTracer.streamCreated(Attributes.EMPTY, headers);
 
     assertThat(headers.keys()).isNotEmpty();
   }
@@ -840,12 +1098,14 @@ public void traceHeaders_propagateSpanContext() throws Exception {
   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();
 
-    CensusTracingModule.ClientCallTracer callTracer =
+    CallAttemptsTracerFactory callTracer =
         censusTracing.newClientCallTracer(BlankSpan.INSTANCE, method);
-    callTracer.newClientStreamTracer(STREAM_INFO, headers);
+    callTracer.newClientStreamTracer(STREAM_INFO, headers).streamCreated(Attributes.EMPTY, headers);
 
     assertThat(headers.keys()).isEmpty();
   }
@@ -853,16 +1113,18 @@ public void traceHeaders_missingCensusImpl_notPropagateSpanContext()
   @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());
 
-    CensusTracingModule.ClientCallTracer callTracer =
+    CallAttemptsTracerFactory callTracer =
         censusTracing.newClientCallTracer(BlankSpan.INSTANCE, method);
-    callTracer.newClientStreamTracer(STREAM_INFO, headers);
+    callTracer.newClientStreamTracer(STREAM_INFO, headers).streamCreated(Attributes.EMPTY, headers);
 
     assertThat(headers.keys()).containsExactlyElementsIn(originalHeaderKeys);
   }
@@ -871,9 +1133,9 @@ public void traceHeaders_clientMissingCensusImpl_preservingHeaders() throws Exce
   public void traceHeaderMalformed() throws Exception {
     // As comparison, normal header parsing
     Metadata headers = new Metadata();
-    headers.put(censusTracing.tracingHeader, fakeClientSpanContext);
+    headers.put(censusTracing.tracingHeader, fakeAttemptSpanContext);
     // mockTracingPropagationHandler was stubbed to always return fakeServerParentSpanContext
-    assertSame(spyClientSpan.getContext(), headers.get(censusTracing.tracingHeader));
+    assertSame(spyAttemptSpan.getContext(), headers.get(censusTracing.tracingHeader));
 
     // Make BinaryPropagationHandler always throw when parsing the header
     when(mockTracingPropagationHandler.fromByteArray(any(byte[].class)))
@@ -881,7 +1143,7 @@ public void traceHeaderMalformed() throws Exception {
 
     headers = new Metadata();
     assertNull(headers.get(censusTracing.tracingHeader));
-    headers.put(censusTracing.tracingHeader, fakeClientSpanContext);
+    headers.put(censusTracing.tracingHeader, fakeAttemptSpanContext);
     assertSame(SpanContext.INVALID, headers.get(censusTracing.tracingHeader));
     assertNotSame(spyClientSpan.getContext(), SpanContext.INVALID);
 
@@ -923,7 +1185,7 @@ private void subtestServerBasicStatsNoHeaders(
     CensusStatsModule localCensusStats =
         new CensusStatsModule(
             tagger, tagCtxSerializer, statsRecorder, fakeClock.getStopwatchSupplier(),
-            true, recordStarts, recordFinishes, recordRealTime);
+            true, recordStarts, recordFinishes, recordRealTime, true);
     ServerStreamTracer.Factory tracerFactory = localCensusStats.getServerTracerFactory();
     ServerStreamTracer tracer =
         tracerFactory.newServerStreamTracer(method.getFullMethodName(), new Metadata());
@@ -935,9 +1197,7 @@ private void subtestServerBasicStatsNoHeaders(
       assertEquals(1, record.tags.size());
       TagValue methodTag = record.tags.get(RpcMeasureConstants.GRPC_SERVER_METHOD);
       assertEquals(method.getFullMethodName(), methodTag.asString());
-      assertEquals(
-          1,
-          record.getMetricAsLongOrFail(DeprecatedCensusConstants.RPC_SERVER_STARTED_COUNT));
+      assertEquals(1, record.getMetricAsLongOrFail(RpcMeasureConstants.GRPC_SERVER_STARTED_RPCS));
     } else {
       assertNull(statsRecorder.pollRecord());
     }
@@ -1011,29 +1271,31 @@ private void subtestServerBasicStatsNoHeaders(
       assertEquals(
           1, record.getMetricAsLongOrFail(DeprecatedCensusConstants.RPC_SERVER_ERROR_COUNT));
       assertEquals(
-          2, record.getMetricAsLongOrFail(DeprecatedCensusConstants.RPC_SERVER_RESPONSE_COUNT));
+          2, record.getMetricAsLongOrFail(RpcMeasureConstants.GRPC_SERVER_SENT_MESSAGES_PER_RPC));
       assertEquals(
           1028 + 99,
-          record.getMetricAsLongOrFail(DeprecatedCensusConstants.RPC_SERVER_RESPONSE_BYTES));
+          record.getMetricAsLongOrFail(RpcMeasureConstants.GRPC_SERVER_SENT_BYTES_PER_RPC));
       assertEquals(
           1128 + 865,
           record.getMetricAsLongOrFail(
               DeprecatedCensusConstants.RPC_SERVER_UNCOMPRESSED_RESPONSE_BYTES));
       assertEquals(
-          2, record.getMetricAsLongOrFail(DeprecatedCensusConstants.RPC_SERVER_REQUEST_COUNT));
+          2,
+          record.getMetricAsLongOrFail(RpcMeasureConstants.GRPC_SERVER_RECEIVED_MESSAGES_PER_RPC));
       assertEquals(
           34 + 154,
-          record.getMetricAsLongOrFail(DeprecatedCensusConstants.RPC_SERVER_REQUEST_BYTES));
+          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(DeprecatedCensusConstants.RPC_SERVER_SERVER_LATENCY));
+          record.getMetricAsLongOrFail(RpcMeasureConstants.GRPC_SERVER_SERVER_LATENCY));
     } else {
       assertNull(statsRecorder.pollRecord());
     }
   }
 
+  @SuppressWarnings("deprecation")
   @Test
   public void serverBasicTracingNoHeaders() {
     ServerStreamTracer.Factory tracerFactory = censusTracing.getServerTracerFactory();
@@ -1045,7 +1307,7 @@ public void serverBasicTracingNoHeaders() {
     verify(spyServerSpanBuilder).setRecordEvents(eq(true));
 
     Context filteredContext = serverStreamTracer.filterContext(Context.ROOT);
-    assertSame(spyServerSpan, ContextUtils.getValue(filteredContext));
+    assertSame(spyServerSpan, io.opencensus.trace.unsafe.ContextUtils.getValue(filteredContext));
 
     serverStreamTracer.serverCallStarted(
         new CallInfo<>(method, Attributes.EMPTY, null));
@@ -1062,7 +1324,7 @@ public void serverBasicTracingNoHeaders() {
     serverStreamTracer.streamClosed(Status.CANCELLED);
 
     InOrder inOrder = inOrder(spyServerSpan);
-    inOrder.verify(spyServerSpan, times(3)).addMessageEvent(messageEventCaptor.capture());
+    inOrder.verify(spyServerSpan, times(2)).addMessageEvent(messageEventCaptor.capture());
     List<MessageEvent> events = messageEventCaptor.getAllValues();
     assertEquals(
         MessageEvent.builder(MessageEvent.Type.SENT, 0).setCompressedMessageSize(882).build(),
@@ -1070,12 +1332,16 @@ public void serverBasicTracingNoHeaders() {
     assertEquals(
         MessageEvent.builder(MessageEvent.Type.SENT, 1).setUncompressedMessageSize(27).build(),
         events.get(1));
-    assertEquals(
-        MessageEvent.builder(MessageEvent.Type.RECEIVED, 0)
-            .setCompressedMessageSize(255)
-            .setUncompressedMessageSize(90)
-            .build(),
-        events.get(2));
+
+    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)
@@ -1151,24 +1417,24 @@ public void generateTraceSpanName() {
 
   private static void assertNoServerContent(StatsTestUtils.MetricsRecord record) {
     assertNull(record.getMetric(DeprecatedCensusConstants.RPC_SERVER_ERROR_COUNT));
-    assertNull(record.getMetric(DeprecatedCensusConstants.RPC_SERVER_REQUEST_COUNT));
-    assertNull(record.getMetric(DeprecatedCensusConstants.RPC_SERVER_RESPONSE_COUNT));
-    assertNull(record.getMetric(DeprecatedCensusConstants.RPC_SERVER_REQUEST_BYTES));
-    assertNull(record.getMetric(DeprecatedCensusConstants.RPC_SERVER_RESPONSE_BYTES));
+    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(DeprecatedCensusConstants.RPC_SERVER_SERVER_LATENCY));
+    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(DeprecatedCensusConstants.RPC_CLIENT_REQUEST_COUNT));
-    assertNull(record.getMetric(DeprecatedCensusConstants.RPC_CLIENT_RESPONSE_COUNT));
-    assertNull(record.getMetric(DeprecatedCensusConstants.RPC_CLIENT_REQUEST_BYTES));
-    assertNull(record.getMetric(DeprecatedCensusConstants.RPC_CLIENT_RESPONSE_BYTES));
-    assertNull(record.getMetric(DeprecatedCensusConstants.RPC_CLIENT_ROUNDTRIP_LATENCY));
-    assertNull(record.getMetric(DeprecatedCensusConstants.RPC_CLIENT_SERVER_ELAPSED_TIME));
+    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));
   }
@@ -1184,15 +1450,20 @@ public void newTagsPopulateOldViews() throws InterruptedException {
 
     CensusStatsModule localCensusStats = new CensusStatsModule(
         tagger, tagCtxSerializer, localStats.getStatsRecorder(), fakeClock.getStopwatchSupplier(),
-        false, false, true, false /* real-time */);
+        false, false, true, false /* real-time */, true);
 
-    CensusStatsModule.ClientCallTracer callTracer =
-        localCensusStats.newClientCallTracer(
-            tagger.empty(), method.getFullMethodName());
+    CensusStatsModule.CallAttemptsTracerFactory callAttemptsTracerFactory =
+        new CensusStatsModule.CallAttemptsTracerFactory(
+            localCensusStats, tagger.empty(), method.getFullMethodName());
 
-    callTracer.newClientStreamTracer(STREAM_INFO, new Metadata());
+    Metadata headers = new Metadata();
+    ClientStreamTracer tracer =
+        callAttemptsTracerFactory.newClientStreamTracer(STREAM_INFO, headers);
+    tracer.streamCreated(Attributes.EMPTY, headers);
     fakeClock.forwardTime(30, MILLISECONDS);
-    callTracer.callEnded(Status.PERMISSION_DENIED.withDescription("No you don't"));
+    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);
@@ -1261,7 +1532,82 @@ public Long apply(AggregationData arg) {
         });
   }
 
-  private static class CallInfo<ReqT, RespT> extends ServerCallInfo<ReqT, RespT> {
+  @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;
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/compiler/BUILD.bazel b/compiler/BUILD.bazel
index f88075c0e09..a9ffe77a55a 100644
--- a/compiler/BUILD.bazel
+++ b/compiler/BUILD.bazel
@@ -1,4 +1,6 @@
 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
@@ -11,19 +13,20 @@ cc_binary(
     ],
     visibility = ["//visibility:public"],
     deps = [
+        "@abseil-cpp//absl/strings",
         "@com_google_protobuf//:protoc_lib",
     ],
 )
 
 java_library(
     name = "java_grpc_library_deps__do_not_reference",
+    visibility = ["//xds:__pkg__"],
     exports = [
         "//api",
         "//protobuf",
         "//stub",
-        "//stub:javax_annotation",
-        "@com_google_code_findbugs_jsr305//jar",
-        "@com_google_guava_guava//jar",
+        artifact("com.google.code.findbugs:jsr305"),
+        artifact("com.google.guava:guava"),
         "@com_google_protobuf//:protobuf_java",
     ],
 )
@@ -34,9 +37,8 @@ java_library(
         "//api",
         "//protobuf-lite",
         "//stub",
-        "//stub:javax_annotation",
-        "@com_google_code_findbugs_jsr305//jar",
-        "@com_google_guava_guava//jar",
+        artifact("com.google.code.findbugs:jsr305"),
+        artifact("com.google.guava:guava"),
     ],
 )
 
diff --git a/compiler/README.md b/compiler/README.md
index 81dbff4adbc..25e557d82eb 100644
--- a/compiler/README.md
+++ b/compiler/README.md
@@ -14,14 +14,11 @@ 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.
 
-## System requirement
+## Compiling and testing the codegen
 
-* Linux, Mac OS X with Clang, or Windows with MSYS2
-* Java 7 or up
-* [Protobuf](https://github.com/google/protobuf) 3.12.0 or up
+Set up your system as described in [COMPILING.md](../COMPILING.md).
 
-## Compiling and testing the codegen
-Change to the `compiler` directory:
+Then change to the `compiler` directory:
 ```
 $ cd $GRPC_JAVA_ROOT/compiler
 ```
diff --git a/compiler/build.gradle b/compiler/build.gradle
index 60d3a436f6c..f970f629e19 100644
--- a/compiler/build.gradle
+++ b/compiler/build.gradle
@@ -50,14 +50,22 @@ model {
             }
         }
         gcc(Gcc) {
-            target("ppcle_64")
+            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")
+            target("s390_64") {
+                cppCompiler.executable = 's390x-linux-gnu-g++'
+                linker.executable = 's390x-linux-gnu-g++'
+            }
+            target("loongarch_64")
         }
         clang(Clang) {
+            target("aarch_64") {}
         }
     }
 
@@ -67,6 +75,8 @@ model {
         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" }
     }
 
     components {
@@ -75,8 +85,10 @@ model {
                 'x86_32',
                 'x86_64',
                 'ppcle_64',
+                'riscv_64',
                 'aarch_64',
-                's390_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.
@@ -90,70 +102,78 @@ model {
         all {
             if (toolChain in Gcc || toolChain in Clang) {
                 cppCompiler.define("GRPC_VERSION", version)
-                cppCompiler.args "--std=c++0x"
+                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",
-                            "-static-libstdc++",
                             "-Wl,-Bdynamic", "-lpthread", "-s"
                 }
                 addEnvArgs("LDFLAGS", linker.args)
             } else if (toolChain in VisualCpp) {
                 usingVisualCpp = true
                 cppCompiler.define("GRPC_VERSION", version)
-                cppCompiler.args "/EHsc", "/MT"
+                cppCompiler.args "/EHsc", "/MT", "/std:c++17"
                 if (rootProject.hasProperty('vcProtobufInclude')) {
                     cppCompiler.args "/I${rootProject.vcProtobufInclude}"
-                }
-                linker.args "libprotobuf.lib", "libprotoc.lib"
+                } 
+                linker.args.add("libprotoc.lib")
+                linker.args.add("libprotobuf.lib")
                 if (rootProject.hasProperty('vcProtobufLibs')) {
-                    linker.args "/LIBPATH:${rootProject.vcProtobufLibs}"
+                    String libsList = rootProject.property('vcProtobufLibs') as String
+                    libsList.split(',').each() { lib -> linker.args.add(lib) }
                 }
             }
         }
     }
 }
 
-configurations {
-    testLiteImplementation
+sourceSets {
+    testLite {
+        proto { setSrcDirs(['src/test/proto']) }
+    }
 }
 
 dependencies {
     testImplementation project(':grpc-protobuf'),
-            project(':grpc-stub'),
-            libraries.javax_annotation
+            project(':grpc-stub')
     testLiteImplementation project(':grpc-protobuf-lite'),
-            project(':grpc-stub'),
-            libraries.javax_annotation
-}
-
-sourceSets {
-    testLite {
-        proto { setSrcDirs(['src/test/proto']) }
-    }
+            project(':grpc-stub')
 }
 
-compileTestJava {
-    options.errorprone.excludedPaths = ".*/build/generated/source/proto/.*"
+tasks.named("compileTestJava").configure {
+    options.errorprone.excludedPaths = ".*/build/generated/sources/proto/.*"
 }
 
-compileTestLiteJava {
+tasks.named("compileTestLiteJava").configure {
     options.compilerArgs = compileTestJava.options.compilerArgs
     options.compilerArgs += [
         "-Xlint:-cast"
     ]
-    options.errorprone.excludedPaths = ".*/build/generated/source/proto/.*"
+    options.errorprone.excludedPaths = ".*/build/generated/sources/proto/.*"
+}
+
+tasks.named("checkstyleTestLite").configure {
+    enabled = false
 }
 
 protobuf {
@@ -161,33 +181,41 @@ protobuf {
         if (project.hasProperty('protoc')) {
             path = project.protoc
         } else {
-            artifact = "com.google.protobuf:protoc:${protocVersion}"
+            artifact = libs.protobuf.protoc.get()
         }
     }
     plugins {
         grpc { path = javaPluginPath }
     }
     generateProtoTasks {
-        all().each { task ->
-            task.dependsOn 'java_pluginExecutable'
-            task.inputs.file javaPluginPath
+        all().configureEach {
+            dependsOn 'java_pluginExecutable'
+            inputs.file javaPluginPath
         }
-        ofSourceSet('test')*.plugins { grpc {} }
-        ofSourceSet('testLite')*.each { task ->
-            task.builtins {
+        ofSourceSet('test').configureEach {
+            plugins {
+                grpc {
+                    option '@generated=javax'
+                }
+            }
+        }
+        ofSourceSet('testLite').configureEach {
+            builtins {
                 java { option 'lite' }
             }
-            task.plugins {
-                grpc { option 'lite' }
+            plugins {
+                grpc {
+                    option 'lite'
+                }
             }
         }
     }
 }
 
-println "*** Building codegen requires Protobuf version ${protocVersion}"
+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) {
+tasks.register("buildArtifacts", Copy) {
     dependsOn 'java_pluginExecutable'
     from("$buildDir/exe") {
         if (osdetector.os != 'windows') {
@@ -197,9 +225,11 @@ task buildArtifacts(type: Copy) {
     into artifactStagingPath
 }
 
-archivesBaseName = "$protocPluginBaseName"
+base {
+    archivesName = "$protocPluginBaseName"
+}
 
-task checkArtifacts {
+def checkArtifacts = tasks.register("checkArtifacts") {
     dependsOn buildArtifacts
     doLast {
         if (!usingVisualCpp) {
@@ -221,9 +251,10 @@ task checkArtifacts {
             if (ret.exitValue != 0) {
                 throw new GradleException("dumpbin exited with " + ret.exitValue)
             }
-            def dlls = os.toString() =~ /Image has the following dependencies:\s+(.*)\s+Summary/
-            if (dlls[0][1] != "KERNEL32.dll") {
-                throw new Exception("unexpected dll deps: " + dlls[0][1]);
+            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 {
@@ -267,26 +298,38 @@ publishing {
     }
 }
 
-def configureTestTask(Task task, String dep, String extraPackage, String serviceName) {
-    test.dependsOn task
+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"
     }
-    // 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/compiler${extraPackage}${slash}${serviceName}Grpc.java",
-            "$projectDir/src/test${dep}/golden/${serviceName}.java.txt"
+    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))
 }
 
-task testGolden(type: Exec)
-task testLiteGolden(type: Exec)
-task testDeprecatedGolden(type: Exec)
-task testDeprecatedLiteGolden(type: Exec)
-configureTestTask(testGolden, '', '', 'TestService')
-configureTestTask(testLiteGolden, 'Lite', '', 'TestService')
-configureTestTask(testDeprecatedGolden, '', '', 'TestDeprecatedService')
-configureTestTask(testDeprecatedLiteGolden, 'Lite', '', 'TestDeprecatedService')
+def testGolden = tasks.register("testGolden", Exec) {
+    configureTestTask(it, '', 'TestService')
+}
+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
+}
diff --git a/compiler/check-artifact.sh b/compiler/check-artifact.sh
index 13ae89c744a..83b41f50282 100755
--- a/compiler/check-artifact.sh
+++ b/compiler/check-artifact.sh
@@ -61,6 +61,17 @@ checkArch ()
         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
@@ -75,15 +86,17 @@ checkArch ()
       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
@@ -100,14 +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
-      dump_cmd='aarch64-linux-gnu-objdump -x '"$1"' |grep "NEEDED"'
-      white_list="linux-vdso\.so\.1\|libpthread\.so\.0\|libm\.so\.6\|libc\.so\.6\|ld-linux-aarch64\.so\.1"
+      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 e38563448e0..d0f8cdd13d5 100644
--- a/compiler/src/java_plugin/cpp/java_generator.cpp
+++ b/compiler/src/java_plugin/cpp/java_generator.cpp
@@ -14,6 +14,30 @@
  * 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>
@@ -22,11 +46,19 @@
 #include <map>
 #include <set>
 #include <vector>
-#include <google/protobuf/compiler/java/java_names.h>
+#include "absl/strings/escaping.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
@@ -112,11 +144,24 @@ static std::set<std::string> java_keywords = {
   "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
-//  Finally, if the result is a reserved java keyword, append an underscore.
-static std::string MixedLower(const std::string& word) {
+//  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;
@@ -128,7 +173,9 @@ static std::string MixedLower(const std::string& word) {
       after_underscore = false;
     }
   }
-  if (java_keywords.find(w) != java_keywords.end()) {
+  if (java_keywords.find(w) != java_keywords.end() ||
+      (mangle_object_methods &&
+       java_object_methods.find(w) != java_object_methods.end())) {
     return w + "_";
   }
   return w;
@@ -138,7 +185,7 @@ static std::string MixedLower(const std::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 std::string ToAllUpperCase(const std::string& word) {
+static std::string ToAllUpperCase(std::string word) {
   std::string w;
   for (size_t i = 0; i < word.length(); ++i) {
     w += toupper(word[i]);
@@ -149,24 +196,25 @@ static std::string ToAllUpperCase(const std::string& word) {
   return w;
 }
 
-static inline std::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 std::string MethodPropertiesFieldName(const MethodDescriptor* method) {
-  return "METHOD_" + ToAllUpperCase(method->name());
+  return "METHOD_" + ToAllUpperCase(std::string(method->name()));
 }
 
 static inline std::string MethodPropertiesGetterName(const MethodDescriptor* method) {
-  return MixedLower("get_" + method->name() + "_method");
+  return MixedLower("get_" + std::string(method->name()) + "_method");
 }
 
 static inline std::string MethodIdFieldName(const MethodDescriptor* method) {
-  return "METHODID_" + ToAllUpperCase(method->name());
+  return "METHODID_" + ToAllUpperCase(std::string(method->name()));
 }
 
 static inline std::string MessageFullJavaName(const Descriptor* desc) {
-  return protobuf::compiler::java::ClassName(desc);
+  return protobuf::compiler::java::QualifiedClassName(desc);
 }
 
 // TODO(nmittler): Remove once protobuf includes javadoc methods in distribution.
@@ -315,6 +363,26 @@ static std::vector<std::string> GrpcGetDocLinesForDescriptor(const DescriptorTyp
   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<std::string>& lines,
@@ -349,12 +417,33 @@ static void GrpcWriteDocComment(Printer* printer, const std::string& comments) {
   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::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");
@@ -448,7 +537,8 @@ static void PrintMethodFields(
         "            .setResponseMarshaller($ProtoUtils$.marshaller(\n"
         "                $output_type$.getDefaultInstance()))\n");
 
-    (*vars)["proto_method_descriptor_supplier"] = service->name() + "MethodDescriptorSupplier";
+    (*vars)["proto_method_descriptor_supplier"]
+        = std::string(service->name()) + "MethodDescriptorSupplier";
     if (flavor == ProtoFlavor::NORMAL) {
       p->Print(
           *vars,
@@ -468,24 +558,7 @@ static void PrintMethodFields(
   }
 }
 
-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,
+static void PrintBindServiceMethod(const ServiceDescriptor* service,
                                    std::map<std::string, std::string>* vars,
                                    Printer* p);
 
@@ -505,6 +578,9 @@ static void PrintStubFactory(
     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;
   }
@@ -525,80 +601,70 @@ static void PrintStub(
     const ServiceDescriptor* service,
     std::map<std::string, std::string>* vars,
     Printer* p, StubType type) {
-  const std::string service_name = service->name();
+  std::string service_name = std::string(service->name());
   (*vars)["service_name"] = service_name;
-  (*vars)["abstract_name"] = service_name + "ImplBase";
   std::string stub_name = service_name;
-  std::string client_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;
     case BLOCKING_CLIENT_IMPL:
       call_type = BLOCKING_CALL;
       stub_name += "BlockingStub";
-      client_name += "BlockingClient";
       stub_base_class_name = "AbstractBlockingStub";
       break;
-    case FUTURE_CLIENT_INTERFACE:
-      interface = true;
-      FALLTHROUGH;
+    case BLOCKING_V2_CLIENT_IMPL:
+      call_type = BLOCKING_V2_CALL;
+      stub_name += "BlockingV2Stub";
+      stub_base_class_name = "AbstractBlockingStub";
+      break;
     case FUTURE_CLIENT_IMPL:
       call_type = FUTURE_CALL;
       stub_name += "FutureStub";
-      client_name += "FutureClient";
       stub_base_class_name = "AbstractFutureStub";
       break;
-    case ASYNC_INTERFACE:
-      call_type = ASYNC_CALL;
-      interface = true;
-      stub_name += "Stub";
-      stub_base_class_name = "AbstractAsyncStub";
-      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 (interface) {
     p->Print(
         *vars,
-        "public static abstract class $abstract_name$"
-        " implements $BindableService$ {\n");
+        "public interface $stub_name$ {\n");
   } else {
     p->Print(
         *vars,
-        "public static final class $stub_name$"
-        " extends $stub_base_class_name$<$stub_name$> {\n");
+        "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) {
+  if (!interface) {
     p->Print(
         *vars,
         "private $stub_name$(\n"
@@ -627,10 +693,12 @@ static void PrintStub(
     const MethodDescriptor* method = service->method(i);
     (*vars)["input_type"] = MessageFullJavaName(method->input_type());
     (*vars)["output_type"] = MessageFullJavaName(method->output_type());
-    (*vars)["lower_method_name"] = LowerMethodName(method);
-    (*vars)["method_method_name"] = MethodPropertiesGetterName(method);
     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
@@ -644,21 +712,32 @@ static void PrintStub(
 
     // Method signature
     p->Print("\n");
-    // TODO(nmittler): Replace with WriteMethodDocComment once included by the protobuf distro.
-    if (!interface) {
-      GrpcWriteMethodDocComment(p, method);
-    }
+    GrpcWriteMethodDocComment(p, method);
 
     if (method->options().deprecated()) {
       p->Print(*vars, "@$Deprecated$\n");
     }
 
-    p->Print("public ");
+    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) {
+      p->Print("public ");
+    } else {
+      p->Print("default ");
+    }
     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,
@@ -671,6 +750,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
@@ -698,49 +797,65 @@ 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 io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall("
-                "$method_method_name$(), responseObserver);\n");
-          } else {
-            p->Print(
-                *vars,
-                "io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall("
-                "$method_method_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"] = "io.grpc.stub.ClientCalls.blockingServerStreamingCall";
-            (*vars)["params"] = "request";
-          } else {
-            (*vars)["calls_method"] = "io.grpc.stub.ClientCalls.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_method_name$(), getCallOptions(), $params$);\n");
           break;
         case ASYNC_CALL:
           if (server_streaming) {
@@ -777,26 +892,40 @@ static void PrintStub(
               "return $calls_method$(\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);
-    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)
 {
@@ -824,7 +953,6 @@ static void PrintMethodHandlerClass(const ServiceDescriptor* service,
         "private static final int $method_id_name$ = $method_id$;\n");
   }
   p->Print("\n");
-  (*vars)["service_name"] = service->name() + "ImplBase";
   p->Print(
       *vars,
       "private static final class MethodHandlers<Req, Resp> implements\n"
@@ -832,10 +960,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");
@@ -915,14 +1043,15 @@ static void PrintGetServiceDescriptorMethod(const ServiceDescriptor* service,
                                    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_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());
+    (*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::QualifiedClassName(service->file());
     p->Print(
         *vars,
         "private static abstract class $proto_base_descriptor_supplier$\n"
@@ -948,9 +1077,9 @@ static void PrintGetServiceDescriptorMethod(const ServiceDescriptor* service,
         "private static final class $proto_method_descriptor_supplier$\n"
         "    extends $proto_base_descriptor_supplier$\n"
         "    implements $ProtoMethodDescriptorSupplier$ {\n"
-        "  private final String methodName;\n"
+        "  private final $String$ methodName;\n"
         "\n"
-        "  $proto_method_descriptor_supplier$(String methodName) {\n"
+        "  $proto_method_descriptor_supplier$($String$ methodName) {\n"
         "    this.methodName = methodName;\n"
         "  }\n"
         "\n"
@@ -1012,10 +1141,14 @@ static void PrintGetServiceDescriptorMethod(const ServiceDescriptor* service,
   p->Print("}\n");
 }
 
-static void PrintBindServiceMethodBody(const ServiceDescriptor* service,
+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 "
@@ -1056,7 +1189,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();
   }
@@ -1064,15 +1197,17 @@ static void PrintBindServiceMethodBody(const ServiceDescriptor* service,
   p->Outdent();
   p->Outdent();
   p->Outdent();
+  p->Print("}\n\n");
 }
 
 static void PrintService(const ServiceDescriptor* service,
                          std::map<std::string, std::string>* vars,
                          Printer* p,
                          ProtoFlavor flavor,
-                         bool disable_version) {
+                         bool disable_version,
+                         GeneratedAnnotation generated_annotation) {
   (*vars)["service_name"] = service->name();
-  (*vars)["file_name"] = service->file()->name();
+  (*vars)["file_name"] = absl::Utf8SafeCEscape(service->file()->name());
   (*vars)["service_class_name"] = ServiceClassName(service);
   (*vars)["grpc_version"] = "";
   #ifdef GRPC_VERSION
@@ -1081,12 +1216,20 @@ static void PrintService(const ServiceDescriptor* service,
   }
   #endif
   // TODO(nmittler): Replace with WriteServiceDocComment once included by protobuf distro.
-  GrpcWriteServiceDocComment(p, service);
-  p->Print(
-      *vars,
-      "@$Generated$(\n"
-      "    value = \"by gRPC proto compiler$grpc_version$\",\n"
-      "    comments = \"Source: $file_name$\")\n");
+  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");
@@ -1102,7 +1245,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);
@@ -1118,6 +1261,21 @@ static void PrintService(const ServiceDescriptor* service,
   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 $service_name$BlockingV2Stub.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 unary and streaming "
                          "output calls on the service");
@@ -1148,12 +1306,15 @@ static void PrintService(const ServiceDescriptor* service,
   p->Outdent();
   p->Print("}\n\n");
 
-  PrintStub(service, vars, p, ABSTRACT_CLASS);
+  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);
 
   PrintMethodHandlerClass(service, vars, p);
+  PrintBindServiceMethod(service, vars, p);
   PrintGetServiceDescriptorMethod(service, vars, p, flavor);
   p->Outdent();
   p->Print("}\n");
@@ -1168,7 +1329,8 @@ void PrintImports(Printer* p) {
 void GenerateService(const ServiceDescriptor* service,
                      protobuf::io::ZeroCopyOutputStream* out,
                      ProtoFlavor flavor,
-                     bool disable_version) {
+                     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<std::string, std::string> vars;
@@ -1199,8 +1361,9 @@ void GenerateService(const ServiceDescriptor* service,
   vars["RpcMethod"] = "io.grpc.stub.annotations.RpcMethod";
   vars["MethodDescriptor"] = "io.grpc.MethodDescriptor";
   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";
 
@@ -1218,11 +1381,11 @@ void GenerateService(const ServiceDescriptor* service,
   if (!vars["Package"].empty()) {
     vars["Package"].append(".");
   }
-  PrintService(service, &vars, &printer, flavor, disable_version);
+  PrintService(service, &vars, &printer, flavor, disable_version, generated_annotation);
 }
 
 std::string ServiceJavaPackage(const FileDescriptor* file) {
-  std::string result = protobuf::compiler::java::ClassName(file);
+  std::string result = protobuf::compiler::java::QualifiedClassName(file);
   size_t last_dot_pos = result.find_last_of('.');
   if (last_dot_pos != std::string::npos) {
     result.resize(last_dot_pos);
@@ -1233,7 +1396,7 @@ std::string ServiceJavaPackage(const FileDescriptor* file) {
 }
 
 std::string ServiceClassName(const ServiceDescriptor* service) {
-  return service->name() + "Grpc";
+  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 b499c494433..857fcab31d0 100644
--- a/compiler/src/java_plugin/cpp/java_generator.h
+++ b/compiler/src/java_plugin/cpp/java_generator.h
@@ -29,7 +29,7 @@ class LogHelper {
 
  public:
   LogHelper(std::ostream* os) : os(os) {}
-  ~LogHelper() {
+  [[ noreturn ]] ~LogHelper() {
     *os << std::endl;
     ::abort();
   }
@@ -57,6 +57,10 @@ enum ProtoFlavor {
   NORMAL, LITE
 };
 
+enum GeneratedAnnotation {
+  OMIT, JAVAX
+};
+
 // Returns the package name of the gRPC services defined in the given file.
 std::string ServiceJavaPackage(const impl::protobuf::FileDescriptor* file);
 
@@ -68,7 +72,8 @@ std::string ServiceClassName(const impl::protobuf::ServiceDescriptor* service);
 void GenerateService(const impl::protobuf::ServiceDescriptor* service,
                      impl::protobuf::io::ZeroCopyOutputStream* out,
                      ProtoFlavor flavor,
-                     bool disable_version);
+                     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 2eed9d260d1..4b02d6e9884 100644
--- a/compiler/src/java_plugin/cpp/java_plugin.cpp
+++ b/compiler/src/java_plugin/cpp/java_plugin.cpp
@@ -23,6 +23,9 @@
 
 #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>
@@ -45,9 +48,31 @@ class JavaGrpcGenerator : public protobuf::compiler::CodeGenerator {
   JavaGrpcGenerator() {}
   virtual ~JavaGrpcGenerator() {}
 
+// Protobuf 5.27 released edition 2023.
+#if GOOGLE_PROTOBUF_VERSION >= 5027000
   uint64_t GetSupportedFeatures() const override {
-    return FEATURE_PROTO3_OPTIONAL;
+    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,
@@ -58,6 +83,8 @@ class JavaGrpcGenerator : public protobuf::compiler::CodeGenerator {
 
     java_grpc_generator::ProtoFlavor flavor =
         java_grpc_generator::ProtoFlavor::NORMAL;
+    java_grpc_generator::GeneratedAnnotation generated_annotation =
+        java_grpc_generator::GeneratedAnnotation::OMIT;
 
     bool disable_version = false;
     for (size_t i = 0; i < options.size(); i++) {
@@ -65,6 +92,12 @@ class JavaGrpcGenerator : public protobuf::compiler::CodeGenerator {
         flavor = java_grpc_generator::ProtoFlavor::LITE;
       } 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;
+         }
       }
     }
 
@@ -77,7 +110,7 @@ class JavaGrpcGenerator : public protobuf::compiler::CodeGenerator {
       std::unique_ptr<protobuf::io::ZeroCopyOutputStream> output(
           context->Open(filename));
       java_grpc_generator::GenerateService(
-          service, output.get(), flavor, disable_version);
+          service, output.get(), flavor, disable_version, generated_annotation);
     }
     return true;
   }
diff --git a/compiler/src/test/golden/TestDeprecatedService.java.txt b/compiler/src/test/golden/TestDeprecatedService.java.txt
index a023449ed40..0b4924f3e6a 100644
--- a/compiler/src/test/golden/TestDeprecatedService.java.txt
+++ b/compiler/src/test/golden/TestDeprecatedService.java.txt
@@ -8,14 +8,15 @@ import static io.grpc.MethodDescriptor.generateFullMethodName;
  * </pre>
  */
 @javax.annotation.Generated(
-    value = "by gRPC proto compiler (version 1.37.0-SNAPSHOT)",
+    value = "by gRPC proto compiler (version 1.82.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 String SERVICE_NAME = "grpc.testing.compiler.TestDeprecatedService";
+  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,
@@ -63,6 +64,21 @@ public final class TestDeprecatedServiceGrpc {
     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
    */
@@ -99,7 +115,7 @@ public final class TestDeprecatedServiceGrpc {
    * </pre>
    */
   @java.lang.Deprecated
-  public static abstract class TestDeprecatedServiceImplBase implements io.grpc.BindableService {
+  public interface AsyncService {
 
     /**
      * <pre>
@@ -107,31 +123,36 @@ public final class TestDeprecatedServiceGrpc {
      * </pre>
      */
     @java.lang.Deprecated
-    public void deprecatedMethod(io.grpc.testing.compiler.Test.SimpleRequest request,
+    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 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>(
-                  this, METHODID_DEPRECATED_METHOD)))
-          .build();
+      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> {
+  public static final class TestDeprecatedServiceStub
+      extends io.grpc.stub.AbstractAsyncStub<TestDeprecatedServiceStub> {
     private TestDeprecatedServiceStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -157,12 +178,46 @@ public final class TestDeprecatedServiceGrpc {
   }
 
   /**
+   * 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 TestDeprecatedServiceBlockingStub extends io.grpc.stub.AbstractBlockingStub<TestDeprecatedServiceBlockingStub> {
+  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);
@@ -187,12 +242,14 @@ public final class TestDeprecatedServiceGrpc {
   }
 
   /**
+   * 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> {
+  public static final class TestDeprecatedServiceFutureStub
+      extends io.grpc.stub.AbstractFutureStub<TestDeprecatedServiceFutureStub> {
     private TestDeprecatedServiceFutureStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -224,10 +281,10 @@ public final class TestDeprecatedServiceGrpc {
       io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,
       io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,
       io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {
-    private final TestDeprecatedServiceImplBase serviceImpl;
+    private final AsyncService serviceImpl;
     private final int methodId;
 
-    MethodHandlers(TestDeprecatedServiceImplBase serviceImpl, int methodId) {
+    MethodHandlers(AsyncService serviceImpl, int methodId) {
       this.serviceImpl = serviceImpl;
       this.methodId = methodId;
     }
@@ -256,6 +313,18 @@ public final class TestDeprecatedServiceGrpc {
     }
   }
 
+  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() {}
@@ -279,9 +348,9 @@ public final class TestDeprecatedServiceGrpc {
   private static final class TestDeprecatedServiceMethodDescriptorSupplier
       extends TestDeprecatedServiceBaseDescriptorSupplier
       implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
-    private final String methodName;
+    private final java.lang.String methodName;
 
-    TestDeprecatedServiceMethodDescriptorSupplier(String methodName) {
+    TestDeprecatedServiceMethodDescriptorSupplier(java.lang.String methodName) {
       this.methodName = methodName;
     }
 
diff --git a/compiler/src/test/golden/TestService.java.txt b/compiler/src/test/golden/TestService.java.txt
index d106eda5589..5c65890273c 100644
--- a/compiler/src/test/golden/TestService.java.txt
+++ b/compiler/src/test/golden/TestService.java.txt
@@ -8,13 +8,14 @@ import static io.grpc.MethodDescriptor.generateFullMethodName;
  * </pre>
  */
 @javax.annotation.Generated(
-    value = "by gRPC proto compiler (version 1.37.0-SNAPSHOT)",
+    value = "by gRPC proto compiler (version 1.82.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.compiler.TestService";
+  public static final java.lang.String SERVICE_NAME = "grpc.testing.compiler.TestService";
 
   // Static method descriptors that strictly reflect the proto.
   private static volatile io.grpc.MethodDescriptor<io.grpc.testing.compiler.Test.SimpleRequest,
@@ -281,6 +282,21 @@ public final class TestServiceGrpc {
     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
    */
@@ -316,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>
@@ -324,7 +340,7 @@ public final class TestServiceGrpc {
      * The server returns the client payload as-is.
      * </pre>
      */
-    public void unaryCall(io.grpc.testing.compiler.Test.SimpleRequest request,
+    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);
     }
@@ -335,7 +351,7 @@ public final class TestServiceGrpc {
      * The server returns the payload with client desired type and sizes.
      * </pre>
      */
-    public void streamingOutputCall(io.grpc.testing.compiler.Test.StreamingOutputCallRequest request,
+    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);
     }
@@ -346,7 +362,7 @@ 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.compiler.Test.StreamingInputCallRequest> streamingInputCall(
+    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);
     }
@@ -358,7 +374,7 @@ public final class TestServiceGrpc {
      * demonstrates the idea of full bidirectionality.
      * </pre>
      */
-    public io.grpc.stub.StreamObserver<io.grpc.testing.compiler.Test.StreamingOutputCallRequest> fullBidiCall(
+    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);
     }
@@ -371,7 +387,7 @@ public final class TestServiceGrpc {
      * first request.
      * </pre>
      */
-    public io.grpc.stub.StreamObserver<io.grpc.testing.compiler.Test.StreamingOutputCallRequest> halfBidiCall(
+    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);
     }
@@ -382,7 +398,7 @@ public final class TestServiceGrpc {
      * method should have a '_' appended.
      * </pre>
      */
-    public io.grpc.stub.StreamObserver<io.grpc.testing.compiler.Test.StreamingInputCallRequest> import_(
+    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);
     }
@@ -392,7 +408,7 @@ public final class TestServiceGrpc {
      * A unary call that is Safe.
      * </pre>
      */
-    public void safeCall(io.grpc.testing.compiler.Test.SimpleRequest request,
+    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);
     }
@@ -402,79 +418,34 @@ public final class TestServiceGrpc {
      * A unary call that is Idempotent.
      * </pre>
      */
-    public void idempotentCall(io.grpc.testing.compiler.Test.SimpleRequest request,
+    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 abstract class TestServiceImplBase
+      implements io.grpc.BindableService, AsyncService {
 
     @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
-      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>(
-                  this, METHODID_UNARY_CALL)))
-          .addMethod(
-            getStreamingOutputCallMethod(),
-            io.grpc.stub.ServerCalls.asyncServerStreamingCall(
-              new MethodHandlers<
-                io.grpc.testing.compiler.Test.StreamingOutputCallRequest,
-                io.grpc.testing.compiler.Test.StreamingOutputCallResponse>(
-                  this, 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>(
-                  this, 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>(
-                  this, 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>(
-                  this, 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>(
-                  this, METHODID_IMPORT)))
-          .addMethod(
-            getSafeCallMethod(),
-            io.grpc.stub.ServerCalls.asyncUnaryCall(
-              new MethodHandlers<
-                io.grpc.testing.compiler.Test.SimpleRequest,
-                io.grpc.testing.compiler.Test.SimpleResponse>(
-                  this, METHODID_SAFE_CALL)))
-          .addMethod(
-            getIdempotentCallMethod(),
-            io.grpc.stub.ServerCalls.asyncUnaryCall(
-              new MethodHandlers<
-                io.grpc.testing.compiler.Test.SimpleRequest,
-                io.grpc.testing.compiler.Test.SimpleResponse>(
-                  this, METHODID_IDEMPOTENT_CALL)))
-          .build();
+      return TestServiceGrpc.bindService(this);
     }
   }
 
   /**
+   * 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> {
+  public static final class TestServiceStub
+      extends io.grpc.stub.AbstractAsyncStub<TestServiceStub> {
     private TestServiceStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -585,11 +556,132 @@ public final class TestServiceGrpc {
   }
 
   /**
+   * 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 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);
+    }
+  }
+
+  /**
+   * 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> {
+  public static final class TestServiceBlockingStub
+      extends io.grpc.stub.AbstractBlockingStub<TestServiceBlockingStub> {
     private TestServiceBlockingStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -646,11 +738,13 @@ public final class TestServiceGrpc {
   }
 
   /**
+   * 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.AbstractFutureStub<TestServiceFutureStub> {
+  public static final class TestServiceFutureStub
+      extends io.grpc.stub.AbstractFutureStub<TestServiceFutureStub> {
     private TestServiceFutureStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -711,10 +805,10 @@ public final class TestServiceGrpc {
       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;
     }
@@ -767,6 +861,67 @@ public final class TestServiceGrpc {
     }
   }
 
+  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() {}
@@ -790,9 +945,9 @@ public final class TestServiceGrpc {
   private static final class TestServiceMethodDescriptorSupplier
       extends TestServiceBaseDescriptorSupplier
       implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
-    private final String methodName;
+    private final java.lang.String methodName;
 
-    TestServiceMethodDescriptorSupplier(String methodName) {
+    TestServiceMethodDescriptorSupplier(java.lang.String methodName) {
       this.methodName = methodName;
     }
 
diff --git a/compiler/src/testLite/golden/TestDeprecatedService.java.txt b/compiler/src/testLite/golden/TestDeprecatedService.java.txt
index 893d7f41fdc..89ea2e698bf 100644
--- a/compiler/src/testLite/golden/TestDeprecatedService.java.txt
+++ b/compiler/src/testLite/golden/TestDeprecatedService.java.txt
@@ -7,15 +7,13 @@ import static io.grpc.MethodDescriptor.generateFullMethodName;
  * 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.37.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 String SERVICE_NAME = "grpc.testing.compiler.TestDeprecatedService";
+  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,
@@ -62,6 +60,21 @@ public final class TestDeprecatedServiceGrpc {
     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
    */
@@ -98,7 +111,7 @@ public final class TestDeprecatedServiceGrpc {
    * </pre>
    */
   @java.lang.Deprecated
-  public static abstract class TestDeprecatedServiceImplBase implements io.grpc.BindableService {
+  public interface AsyncService {
 
     /**
      * <pre>
@@ -106,31 +119,36 @@ public final class TestDeprecatedServiceGrpc {
      * </pre>
      */
     @java.lang.Deprecated
-    public void deprecatedMethod(io.grpc.testing.compiler.Test.SimpleRequest request,
+    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 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>(
-                  this, METHODID_DEPRECATED_METHOD)))
-          .build();
+      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> {
+  public static final class TestDeprecatedServiceStub
+      extends io.grpc.stub.AbstractAsyncStub<TestDeprecatedServiceStub> {
     private TestDeprecatedServiceStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -156,12 +174,46 @@ public final class TestDeprecatedServiceGrpc {
   }
 
   /**
+   * 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 TestDeprecatedServiceBlockingStub extends io.grpc.stub.AbstractBlockingStub<TestDeprecatedServiceBlockingStub> {
+  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);
@@ -186,12 +238,14 @@ public final class TestDeprecatedServiceGrpc {
   }
 
   /**
+   * 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> {
+  public static final class TestDeprecatedServiceFutureStub
+      extends io.grpc.stub.AbstractFutureStub<TestDeprecatedServiceFutureStub> {
     private TestDeprecatedServiceFutureStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -223,10 +277,10 @@ public final class TestDeprecatedServiceGrpc {
       io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,
       io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,
       io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {
-    private final TestDeprecatedServiceImplBase serviceImpl;
+    private final AsyncService serviceImpl;
     private final int methodId;
 
-    MethodHandlers(TestDeprecatedServiceImplBase serviceImpl, int methodId) {
+    MethodHandlers(AsyncService serviceImpl, int methodId) {
       this.serviceImpl = serviceImpl;
       this.methodId = methodId;
     }
@@ -255,6 +309,18 @@ public final class TestDeprecatedServiceGrpc {
     }
   }
 
+  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() {
diff --git a/compiler/src/testLite/golden/TestService.java.txt b/compiler/src/testLite/golden/TestService.java.txt
index b0386832736..4e9dfb8d682 100644
--- a/compiler/src/testLite/golden/TestService.java.txt
+++ b/compiler/src/testLite/golden/TestService.java.txt
@@ -7,14 +7,12 @@ import static io.grpc.MethodDescriptor.generateFullMethodName;
  * Test service that supports all call types.
  * </pre>
  */
-@javax.annotation.Generated(
-    value = "by gRPC proto compiler (version 1.37.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.compiler.TestService";
+  public static final java.lang.String SERVICE_NAME = "grpc.testing.compiler.TestService";
 
   // Static method descriptors that strictly reflect the proto.
   private static volatile io.grpc.MethodDescriptor<io.grpc.testing.compiler.Test.SimpleRequest,
@@ -273,6 +271,21 @@ public final class TestServiceGrpc {
     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
    */
@@ -308,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>
@@ -316,7 +329,7 @@ public final class TestServiceGrpc {
      * The server returns the client payload as-is.
      * </pre>
      */
-    public void unaryCall(io.grpc.testing.compiler.Test.SimpleRequest request,
+    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);
     }
@@ -327,7 +340,7 @@ public final class TestServiceGrpc {
      * The server returns the payload with client desired type and sizes.
      * </pre>
      */
-    public void streamingOutputCall(io.grpc.testing.compiler.Test.StreamingOutputCallRequest request,
+    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);
     }
@@ -338,7 +351,7 @@ 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.compiler.Test.StreamingInputCallRequest> streamingInputCall(
+    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);
     }
@@ -350,7 +363,7 @@ public final class TestServiceGrpc {
      * demonstrates the idea of full bidirectionality.
      * </pre>
      */
-    public io.grpc.stub.StreamObserver<io.grpc.testing.compiler.Test.StreamingOutputCallRequest> fullBidiCall(
+    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);
     }
@@ -363,7 +376,7 @@ public final class TestServiceGrpc {
      * first request.
      * </pre>
      */
-    public io.grpc.stub.StreamObserver<io.grpc.testing.compiler.Test.StreamingOutputCallRequest> halfBidiCall(
+    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);
     }
@@ -374,7 +387,7 @@ public final class TestServiceGrpc {
      * method should have a '_' appended.
      * </pre>
      */
-    public io.grpc.stub.StreamObserver<io.grpc.testing.compiler.Test.StreamingInputCallRequest> import_(
+    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);
     }
@@ -384,7 +397,7 @@ public final class TestServiceGrpc {
      * A unary call that is Safe.
      * </pre>
      */
-    public void safeCall(io.grpc.testing.compiler.Test.SimpleRequest request,
+    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);
     }
@@ -394,79 +407,34 @@ public final class TestServiceGrpc {
      * A unary call that is Idempotent.
      * </pre>
      */
-    public void idempotentCall(io.grpc.testing.compiler.Test.SimpleRequest request,
+    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 abstract class TestServiceImplBase
+      implements io.grpc.BindableService, AsyncService {
 
     @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
-      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>(
-                  this, METHODID_UNARY_CALL)))
-          .addMethod(
-            getStreamingOutputCallMethod(),
-            io.grpc.stub.ServerCalls.asyncServerStreamingCall(
-              new MethodHandlers<
-                io.grpc.testing.compiler.Test.StreamingOutputCallRequest,
-                io.grpc.testing.compiler.Test.StreamingOutputCallResponse>(
-                  this, 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>(
-                  this, 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>(
-                  this, 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>(
-                  this, 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>(
-                  this, METHODID_IMPORT)))
-          .addMethod(
-            getSafeCallMethod(),
-            io.grpc.stub.ServerCalls.asyncUnaryCall(
-              new MethodHandlers<
-                io.grpc.testing.compiler.Test.SimpleRequest,
-                io.grpc.testing.compiler.Test.SimpleResponse>(
-                  this, METHODID_SAFE_CALL)))
-          .addMethod(
-            getIdempotentCallMethod(),
-            io.grpc.stub.ServerCalls.asyncUnaryCall(
-              new MethodHandlers<
-                io.grpc.testing.compiler.Test.SimpleRequest,
-                io.grpc.testing.compiler.Test.SimpleResponse>(
-                  this, METHODID_IDEMPOTENT_CALL)))
-          .build();
+      return TestServiceGrpc.bindService(this);
     }
   }
 
   /**
+   * 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> {
+  public static final class TestServiceStub
+      extends io.grpc.stub.AbstractAsyncStub<TestServiceStub> {
     private TestServiceStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -577,11 +545,132 @@ public final class TestServiceGrpc {
   }
 
   /**
+   * 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 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);
+    }
+  }
+
+  /**
+   * 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> {
+  public static final class TestServiceBlockingStub
+      extends io.grpc.stub.AbstractBlockingStub<TestServiceBlockingStub> {
     private TestServiceBlockingStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -638,11 +727,13 @@ public final class TestServiceGrpc {
   }
 
   /**
+   * 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.AbstractFutureStub<TestServiceFutureStub> {
+  public static final class TestServiceFutureStub
+      extends io.grpc.stub.AbstractFutureStub<TestServiceFutureStub> {
     private TestServiceFutureStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -703,10 +794,10 @@ public final class TestServiceGrpc {
       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;
     }
@@ -759,6 +850,67 @@ public final class TestServiceGrpc {
     }
   }
 
+  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() {
diff --git a/context/BUILD.bazel b/context/BUILD.bazel
index a59da4ae7ef..0a51dca24a9 100644
--- a/context/BUILD.bazel
+++ b/context/BUILD.bazel
@@ -1,7 +1,7 @@
+load("@rules_java//java:defs.bzl", "java_library")
+
 java_library(
     name = "context",
-    srcs = glob([
-        "src/main/java/**/*.java",
-    ]),
     visibility = ["//visibility:public"],
+    exports = ["//api"],
 )
diff --git a/context/build.gradle b/context/build.gradle
index 4512cc56f0a..46d3d852f43 100644
--- a/context/build.gradle
+++ b/context/build.gradle
@@ -1,19 +1,14 @@
 plugins {
-    id "java"
+    id "java-library"
     id "maven-publish"
-
-    id "me.champeau.gradle.japicmp"
-    id "me.champeau.gradle.jmh"
-    id "ru.vyarus.animalsniffer"
 }
 
 description = 'gRPC: Context'
 
 dependencies {
-    testImplementation libraries.jsr305
-    testImplementation (libraries.guava_testlib) {
-        exclude group: 'junit', module: 'junit'
+    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"
     }
-    signature "org.codehaus.mojo.signature:java17:1.0@signature"
-    signature "net.sf.androidscents.signature:android-api-level-14:4.0_r4@signature"
 }
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
index c6e1ffbb6d7..1a743ff9eda 100644
--- a/core/BUILD.bazel
+++ b/core/BUILD.bazel
@@ -1,3 +1,6 @@
+load("@rules_java//java:defs.bzl", "java_library")
+load("@rules_jvm_external//:defs.bzl", "artifact")
+
 java_library(
     name = "core",
     visibility = ["//visibility:public"],
@@ -6,18 +9,8 @@ java_library(
 
 java_library(
     name = "inprocess",
-    srcs = glob([
-        "src/main/java/io/grpc/inprocess/*.java",
-    ]),
     visibility = ["//visibility:public"],
-    deps = [
-        ":internal",
-        "//api",
-        "//context",
-        "@com_google_code_findbugs_jsr305//jar",
-        "@com_google_guava_guava//jar",
-        "@com_google_j2objc_j2objc_annotations//jar",
-    ],
+    exports = ["//inprocess"],
 )
 
 java_library(
@@ -32,46 +25,31 @@ java_library(
     deps = [
         "//api",
         "//context",
-        "@com_google_android_annotations//jar",
-        "@com_google_code_findbugs_jsr305//jar",
-        "@com_google_code_gson_gson//jar",
-        "@com_google_errorprone_error_prone_annotations//jar",
-        "@com_google_guava_guava//jar",
-        "@com_google_j2objc_j2objc_annotations//jar",
-        "@io_perfmark_perfmark_api//jar",
-        "@org_codehaus_mojo_animal_sniffer_annotations//jar",
+        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",
-    srcs = glob([
-        "src/main/java/io/grpc/util/*.java",
-    ]),
-    resources = glob([
-        "src/bazel-util/resources/**",
-    ]),
     visibility = ["//visibility:public"],
-    deps = [
-        ":internal",
-        "//api",
-        "@com_google_code_findbugs_jsr305//jar",
-        "@com_google_guava_guava//jar",
-        "@com_google_j2objc_j2objc_annotations//jar",
-    ],
+    exports = ["//util"],
 )
 
 # Mirrors the dependencies included in the artifact on Maven Central for usage
-# with maven_install's override_targets. Purposefully does not export any
-# symbols, as it should only be used as a dep for pre-compiled binaries on
-# Maven Central.
+# 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"],
-    runtime_deps = [
-        ":inprocess",
+    exports = [
         ":internal",
-        ":util",
         "//api",
+        "//util",
     ],
 )
diff --git a/core/build.gradle b/core/build.gradle
index f4e0ccc3b62..b320f326b41 100644
--- a/core/build.gradle
+++ b/core/build.gradle
@@ -1,58 +1,69 @@
 buildscript {
     dependencies {
-        classpath 'com.google.guava:guava:30.0-android'
+        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.gradle.jmh"
+    id "me.champeau.jmh"
     id "ru.vyarus.animalsniffer"
 }
 
-import static java.nio.charset.StandardCharsets.US_ASCII;
-
-import com.google.common.primitives.Bytes;
-
 description = 'gRPC: Core'
 
-evaluationDependsOn(project(':grpc-context').path)
-evaluationDependsOn(project(':grpc-api').path)
-
 dependencies {
     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
-    guavaDependency 'implementation'
-    perfmarkDependency 'implementation'
-    testImplementation project(':grpc-context').sourceSets.test.output,
-            project(':grpc-api').sourceSets.test.output,
-            project(':grpc-testing'),
-            project(':grpc-grpclb')
-    testImplementation (libraries.guava_testlib) {
-        exclude group: 'junit', module: 'junit'
-    }
+            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 "org.codehaus.mojo.signature:java17:1.0@signature"
-    signature "net.sf.androidscents.signature:android-api-level-14:4.0_r4@signature"
+    signature (libraries.signature.java) {
+        artifact {
+            extension = "signature"
+        }
+    }
+    signature (libraries.signature.android) {
+        artifact {
+            extension = "signature"
+        }
+    }
 }
 
-javadoc {
+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 = [
@@ -61,61 +72,10 @@ animalsniffer {
     ]
 }
 
-import net.ltgt.gradle.errorprone.CheckSeverity
-
-def replaceBytes(byte[] haystack, byte[] needle, byte[] replacement) {
-    int i = Bytes.indexOf(haystack, needle);
-    assert i != -1;
-    byte[] result = new byte[haystack.length - needle.length + replacement.length];
-    System.arraycopy(haystack, 0, result, 0, i);
-    System.arraycopy(replacement, 0, result, i, replacement.length);
-    System.arraycopy(haystack, i + needle.length, result, i + replacement.length, haystack.length - i - needle.length);
-    return result;
-}
-
-def bigEndianShortBytes(int value) {
-    return [value >> 8, value & 0xFF] as byte[];
-}
-
-def replaceConstant(File file, String needle, String replacement) {
-    // CONSTANT_Utf8_info. https://docs.oracle.com/javase/specs/jvms/se7/html/jvms-4.html#jvms-4.4.7
-    byte[] needleBytes = Bytes.concat(
-        [1] as byte[], bigEndianShortBytes(needle.length()), needle.getBytes(US_ASCII));
-    byte[] replacementBytes = Bytes.concat(
-        [1] as byte[], bigEndianShortBytes(replacement.length()), replacement.getBytes(US_ASCII));
-    file.setBytes(replaceBytes(file.getBytes(), needleBytes, replacementBytes));
-}
-
-plugins.withId("java") {
-    compileJava {
-        doLast {
-            // Replace value of Signature Attribute.
-            // https://docs.oracle.com/javase/specs/jvms/se7/html/jvms-4.html#jvms-4.7.9
-	    //
-	    // Have new compilations compile against a public class, without breaking the internal
-	    // ABI for the moment. After giving users some time to recompile, this should be removed
-	    // and #7211 can continue. When this is removed, at the very least the generics need to
-	    // be changed to avoid <? extends io.grpc.internal.*>.
-            project.replaceConstant(
-                destinationDirectory.file(
-                    "io/grpc/internal/AbstractManagedChannelImplBuilder.class").get().getAsFile(),
-                "<T:Lio/grpc/internal/AbstractManagedChannelImplBuilder<TT;>;>Lio/grpc/ManagedChannelBuilder<TT;>;",
-                "<T:Lio/grpc/ManagedChannelBuilder<TT;>;>Lio/grpc/ManagedChannelBuilder<TT;>;");
-            project.replaceConstant(
-                destinationDirectory.file(
-                    "io/grpc/internal/AbstractServerImplBuilder.class").get().getAsFile(),
-                "<T:Lio/grpc/internal/AbstractServerImplBuilder<TT;>;>Lio/grpc/ServerBuilder<TT;>;",
-                "<T:Lio/grpc/ServerBuilder<TT;>;>Lio/grpc/ServerBuilder<TT;>;");
-        }
-    }
-
-    compileJmhJava {
-        // This project targets Java 7 (no method references)
-        options.errorprone.check("UnnecessaryAnonymousClass", CheckSeverity.OFF)
-    }
-}
+components.java.withVariantsFromConfiguration(configurations.testFixturesApiElements) { skip() }
+components.java.withVariantsFromConfiguration(configurations.testFixturesRuntimeElements) { skip() }
 
-task versionFile() {
+tasks.register("versionFile") {
     doLast {
         new File(buildDir, "version").write("${project.version}\n")
     }
diff --git a/core/src/bazel-util/resources/META-INF/services/io.grpc.LoadBalancerProvider b/core/src/bazel-util/resources/META-INF/services/io.grpc.LoadBalancerProvider
deleted file mode 100644
index 4c21dd2e1bf..00000000000
--- a/core/src/bazel-util/resources/META-INF/services/io.grpc.LoadBalancerProvider
+++ /dev/null
@@ -1 +0,0 @@
-io.grpc.util.SecretRoundRobinLoadBalancerProvider$Provider
diff --git a/core/src/jmh/java/io/grpc/internal/StatsTraceContextBenchmark.java b/core/src/jmh/java/io/grpc/internal/StatsTraceContextBenchmark.java
index aec2659f024..4d4349eef1b 100644
--- a/core/src/jmh/java/io/grpc/internal/StatsTraceContextBenchmark.java
+++ b/core/src/jmh/java/io/grpc/internal/StatsTraceContextBenchmark.java
@@ -17,7 +17,7 @@
 package io.grpc.internal;
 
 import io.grpc.Attributes;
-import io.grpc.CallOptions;
+import io.grpc.ClientStreamTracer;
 import io.grpc.Metadata;
 import io.grpc.MethodDescriptor;
 import io.grpc.ServerStreamTracer;
@@ -50,7 +50,8 @@ public class StatsTraceContextBenchmark {
   @BenchmarkMode(Mode.SampleTime)
   @OutputTimeUnit(TimeUnit.NANOSECONDS)
   public StatsTraceContext newClientContext() {
-    return StatsTraceContext.newClientContext(CallOptions.DEFAULT, Attributes.EMPTY, emptyMetadata);
+    return StatsTraceContext.newClientContext(
+        new ClientStreamTracer[] { new ClientStreamTracer() {} }, Attributes.EMPTY, emptyMetadata);
   }
 
   /**
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 8d285897fcb..00000000000
--- a/core/src/main/java/io/grpc/inprocess/InProcessChannelBuilder.java
+++ /dev/null
@@ -1,266 +0,0 @@
-/*
- * 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 io.grpc.ChannelCredentials;
-import io.grpc.ChannelLogger;
-import io.grpc.ExperimentalApi;
-import io.grpc.Internal;
-import io.grpc.ManagedChannelBuilder;
-import io.grpc.internal.AbstractManagedChannelImplBuilder;
-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.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
-    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);
-  }
-
-  /**
-   * Always fails.  Call {@link #forName} instead.
-   */
-  public static InProcessChannelBuilder forTarget(String target) {
-    throw new UnsupportedOperationException("call forName() instead");
-  }
-
-  /**
-   * Always fails.  Call {@link #forName} instead.
-   */
-  public static InProcessChannelBuilder forAddress(String name, int port) {
-    throw new UnsupportedOperationException("call forName() instead");
-  }
-
-  private final ManagedChannelImplBuilder managedChannelImplBuilder;
-  private final String name;
-  private ScheduledExecutorService scheduledExecutorService;
-  private int maxInboundMetadataSize = Integer.MAX_VALUE;
-  private boolean transportIncludeStatusCause = false;
-
-  private InProcessChannelBuilder(String name) {
-    this.name = checkNotNull(name, "name");
-
-    final class InProcessChannelTransportFactoryBuilder implements ClientTransportFactoryBuilder {
-      @Override
-      public ClientTransportFactory buildClientTransportFactory() {
-        return buildTransportFactory();
-      }
-    }
-
-    managedChannelImplBuilder = new ManagedChannelImplBuilder(new InProcessSocketAddress(name),
-        "localhost", 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);
-  }
-
-  @Internal
-  @Override
-  protected ManagedChannelBuilder<?> delegate() {
-    return managedChannelImplBuilder;
-  }
-
-  @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 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;
-  }
-
-  ClientTransportFactory buildTransportFactory() {
-    return new InProcessClientTransportFactory(
-        name, scheduledExecutorService, maxInboundMetadataSize, transportIncludeStatusCause);
-  }
-
-  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 String name;
-    private final ScheduledExecutorService timerService;
-    private final boolean useSharedTimer;
-    private final int maxInboundMetadataSize;
-    private boolean closed;
-    private final boolean includeCauseWithStatus;
-
-    private InProcessClientTransportFactory(
-        String name,
-        @Nullable ScheduledExecutorService scheduledExecutorService,
-        int maxInboundMetadataSize, boolean includeCauseWithStatus) {
-      this.name = name;
-      useSharedTimer = scheduledExecutorService == null;
-      timerService = useSharedTimer
-          ? SharedResourceHolder.get(GrpcUtil.TIMER_SERVICE) : scheduledExecutorService;
-      this.maxInboundMetadataSize = maxInboundMetadataSize;
-      this.includeCauseWithStatus = includeCauseWithStatus;
-    }
-
-    @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(
-          name, maxInboundMetadataSize, options.getAuthority(), options.getUserAgent(),
-          options.getEagAttributes(), includeCauseWithStatus);
-    }
-
-    @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);
-      }
-    }
-  }
-}
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 7922ebd21a1..00000000000
--- a/core/src/main/java/io/grpc/inprocess/InProcessServer.java
+++ /dev/null
@@ -1,135 +0,0 @@
-/*
- * 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(String name) {
-    return registry.get(name);
-  }
-
-  private final String name;
-  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.name = builder.name;
-    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.
-    if (registry.putIfAbsent(name, this) != null) {
-      throw new IOException("name already registered: " + name);
-    }
-  }
-
-  @Override
-  public SocketAddress getListenSocketAddress() {
-    return new InProcessSocketAddress(name);
-  }
-
-  @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() {
-    if (!registry.remove(name, this)) {
-      throw new AssertionError();
-    }
-    scheduler = schedulerPool.returnObject(scheduler);
-    synchronized (this) {
-      shutdown = true;
-      listener.serverShutdown();
-    }
-  }
-
-  @Override
-  public String toString() {
-    return MoreObjects.toStringHelper(this).add("name", name).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/core/src/main/java/io/grpc/inprocess/InProcessTransport.java b/core/src/main/java/io/grpc/inprocess/InProcessTransport.java
deleted file mode 100644
index 5967bf581bd..00000000000
--- a/core/src/main/java/io/grpc/inprocess/InProcessTransport.java
+++ /dev/null
@@ -1,894 +0,0 @@
-/*
- * 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 static java.lang.Math.max;
-
-import com.google.common.base.MoreObjects;
-import com.google.common.base.Optional;
-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.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.Metadata;
-import io.grpc.MethodDescriptor;
-import io.grpc.SecurityLevel;
-import io.grpc.ServerStreamTracer;
-import io.grpc.Status;
-import io.grpc.internal.ClientStream;
-import io.grpc.internal.ClientStreamListener;
-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.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 io.grpc.internal.StreamListener;
-import java.io.InputStream;
-import java.util.ArrayDeque;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.IdentityHashMap;
-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.annotation.CheckReturnValue;
-import javax.annotation.Nullable;
-import javax.annotation.concurrent.GuardedBy;
-import javax.annotation.concurrent.ThreadSafe;
-
-@ThreadSafe
-final class InProcessTransport implements ServerTransport, ConnectionClientTransport {
-  private static final Logger log = Logger.getLogger(InProcessTransport.class.getName());
-
-  private final InternalLogId logId;
-  private final String name;
-  private final int clientMaxInboundMetadataSize;
-  private final String authority;
-  private final String userAgent;
-  private final Optional<ServerListener> optionalServerListener;
-  private int serverMaxInboundMetadataSize;
-  private final boolean includeCauseWithStatus;
-  private ObjectPool<ScheduledExecutorService> serverSchedulerPool;
-  private ScheduledExecutorService serverScheduler;
-  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 final Set<InProcessStream> streams = Collections.newSetFromMap(
-          new IdentityHashMap<InProcessStream, Boolean>());
-  @GuardedBy("this")
-  private List<ServerStreamTracer.Factory> serverStreamTracerFactories;
-  private final Attributes attributes;
-
-  @GuardedBy("this")
-  private final InUseStateAggregator<InProcessStream> inUseState =
-      new InUseStateAggregator<InProcessStream>() {
-        @Override
-        protected void handleInUse() {
-          clientTransportListener.transportInUse(true);
-        }
-
-        @Override
-        protected void handleNotInUse() {
-          clientTransportListener.transportInUse(false);
-        }
-      };
-
-  private InProcessTransport(String name, int maxInboundMetadataSize, String authority,
-      String userAgent, Attributes eagAttrs,
-      Optional<ServerListener> optionalServerListener, boolean includeCauseWithStatus) {
-    this.name = name;
-    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, new InProcessSocketAddress(name))
-        .set(Grpc.TRANSPORT_ATTR_LOCAL_ADDR, new InProcessSocketAddress(name))
-        .build();
-    this.optionalServerListener = optionalServerListener;
-    logId = InternalLogId.allocate(getClass(), name);
-    this.includeCauseWithStatus = includeCauseWithStatus;
-  }
-
-  public InProcessTransport(
-      String name, int maxInboundMetadataSize, String authority, String userAgent,
-      Attributes eagAttrs, boolean includeCauseWithStatus) {
-    this(name, maxInboundMetadataSize, authority, userAgent, eagAttrs,
-        Optional.<ServerListener>absent(), includeCauseWithStatus);
-  }
-
-  InProcessTransport(
-      String name, int maxInboundMetadataSize, String authority, String userAgent,
-      Attributes eagAttrs, ObjectPool<ScheduledExecutorService> serverSchedulerPool,
-      List<ServerStreamTracer.Factory> serverStreamTracerFactories,
-      ServerListener serverListener) {
-    this(name, maxInboundMetadataSize, authority, userAgent, eagAttrs,
-        Optional.of(serverListener), false);
-    this.serverMaxInboundMetadataSize = maxInboundMetadataSize;
-    this.serverSchedulerPool = serverSchedulerPool;
-    this.serverStreamTracerFactories = serverStreamTracerFactories;
-  }
-
-  @CheckReturnValue
-  @Override
-  public synchronized Runnable start(ManagedClientTransport.Listener listener) {
-    this.clientTransportListener = listener;
-    if (optionalServerListener.isPresent()) {
-      serverScheduler = serverSchedulerPool.getObject();
-      serverTransportListener = optionalServerListener.get().transportCreated(this);
-    } else {
-      InProcessServer server = InProcessServer.findServer(name);
-      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: " + 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))
-              .set(Grpc.TRANSPORT_ATTR_LOCAL_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) {
-    if (shutdownStatus != null) {
-      return failedClientStream(
-          StatsTraceContext.newClientContext(callOptions, attributes, headers), 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(
-                "Request metadata larger than %d: %d",
-                serverMaxInboundMetadataSize,
-                metadataSize));
-        return failedClientStream(
-            StatsTraceContext.newClientContext(callOptions, attributes, headers), status);
-      }
-    }
-
-    return new InProcessStream(method, headers, callOptions, authority).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, 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.asRuntimeException());
-        }
-      });
-    } 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("name", name)
-        .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);
-  }
-
-  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) {
-      this.method = checkNotNull(method, "method");
-      this.headers = checkNotNull(headers, "headers");
-      this.callOptions = checkNotNull(callOptions, "callOptions");
-      this.authority = authority;
-      this.clientStream = new InProcessClientStream(callOptions, headers);
-      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;
-      @GuardedBy("this")
-      private ClientStreamListener clientStreamListener;
-      @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) {
-              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.messagesAvailable(clientReceiveQueue.poll());
-        }
-        // Attempt being reentrant-safe
-        if (closed) {
-          return false;
-        }
-        if (clientReceiveQueue.isEmpty() && clientNotifyStatus != null) {
-          closed = true;
-          clientStream.statsTraceCtx.clientInboundTrailers(clientNotifyTrailers);
-          clientStream.statsTraceCtx.streamClosed(clientNotifyStatus);
-          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;
-        }
-        statsTraceCtx.outboundMessage(outboundSeqNo);
-        statsTraceCtx.outboundMessageSent(outboundSeqNo, -1, -1);
-        clientStream.statsTraceCtx.inboundMessage(outboundSeqNo);
-        clientStream.statsTraceCtx.inboundMessageRead(outboundSeqNo, -1, -1);
-        outboundSeqNo++;
-        StreamListener.MessageProducer producer = new SingleMessageProducer(message);
-        if (clientRequested > 0) {
-          clientRequested--;
-          clientStreamListener.messagesAvailable(producer);
-        } else {
-          clientReceiveQueue.add(producer);
-        }
-      }
-
-      @Override
-      public void flush() {}
-
-      @Override
-      public synchronized boolean isReady() {
-        if (closed) {
-          return false;
-        }
-        return clientRequested > 0;
-      }
-
-      @Override
-      public void writeHeaders(Metadata headers) {
-        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(
-                    "Response header metadata larger than %d: %d",
-                    clientMaxInboundMetadataSize,
-                    metadataSize));
-            notifyClientClose(failedStatus, new Metadata());
-            return;
-          }
-        }
-
-        synchronized (this) {
-          if (closed) {
-            return;
-          }
-
-          clientStream.statsTraceCtx.clientInboundHeaders();
-          clientStreamListener.headersRead(headers);
-        }
-      }
-
-      @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(
-                    "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);
-            clientStreamListener.closed(clientStatus, trailers);
-          } else {
-            clientNotifyStatus = clientStatus;
-            clientNotifyTrailers = trailers;
-          }
-        }
-
-        streamClosed();
-      }
-
-      @Override
-      public void cancel(Status status) {
-        if (!internalCancel(Status.CANCELLED.withDescription("server cancelled stream"))) {
-          return;
-        }
-        clientStream.serverClosed(status, status);
-        streamClosed();
-      }
-
-      private synchronized boolean internalCancel(Status clientStatus) {
-        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);
-        clientStreamListener.closed(clientStatus, new Metadata());
-        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;
-      }
-    }
-
-    private class InProcessClientStream implements ClientStream {
-      final StatsTraceContext statsTraceCtx;
-      final CallOptions callOptions;
-      @GuardedBy("this")
-      private ServerStreamListener serverStreamListener;
-      @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, Metadata headers) {
-        this.callOptions = callOptions;
-        statsTraceCtx = StatsTraceContext.newClientContext(callOptions, attributes, headers);
-      }
-
-      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.messagesAvailable(serverReceiveQueue.poll());
-        }
-        if (serverReceiveQueue.isEmpty() && serverNotifyHalfClose) {
-          serverNotifyHalfClose = false;
-          serverStreamListener.halfClosed();
-        }
-        boolean nowReady = serverRequested > 0;
-        return !previouslyReady && nowReady;
-      }
-
-      private void serverClosed(Status serverListenerStatus, Status serverTracerStatus) {
-        internalCancel(serverListenerStatus, serverTracerStatus);
-      }
-
-      @Override
-      public synchronized void writeMessage(InputStream message) {
-        if (closed) {
-          return;
-        }
-        statsTraceCtx.outboundMessage(outboundSeqNo);
-        statsTraceCtx.outboundMessageSent(outboundSeqNo, -1, -1);
-        serverStream.statsTraceCtx.inboundMessage(outboundSeqNo);
-        serverStream.statsTraceCtx.inboundMessageRead(outboundSeqNo, -1, -1);
-        outboundSeqNo++;
-        StreamListener.MessageProducer producer = new SingleMessageProducer(message);
-        if (serverRequested > 0) {
-          serverRequested--;
-          serverStreamListener.messagesAvailable(producer);
-        } else {
-          serverReceiveQueue.add(producer);
-        }
-      }
-
-      @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 synchronized boolean internalCancel(
-          Status serverListenerStatus, Status serverTracerStatus) {
-        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);
-        serverStreamListener.closed(serverListenerStatus);
-        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) {
-          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);
-        long effectiveTimeout = max(0, deadline.timeRemaining(TimeUnit.NANOSECONDS));
-        headers.put(TIMEOUT_KEY, effectiveTimeout);
-      }
-
-      @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/core/src/main/java/io/grpc/inprocess/InternalInProcess.java b/core/src/main/java/io/grpc/inprocess/InternalInProcess.java
deleted file mode 100644
index 021b07a80bc..00000000000
--- a/core/src/main/java/io/grpc/inprocess/InternalInProcess.java
+++ /dev/null
@@ -1,65 +0,0 @@
-/*
- * 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.Attributes;
-import io.grpc.Internal;
-import io.grpc.ServerStreamTracer;
-import io.grpc.internal.ConnectionClientTransport;
-import io.grpc.internal.ObjectPool;
-import io.grpc.internal.ServerListener;
-import java.util.List;
-import java.util.concurrent.ScheduledExecutorService;
-
-/**
- * Internal {@link InProcessTransport} accessor.
- *
- * <p>This is intended for use by io.grpc.internal, and the specifically
- * supported transport packages.
- */
-@Internal
-public final class InternalInProcess {
-
-  private InternalInProcess() {}
-
-  /**
-   * Creates a new InProcessTransport.
-   *
-   * <p>When started, the transport will be registered with the given
-   * {@link ServerListener}.
-   */
-  @Internal
-  public static ConnectionClientTransport createInProcessTransport(
-      String name,
-      int maxInboundMetadataSize,
-      String authority,
-      String userAgent,
-      Attributes eagAttrs,
-      ObjectPool<ScheduledExecutorService> serverSchedulerPool,
-      List<ServerStreamTracer.Factory> serverStreamTracerFactories,
-      ServerListener serverListener) {
-    return new InProcessTransport(
-        name,
-        maxInboundMetadataSize,
-        authority,
-        userAgent,
-        eagAttrs,
-        serverSchedulerPool,
-        serverStreamTracerFactories,
-        serverListener);
-  }
-}
diff --git a/core/src/main/java/io/grpc/internal/AbstractClientStream.java b/core/src/main/java/io/grpc/internal/AbstractClientStream.java
index bf032da3148..bce1820b482 100644
--- a/core/src/main/java/io/grpc/internal/AbstractClientStream.java
+++ b/core/src/main/java/io/grpc/internal/AbstractClientStream.java
@@ -21,7 +21,6 @@
 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 static java.lang.Math.max;
 
 import com.google.common.annotations.VisibleForTesting;
 import com.google.common.base.Preconditions;
@@ -44,9 +43,9 @@
 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.
+ * 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, MessageFramer.Sink {
@@ -92,8 +91,8 @@ void writeFrame(
 
   private final TransportTracer transportTracer;
   private final Framer framer;
-  private boolean shouldBeCountedForInUse;
-  private boolean useGet;
+  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
@@ -102,6 +101,7 @@ void writeFrame(
    */
   private volatile boolean cancelled;
 
+  @SuppressWarnings("this-escape")
   protected AbstractClientStream(
       WritableBufferAllocator bufferAllocator,
       StatsTraceContext statsTraceCtx,
@@ -114,7 +114,7 @@ protected AbstractClientStream(
     this.shouldBeCountedForInUse = GrpcUtil.shouldBeCountedForInUse(callOptions);
     this.useGet = useGet;
     if (!useGet) {
-      framer = new MessageFramer(this, bufferAllocator, statsTraceCtx);
+      this.framer = new MessageFramer(this, bufferAllocator, statsTraceCtx);
       this.headers = headers;
     } else {
       framer = new GetFramer(headers, statsTraceCtx);
@@ -124,8 +124,7 @@ protected AbstractClientStream(
   @Override
   public void setDeadline(Deadline deadline) {
     headers.discardAll(TIMEOUT_KEY);
-    long effectiveTimeout = max(0, deadline.timeRemaining(TimeUnit.NANOSECONDS));
-    headers.put(TIMEOUT_KEY, effectiveTimeout);
+    headers.put(TIMEOUT_KEY, deadline.timeRemaining(TimeUnit.NANOSECONDS));
   }
 
   @Override
@@ -217,7 +216,7 @@ protected TransportTracer getTransportTracer() {
     return transportTracer;
   }
 
-  /** This should only called from the transport thread. */
+  /** 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;
@@ -243,9 +242,13 @@ protected abstract static class TransportState extends AbstractStream.TransportS
     protected TransportState(
         int maxMessageSize,
         StatsTraceContext statsTraceCtx,
-        TransportTracer transportTracer) {
+        TransportTracer transportTracer,
+        CallOptions options) {
       super(maxMessageSize, statsTraceCtx, transportTracer);
       this.statsTraceCtx = checkNotNull(statsTraceCtx, "statsTraceCtx");
+      if (options.getOnReadyThreshold() != null) {
+        this.setOnReadyThreshold(options.getOnReadyThreshold());
+      }
     }
 
     private void setFullStreamDecompression(boolean fullStreamDecompression) {
@@ -300,7 +303,7 @@ protected final boolean isOutboundClosed() {
      */
     protected void inboundHeadersReceived(Metadata headers) {
       checkState(!statusReported, "Received headers on closed stream");
-      statsTraceCtx.clientInboundHeaders();
+      statsTraceCtx.clientInboundHeaders(headers);
 
       boolean compressedStream = false;
       String streamEncoding = headers.get(CONTENT_ENCODING_KEY);
@@ -331,8 +334,7 @@ protected void inboundHeadersReceived(Metadata headers) {
           if (compressedStream) {
             deframeFailed(
                 Status.INTERNAL
-                    .withDescription(
-                        String.format("Full stream and gRPC message encoding cannot both be set"))
+                    .withDescription("Full stream and gRPC message encoding cannot both be set")
                     .asRuntimeException());
             return;
           }
@@ -456,10 +458,10 @@ private void closeListener(
       if (!listenerClosed) {
         listenerClosed = true;
         statsTraceCtx.streamClosed(status);
-        listener().closed(status, rpcProgress, trailers);
         if (getTransportTracer() != null) {
           getTransportTracer().reportStreamClosed(status.isOk());
         }
+        listener().closed(status, rpcProgress, 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 84a930e369f..00000000000
--- a/core/src/main/java/io/grpc/internal/AbstractManagedChannelImplBuilder.java
+++ /dev/null
@@ -1,277 +0,0 @@
-/*
- * 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 com.google.common.base.MoreObjects;
-import io.grpc.BinaryLog;
-import io.grpc.ClientInterceptor;
-import io.grpc.CompressorRegistry;
-import io.grpc.DecompressorRegistry;
-import io.grpc.ManagedChannel;
-import io.grpc.ManagedChannelBuilder;
-import io.grpc.NameResolver;
-import io.grpc.ProxyDetector;
-import java.util.List;
-import java.util.Map;
-import java.util.concurrent.Executor;
-import java.util.concurrent.TimeUnit;
-import javax.annotation.Nullable;
-
-/**
- * Temporarily duplicates {@link io.grpc.ForwardingChannelBuilder} to fix ABI backward
- * compatibility.
- *
- * @param <T> The concrete type of this builder.
- * @see <a href="https://github.com/grpc/grpc-java/issues/7211">grpc/grpc-java#7211</a>
- */
-public abstract class AbstractManagedChannelImplBuilder
-    <T extends AbstractManagedChannelImplBuilder<T>> extends ManagedChannelBuilder<T> {
-
-  /**
-   * The default constructor.
-   */
-  protected AbstractManagedChannelImplBuilder() {}
-
-  /**
-   * This method serves to force sub classes to "hide" this static factory.
-   */
-  public static ManagedChannelBuilder<?> forAddress(String name, int port) {
-    throw new UnsupportedOperationException("Subclass failed to hide static factory");
-  }
-
-  /**
-   * This method serves to force sub classes to "hide" this static factory.
-   */
-  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
-  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 enableFullStreamDecompression() {
-    delegate().enableFullStreamDecompression();
-    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 {@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.
-   */
-  protected final T thisT() {
-    @SuppressWarnings("unchecked")
-    T thisT = (T) this;
-    return thisT;
-  }
-}
diff --git a/core/src/main/java/io/grpc/internal/AbstractReadableBuffer.java b/core/src/main/java/io/grpc/internal/AbstractReadableBuffer.java
index e43b7a7cc0e..16c046dfc36 100644
--- a/core/src/main/java/io/grpc/internal/AbstractReadableBuffer.java
+++ b/core/src/main/java/io/grpc/internal/AbstractReadableBuffer.java
@@ -16,6 +16,8 @@
 
 package io.grpc.internal;
 
+import java.nio.ByteBuffer;
+
 /**
  * Abstract base class for {@link ReadableBuffer} implementations.
  */
@@ -45,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 715161c0635..00000000000
--- a/core/src/main/java/io/grpc/internal/AbstractServerImplBuilder.java
+++ /dev/null
@@ -1,182 +0,0 @@
-/*
- * 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 com.google.common.base.MoreObjects;
-import io.grpc.BinaryLog;
-import io.grpc.BindableService;
-import io.grpc.CompressorRegistry;
-import io.grpc.DecompressorRegistry;
-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 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 method to another builder by default.
- *
- * <p>Temporarily duplicates io.grpc.ForwardingServerBuilder (temporarily package-private)
- * to fix ABI backward compatibility.
-
- * @param <T> The concrete type of this builder.
- * @see <a href="https://github.com/grpc/grpc-java/issues/7211">grpc/grpc-java#7211</a>
- */
-public abstract class AbstractServerImplBuilder
-    <T extends AbstractServerImplBuilder<T>> extends ServerBuilder<T> {
-
-  /** The default constructor. */
-  protected AbstractServerImplBuilder() {}
-
-  /**
-   * This method serves to force sub classes to "hide" this static factory.
-   */
-  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 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 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.
-   */
-  protected final 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 55724fdff88..c468cba978a 100644
--- a/core/src/main/java/io/grpc/internal/AbstractServerStream.java
+++ b/core/src/main/java/io/grpc/internal/AbstractServerStream.java
@@ -41,7 +41,7 @@ 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.
@@ -50,7 +50,7 @@ protected interface Sink {
      * @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, int numMessages);
+    void writeFrame(WritableBuffer frame, boolean flush, int numMessages);
 
     /**
      * Sends trailers to the remote end point. This call implies end of stream.
@@ -75,10 +75,11 @@ protected interface Sink {
   private boolean outboundClosed;
   private boolean headersSent;
 
+  @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
@@ -96,11 +97,11 @@ protected final MessageFramer framer() {
   }
 
   @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
@@ -108,7 +109,14 @@ 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, numMessages);
+    if (frame == null) {
+      assert endOfStream;
+      return;
+    }
+    if (endOfStream) {
+      flush = false;
+    }
+    abstractServerStreamSink().writeFrame(frame, flush, numMessages);
   }
 
   @Override
@@ -171,7 +179,20 @@ public StatsTraceContext statsTraceContext() {
   }
 
   /**
-   * This should only called from the transport thread (except for private interactions with
+   * 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 {
@@ -217,8 +238,8 @@ public final void onStreamAllocated() {
     @Override
     public void deframerClosed(boolean hasPartialMessage) {
       deframerClosed = true;
-      if (endOfStream) {
-        if (!immediateCloseRequested && hasPartialMessage) {
+      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(
@@ -236,6 +257,8 @@ public void deframerClosed(boolean hasPartialMessage) {
       }
     }
 
+
+
     @Override
     protected ServerStreamListener listener() {
       return listener;
@@ -271,6 +294,7 @@ public void inboundDataReceived(ReadableBuffer frame, boolean endOfStream) {
      */
     public final void transportReportStatus(final Status status) {
       Preconditions.checkArgument(!status.isOk(), "status must not be OK");
+      onStreamDeallocated();
       if (deframerClosed) {
         deframerClosedTask = null;
         closeListener(status);
@@ -293,6 +317,7 @@ public void run() {
      * #transportReportStatus}.
      */
     public void complete() {
+      onStreamDeallocated();
       if (deframerClosed) {
         deframerClosedTask = null;
         closeListener(Status.OK);
@@ -328,7 +353,6 @@ private void closeListener(Status newStatus) {
           getTransportTracer().reportStreamClosed(closedStatus.isOk());
         }
         listenerClosed = true;
-        onStreamDeallocated();
         listener().closed(newStatus);
       }
     }
diff --git a/core/src/main/java/io/grpc/internal/AbstractStream.java b/core/src/main/java/io/grpc/internal/AbstractStream.java
index e0660182493..9f5fb035dab 100644
--- a/core/src/main/java/io/grpc/internal/AbstractStream.java
+++ b/core/src/main/java/io/grpc/internal/AbstractStream.java
@@ -20,19 +20,24 @@
 import static com.google.common.base.Preconditions.checkState;
 
 import com.google.common.annotations.VisibleForTesting;
+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;
 
 /**
  * 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 {
+  private static final Logger log = Logger.getLogger(AbstractStream.class.getName());
+
   /** The framer to use for sending messages. */
   protected abstract Framer framer();
 
@@ -76,6 +81,19 @@ public final void flush() {
     }
   }
 
+  /**
+   * 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.
+   */
+  protected void setOnReadyThreshold(int numBytes) {
+    transportState().setOnReadyThreshold(numBytes);
+  }
+
   /**
    * Closes the underlying framer. Should be called when the outgoing stream is gracefully closed
    * (half closure on client; closure on server).
@@ -91,9 +109,6 @@ public final void setCompressor(Compressor compressor) {
 
   @Override
   public boolean isReady() {
-    if (framer().isClosed()) {
-      return false;
-    }
     return transportState().isReady();
   }
 
@@ -108,7 +123,7 @@ protected final void onSendingBytes(int numBytes) {
   }
 
   /**
-   * Stream state as used by the transport. This should only called from the transport thread
+   * Stream state as used by the transport. This should only be called from the transport thread
    * (except for private interactions with {@code AbstractStream}).
    */
   public abstract static class TransportState
@@ -145,20 +160,25 @@ public abstract static class TransportState
     @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");
-      rawDeframer = new MessageDeframer(
+      this.rawDeframer = new MessageDeframer(
           this,
           Codec.Identity.NONE,
           maxMessageSize,
           statsTraceCtx,
           transportTracer);
       // TODO(#7168): use MigratingThreadDeframer when enabling retry doesn't break.
-      deframer = rawDeframer;
+      deframer = this.rawDeframer;
+      onReadyThreshold = DEFAULT_ONREADY_THRESHOLD;
     }
 
     final void optimizeForDirectExecutor() {
@@ -180,6 +200,20 @@ final void setMaxInboundMessageSize(int maxSize) {
      */
     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;
+      }
+    }
+
     @Override
     public void messagesAvailable(StreamListener.MessageProducer producer) {
       listener().messagesAvailable(producer);
@@ -222,25 +256,19 @@ protected final void deframe(final ReadableBuffer frame) {
      */
     private void requestMessagesFromDeframer(final int numMessages) {
       if (deframer instanceof ThreadOptimizedDeframer) {
-        PerfMark.startTask("AbstractStream.request");
-        try {
+        try (TaskCloseable ignore = PerfMark.traceTask("AbstractStream.request")) {
           deframer.request(numMessages);
-        } finally {
-          PerfMark.stopTask("AbstractStream.request");
         }
         return;
       }
       final Link link = PerfMark.linkOut();
       class RequestRunnable implements Runnable {
         @Override public void run() {
-          PerfMark.startTask("AbstractStream.request");
-          PerfMark.linkIn(link);
-          try {
+          try (TaskCloseable ignore = PerfMark.traceTask("AbstractStream.request")) {
+            PerfMark.linkIn(link);
             deframer.request(numMessages);
           } catch (Throwable t) {
             deframeFailed(t);
-          } finally {
-            PerfMark.stopTask("AbstractStream.request");
           }
         }
       }
@@ -267,7 +295,7 @@ protected final void setDecompressor(Decompressor decompressor) {
 
     private boolean isReady() {
       synchronized (onReadyLock) {
-        return allocated && numSentBytesQueued < DEFAULT_ONREADY_THRESHOLD && !deallocated;
+        return allocated && numSentBytesQueued < onReadyThreshold && !deallocated;
       }
     }
 
@@ -299,6 +327,12 @@ protected final void onStreamDeallocated() {
       }
     }
 
+    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.
@@ -324,9 +358,9 @@ public final void onSentBytes(int numBytes) {
       synchronized (onReadyLock) {
         checkState(allocated,
             "onStreamAllocated was not called, but it seems the stream is active");
-        boolean belowThresholdBefore = numSentBytesQueued < DEFAULT_ONREADY_THRESHOLD;
+        boolean belowThresholdBefore = numSentBytesQueued < onReadyThreshold;
         numSentBytesQueued -= numBytes;
-        boolean belowThresholdAfter = numSentBytesQueued < DEFAULT_ONREADY_THRESHOLD;
+        boolean belowThresholdAfter = numSentBytesQueued < onReadyThreshold;
         doNotify = !belowThresholdBefore && belowThresholdAfter;
       }
       if (doNotify) {
@@ -342,6 +376,12 @@ 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/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
index 037d49cb72f..dcefa8f8351 100644
--- a/core/src/main/java/io/grpc/internal/AutoConfiguredLoadBalancerFactory.java
+++ b/core/src/main/java/io/grpc/internal/AutoConfiguredLoadBalancerFactory.java
@@ -19,19 +19,15 @@
 import static com.google.common.base.Preconditions.checkNotNull;
 
 import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.MoreObjects;
-import io.grpc.Attributes;
 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.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.NameResolver.ConfigOrError;
@@ -42,12 +38,10 @@
 import java.util.Map;
 import javax.annotation.Nullable;
 
-// TODO(creamsoup) fully deprecate LoadBalancer.ATTR_LOAD_BALANCING_CONFIG
-@SuppressWarnings("deprecation")
-public final class AutoConfiguredLoadBalancerFactory {
+public final class AutoConfiguredLoadBalancerFactory extends LoadBalancerProvider {
 
   private final LoadBalancerRegistry registry;
-  private final String defaultPolicy;
+  private final LoadBalancerProvider defaultProvider;
 
   public AutoConfiguredLoadBalancerFactory(String defaultPolicy) {
     this(LoadBalancerRegistry.getDefaultRegistry(), defaultPolicy);
@@ -56,81 +50,55 @@ public AutoConfiguredLoadBalancerFactory(String defaultPolicy) {
   @VisibleForTesting
   AutoConfiguredLoadBalancerFactory(LoadBalancerRegistry registry, String defaultPolicy) {
     this.registry = checkNotNull(registry, "registry");
-    this.defaultPolicy = checkNotNull(defaultPolicy, "defaultPolicy");
+    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);
   }
 
-  private static final class NoopLoadBalancer extends LoadBalancer {
-
-    @Override
-    @Deprecated
-    public void handleResolvedAddressGroups(List<EquivalentAddressGroup> s, Attributes a) {}
-
-    @Override
-    public void handleResolvedAddresses(ResolvedAddresses resolvedAddresses) {}
-
-    @Override
-    public void handleNameResolutionError(Status error) {}
-
-    @Override
-    public void shutdown() {}
-  }
-
   @VisibleForTesting
-  public final class AutoConfiguredLoadBalancer {
+  public final class AutoConfiguredLoadBalancer extends LoadBalancer {
     private final Helper helper;
     private LoadBalancer delegate;
     private LoadBalancerProvider delegateProvider;
 
     AutoConfiguredLoadBalancer(Helper helper) {
       this.helper = helper;
-      delegateProvider = registry.getProvider(defaultPolicy);
-      if (delegateProvider == null) {
-        throw new IllegalStateException("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.");
-      }
+      this.delegateProvider = defaultProvider;
       delegate = delegateProvider.newLoadBalancer(helper);
     }
 
-    public void handleResolvedAddresses(ResolvedAddresses resolvedAddresses) {
-      tryHandleResolvedAddresses(resolvedAddresses);
-    }
-
     /**
-     * Returns non-OK status if resolvedAddresses is empty and delegate lb requires address ({@link
-     * LoadBalancer#canHandleEmptyAddressListFromNameResolution()} returns {@code false}). {@code
-     * AutoConfiguredLoadBalancer} doesn't expose {@code
-     * canHandleEmptyAddressListFromNameResolution} because it depends on the delegated LB.
+     * Returns non-OK status if the delegate rejects the resolvedAddresses (e.g. if it does not
+     * support an empty list).
      */
-    Status tryHandleResolvedAddresses(ResolvedAddresses resolvedAddresses) {
-      List<EquivalentAddressGroup> servers = resolvedAddresses.getAddresses();
-      Attributes attributes = resolvedAddresses.getAttributes();
+    @Override
+    public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
       PolicySelection policySelection =
           (PolicySelection) resolvedAddresses.getLoadBalancingPolicyConfig();
 
       if (policySelection == null) {
-        LoadBalancerProvider defaultProvider;
-        try {
-          defaultProvider = getProviderOrThrow(defaultPolicy, "using default policy");
-        } catch (PolicyException e) {
-          Status s = Status.INTERNAL.withDescription(e.getMessage());
-          helper.updateBalancingState(ConnectivityState.TRANSIENT_FAILURE, new FailingPicker(s));
-          delegate.shutdown();
-          delegateProvider = null;
-          delegate = new NoopLoadBalancer();
-          return Status.OK;
-        }
         policySelection =
             new PolicySelection(defaultProvider, /* config= */ null);
       }
 
       if (delegateProvider == null
           || !policySelection.provider.getPolicyName().equals(delegateProvider.getPolicyName())) {
-        helper.updateBalancingState(ConnectivityState.CONNECTING, new EmptyPicker());
+        helper.updateBalancingState(
+            ConnectivityState.CONNECTING, new FixedResultPicker(PickResult.withNoResult()));
         delegate.shutdown();
         delegateProvider = policySelection.provider;
         LoadBalancer old = delegate;
@@ -145,36 +113,32 @@ Status tryHandleResolvedAddresses(ResolvedAddresses resolvedAddresses) {
             ChannelLogLevel.DEBUG, "Load-balancing config: {0}", policySelection.config);
       }
 
-      LoadBalancer delegate = getDelegate();
-      if (resolvedAddresses.getAddresses().isEmpty()
-          && !delegate.canHandleEmptyAddressListFromNameResolution()) {
-        return Status.UNAVAILABLE.withDescription(
-            "NameResolver returned no usable address. addrs=" + servers + ", attrs=" + attributes);
-      } else {
-        delegate.handleResolvedAddresses(
-            ResolvedAddresses.newBuilder()
-                .setAddresses(resolvedAddresses.getAddresses())
-                .setAttributes(attributes)
-                .setLoadBalancingPolicyConfig(lbConfig)
-                .build());
-        return Status.OK;
-      }
+      return getDelegate().acceptResolvedAddresses(
+          ResolvedAddresses.newBuilder()
+              .setAddresses(resolvedAddresses.getAddresses())
+              .setAttributes(resolvedAddresses.getAttributes())
+              .setLoadBalancingPolicyConfig(lbConfig)
+              .build());
     }
 
-    void handleNameResolutionError(Status error) {
+    @Override
+    public void handleNameResolutionError(Status error) {
       getDelegate().handleNameResolutionError(error);
     }
 
+    @Override
     @Deprecated
-    void handleSubchannelState(Subchannel subchannel, ConnectivityStateInfo stateInfo) {
+    public void handleSubchannelState(Subchannel subchannel, ConnectivityStateInfo stateInfo) {
       getDelegate().handleSubchannelState(subchannel, stateInfo);
     }
 
-    void requestConnection() {
+    @Override
+    public void requestConnection() {
       getDelegate().requestConnection();
     }
 
-    void shutdown() {
+    @Override
+    public void shutdown() {
       delegate.shutdown();
       delegate = null;
     }
@@ -195,16 +159,6 @@ LoadBalancerProvider getDelegateProvider() {
     }
   }
 
-  private LoadBalancerProvider getProviderOrThrow(String policy, String choiceReason)
-      throws PolicyException {
-    LoadBalancerProvider provider = registry.getProvider(policy);
-    if (provider == null) {
-      throw new PolicyException(
-          "Trying to load '" + policy + "' because " + choiceReason + ", but it's unavailable");
-    }
-    return provider;
-  }
-
   /**
    * Parses first available LoadBalancer policy from service config. Available LoadBalancer should
    * be registered to {@link LoadBalancerRegistry}. If the first available LoadBalancer policy is
@@ -225,8 +179,11 @@ private LoadBalancerProvider getProviderOrThrow(String policy, String choiceReas
    *
    * @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
-  ConfigOrError parseLoadBalancerPolicy(Map<String, ?> serviceConfig) {
+  @Override
+  public ConfigOrError parseLoadBalancingPolicyConfig(Map<String, ?> serviceConfig) {
     try {
       List<LbConfig> loadBalancerConfigs = null;
       if (serviceConfig != null) {
@@ -244,38 +201,18 @@ ConfigOrError parseLoadBalancerPolicy(Map<String, ?> serviceConfig) {
     }
   }
 
-  @VisibleForTesting
-  static final class PolicyException extends Exception {
-    private static final long serialVersionUID = 1L;
-
-    private PolicyException(String msg) {
-      super(msg);
-    }
+  @Override
+  public boolean isAvailable() {
+    return true;
   }
 
-  private static final class EmptyPicker extends SubchannelPicker {
-
-    @Override
-    public PickResult pickSubchannel(PickSubchannelArgs args) {
-      return PickResult.withNoResult();
-    }
-
-    @Override
-    public String toString() {
-      return MoreObjects.toStringHelper(EmptyPicker.class).toString();
-    }
+  @Override
+  public int getPriority() {
+    return 5;
   }
 
-  private static final class FailingPicker extends SubchannelPicker {
-    private final Status failure;
-
-    FailingPicker(Status failure) {
-      this.failure = failure;
-    }
-
-    @Override
-    public PickResult pickSubchannel(PickSubchannelArgs args) {
-      return PickResult.withError(failure);
-    }
+  @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 cdca4a22606..c80ef9e1f9d 100644
--- a/core/src/main/java/io/grpc/internal/BackoffPolicy.java
+++ b/core/src/main/java/io/grpc/internal/BackoffPolicy.java
@@ -20,7 +20,7 @@
  * Determines how long to wait before doing some action (typically a retry, or a reconnect).
  */
 public interface BackoffPolicy {
-  public interface Provider {
+  interface Provider {
     BackoffPolicy get();
   }
 
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 0b1ce3514a2..97a74bda97e 100644
--- a/core/src/main/java/io/grpc/internal/CallCredentialsApplyingTransportFactory.java
+++ b/core/src/main/java/io/grpc/internal/CallCredentialsApplyingTransportFactory.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2016 The gRPC Authors
+ * Copyright 2016,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.
@@ -19,23 +19,26 @@
 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 java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.atomic.AtomicInteger;
-import javax.annotation.concurrent.GuardedBy;
 
 final class CallCredentialsApplyingTransportFactory implements ClientTransportFactory {
   private final ClientTransportFactory delegate;
@@ -72,6 +75,11 @@ 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;
@@ -104,7 +112,8 @@ protected ConnectionClientTransport delegate() {
     @Override
     @SuppressWarnings("deprecation")
     public ClientStream newStream(
-        final MethodDescriptor<?, ?> method, Metadata headers, final CallOptions callOptions) {
+        final MethodDescriptor<?, ?> method, Metadata headers, final CallOptions callOptions,
+        ClientStreamTracer[] tracers) {
       CallCredentials creds = callOptions.getCredentials();
       if (creds == null) {
         creds = channelCallCredentials;
@@ -113,10 +122,10 @@ public ClientStream newStream(
       }
       if (creds != null) {
         MetadataApplierImpl applier = new MetadataApplierImpl(
-            delegate, method, headers, callOptions, applierListener);
+            delegate, method, headers, callOptions, applierListener, tracers);
         if (pendingApplier.incrementAndGet() > 0) {
           applierListener.onComplete();
-          return new FailingClientStream(shutdownStatus);
+          return new FailingClientStream(shutdownStatus, tracers);
         }
         RequestInfo requestInfo = new RequestInfo() {
             @Override
@@ -124,6 +133,11 @@ public ClientStream newStream(
               return method;
             }
 
+            @Override
+            public CallOptions getCallOptions() {
+              return callOptions;
+            }
+
             @Override
             public SecurityLevel getSecurityLevel() {
               return firstNonNull(
@@ -142,8 +156,21 @@ public Attributes getTransportAttrs() {
             }
           };
         try {
-          creds.applyRequestMetadata(
-              requestInfo, firstNonNull(callOptions.getExecutor(), appExecutor), applier);
+          // 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")
@@ -152,9 +179,9 @@ public Attributes getTransportAttrs() {
         return applier.returnStream();
       } else {
         if (pendingApplier.get() >= 0) {
-          return new FailingClientStream(shutdownStatus);
+          return new FailingClientStream(shutdownStatus, tracers);
         }
-        return delegate.newStream(method, headers, callOptions);
+        return delegate.newStream(method, headers, callOptions, tracers);
       }
     }
 
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/ChannelLoggerImpl.java b/core/src/main/java/io/grpc/internal/ChannelLoggerImpl.java
index e000d872e8a..e8504498cdb 100644
--- a/core/src/main/java/io/grpc/internal/ChannelLoggerImpl.java
+++ b/core/src/main/java/io/grpc/internal/ChannelLoggerImpl.java
@@ -97,8 +97,9 @@ private static Severity toTracerSeverity(ChannelLogLevel level) {
   private static Level toJavaLogLevel(ChannelLogLevel level) {
     switch (level) {
       case ERROR:
-        return Level.FINE;
       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
index 8c8243c9021..a9730a365cc 100644
--- a/core/src/main/java/io/grpc/internal/ChannelTracer.java
+++ b/core/src/main/java/io/grpc/internal/ChannelTracer.java
@@ -18,6 +18,7 @@
 
 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;
@@ -31,7 +32,6 @@
 import java.util.logging.LogRecord;
 import java.util.logging.Logger;
 import javax.annotation.Nullable;
-import javax.annotation.concurrent.GuardedBy;
 
 /**
  * Tracks a collections of channel tracing events for a channel/subchannel.
diff --git a/core/src/main/java/io/grpc/internal/ClientCallImpl.java b/core/src/main/java/io/grpc/internal/ClientCallImpl.java
index 7ee9b10c4b1..4b24b1eae3d 100644
--- a/core/src/main/java/io/grpc/internal/ClientCallImpl.java
+++ b/core/src/main/java/io/grpc/internal/ClientCallImpl.java
@@ -20,19 +20,21 @@
 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 java.lang.Math.max;
 
 import com.google.common.annotations.VisibleForTesting;
 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;
@@ -50,6 +52,7 @@
 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;
@@ -58,6 +61,7 @@
 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;
@@ -70,6 +74,7 @@ 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;
@@ -77,16 +82,13 @@ final class ClientCallImpl<ReqT, RespT> extends ClientCall<ReqT, RespT> {
   private final boolean callExecutorIsDirect;
   private final CallTracer channelCallsTracer;
   private final Context context;
-  private volatile ScheduledFuture<?> deadlineCancellationFuture;
+  private CancellationHandler cancellationHandler;
   private final boolean unaryRequest;
   private CallOptions callOptions;
   private ClientStream stream;
-  private volatile boolean cancelListenersShouldBeRemoved;
   private boolean cancelCalled;
   private boolean halfCloseCalled;
   private final ClientStreamProvider clientStreamProvider;
-  private final ContextCancellationListener cancellationListener =
-      new ContextCancellationListener();
   private final ScheduledExecutorService deadlineCancellationExecutor;
   private boolean fullStreamDecompression;
   private DecompressorRegistry decompressorRegistry = DecompressorRegistry.getDefaultInstance();
@@ -123,13 +125,6 @@ final class ClientCallImpl<ReqT, RespT> extends ClientCall<ReqT, RespT> {
     PerfMark.event("ClientCall.<init>", tag);
   }
 
-  private final class ContextCancellationListener implements CancellationListener {
-    @Override
-    public void cancelled(Context context) {
-      stream.cancel(statusFromCancelled(context));
-    }
-  }
-
   /**
    * Provider of {@link ClientStream}s.
    */
@@ -162,6 +157,7 @@ static void prepareHeaders(
       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());
@@ -183,11 +179,9 @@ static void prepareHeaders(
 
   @Override
   public void start(Listener<RespT> observer, Metadata headers) {
-    PerfMark.startTask("ClientCall.start", tag);
-    try {
+    try (TaskCloseable ignore = PerfMark.traceTask("ClientCall.start")) {
+      PerfMark.attachTag(tag);
       startInternal(observer, headers);
-    } finally {
-      PerfMark.stopTask("ClientCall.start", tag);
     }
   }
 
@@ -248,15 +242,24 @@ public void runInContext() {
     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) {
-      logIfContextNarrowedTimeout(
-          effectiveDeadline, context.getDeadline(), callOptions.getDeadline());
       stream = clientStreamProvider.newStream(method, callOptions, headers, context);
     } else {
-      stream = new FailingClientStream(
-          DEADLINE_EXCEEDED.withDescription(
-              "ClientCall started after deadline exceeded: " + effectiveDeadline));
+      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) {
@@ -286,21 +289,7 @@ public void runInContext() {
     // they receive cancel before start. Issue #1343 has more details
 
     // Propagate later Context cancellation to the remote side.
-    context.addListener(cancellationListener, directExecutor());
-    if (effectiveDeadline != null
-        // If the context has the effective deadline, we don't need to schedule an extra task.
-        && !effectiveDeadline.equals(context.getDeadline())
-        // If the channel has been terminated, we don't need to schedule an extra task.
-        && deadlineCancellationExecutor != null) {
-      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();
   }
 
   private void applyMethodConfig() {
@@ -342,71 +331,96 @@ private void applyMethodConfig() {
     }
   }
 
-  private static void logIfContextNarrowedTimeout(
-      Deadline effectiveDeadline, @Nullable Deadline outerCallDeadline,
-      @Nullable Deadline callDeadline) {
-    if (!log.isLoggable(Level.FINE) || effectiveDeadline == null
-        || !effectiveDeadline.equals(outerCallDeadline)) {
-      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);
+      }
     }
 
-    long effectiveTimeout = max(0, effectiveDeadline.timeRemaining(TimeUnit.NANOSECONDS));
-    StringBuilder builder = new StringBuilder(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.fine(builder.toString());
-  }
-
-  private void removeContextListenerAndCancelDeadlineFuture() {
-    context.removeListener(cancellationListener);
-    ScheduledFuture<?> f = deadlineCancellationFuture;
-    if (f != null) {
-      f.cancel(false);
+    // 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 class DeadlineTimer implements Runnable {
-    private final long remainingNanos;
-
-    DeadlineTimer(long remainingNanos) {
-      this.remainingNanos = remainingNanos;
+    @Override
+    public void cancelled(Context context) {
+      if (hasDeadline && contextIsDeadlineSource
+          && context.cancellationCause() instanceof TimeoutException) {
+        stream.cancel(formatDeadlineExceededStatus());
+        return;
+      }
+      stream.cancel(statusFromCancelled(context));
     }
 
     @Override
     public void run() {
-      InsightBuilder insight = new InsightBuilder();
-      stream.appendTimeoutInsight(insight);
+      stream.cancel(formatDeadlineExceededStatus());
+    }
+
+    Status formatDeadlineExceededStatus() {
       // DelayedStream.cancel() is safe to call from a thread that is different from where the
       // stream is created.
       long seconds = Math.abs(remainingNanos) / TimeUnit.SECONDS.toNanos(1);
       long nanos = Math.abs(remainingNanos) % TimeUnit.SECONDS.toNanos(1);
 
       StringBuilder buf = new StringBuilder();
-      buf.append("deadline exceeded after ");
+      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. ");
-      buf.append(insight);
-      stream.cancel(DEADLINE_EXCEEDED.augmentDescription(buf.toString()));
+      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) {
-    long remainingNanos = deadline.timeRemaining(TimeUnit.NANOSECONDS);
-    return deadlineCancellationExecutor.schedule(
-        new LogExceptionRunnable(
-            new DeadlineTimer(remainingNanos)), remainingNanos, TimeUnit.NANOSECONDS);
-  }
-
   @Nullable
   private Deadline effectiveDeadline() {
     // Call options and context are immutable, so we don't need to cache the deadline.
@@ -426,23 +440,19 @@ private static Deadline min(@Nullable Deadline deadline0, @Nullable Deadline dea
 
   @Override
   public void request(int numMessages) {
-    PerfMark.startTask("ClientCall.request", tag);
-    try {
+    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);
-    } finally {
-      PerfMark.stopTask("ClientCall.request", tag);
     }
   }
 
   @Override
   public void cancel(@Nullable String message, @Nullable Throwable cause) {
-    PerfMark.startTask("ClientCall.cancel", tag);
-    try {
+    try (TaskCloseable ignore = PerfMark.traceTask("ClientCall.cancel")) {
+      PerfMark.attachTag(tag);
       cancelInternal(message, cause);
-    } finally {
-      PerfMark.stopTask("ClientCall.cancel", tag);
     }
   }
 
@@ -471,17 +481,18 @@ private void cancelInternal(@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() {
-    PerfMark.startTask("ClientCall.halfClose", tag);
-    try {
+    try (TaskCloseable ignore = PerfMark.traceTask("ClientCall.halfClose")) {
+      PerfMark.attachTag(tag);
       halfCloseInternal();
-    } finally {
-      PerfMark.stopTask("ClientCall.halfClose", tag);
     }
   }
 
@@ -495,11 +506,9 @@ private void halfCloseInternal() {
 
   @Override
   public void sendMessage(ReqT message) {
-    PerfMark.startTask("ClientCall.sendMessage", tag);
-    try {
+    try (TaskCloseable ignore = PerfMark.traceTask("ClientCall.sendMessage")) {
+      PerfMark.attachTag(tag);
       sendMessageInternal(message);
-    } finally {
-      PerfMark.stopTask("ClientCall.sendMessage", tag);
     }
   }
 
@@ -538,6 +547,9 @@ public void setMessageCompression(boolean enabled) {
 
   @Override
   public boolean isReady() {
+    if (halfCloseCalled) {
+      return false;
+    }
     return stream.isReady();
   }
 
@@ -550,7 +562,11 @@ public Attributes getAttributes() {
   }
 
   private void closeObserver(Listener<RespT> observer, Status status, Metadata trailers) {
-    observer.onClose(status, trailers);
+    try {
+      observer.onClose(status, trailers);
+    } catch (RuntimeException ex) {
+      log.log(Level.WARNING, "Exception thrown by onClose() in ClientCall", ex);
+    }
   }
 
   @Override
@@ -580,109 +596,93 @@ private void exceptionThrown(Status status) {
 
     @Override
     public void headersRead(final Metadata headers) {
-      PerfMark.startTask("ClientStreamListener.headersRead", tag);
-      final Link link = PerfMark.linkOut();
-
-      final class HeadersRead extends ContextRunnable {
-        HeadersRead() {
-          super(context);
-        }
-
-        @Override
-        public void runInContext() {
-          PerfMark.startTask("ClientCall$Listener.headersRead", tag);
-          PerfMark.linkIn(link);
-          try {
-            runInternal();
-          } finally {
-            PerfMark.stopTask("ClientCall$Listener.headersRead", tag);
+      try (TaskCloseable ignore = PerfMark.traceTask("ClientStreamListener.headersRead")) {
+        PerfMark.attachTag(tag);
+        final Link link = PerfMark.linkOut();
+        final class HeadersRead extends ContextRunnable {
+          HeadersRead() {
+            super(context);
           }
-        }
 
-        private void runInternal() {
-          if (exceptionStatus != null) {
-            return;
+          @Override
+          public void runInContext() {
+            try (TaskCloseable ignore = PerfMark.traceTask("ClientCall$Listener.headersRead")) {
+              PerfMark.attachTag(tag);
+              PerfMark.linkIn(link);
+              runInternal();
+            }
           }
-          try {
-            observer.onHeaders(headers);
-          } catch (Throwable t) {
-            exceptionThrown(
-                Status.CANCELLED.withCause(t).withDescription("Failed to read headers"));
+
+          private void runInternal() {
+            if (exceptionStatus != null) {
+              return;
+            }
+            try {
+              observer.onHeaders(headers);
+            } catch (Throwable t) {
+              exceptionThrown(
+                  Status.CANCELLED.withCause(t).withDescription("Failed to read headers"));
+            }
           }
         }
-      }
 
-      try {
         callExecutor.execute(new HeadersRead());
-      } finally {
-        PerfMark.stopTask("ClientStreamListener.headersRead", tag);
       }
     }
 
     @Override
     public void messagesAvailable(final MessageProducer producer) {
-      PerfMark.startTask("ClientStreamListener.messagesAvailable", tag);
-      final Link link = PerfMark.linkOut();
-
-      final class MessagesAvailable extends ContextRunnable {
-        MessagesAvailable() {
-          super(context);
-        }
-
-        @Override
-        public void runInContext() {
-          PerfMark.startTask("ClientCall$Listener.messagesAvailable", tag);
-          PerfMark.linkIn(link);
-          try {
-            runInternal();
-          } finally {
-            PerfMark.stopTask("ClientCall$Listener.messagesAvailable", tag);
+      try (TaskCloseable ignore = PerfMark.traceTask("ClientStreamListener.messagesAvailable")) {
+        PerfMark.attachTag(tag);
+        final Link link = PerfMark.linkOut();
+        final class MessagesAvailable extends ContextRunnable {
+          MessagesAvailable() {
+            super(context);
           }
-        }
 
-        private void runInternal() {
-          if (exceptionStatus != null) {
-            GrpcUtil.closeQuietly(producer);
-            return;
+          @Override
+          public void runInContext() {
+            try (TaskCloseable ignore =
+                     PerfMark.traceTask("ClientCall$Listener.messagesAvailable")) {
+              PerfMark.attachTag(tag);
+              PerfMark.linkIn(link);
+              runInternal();
+            }
           }
-          try {
-            InputStream message;
-            while ((message = producer.next()) != null) {
-              try {
-                observer.onMessage(method.parseResponse(message));
-              } catch (Throwable t) {
-                GrpcUtil.closeQuietly(message);
-                throw t;
+
+          private void runInternal() {
+            if (exceptionStatus != null) {
+              GrpcUtil.closeQuietly(producer);
+              return;
+            }
+            try {
+              InputStream message;
+              while ((message = producer.next()) != null) {
+                try {
+                  observer.onMessage(method.parseResponse(message));
+                } catch (Throwable t) {
+                  GrpcUtil.closeQuietly(message);
+                  throw t;
+                }
+                message.close();
               }
-              message.close();
+            } catch (Throwable t) {
+              GrpcUtil.closeQuietly(producer);
+              exceptionThrown(
+                  Status.CANCELLED.withCause(t).withDescription("Failed to read message."));
             }
-          } catch (Throwable t) {
-            GrpcUtil.closeQuietly(producer);
-            exceptionThrown(
-                Status.CANCELLED.withCause(t).withDescription("Failed to read message."));
           }
         }
-      }
 
-      try {
         callExecutor.execute(new MessagesAvailable());
-      } finally {
-        PerfMark.stopTask("ClientStreamListener.messagesAvailable", tag);
       }
     }
 
-    @Override
-    public void closed(Status status, Metadata trailers) {
-      closed(status, RpcProgress.PROCESSED, trailers);
-    }
-
     @Override
     public void closed(Status status, RpcProgress rpcProgress, Metadata trailers) {
-      PerfMark.startTask("ClientStreamListener.closed", tag);
-      try {
+      try (TaskCloseable ignore = PerfMark.traceTask("ClientStreamListener.closed")) {
+        PerfMark.attachTag(tag);
         closedInternal(status, rpcProgress, trailers);
-      } finally {
-        PerfMark.stopTask("ClientStreamListener.closed", tag);
       }
     }
 
@@ -694,10 +694,7 @@ private void closedInternal(
         // 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()) {
-          InsightBuilder insight = new InsightBuilder();
-          stream.appendTimeoutInsight(insight);
-          status = DEADLINE_EXCEEDED.augmentDescription(
-              "ClientCall was cancelled at or after deadline. " + insight);
+          status = cancellationHandler.formatDeadlineExceededStatus();
           // Replace trailers to prevent mixing sources of status and trailers.
           trailers = new Metadata();
         }
@@ -712,16 +709,15 @@ final class StreamClosed extends ContextRunnable {
 
         @Override
         public void runInContext() {
-          PerfMark.startTask("ClientCall$Listener.onClose", tag);
-          PerfMark.linkIn(link);
-          try {
+          try (TaskCloseable ignore = PerfMark.traceTask("ClientCall$Listener.onClose")) {
+            PerfMark.attachTag(tag);
+            PerfMark.linkIn(link);
             runInternal();
-          } finally {
-            PerfMark.stopTask("ClientCall$Listener.onClose", tag);
           }
         }
 
         private void runInternal() {
+          cancellationHandler.tearDown();
           Status status = savedStatus;
           Metadata trailers = savedTrailers;
           if (exceptionStatus != null) {
@@ -734,11 +730,9 @@ private void runInternal() {
             // Replace trailers to prevent mixing sources of status and trailers.
             trailers = new Metadata();
           }
-          cancelListenersShouldBeRemoved = true;
           try {
             closeObserver(observer, status, trailers);
           } finally {
-            removeContextListenerAndCancelDeadlineFuture();
             channelCallsTracer.reportCallEnded(status.isOk());
           }
         }
@@ -752,43 +746,38 @@ public void onReady() {
       if (method.getType().clientSendsOneMessage()) {
         return;
       }
+      try (TaskCloseable ignore = PerfMark.traceTask("ClientStreamListener.onReady")) {
+        PerfMark.attachTag(tag);
+        final Link link = PerfMark.linkOut();
 
-      PerfMark.startTask("ClientStreamListener.onReady", tag);
-      final Link link = PerfMark.linkOut();
-
-      final class StreamOnReady extends ContextRunnable {
-        StreamOnReady() {
-          super(context);
-        }
-
-        @Override
-        public void runInContext() {
-          PerfMark.startTask("ClientCall$Listener.onReady", tag);
-          PerfMark.linkIn(link);
-          try {
-            runInternal();
-          } finally {
-            PerfMark.stopTask("ClientCall$Listener.onReady", tag);
+        final class StreamOnReady extends ContextRunnable {
+          StreamOnReady() {
+            super(context);
           }
-        }
 
-        private void runInternal() {
-          if (exceptionStatus != null) {
-            return;
+          @Override
+          public void runInContext() {
+            try (TaskCloseable ignore = PerfMark.traceTask("ClientCall$Listener.onReady")) {
+              PerfMark.attachTag(tag);
+              PerfMark.linkIn(link);
+              runInternal();
+            }
           }
-          try {
-            observer.onReady();
-          } catch (Throwable t) {
-            exceptionThrown(
-                Status.CANCELLED.withCause(t).withDescription("Failed to call onReady."));
+
+          private void runInternal() {
+            if (exceptionStatus != null) {
+              return;
+            }
+            try {
+              observer.onReady();
+            } catch (Throwable t) {
+              exceptionThrown(
+                  Status.CANCELLED.withCause(t).withDescription("Failed to call onReady."));
+            }
           }
         }
-      }
 
-      try {
         callExecutor.execute(new StreamOnReady());
-      } finally {
-        PerfMark.stopTask("ClientStreamListener.onReady", tag);
       }
     }
   }
diff --git a/core/src/main/java/io/grpc/internal/ClientStreamListener.java b/core/src/main/java/io/grpc/internal/ClientStreamListener.java
index 6374d55a162..85a0626d426 100644
--- a/core/src/main/java/io/grpc/internal/ClientStreamListener.java
+++ b/core/src/main/java/io/grpc/internal/ClientStreamListener.java
@@ -25,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.
    *
@@ -33,21 +33,6 @@ public interface ClientStreamListener extends StreamListener {
    */
   void headersRead(Metadata headers);
 
-  /**
-   * Called when the stream is fully closed. {@link
-   * io.grpc.Status.Code#OK} is the only status code that is guaranteed
-   * to have been sent from the remote server. Any other status code may have been caused by
-   * abnormal stream termination. This is guaranteed to always be the final call on a listener. No
-   * further callbacks will be issued.
-   *
-   * <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 trailers trailing metadata
-   */
-  // TODO(zdapeng): remove this method in favor of the 3-arg one.
-  void closed(Status status, Metadata trailers);
-
   /**
    * Called when the stream is fully closed. {@link
    * io.grpc.Status.Code#OK} is the only status code that is guaranteed
@@ -68,16 +53,21 @@ public interface ClientStreamListener extends StreamListener {
    */
   enum RpcProgress {
     /**
-     * The RPC is processed by the server normally.
+     * The RPC may have been processed by the server.
      */
     PROCESSED,
     /**
-     * The RPC is not processed by the server's application logic.
+     * 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
+    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 cc8471ab6a3..fd0f30b8bf1 100644
--- a/core/src/main/java/io/grpc/internal/ClientTransport.java
+++ b/core/src/main/java/io/grpc/internal/ClientTransport.java
@@ -17,10 +17,12 @@
 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;
 
@@ -46,16 +48,21 @@ public interface ClientTransport extends InternalInstrumented<SocketStats> {
    * @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 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);
+  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).
    *
@@ -84,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 4d2ee92a0aa..6023fb14aa9 100644
--- a/core/src/main/java/io/grpc/internal/ClientTransportFactory.java
+++ b/core/src/main/java/io/grpc/internal/ClientTransportFactory.java
@@ -18,15 +18,17 @@
 
 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 io.grpc.MetricRecorder;
 import java.io.Closeable;
 import java.net.SocketAddress;
+import java.util.Collection;
 import java.util.concurrent.ScheduledExecutorService;
-import javax.annotation.CheckReturnValue;
 import javax.annotation.Nullable;
 
 /** Pre-configured factory for creating {@link ConnectionClientTransport} instances. */
@@ -73,6 +75,11 @@ ConnectionClientTransport newClientTransport(
   @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
@@ -85,6 +92,8 @@ final class ClientTransportOptions {
     private Attributes eagAttributes = Attributes.EMPTY;
     @Nullable private String userAgent;
     @Nullable private HttpConnectProxiedSocketAddress connectProxiedSocketAddr;
+    private MetricRecorder metricRecorder = new MetricRecorder() {
+    };
 
     public ChannelLogger getChannelLogger() {
       return channelLogger;
@@ -95,6 +104,15 @@ public ClientTransportOptions setChannelLogger(ChannelLogger channelLogger) {
       return this;
     }
 
+    public MetricRecorder getMetricRecorder() {
+      return metricRecorder;
+    }
+
+    public ClientTransportOptions setMetricRecorder(MetricRecorder metricRecorder) {
+      this.metricRecorder = Preconditions.checkNotNull(metricRecorder, "metricRecorder");
+      return this;
+    }
+
     public String getAuthority() {
       return authority;
     }
diff --git a/core/src/main/java/io/grpc/internal/CompositeReadableBuffer.java b/core/src/main/java/io/grpc/internal/CompositeReadableBuffer.java
index 34021d8a82b..6cedb2caee9 100644
--- a/core/src/main/java/io/grpc/internal/CompositeReadableBuffer.java
+++ b/core/src/main/java/io/grpc/internal/CompositeReadableBuffer.java
@@ -18,10 +18,11 @@
 
 import java.io.IOException;
 import java.io.OutputStream;
-import java.nio.Buffer;
 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
@@ -33,15 +34,17 @@
  */
 public class CompositeReadableBuffer extends AbstractReadableBuffer {
 
+  private final Deque<ReadableBuffer> readableBuffers;
+  private Deque<ReadableBuffer> rewindableBuffers;
   private int readableBytes;
-  private final Queue<ReadableBuffer> buffers;
+  private boolean marked;
 
   public CompositeReadableBuffer(int initialCapacity) {
-    buffers = new ArrayDeque<>(initialCapacity);
+    readableBuffers = new ArrayDeque<>(initialCapacity);
   }
 
   public CompositeReadableBuffer() {
-    buffers = new ArrayDeque<>();
+    readableBuffers = new ArrayDeque<>();
   }
 
   /**
@@ -51,16 +54,24 @@ public CompositeReadableBuffer() {
    * 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;
@@ -108,30 +119,6 @@ public int read(ReadableBuffer buffer, int length, byte[] dest, int offset) {
         }
       };
 
-  @Override
-  public void readBytes(byte[] dest, int destOffset, int length) {
-    executeNoThrow(BYTE_ARRAY_OP, length, dest, destOffset);
-  }
-
-  private static final NoThrowReadOperation<ByteBuffer> BYTE_BUF_OP =
-      new NoThrowReadOperation<ByteBuffer>() {
-        @Override
-        public int read(ReadableBuffer buffer, int length, ByteBuffer dest, int unused) {
-          // Change the limit so that only lengthToCopy bytes are available.
-          int prevLimit = dest.limit();
-          ((Buffer) dest).limit(dest.position() + length);
-          // Write the bytes and restore the original limit.
-          buffer.readBytes(dest);
-          ((Buffer) dest).limit(prevLimit);
-          return 0;
-        }
-      };
-
-  @Override
-  public void readBytes(ByteBuffer dest) {
-    executeNoThrow(BYTE_BUF_OP, dest.remaining(), dest, 0);
-  }
-
   private static final ReadOperation<OutputStream> STREAM_OP =
       new ReadOperation<OutputStream>() {
         @Override
@@ -142,6 +129,11 @@ public int read(ReadableBuffer buffer, int length, OutputStream dest, int unused
         }
       };
 
+  @Override
+  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);
@@ -158,22 +150,27 @@ public ReadableBuffer readBytes(int length) {
     ReadableBuffer newBuffer = null;
     CompositeReadableBuffer newComposite = null;
     do {
-      ReadableBuffer buffer = buffers.peek();
+      ReadableBuffer buffer = readableBuffers.peek();
       int readable = buffer.readableBytes();
       ReadableBuffer readBuffer;
       if (readable > length) {
         readBuffer = buffer.readBytes(length);
         length = 0;
       } else {
-        readBuffer = buffers.poll();
+        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(buffers.size() + 2, 16));
+          newComposite = new CompositeReadableBuffer(
+              length == 0 ? 2 : Math.min(readableBuffers.size() + 2, 16));
           newComposite.addBuffer(newBuffer);
           newBuffer = newComposite;
         }
@@ -183,10 +180,77 @@ public ReadableBuffer readBytes(int length) {
     return newBuffer;
   }
 
+  @Override
+  public boolean markSupported() {
+    for (ReadableBuffer buffer : readableBuffers) {
+      if (!buffer.markSupported()) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  @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 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();
+    }
+  }
+
+  @Override
+  public boolean byteBufferSupported() {
+    for (ReadableBuffer buffer : readableBuffers) {
+      if (!buffer.byteBufferSupported()) {
+        return false;
+      }
+    }
+    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();
+      }
     }
   }
 
@@ -197,12 +261,12 @@ public void close() {
   private <T> int execute(ReadOperation<T> op, int length, T dest, int value) throws IOException {
     checkReadable(length);
 
-    if (!buffers.isEmpty()) {
+    if (!readableBuffers.isEmpty()) {
       advanceBufferIfNecessary();
     }
 
-    for (; length > 0 && !buffers.isEmpty(); advanceBufferIfNecessary()) {
-      ReadableBuffer buffer = buffers.peek();
+    for (; length > 0 && !readableBuffers.isEmpty(); advanceBufferIfNecessary()) {
+      ReadableBuffer buffer = readableBuffers.peek();
       int lengthToCopy = Math.min(length, buffer.readableBytes());
 
       // Perform the read operation for this buffer.
@@ -232,9 +296,24 @@ private <T> int executeNoThrow(NoThrowReadOperation<T> op, int length, T dest, i
    * 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();
+    }
+  }
+
+  /**
+   * Removes one buffer from the front and closes it.
+   */
+  private void advanceBuffer() {
+    if (marked) {
+      rewindableBuffers.add(readableBuffers.remove());
+      ReadableBuffer next = readableBuffers.peek();
+      if (next != null) {
+        next.mark();
+      }
+    } else {
+      readableBuffers.remove().close();
     }
   }
 
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/DelayedClientCall.java b/core/src/main/java/io/grpc/internal/DelayedClientCall.java
index fbb24633d72..e0c05ca637e 100644
--- a/core/src/main/java/io/grpc/internal/DelayedClientCall.java
+++ b/core/src/main/java/io/grpc/internal/DelayedClientCall.java
@@ -22,6 +22,7 @@
 
 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;
@@ -38,7 +39,6 @@
 import java.util.logging.Level;
 import java.util.logging.Logger;
 import javax.annotation.Nullable;
-import javax.annotation.concurrent.GuardedBy;
 
 /**
  * A call that queues requests before a real call is ready to be delegated to.
@@ -64,6 +64,8 @@ public class DelayedClientCall<ReqT, RespT> extends ClientCall<ReqT, RespT> {
    * 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")
@@ -81,48 +83,67 @@ protected DelayedClientCall(
     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();
-    if (deadline == null && contextDeadline == null) {
-      return null;
-    }
-    long remainingNanos = Long.MAX_VALUE;
-    if (deadline != null) {
-      remainingNanos = Math.min(remainingNanos, deadline.timeRemaining(NANOSECONDS));
-    }
-    if (contextDeadline != null && contextDeadline.timeRemaining(NANOSECONDS) < remainingNanos) {
+    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(" Explicit call timeout was '%d' ns.", callTimeout));
+          builder.append(String.format(
+              Locale.US, " Explicit call timeout was '%d' ns.", callTimeout));
         }
         logger.fine(builder.toString());
       }
-    }
-    long seconds = Math.abs(remainingNanos) / TimeUnit.SECONDS.toNanos(1);
-    long nanos = Math.abs(remainingNanos) % TimeUnit.SECONDS.toNanos(1);
-    final StringBuilder buf = new StringBuilder();
-    if (remainingNanos < 0) {
-      buf.append("ClientCall started after deadline exceeded. Deadline exceeded after -");
     } else {
-      buf.append("Deadline exceeded after ");
+      return null;
     }
-    buf.append(seconds);
-    buf.append(String.format(Locale.US, ".%09d", nanos));
-    buf.append("s. ");
-    /** Cancels the call if deadline exceeded prior to the real call being set. */
+
+    /* 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
@@ -141,19 +162,41 @@ public void run() {
    * <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 void setCall(ClientCall<ReqT, RespT> call) {
+  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;
+        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;
     }
-    drainPendingCalls();
+    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;
@@ -163,7 +206,8 @@ public final void start(Listener<RespT> listener, final Metadata headers) {
       savedError = error;
       savedPassThrough = passThrough;
       if (!savedPassThrough) {
-        listener = delayedListener = new DelayedListener<>(listener);
+        listener = delayedListener = new DelayedListener<>(this, listener);
+        startHeaders = headers;
       }
     }
     if (savedError != null) {
@@ -172,15 +216,7 @@ public final void start(Listener<RespT> listener, final Metadata headers) {
     }
     if (savedPassThrough) {
       realCall.start(listener, headers);
-    } else {
-      final Listener<RespT> finalListener = listener;
-      delayOrExecute(new Runnable() {
-        @Override
-        public void run() {
-          realCall.start(finalListener, headers);
-        }
-      });
-    }
+    } // else realCall.start() will be called by setCall
   }
 
   // When this method returns, passThrough is guaranteed to be true
@@ -229,6 +265,7 @@ public void run() {
       if (listenerToClose != null) {
         callExecutor.execute(new CloseListenerRunnable(listenerToClose, status));
       }
+      internalStart(listenerToClose); // listener instance doesn't matter
       drainPendingCalls();
     }
     callCancelled();
@@ -408,15 +445,33 @@ public void runInContext() {
   }
 
   private static final class DelayedListener<RespT> extends Listener<RespT> {
+    private final DelayedClientCall<?, RespT> call;
     private final Listener<RespT> realListener;
     private volatile boolean passThrough;
+    private volatile Status exceptionStatus;
     @GuardedBy("this")
     private List<Runnable> pendingCallbacks = new ArrayList<>();
 
-    public DelayedListener(Listener<RespT> listener) {
+    public DelayedListener(DelayedClientCall<?, RespT> call, Listener<RespT> listener) {
+      this.call = call;
       this.realListener = listener;
     }
 
+    /**
+     * Cancels call and schedules onClose() notification. May only be called from within a
+     * DelayedListener callback dispatch (either queued drain or passThrough). Visibility of the
+     * write to {@code exceptionStatus} does not rely on a single callback executor; it is a
+     * {@code volatile} field, and callback queuing/pass-through transitions are coordinated by
+     * this listener's synchronization so subsequent callbacks observe the updated status.
+     */
+    private void exceptionThrown(Throwable t, String description) {
+      // onClose() must be delivered exactly once and last. Other callbacks may already be queued
+      // ahead of realCall's eventual onClose, so we can't call onClose() here. We set the status
+      // and overwrite the onClose() details when it arrives.
+      exceptionStatus = Status.CANCELLED.withCause(t).withDescription(description);
+      call.cancel(description, t);
+    }
+
     private void delayOrExecute(Runnable runnable) {
       synchronized (this) {
         if (!passThrough) {
@@ -430,37 +485,75 @@ private void delayOrExecute(Runnable runnable) {
     @Override
     public void onHeaders(final Metadata headers) {
       if (passThrough) {
-        realListener.onHeaders(headers);
+        deliverHeaders(headers);
       } else {
         delayOrExecute(new Runnable() {
           @Override
           public void run() {
-            realListener.onHeaders(headers);
+            deliverHeaders(headers);
           }
         });
       }
     }
 
+    private void deliverHeaders(Metadata headers) {
+      if (exceptionStatus != null) {
+        return;
+      }
+      try {
+        realListener.onHeaders(headers);
+      } catch (Throwable t) {
+        exceptionThrown(t, "Failed to read headers");
+      }
+    }
+
     @Override
     public void onMessage(final RespT message) {
       if (passThrough) {
-        realListener.onMessage(message);
+        deliverMessage(message);
       } else {
         delayOrExecute(new Runnable() {
           @Override
           public void run() {
-            realListener.onMessage(message);
+            deliverMessage(message);
           }
         });
       }
     }
 
+    private void deliverMessage(RespT message) {
+      if (exceptionStatus != null) {
+        return;
+      }
+      try {
+        realListener.onMessage(message);
+      } catch (Throwable t) {
+        exceptionThrown(t, "Failed to read message.");
+      }
+    }
+
     @Override
     public void onClose(final Status status, final Metadata trailers) {
       delayOrExecute(new Runnable() {
         @Override
         public void run() {
-          realListener.onClose(status, trailers);
+          Status effectiveStatus = status;
+          Metadata effectiveTrailers = trailers;
+          if (exceptionStatus != null) {
+            // Ideally status matches exceptionStatus, since exceptionStatus was used to cancel
+            // the call. However, cancel() may reconstruct a new Status instance, and the cancel
+            // is racy so this onClose may have already been queued when the cancellation
+            // occurred. Since other callbacks throw away data if exceptionStatus != null, it is
+            // semantically essential that we _not_ use a status provided by the server.
+            effectiveStatus = exceptionStatus;
+            // Replace trailers to prevent mixing sources of status and trailers.
+            effectiveTrailers = new Metadata();
+          }
+          try {
+            realListener.onClose(effectiveStatus, effectiveTrailers);
+          } catch (RuntimeException ex) {
+            logger.log(Level.WARNING, "Exception thrown by onClose() in ClientCall", ex);
+          }
         }
       });
     }
@@ -468,17 +561,28 @@ public void run() {
     @Override
     public void onReady() {
       if (passThrough) {
-        realListener.onReady();
+        deliverOnReady();
       } else {
         delayOrExecute(new Runnable() {
           @Override
           public void run() {
-            realListener.onReady();
+            deliverOnReady();
           }
         });
       }
     }
 
+    private void deliverOnReady() {
+      if (exceptionStatus != null) {
+        return;
+      }
+      try {
+        realListener.onReady();
+      } catch (Throwable t) {
+        exceptionThrown(t, "Failed to call onReady.");
+      }
+    }
+
     void drainPendingCallbacks() {
       assert !passThrough;
       List<Runnable> toRun = new ArrayList<>();
@@ -498,7 +602,6 @@ void drainPendingCallbacks() {
         }
         for (Runnable runnable : toRun) {
           // Avoid calling listener while lock is held to prevent deadlocks.
-          // TODO(ejona): exception handling
           runnable.run();
         }
         toRun.clear();
diff --git a/core/src/main/java/io/grpc/internal/DelayedClientTransport.java b/core/src/main/java/io/grpc/internal/DelayedClientTransport.java
index 6a72eb7c21e..5569e1eecf8 100644
--- a/core/src/main/java/io/grpc/internal/DelayedClientTransport.java
+++ b/core/src/main/java/io/grpc/internal/DelayedClientTransport.java
@@ -19,7 +19,9 @@
 import com.google.common.annotations.VisibleForTesting;
 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.InternalChannelz.SocketStats;
 import io.grpc.InternalLogId;
@@ -38,7 +40,6 @@
 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 {@link
@@ -68,28 +69,13 @@ final class DelayedClientTransport implements ManagedClientTransport {
   @GuardedBy("lock")
   private Collection<PendingStream> pendingStreams = new LinkedHashSet<>();
 
-  /**
-   * When {@code shutdownStatus != null && !hasPendingStreams()}, then the transport is considered
-   * terminated.
-   */
-  @GuardedBy("lock")
-  private Status shutdownStatus;
-
-  /**
-   * The last picker that {@link #reprocess} has used. May be set to null when the channel has moved
-   * to idle.
-   */
-  @GuardedBy("lock")
-  @Nullable
-  private SubchannelPicker lastPicker;
-
-  @GuardedBy("lock")
-  private long lastPickerVersion;
+  /** Immutable state needed for picking. 'lock' must be held for writing. */
+  private volatile PickerState pickerState = new PickerState(null, null);
 
   /**
    * Creates a new delayed transport.
    *
-   * @param defaultAppExecutor pending streams will create real streams and run bufferred operations
+   * @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
@@ -133,35 +119,48 @@ public void run() {
    */
   @Override
   public final ClientStream newStream(
-      MethodDescriptor<?, ?> method, Metadata headers, CallOptions callOptions) {
+      MethodDescriptor<?, ?> method, Metadata headers, CallOptions callOptions,
+      ClientStreamTracer[] tracers) {
     try {
-      PickSubchannelArgs args = new PickSubchannelArgsImpl(method, headers, callOptions);
-      SubchannelPicker picker = null;
-      long pickerVersion = -1;
+      PickSubchannelArgs args = new PickSubchannelArgsImpl(
+          method, headers, callOptions, new PickDetailsConsumerImpl(tracers));
+      PickerState state = pickerState;
       while (true) {
-        synchronized (lock) {
-          if (shutdownStatus != null) {
-            return new FailingClientStream(shutdownStatus);
-          }
-          if (lastPicker == null) {
-            return createPendingStream(args);
+        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());
           }
-          // Check for second time through the loop, and whether anything changed
-          if (picker != null && pickerVersion == lastPickerVersion) {
-            return createPendingStream(args);
+          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;
           }
-          picker = lastPicker;
-          pickerVersion = lastPickerVersion;
-        }
-        PickResult pickResult = picker.pickSubchannel(args);
-        ClientTransport transport = GrpcUtil.getTransportFromPickResult(pickResult,
-            callOptions.isWaitForReady());
-        if (transport != null) {
-          return transport.newStream(
-              args.getMethodDescriptor(), args.getHeaders(), args.getCallOptions());
         }
         // 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.
+        // 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);
+          }
+          state = newerState;
+        }
       }
     } finally {
       syncContext.drain();
@@ -173,12 +172,19 @@ public final ClientStream newStream(
    * schedule tasks on syncContext.
    */
   @GuardedBy("lock")
-  private PendingStream createPendingStream(PickSubchannelArgs args) {
-    PendingStream pendingStream = new PendingStream(args);
+  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();
+    }
     pendingStreams.add(pendingStream);
     if (getPendingStreamsCount() == 1) {
       syncContext.executeLater(reportTransportInUse);
     }
+    for (ClientStreamTracer streamTracer : tracers) {
+      streamTracer.createPendingStream();
+    }
     return pendingStream;
   }
 
@@ -195,21 +201,21 @@ public ListenableFuture<SocketStats> getStats() {
   }
 
   /**
-   * 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
+   * 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(final Status status) {
     synchronized (lock) {
-      if (shutdownStatus != null) {
+      if (pickerState.shutdownStatus != null) {
         return;
       }
-      shutdownStatus = status;
+      pickerState = pickerState.withShutdownStatus(status);
       syncContext.executeLater(new Runnable() {
           @Override
           public void run() {
-            listener.transportShutdown(status);
+            listener.transportShutdown(status, SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
           }
         });
       if (!hasPendingStreams() && reportTransportTerminated != null) {
@@ -239,7 +245,8 @@ public final void shutdownNow(Status status) {
     }
     if (savedReportTransportTerminated != null) {
       for (PendingStream stream : savedPendingStreams) {
-        Runnable runnable = stream.setStream(new FailingClientStream(status, RpcProgress.REFUSED));
+        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
@@ -279,8 +286,7 @@ final int getPendingStreamsCount() {
   final void reprocess(@Nullable SubchannelPicker picker) {
     ArrayList<PendingStream> toProcess;
     synchronized (lock) {
-      lastPicker = picker;
-      lastPickerVersion++;
+      pickerState = pickerState.withPicker(picker);
       if (picker == null || !hasPendingStreams()) {
         return;
       }
@@ -291,6 +297,9 @@ final void reprocess(@Nullable SubchannelPicker picker) {
     for (final PendingStream stream : toProcess) {
       PickResult pickResult = picker.pickSubchannel(stream.args);
       CallOptions callOptions = stream.args.getCallOptions();
+      if (callOptions.isWaitForReady() && pickResult.hasResult()) {
+        stream.lastPickStatus = pickResult.getStatus();
+      }
       final ClientTransport transport = GrpcUtil.getTransportFromPickResult(pickResult,
           callOptions.isWaitForReady());
       if (transport != null) {
@@ -301,7 +310,7 @@ final void reprocess(@Nullable SubchannelPicker picker) {
         if (callOptions.getExecutor() != null) {
           executor = callOptions.getExecutor();
         }
-        Runnable runnable = stream.createRealStream(transport);
+        Runnable runnable = stream.createRealStream(transport, pickResult.getAuthorityOverride());
         if (runnable != null) {
           executor.execute(runnable);
         }
@@ -316,7 +325,11 @@ final void reprocess(@Nullable SubchannelPicker picker) {
       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()) {
@@ -329,7 +342,7 @@ final void reprocess(@Nullable SubchannelPicker picker) {
         // (which would shutdown the transports and LoadBalancer) because the gap should be shorter
         // than IDLE_MODE_DEFAULT_TIMEOUT_MILLIS (1 second).
         syncContext.executeLater(reportTransportNotInUse);
-        if (shutdownStatus != null && reportTransportTerminated != null) {
+        if (pickerState.shutdownStatus != null && reportTransportTerminated != null) {
           syncContext.executeLater(reportTransportTerminated);
           reportTransportTerminated = null;
         }
@@ -346,21 +359,33 @@ public InternalLogId getLogId() {
   private class PendingStream extends DelayedStream {
     private final PickSubchannelArgs args;
     private final Context context = Context.current();
+    private final ClientStreamTracer[] tracers;
+    private volatile Status lastPickStatus;
 
-    private PendingStream(PickSubchannelArgs args) {
+    private PendingStream(PickSubchannelArgs args, ClientStreamTracer[] tracers) {
+      super("connecting_and_lb");
       this.args = args;
+      this.tracers = tracers;
     }
 
     /** Runnable may be null. */
-    private Runnable createRealStream(ClientTransport transport) {
+    private Runnable createRealStream(ClientTransport transport, String authorityOverride) {
       ClientStream realStream;
       Context origContext = context.attach();
       try {
         realStream = transport.newStream(
-            args.getMethodDescriptor(), args.getHeaders(), args.getCallOptions());
+            args.getMethodDescriptor(), args.getHeaders(), args.getCallOptions(),
+            tracers);
       } finally {
         context.detach(origContext);
       }
+      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);
     }
 
@@ -372,7 +397,7 @@ public void cancel(Status reason) {
           boolean justRemovedAnElement = pendingStreams.remove(this);
           if (!hasPendingStreams() && justRemovedAnElement) {
             syncContext.executeLater(reportTransportNotInUse);
-            if (shutdownStatus != null) {
+            if (pickerState.shutdownStatus != null) {
               syncContext.executeLater(reportTransportTerminated);
               reportTransportTerminated = null;
             }
@@ -382,12 +407,51 @@ public void cancel(Status reason) {
       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);
     }
   }
+
+  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 PickerState withPicker(SubchannelPicker newPicker) {
+      return new PickerState(newPicker, this.shutdownStatus);
+    }
+
+    public PickerState withShutdownStatus(Status newShutdownStatus) {
+      return new PickerState(this.lastPicker, newShutdownStatus);
+    }
+  }
 }
diff --git a/core/src/main/java/io/grpc/internal/DelayedStream.java b/core/src/main/java/io/grpc/internal/DelayedStream.java
index 7abd517032f..a2b1e963ac5 100644
--- a/core/src/main/java/io/grpc/internal/DelayedStream.java
+++ b/core/src/main/java/io/grpc/internal/DelayedStream.java
@@ -20,17 +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.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.CheckReturnValue;
-import javax.annotation.concurrent.GuardedBy;
 
 /**
  * A stream that queues requests before the transport is available, and delegates to a real stream
@@ -41,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. */
@@ -63,6 +65,14 @@ class DelayedStream implements ClientStream {
   // 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) {
     checkState(listener == null, "May only be called before start");
@@ -103,11 +113,13 @@ public void appendTimeoutInsight(InsightBuilder insight) {
         return;
       }
       if (realStream != null) {
-        insight.appendKeyValue("buffered_nanos", streamSetTimeNanos - startTimeNanos);
+        insight.appendKeyValue(
+            bufferContext + "_delay", "" + (streamSetTimeNanos - startTimeNanos) + "ns");
         realStream.appendTimeoutInsight(insight);
       } else {
-        insight.appendKeyValue("buffered_nanos", System.nanoTime() - startTimeNanos);
-        insight.append("waiting_for_connection");
+        insight.appendKeyValue(
+            bufferContext + "_delay", "" + (System.nanoTime() - startTimeNanos) + "ns");
+        insight.append("was_still_waiting");
       }
     }
   }
@@ -207,7 +219,6 @@ private void delayOrExecute(Runnable runnable) {
 
   @Override
   public void setAuthority(final String authority) {
-    checkState(listener == null, "May only be called before start");
     checkNotNull(authority, "authority");
     preStartPendingCalls.add(new Runnable() {
       @Override
@@ -235,7 +246,7 @@ public void start(ClientStreamListener listener) {
       startTimeNanos = System.nanoTime();
     }
     if (savedError != null) {
-      listener.closed(savedError, new Metadata());
+      listener.closed(savedError, RpcProgress.PROCESSED, new Metadata());
       return;
     }
 
@@ -323,11 +334,15 @@ public void run() {
       });
     } else {
       drainPendingCalls();
+      onEarlyCancellation(reason);
       // Note that listener is a DelayedStreamListener
-      listener.closed(reason, new Metadata());
+      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);
@@ -495,16 +510,6 @@ public void run() {
       });
     }
 
-    @Override
-    public void closed(final Status status, final Metadata trailers) {
-      delayOrExecute(new Runnable() {
-        @Override
-        public void run() {
-          realListener.closed(status, trailers);
-        }
-      });
-    }
-
     @Override
     public void closed(
         final Status status, final RpcProgress rpcProgress,
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 bc994a01035..1c1d95ed616 100644
--- a/core/src/main/java/io/grpc/internal/DnsNameResolver.java
+++ b/core/src/main/java/io/grpc/internal/DnsNameResolver.java
@@ -23,15 +23,14 @@
 import com.google.common.base.Objects;
 import com.google.common.base.Preconditions;
 import com.google.common.base.Stopwatch;
-import com.google.common.base.Throwables;
 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.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;
@@ -59,7 +58,7 @@
  * A DNS-based {@link NameResolver}.
  *
  * <p>Each {@code A} or {@code AAAA} record emits an {@link EquivalentAddressGroup} in the list
- * passed to {@link NameResolver.Listener2#onResult(ResolutionResult)}.
+ * passed to {@link NameResolver.Listener2#onResult2(ResolutionResult)}.
  *
  * @see DnsNameResolverProvider
  */
@@ -100,7 +99,7 @@ public class DnsNameResolver extends NameResolver {
    * 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.
+   * <p>For android, gRPC uses a fixed value; this property value will be ignored.
    */
   @VisibleForTesting
   static final String NETWORKADDRESS_CACHE_TTL_PROPERTY = "networkaddress.cache.ttl";
@@ -133,10 +132,10 @@ public class DnsNameResolver extends NameResolver {
   private final String host;
   private final int port;
 
-  /** Executor that will be used if an Executor is not provide via {@link NameResolver.Args}. */
-  private final Resource<Executor> executorResource;
+  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;
@@ -144,10 +143,6 @@ public class DnsNameResolver extends NameResolver {
   private boolean shutdown;
   private Executor executor;
 
-  /** True if using an executor resource that should be released after use. */
-  private final boolean usingExecutorResource;
-  private final ServiceConfigParser serviceConfigParser;
-
   private boolean resolving;
 
   // The field must be accessed from syncContext, although the methods on an Listener2 can be called
@@ -164,7 +159,7 @@ protected DnsNameResolver(
     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.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("//" + checkNotNull(name, "name"));
@@ -178,11 +173,15 @@ protected DnsNameResolver(
       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.executor = args.getOffloadExecutor();
-    this.usingExecutorResource = executor == null;
     this.serviceConfigParser = checkNotNull(args.getServiceConfigParser(), "serviceConfigParser");
   }
 
@@ -199,9 +198,7 @@ protected String getHost() {
   @Override
   public void start(Listener2 listener) {
     Preconditions.checkState(this.listener == null, "already started");
-    if (usingExecutorResource) {
-      executor = SharedResourceHolder.get(executorResource);
-    }
+    executor = executorPool.getObject();
     this.listener = checkNotNull(listener, "listener");
     resolve();
   }
@@ -212,20 +209,8 @@ public void refresh() {
     resolve();
   }
 
-  private List<EquivalentAddressGroup> resolveAddresses() {
-    List<? extends InetAddress> addresses;
-    Exception addressesException = null;
-    try {
-      addresses = addressResolver.resolveAddress(host);
-    } catch (Exception e) {
-      addressesException = e;
-      Throwables.throwIfUnchecked(e);
-      throw new RuntimeException(e);
-    } finally {
-      if (addressesException != null) {
-        logger.log(Level.FINE, "Address resolution failure", addressesException);
-      }
-    }
+  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) {
@@ -276,21 +261,19 @@ private EquivalentAddressGroup detectProxy() throws IOException {
   /**
    * Main logic of name resolution.
    */
-  protected InternalResolutionResult doResolve(boolean forceTxt) {
-    InternalResolutionResult result = new InternalResolutionResult();
+  protected ResolutionResult doResolve() {
+    ResolutionResult.Builder resultBuilder = ResolutionResult.newBuilder();
     try {
-      result.addresses = resolveAddresses();
+      resultBuilder.setAddressesOrError(StatusOr.fromValue(resolveAddresses()));
     } catch (Exception e) {
-      if (!forceTxt) {
-        result.error =
-            Status.UNAVAILABLE.withDescription("Unable to resolve host " + host).withCause(e);
-        return result;
-      }
+      logger.log(Level.FINE, "Address resolution failure", e);
+      resultBuilder.setAddressesOrError(StatusOr.fromStatus(
+          Status.UNAVAILABLE.withDescription("Unable to resolve host " + host).withCause(e)));
     }
     if (enableTxt) {
-      result.config = resolveServiceConfig();
+      resultBuilder.setServiceConfig(resolveServiceConfig());
     }
-    return result;
+    return resultBuilder.build();
   }
 
   private final class Resolve implements Runnable {
@@ -305,37 +288,32 @@ public void run() {
       if (logger.isLoggable(Level.FINER)) {
         logger.finer("Attempting DNS resolution of " + host);
       }
-      InternalResolutionResult result = null;
+      ResolutionResult 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);
           }
-          resolutionResultBuilder.setAddresses(Collections.singletonList(proxiedAddr));
+          result = ResolutionResult.newBuilder()
+              .setAddressesOrError(StatusOr.fromValue(Collections.singletonList(proxiedAddr)))
+              .build();
         } else {
-          result = doResolve(false);
-          if (result.error != null) {
-            savedListener.onError(result.error);
-            return;
-          }
-          if (result.addresses != null) {
-            resolutionResultBuilder.setAddresses(result.addresses);
-          }
-          if (result.config != null) {
-            resolutionResultBuilder.setServiceConfig(result.config);
-          }
-          if (result.attributes != null) {
-            resolutionResultBuilder.setAttributes(result.attributes);
-          }
+          result = doResolve();
         }
-        savedListener.onResult(resolutionResultBuilder.build());
+        ResolutionResult savedResult = result;
+        syncContext.execute(() -> {
+          savedListener.onResult2(savedResult);
+        });
       } catch (IOException e) {
-        savedListener.onError(
-            Status.UNAVAILABLE.withDescription("Unable to resolve host " + host).withCause(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;
+        final boolean succeed = result != null && result.getAddressesOrError().hasValue();
         syncContext.execute(new Runnable() {
           @Override
           public void run() {
@@ -401,8 +379,8 @@ public void shutdown() {
       return;
     }
     shutdown = true;
-    if (executor != null && usingExecutorResource) {
-      executor = SharedResourceHolder.release(executorResource, executor);
+    if (executor != null) {
+      executor = executorPool.returnObject(executor);
     }
   }
 
@@ -411,6 +389,7 @@ final int getPort() {
   }
 
   /**
+   * Parse TXT service config records as JSON.
    *
    * @throws IOException if one of the txt records contains improperly formatted JSON.
    */
@@ -434,7 +413,7 @@ final int getPort() {
 
   @Nullable
   private static final Double getPercentageFromChoice(Map<String, ?> serviceConfigChoice) {
-    return JsonUtil.getNumber(serviceConfigChoice, SERVICE_CONFIG_CHOICE_PERCENTAGE_KEY);
+    return JsonUtil.getNumberAsDouble(serviceConfigChoice, SERVICE_CONFIG_CHOICE_PERCENTAGE_KEY);
   }
 
   @Nullable
@@ -452,12 +431,14 @@ private static final List<String> getHostnamesFromChoice(Map<String, ?> serviceC
 
   /**
    * Returns value of network address cache ttl property if not Android environment. For android,
-   * DnsNameResolver does not cache the dns lookup result.
+   * DnsNameResolver uses a fixed value.
    */
   private static long getNetworkAddressCacheTtlNanos(boolean isAndroid) {
     if (isAndroid) {
-      // on Android, ignore dns cache.
-      return 0;
+      // On Android, use fixed value. If the network used changes this value shouldn't matter, as
+      // channel.enterIdle() should be called and this name resolver instance will be discarded. The
+      // new name resolver instance will then re-request.
+      return TimeUnit.SECONDS.toNanos(DEFAULT_NETWORK_CACHE_TTL_SECONDS);
     }
 
     String cacheTtlPropertyValue = System.getProperty(NETWORKADDRESS_CACHE_TTL_PROPERTY);
@@ -479,7 +460,7 @@ private static long getNetworkAddressCacheTtlNanos(boolean isAndroid) {
    * 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>
+   *     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.
    */
@@ -534,18 +515,6 @@ private static long getNetworkAddressCacheTtlNanos(boolean isAndroid) {
     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.
    */
diff --git a/core/src/main/java/io/grpc/internal/DnsNameResolverProvider.java b/core/src/main/java/io/grpc/internal/DnsNameResolverProvider.java
index 1c9290d2fc0..14b56f1a12a 100644
--- a/core/src/main/java/io/grpc/internal/DnsNameResolverProvider.java
+++ b/core/src/main/java/io/grpc/internal/DnsNameResolverProvider.java
@@ -21,29 +21,43 @@
 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, NameResolver.Args args) {
+  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("/"),
@@ -55,7 +69,26 @@ public DnsNameResolver newNameResolver(URI targetUri, NameResolver.Args args) {
           args,
           GrpcUtil.SHARED_CHANNEL_EXECUTOR,
           Stopwatch.createUnstarted(),
-          InternalServiceProviders.isAndroid(getClass().getClassLoader()));
+          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;
     }
@@ -75,4 +108,9 @@ protected boolean isAvailable() {
   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/FailingClientStream.java b/core/src/main/java/io/grpc/internal/FailingClientStream.java
index 6d368b6975f..6388ef8b6ee 100644
--- a/core/src/main/java/io/grpc/internal/FailingClientStream.java
+++ b/core/src/main/java/io/grpc/internal/FailingClientStream.java
@@ -18,6 +18,7 @@
 
 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;
@@ -30,27 +31,33 @@ 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) {
-    this(error, RpcProgress.PROCESSED);
+  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) {
+  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;
+    for (ClientStreamTracer tracer : tracers) {
+      tracer.streamClosed(error);
+    }
     listener.closed(error, rpcProgress, new Metadata());
   }
 
diff --git a/core/src/main/java/io/grpc/internal/FailingClientTransport.java b/core/src/main/java/io/grpc/internal/FailingClientTransport.java
index 25d20017c92..37194c46a29 100644
--- a/core/src/main/java/io/grpc/internal/FailingClientTransport.java
+++ b/core/src/main/java/io/grpc/internal/FailingClientTransport.java
@@ -21,6 +21,7 @@
 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;
@@ -45,15 +46,16 @@ class FailingClientTransport implements ClientTransport {
 
   @Override
   public ClientStream newStream(
-      MethodDescriptor<?, ?> method, Metadata headers, CallOptions callOptions) {
-    return new FailingClientStream(error, rpcProgress);
+      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);
         }
       });
   }
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/ForwardingClientStreamListener.java b/core/src/main/java/io/grpc/internal/ForwardingClientStreamListener.java
index d4e7790bd0a..904293b5bed 100644
--- a/core/src/main/java/io/grpc/internal/ForwardingClientStreamListener.java
+++ b/core/src/main/java/io/grpc/internal/ForwardingClientStreamListener.java
@@ -29,11 +29,6 @@ public void headersRead(Metadata headers) {
     delegate().headersRead(headers);
   }
 
-  @Override
-  public void closed(Status status, Metadata trailers) {
-    delegate().closed(status, trailers);
-  }
-
   @Override
   public void closed(Status status, RpcProgress rpcProgress, Metadata trailers) {
     delegate().closed(status, rpcProgress, trailers);
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 e54f8b169d6..bfdccbe5d6a 100644
--- a/core/src/main/java/io/grpc/internal/ForwardingConnectionClientTransport.java
+++ b/core/src/main/java/io/grpc/internal/ForwardingConnectionClientTransport.java
@@ -20,6 +20,7 @@
 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;
@@ -45,8 +46,9 @@ public void shutdownNow(Status status) {
 
   @Override
   public ClientStream newStream(
-      MethodDescriptor<?, ?> method, Metadata headers, CallOptions callOptions) {
-    return delegate().newStream(method, headers, callOptions);
+      MethodDescriptor<?, ?> method, Metadata headers, CallOptions callOptions,
+      ClientStreamTracer[] tracers) {
+    return delegate().newStream(method, headers, callOptions, tracers);
   }
 
   @Override
diff --git a/core/src/main/java/io/grpc/internal/ForwardingReadableBuffer.java b/core/src/main/java/io/grpc/internal/ForwardingReadableBuffer.java
index 954d0ac5486..7e690309647 100644
--- a/core/src/main/java/io/grpc/internal/ForwardingReadableBuffer.java
+++ b/core/src/main/java/io/grpc/internal/ForwardingReadableBuffer.java
@@ -21,6 +21,7 @@
 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}.
@@ -66,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);
@@ -96,6 +92,37 @@ 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();
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
index da43ae14800..f95f9b9dab8 100644
--- a/core/src/main/java/io/grpc/internal/GrpcAttributes.java
+++ b/core/src/main/java/io/grpc/internal/GrpcAttributes.java
@@ -42,5 +42,8 @@ public final class GrpcAttributes {
   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 2192e223aa2..c419f028f58 100644
--- a/core/src/main/java/io/grpc/internal/GrpcUtil.java
+++ b/core/src/main/java/io/grpc/internal/GrpcUtil.java
@@ -17,6 +17,7 @@
 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;
@@ -28,7 +29,9 @@
 import com.google.common.util.concurrent.ThreadFactoryBuilder;
 import io.grpc.CallOptions;
 import io.grpc.ClientStreamTracer;
+import io.grpc.ClientStreamTracer.StreamInfo;
 import io.grpc.InternalChannelz.SocketStats;
+import io.grpc.InternalFeatureFlags;
 import io.grpc.InternalLogId;
 import io.grpc.InternalMetadata;
 import io.grpc.InternalMetadata.TrustedAsciiMarshaller;
@@ -45,15 +48,20 @@
 import java.io.Closeable;
 import java.io.IOException;
 import java.io.InputStream;
-import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.net.HttpURLConnection;
-import java.net.InetSocketAddress;
 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;
@@ -72,6 +80,17 @@ public final class GrpcUtil {
 
   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");
 
   /**
@@ -104,6 +123,9 @@ public final class GrpcUtil {
   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) {
@@ -197,7 +219,7 @@ public byte[] parseAsciiString(byte[] serialized) {
 
   public static final Splitter ACCEPT_ENCODING_SPLITTER = Splitter.on(',').trimResults();
 
-  private static final String IMPLEMENTATION_VERSION = "1.37.0-SNAPSHOT"; // CURRENT_GRPC_VERSION
+  public static final String IMPLEMENTATION_VERSION = "1.82.0-SNAPSHOT"; // CURRENT_GRPC_VERSION
 
   /**
    * The default timeout in nanos for a keepalive ping request.
@@ -219,6 +241,12 @@ public byte[] parseAsciiString(byte[] serialized) {
    */
   public static final long DEFAULT_SERVER_KEEPALIVE_TIMEOUT_NANOS = TimeUnit.SECONDS.toNanos(20L);
 
+  /**
+   * The default minimum time between client keepalive pings permitted by server.
+   */
+  public static final long DEFAULT_SERVER_PERMIT_KEEPALIVE_TIME_NANOS
+          = TimeUnit.MINUTES.toNanos(5L);
+
   /**
    * The magic keepalive time value that disables keepalive.
    */
@@ -253,6 +281,8 @@ public ProxiedSocketAddress proxyFor(SocketAddress targetServerAddress) {
   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.
@@ -414,7 +444,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;
@@ -503,8 +533,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;
   }
@@ -606,29 +636,10 @@ public Stopwatch get() {
       }
     };
 
-  /**
-   * Returns the host via {@link InetSocketAddress#getHostString} if it is possible,
-   * i.e. in jdk >= 7.
-   * Otherwise, return it via {@link InetSocketAddress#getHostName} which may incur a DNS lookup.
-   */
-  public static String getHost(InetSocketAddress addr) {
-    try {
-      Method getHostStringMethod = InetSocketAddress.class.getMethod("getHostString");
-      return (String) getHostStringMethod.invoke(addr);
-    } catch (NoSuchMethodException e) {
-      // noop
-    } catch (IllegalAccessException e) {
-      // noop
-    } catch (InvocationTargetException e) {
-      // noop
-    }
-    return addr.getHostName();
-  }
-
   /**
    * 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
@@ -646,12 +657,14 @@ public static String getHost(InetSocketAddress addr) {
   static class TimeoutMarshaller implements Metadata.AsciiMarshaller<Long> {
 
     @Override
-    public String toAsciiString(Long timeoutNanos) {
+    public String toAsciiString(Long timeoutNanosObject) {
       long cutoff = 100000000;
+      // 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 < 0) {
-        throw new IllegalArgumentException("Timeout too small");
-      } else if (timeoutNanos < cutoff) {
+      if (timeoutNanos < cutoff) {
         return timeoutNanos + "n";
       } else if (timeoutNanos < cutoff * 1000L) {
         return unit.toMicros(timeoutNanos) + "u";
@@ -711,9 +724,14 @@ static ClientTransport getTransportFromPickResult(PickResult result, boolean isW
       return new ClientTransport() {
         @Override
         public ClientStream newStream(
-            MethodDescriptor<?, ?> method, Metadata headers, CallOptions callOptions) {
-          return transport.newStream(
-              method, headers, callOptions.withStreamTracerFactory(streamTracerFactory));
+            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
@@ -734,15 +752,38 @@ public ListenableFuture<SocketStats> getStats() {
     }
     if (!result.getStatus().isOk()) {
       if (result.isDrop()) {
-        return new FailingClientTransport(result.getStatus(), RpcProgress.DROPPED);
+        return new FailingClientTransport(
+            replaceInappropriateControlPlaneStatus(result.getStatus()), RpcProgress.DROPPED);
       }
       if (!isWaitForReady) {
-        return new FailingClientTransport(result.getStatus(), RpcProgress.PROCESSED);
+        return new FailingClientTransport(
+            replaceInappropriateControlPlaneStatus(result.getStatus()), RpcProgress.PROCESSED);
       }
     }
     return null;
   }
 
+  /** 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;
+  }
+
   /** Quietly closes all messages in MessageProducer. */
   static void closeQuietly(MessageProducer producer) {
     InputStream message;
@@ -767,6 +808,50 @@ public static void closeQuietly(@Nullable Closeable message) {
     }
   }
 
+  /** 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
@@ -791,5 +876,98 @@ static <T> boolean iterableContains(Iterable<T> iterable, T item) {
     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) {
+    return InternalFeatureFlags.getFlag(envVarName, enableByDefault);
+  }
+
+
+
   private GrpcUtil() {}
 }
diff --git a/core/src/main/java/io/grpc/internal/Http2ClientStreamTransportState.java b/core/src/main/java/io/grpc/internal/Http2ClientStreamTransportState.java
index c2bcb350a9f..7124f2fc88a 100644
--- a/core/src/main/java/io/grpc/internal/Http2ClientStreamTransportState.java
+++ b/core/src/main/java/io/grpc/internal/Http2ClientStreamTransportState.java
@@ -16,13 +16,14 @@
 
 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;
 
 /**
@@ -61,14 +62,15 @@ 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,
-      TransportTracer transportTracer) {
-    super(maxMessageSize, statsTraceCtx, transportTracer);
+      TransportTracer transportTracer,
+      CallOptions options) {
+    super(maxMessageSize, statsTraceCtx, transportTracer, options);
   }
 
   /**
@@ -138,6 +140,7 @@ protected void transportDataReceived(ReadableBuffer frame, boolean endOfStream)
       }
     } else {
       if (!headersReceived) {
+        frame.close();
         http2ProcessingFailed(
             Status.INTERNAL.withDescription("headers not received before payload"),
             false,
@@ -220,8 +223,11 @@ private Status validateInitialMetadata(Metadata headers) {
     }
     String contentType = headers.get(GrpcUtil.CONTENT_TYPE_KEY);
     if (!GrpcUtil.isGrpcContentType(contentType)) {
-      return GrpcUtil.httpStatusToGrpcStatus(httpStatus)
-          .augmentDescription("invalid content-type: " + contentType);
+      Status status = GrpcUtil.httpStatusToGrpcStatus(httpStatus);
+      if (contentType == null) {
+        return status.augmentDescription("missing content-type in response headers");
+      }
+      return status.augmentDescription("invalid content-type: " + contentType);
     }
     return null;
   }
@@ -239,7 +245,7 @@ private static Charset extractCharset(Metadata headers) {
         // Ignore and assume UTF-8
       }
     }
-    return Charsets.UTF_8;
+    return StandardCharsets.UTF_8;
   }
 
   /**
diff --git a/core/src/main/java/io/grpc/internal/Http2Ping.java b/core/src/main/java/io/grpc/internal/Http2Ping.java
index 6104d876373..e3520295625 100644
--- a/core/src/main/java/io/grpc/internal/Http2Ping.java
+++ b/core/src/main/java/io/grpc/internal/Http2Ping.java
@@ -17,6 +17,8 @@
 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;
@@ -24,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
@@ -62,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
@@ -144,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) {
@@ -167,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));
   }
 
@@ -203,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 f4f3a186d88..f3d870e8797 100644
--- a/core/src/main/java/io/grpc/internal/InUseStateAggregator.java
+++ b/core/src/main/java/io/grpc/internal/InUseStateAggregator.java
@@ -53,6 +53,21 @@ public final boolean isInUse() {
     return !inUseObjects.isEmpty();
   }
 
+  /**
+   * 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.
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/InternalServer.java b/core/src/main/java/io/grpc/internal/InternalServer.java
index 0445ae3dfab..a6079081233 100644
--- a/core/src/main/java/io/grpc/internal/InternalServer.java
+++ b/core/src/main/java/io/grpc/internal/InternalServer.java
@@ -50,7 +50,7 @@ public interface InternalServer {
   void shutdown();
 
   /**
-   * Returns the first listening socket address.  May change after {@link start(ServerListener)} is
+   * Returns the first listening socket address.  May change after {@link #start(ServerListener)} is
    * called.
    */
   SocketAddress getListenSocketAddress();
@@ -61,7 +61,7 @@ public interface InternalServer {
   @Nullable InternalInstrumented<SocketStats> getListenSocketStats();
 
   /**
-   * Returns a list of listening socket addresses.  May change after {@link start(ServerListener)}
+   * Returns a list of listening socket addresses.  May change after {@link #start(ServerListener)}
    * is called.
    */
   List<? extends SocketAddress> getListenSocketAddresses();
diff --git a/core/src/main/java/io/grpc/internal/InternalSubchannel.java b/core/src/main/java/io/grpc/internal/InternalSubchannel.java
index 97be3f26e0e..00a66b1c1df 100644
--- a/core/src/main/java/io/grpc/internal/InternalSubchannel.java
+++ b/core/src/main/java/io/grpc/internal/InternalSubchannel.java
@@ -34,17 +34,24 @@
 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.InternalEquivalentAddressGroup;
 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;
@@ -74,7 +81,11 @@ final class InternalSubchannel implements InternalInstrumented<ChannelStats>, Tr
   private final InternalChannelz channelz;
   private final CallTracer callsTracer;
   private final ChannelTracer channelTracer;
+  private final MetricRecorder metricRecorder;
   private final ChannelLogger channelLogger;
+  private final boolean reconnectDisabled;
+
+  private final List<ClientTransportFilter> transportFilters;
 
   /**
    * All field must be mutated in the syncContext.
@@ -153,12 +164,21 @@ protected void handleNotInUse() {
 
   private Status shutdownReason;
 
-  InternalSubchannel(List<EquivalentAddressGroup> addressGroups, 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) {
+  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");
@@ -173,12 +193,17 @@ protected void handleNotInUse() {
     this.scheduledExecutor = scheduledExecutor;
     this.connectingTimer = stopwatchSupplier.get();
     this.syncContext = syncContext;
+    this.metricRecorder = metricRecorder;
     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);
   }
 
   ChannelLogger getChannelLogger() {
@@ -243,6 +268,7 @@ private void startNewTransport() {
           .setAuthority(eagChannelAuthority != null ? eagChannelAuthority : authority)
           .setEagAttributes(currentEagAttributes)
           .setUserAgent(userAgent)
+          .setMetricRecorder(metricRecorder)
           .setHttpConnectProxiedSocketAddress(proxiedAddr);
     TransportLogger transportLogger = new TransportLogger();
     // In case the transport logs in the constructor, use the subchannel logId
@@ -255,7 +281,7 @@ private void startNewTransport() {
     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) {
       syncContext.executeLater(runnable);
     }
@@ -281,6 +307,11 @@ public void run() {
     }
 
     gotoState(ConnectivityStateInfo.forTransientFailure(status));
+
+    if (reconnectDisabled) {
+      return;
+    }
+
     if (reconnectPolicy == null) {
       reconnectPolicy = backoffPolicyProvider.get();
     }
@@ -299,7 +330,7 @@ public void run() {
   }
 
   /**
-   * Immediately attempt to reconnect if the current state is TRANSIENT_FAILURE. Otherwise this
+   * Immediately attempt to reconnect if the current state is TRANSIENT_FAILURE. Otherwise, this
    * method has no effect.
    */
   void resetConnectBackoff() {
@@ -328,8 +359,12 @@ private void gotoState(final ConnectivityStateInfo newState) {
 
     if (state.getState() != newState.getState()) {
       Preconditions.checkState(state.getState() != SHUTDOWN,
-          "Cannot transition out of SHUTDOWN to " + newState);
-      state = 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);
     }
   }
@@ -339,12 +374,12 @@ 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() {
-        List<EquivalentAddressGroup> newImmutableAddressGroups =
-            Collections.unmodifiableList(new ArrayList<>(newAddressGroups));
         ManagedClientTransport savedTransport = null;
         SocketAddress previousAddress = addressIndex.getCurrentAddress();
         addressIndex.updateGroups(newImmutableAddressGroups);
@@ -519,6 +554,13 @@ public void run() {
     return channelStatsFuture;
   }
 
+  /**
+   * Return attributes for server address connected by sub channel.
+   */
+  public Attributes getConnectedAddressAttributes() {
+    return connectedAddressAttributes;
+  }
+
   ConnectivityState getState() {
     return state.getState();
   }
@@ -532,12 +574,19 @@ private static void checkListHasNoNulls(List<?> list, String 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 Attributes filterTransport(Attributes attributes) {
+      for (ClientTransportFilter filter : transportFilters) {
+        attributes = Preconditions.checkNotNull(filter.transportReady(attributes),
+            "Filter %s returned null", filter);
+      }
+      return attributes;
     }
 
     @Override
@@ -555,7 +604,15 @@ public void run() {
           } else if (pendingTransport == transport) {
             activeTransport = transport;
             pendingTransport = null;
+            connectedAddressAttributes = addressIndex.getCurrentEagAttributes();
             gotoNonErrorState(READY);
+            subchannelMetrics.recordConnectionAttemptSucceeded(/* target= */ target,
+                /* backendService= */ getBackendServiceOrDefault(
+                    addressIndex.getCurrentEagAttributes()),
+                /* locality= */ getAttributeOrDefault(addressIndex.getCurrentEagAttributes(),
+                    EquivalentAddressGroup.ATTR_LOCALITY_NAME),
+                /* securityLevel= */ extractSecurityLevel(addressIndex.getCurrentEagAttributes()
+                    .get(GrpcAttributes.ATTR_SECURITY_LEVEL)));
           }
         }
       });
@@ -567,7 +624,7 @@ public void transportInUse(boolean inUse) {
     }
 
     @Override
-    public void transportShutdown(final Status s) {
+    public void transportShutdown(final Status s, final DisconnectError disconnectError) {
       channelLogger.log(
           ChannelLogLevel.INFO, "{0} SHUTDOWN with {1}", transport.getLogId(), printShortStatus(s));
       shutdownInitiated = true;
@@ -581,11 +638,24 @@ public void run() {
             activeTransport = null;
             addressIndex.reset();
             gotoNonErrorState(IDLE);
+            subchannelMetrics.recordDisconnection(/* target= */ target,
+                /* backendService= */ getBackendServiceOrDefault(
+                    addressIndex.getCurrentEagAttributes()),
+                /* 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= */ getBackendServiceOrDefault(
+                    addressIndex.getCurrentEagAttributes()),
+                /* locality= */ getAttributeOrDefault(addressIndex.getCurrentEagAttributes(),
+                    EquivalentAddressGroup.ATTR_LOCALITY_NAME));
             Preconditions.checkState(state.getState() == CONNECTING,
                 "Expected state is CONNECTING, actual state is %s", state.getState());
             addressIndex.increment();
-            // Continue reconnect if there are still addresses to try.
+            // Continue to reconnect if there are still addresses to try.
             if (!addressIndex.isValid()) {
               pendingTransport = null;
               addressIndex.reset();
@@ -608,6 +678,9 @@ public void transportTerminated() {
       channelLogger.log(ChannelLogLevel.INFO, "{0} Terminated", transport.getLogId());
       channelz.removeClientSocket(transport);
       handleTransportInUseState(transport, false);
+      for (ClientTransportFilter filter : transportFilters) {
+        filter.transportTerminated(transport.getAttributes());
+      }
       syncContext.execute(new Runnable() {
         @Override
         public void run() {
@@ -618,6 +691,35 @@ public void run() {
         }
       });
     }
+
+    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);
+      }
+    }
+
+    private String getAttributeOrDefault(Attributes attributes, Attributes.Key<String> key) {
+      String value = attributes.get(key);
+      return value == null ? "" : value;
+    }
+
+    private String getBackendServiceOrDefault(Attributes attributes) {
+      String value = attributes.get(InternalEquivalentAddressGroup.ATTR_BACKEND_SERVICE);
+      if (value == null) {
+        value = attributes.get(NameResolver.ATTR_BACKEND_SERVICE);
+      }
+      return value == null ? "" : value;
+    }
   }
 
   // All methods are called in syncContext
@@ -667,8 +769,9 @@ protected ConnectionClientTransport delegate() {
 
     @Override
     public ClientStream newStream(
-        MethodDescriptor<?, ?> method, Metadata headers, CallOptions callOptions) {
-      final ClientStream streamDelegate = super.newStream(method, headers, callOptions);
+        MethodDescriptor<?, ?> method, Metadata headers, CallOptions callOptions,
+        ClientStreamTracer[] tracers) {
+      final ClientStream streamDelegate = super.newStream(method, headers, callOptions, tracers);
       return new ForwardingClientStream() {
         @Override
         protected ClientStream delegate() {
@@ -684,12 +787,6 @@ protected ClientStreamListener delegate() {
               return listener;
             }
 
-            @Override
-            public void closed(Status status, Metadata trailers) {
-              callTracer.reportCallEnded(status.isOk());
-              super.closed(status, trailers);
-            }
-
             @Override
             public void closed(
                 Status status, RpcProgress rpcProgress, Metadata trailers) {
@@ -776,6 +873,9 @@ private String printShortStatus(Status status) {
     if (status.getDescription() != null) {
       buffer.append("(").append(status.getDescription()).append(")");
     }
+    if (status.getCause() != null) {
+      buffer.append("[").append(status.getCause()).append("]");
+    }
     return buffer.toString();
   }
 
diff --git a/core/src/main/java/io/grpc/internal/JndiResourceResolverFactory.java b/core/src/main/java/io/grpc/internal/JndiResourceResolverFactory.java
index a13c9fe4665..d9eca2be800 100644
--- a/core/src/main/java/io/grpc/internal/JndiResourceResolverFactory.java
+++ b/core/src/main/java/io/grpc/internal/JndiResourceResolverFactory.java
@@ -43,6 +43,7 @@
 final class JndiResourceResolverFactory implements DnsNameResolver.ResourceResolverFactory {
 
   @Nullable
+  @SuppressWarnings("StaticAssignmentOfThrowable")
   private static final Throwable JNDI_UNAVAILABILITY_CAUSE = initJndi();
 
   // @UsedReflectively
@@ -140,7 +141,7 @@ public List<SrvRecord> resolveSrv(String host) throws Exception {
       Level level = Level.WARNING;
       for (String rawSrv : rawSrvRecords) {
         try {
-          String[] parts = whitespace.split(rawSrv);
+          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(".")) {
@@ -194,8 +195,7 @@ static String unquote(String txtRecord) {
 
   @VisibleForTesting
   @IgnoreJRERequirement
-  // Hashtable is required. https://github.com/google/error-prone/issues/1766
-  @SuppressWarnings("JdkObsolete")
+  @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.
diff --git a/core/src/main/java/io/grpc/internal/JsonParser.java b/core/src/main/java/io/grpc/internal/JsonParser.java
index 384d29754f0..14f78c09e72 100644
--- a/core/src/main/java/io/grpc/internal/JsonParser.java
+++ b/core/src/main/java/io/grpc/internal/JsonParser.java
@@ -16,6 +16,7 @@
 
 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;
@@ -41,7 +42,8 @@ private JsonParser() {}
 
   /**
    * Parses a json string, returning either a {@code Map<String, ?>}, {@code List<?>},
-   * {@code String}, {@code Double}, {@code Boolean}, or {@code null}.
+   * {@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));
@@ -81,6 +83,7 @@ private static Object parseRecursive(JsonReader jr) throws IOException {
     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);
     }
@@ -105,4 +108,4 @@ 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
index d80b4ed44c4..6c9274702b6 100644
--- a/core/src/main/java/io/grpc/internal/JsonUtil.java
+++ b/core/src/main/java/io/grpc/internal/JsonUtil.java
@@ -20,6 +20,7 @@
 
 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;
@@ -96,57 +97,119 @@ public static List<String> getListOfStrings(Map<String, ?> obj, String key) {
 
   /**
    * Gets a number from an object for the given key.  If the key is not present, this returns null.
-   * If the value is not a Double, throws an exception.
+   * If the value does not represent a double, throws an exception.
    */
   @Nullable
-  public static Double getNumber(Map<String, ?> obj, String key) {
+  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)) {
-      throw new ClassCastException(
-          String.format("value '%s' for key '%s' in '%s' is not Double", value, key, obj));
+    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));
+      }
     }
-    return (Double) value;
+    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 is not a Double or loses precision when cast to an
-   * integer, throws an exception.
+   * 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) {
-    Double d = getNumber(obj, key);
-    if (d == null) {
+    assert key != null;
+    if (!obj.containsKey(key)) {
       return null;
     }
-    int i = d.intValue();
-    if (i != d) {
-      throw new ClassCastException("Number expected to be integer: " + d);
+    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));
+      }
     }
-    return i;
+    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 is not a Double or loses precision when cast to an
-   * long, throws an exception.
+   * 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) {
-    Double d = getNumber(obj, key);
-    if (d == null) {
+    assert key != null;
+    if (!obj.containsKey(key)) {
       return null;
     }
-    long l = d.longValue();
-    if (l != d) {
-      throw new ClassCastException("Number expected to be long: " + d);
+    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));
+      }
     }
-    return l;
+    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.
@@ -209,7 +272,8 @@ public static Boolean getBoolean(Map<String, ?> obj, String key) {
     for (int i = 0; i < rawList.size(); i++) {
       if (!(rawList.get(i) instanceof Map)) {
         throw new ClassCastException(
-            String.format("value %s for idx %d in %s is not object", rawList.get(i), i, rawList));
+            String.format(
+                Locale.US, "value %s for idx %d in %s is not object", rawList.get(i), i, rawList));
       }
     }
     return (List<Map<String, ?>>) rawList;
@@ -225,6 +289,7 @@ public static List<String> checkStringList(List<?> rawList) {
       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));
       }
     }
@@ -291,23 +356,24 @@ private static int parseNanos(String value) throws ParseException {
     return result;
   }
 
-  private static final long NANOS_PER_SECOND = TimeUnit.SECONDS.toNanos(1);
+  private static final int NANOS_PER_SECOND = 1_000_000_000;
 
   /**
    * Copy of {@link com.google.protobuf.util.Durations#normalizedDuration}.
    */
-  @SuppressWarnings("NarrowingCompoundAssignment")
+  // 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 since nanos is negative (and we're adding)
+      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 since nanos is positive (and we're subtracting)
+      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)) {
diff --git a/netty/src/main/java/io/grpc/netty/KeepAliveEnforcer.java b/core/src/main/java/io/grpc/internal/KeepAliveEnforcer.java
similarity index 93%
rename from netty/src/main/java/io/grpc/netty/KeepAliveEnforcer.java
rename to core/src/main/java/io/grpc/internal/KeepAliveEnforcer.java
index 6470e440327..6480336470c 100644
--- a/netty/src/main/java/io/grpc/netty/KeepAliveEnforcer.java
+++ b/core/src/main/java/io/grpc/internal/KeepAliveEnforcer.java
@@ -14,19 +14,19 @@
  * limitations under the License.
  */
 
-package io.grpc.netty;
+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;
-import javax.annotation.CheckReturnValue;
 
 /** Monitors the client's PING usage to make sure the rate is permitted. */
-class KeepAliveEnforcer {
+public final class KeepAliveEnforcer {
   @VisibleForTesting
-  static final int MAX_PING_STRIKES = 2;
+  public static final int MAX_PING_STRIKES = 2;
   @VisibleForTesting
-  static final long IMPLICIT_PERMIT_TIME_NANOS = TimeUnit.HOURS.toNanos(2);
+  public static final long IMPLICIT_PERMIT_TIME_NANOS = TimeUnit.HOURS.toNanos(2);
 
   private final boolean permitWithoutCalls;
   private final long minTimeNanos;
diff --git a/core/src/main/java/io/grpc/internal/KeepAliveManager.java b/core/src/main/java/io/grpc/internal/KeepAliveManager.java
index 28e2a87276b..535b3a82524 100644
--- a/core/src/main/java/io/grpc/internal/KeepAliveManager.java
+++ b/core/src/main/java/io/grpc/internal/KeepAliveManager.java
@@ -22,11 +22,12 @@
 import com.google.common.annotations.VisibleForTesting;
 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.GuardedBy;
+import javax.annotation.concurrent.ThreadSafe;
 
 /**
  * Manages keepalive pings.
@@ -262,9 +263,25 @@ public interface KeepAlivePinger {
    * Default client side {@link KeepAlivePinger}.
    */
   public static final class ClientKeepAlivePinger implements KeepAlivePinger {
-    private final ConnectionClientTransport transport;
 
-    public ClientKeepAlivePinger(ConnectionClientTransport transport) {
+
+    /**
+     * 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);
+    }
+
+    private final TransportWithDisconnectReason transport;
+
+    public ClientKeepAlivePinger(TransportWithDisconnectReason transport) {
       this.transport = transport;
     }
 
@@ -275,9 +292,10 @@ public void ping() {
         public void onSuccess(long roundTripTimeNanos) {}
 
         @Override
-        public void onFailure(Throwable cause) {
+        public void onFailure(Status cause) {
           transport.shutdownNow(Status.UNAVAILABLE.withDescription(
-              "Keepalive failed. The connection is likely gone"));
+                  "Keepalive failed. The connection is likely gone"),
+              SimpleDisconnectError.CONNECTION_TIMED_OUT);
         }
       }, MoreExecutors.directExecutor());
     }
@@ -285,7 +303,8 @@ public void onFailure(Throwable cause) {
     @Override
     public void onPingTimeout() {
       transport.shutdownNow(Status.UNAVAILABLE.withDescription(
-          "Keepalive failed. The connection is likely gone"));
+              "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 546e72911ca..f4c6f2fc8ef 100644
--- a/core/src/main/java/io/grpc/internal/LogExceptionRunnable.java
+++ b/core/src/main/java/io/grpc/internal/LogExceptionRunnable.java
@@ -19,7 +19,6 @@
 import static com.google.common.base.Preconditions.checkNotNull;
 
 import com.google.common.base.Throwables;
-
 import java.util.logging.Level;
 import java.util.logging.Logger;
 
diff --git a/core/src/main/java/io/grpc/internal/ManagedChannelImpl.java b/core/src/main/java/io/grpc/internal/ManagedChannelImpl.java
index 0ab8d49b68e..e423220e3ad 100644
--- a/core/src/main/java/io/grpc/internal/ManagedChannelImpl.java
+++ b/core/src/main/java/io/grpc/internal/ManagedChannelImpl.java
@@ -19,6 +19,8 @@
 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;
@@ -30,6 +32,7 @@
 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.concurrent.GuardedBy;
 import io.grpc.Attributes;
 import io.grpc.CallCredentials;
 import io.grpc.CallOptions;
@@ -41,13 +44,15 @@
 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.ForwardingChannelBuilder;
+import io.grpc.ForwardingChannelBuilder2;
 import io.grpc.ForwardingClientCall;
 import io.grpc.Grpc;
 import io.grpc.InternalChannelz;
@@ -64,19 +69,23 @@
 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.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.StatusOr;
 import io.grpc.SynchronizationContext;
 import io.grpc.SynchronizationContext.ScheduledHandle;
-import io.grpc.internal.AutoConfiguredLoadBalancerFactory.AutoConfiguredLoadBalancer;
 import io.grpc.internal.ClientCallImpl.ClientStreamProvider;
 import io.grpc.internal.ClientTransportFactory.SwapChannelCredentialsResult;
 import io.grpc.internal.ManagedChannelImplBuilder.ClientTransportFactoryBuilder;
@@ -108,22 +117,15 @@
 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
 final class ManagedChannelImpl extends ManagedChannel implements
     InternalInstrumented<ChannelStats> {
-  static final Logger logger = 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 | "+" | "-" | "." )
   @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;
 
@@ -150,24 +152,25 @@ 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;
   @Nullable
   private final String authorityOverride;
   private final NameResolverRegistry nameResolverRegistry;
-  private final NameResolver.Factory nameResolverFactory;
+  private final UriWrapper targetUri;
+  private final NameResolverProvider nameResolverProvider;
   private final NameResolver.Args nameResolverArgs;
-  private final AutoConfiguredLoadBalancerFactory loadBalancerFactory;
+  private final LoadBalancerProvider loadBalancerFactory;
   private final ClientTransportFactory originalTransportFactory;
   @Nullable
   private final ChannelCredentials originalChannelCreds;
   private final ClientTransportFactory transportFactory;
-  private final ClientTransportFactory oobTransportFactory;
   private final RestrictedScheduledExecutor scheduledExecutor;
   private final Executor executor;
   private final ObjectPool<? extends Executor> executorPool;
-  private final ObjectPool<? extends Executor> balancerRpcExecutorPool;
   private final ExecutorHolder balancerRpcExecutorHolder;
   private final ExecutorHolder offloadExecutorHolder;
   private final TimeProvider timeProvider;
@@ -182,7 +185,12 @@ public void uncaughtException(Thread t, Throwable e) {
               Level.SEVERE,
               "[" + getLogId() + "] Uncaught exception in the SynchronizationContext. Panic!",
               e);
-          panic(e);
+          try {
+            panic(e);
+          } catch (Throwable anotherT) {
+            logger.log(
+                Level.SEVERE, "[" + getLogId() + "] Uncaught exception while panicking", anotherT);
+          }
         }
       });
 
@@ -192,7 +200,7 @@ public void uncaughtException(Thread t, Throwable e) {
   private final CompressorRegistry compressorRegistry;
 
   private final Supplier<Stopwatch> stopwatchSupplier;
-  /** The timout before entering idle mode. */
+  /** The timeout before entering idle mode. */
   private final long idleTimeoutMillis;
 
   private final ConnectivityStateManager channelStateManager = new ConnectivityStateManager();
@@ -204,6 +212,8 @@ public void uncaughtException(Thread t, Throwable e) {
    * {@link RealChannel}.
    */
   private final Channel interceptorChannel;
+
+  private final List<ClientTransportFilter> transportFilters;
   @Nullable private final String userAgent;
 
   // Only null after channel is terminated. Must be assigned from the syncContext.
@@ -216,11 +226,6 @@ public void uncaughtException(Thread t, Throwable e) {
   @Nullable
   private LbHelperImpl lbHelper;
 
-  // Must ONLY be assigned from updateSubchannelPicker(), which is called from syncContext.
-  // null if channel is in idle mode.
-  @Nullable
-  private volatile SubchannelPicker subchannelPicker;
-
   // Must be accessed from the syncContext
   private boolean panicMode;
 
@@ -234,9 +239,6 @@ public void uncaughtException(Thread t, Throwable e) {
   private Collection<RealChannel.PendingCall<?, ?>> pendingCalls;
   private final Object pendingCallsInUseObject = new Object();
 
-  // Must be mutated from syncContext
-  private final Set<OobChannel> oobChannels = new HashSet<>(1, .75f);
-
   // reprocess() must be run from syncContext
   private final DelayedClientTransport delayedTransport;
   private final UncommittedRetriableStreamsRegistry uncommittedRetriableStreamsRegistry
@@ -247,8 +249,7 @@ public void uncaughtException(Thread t, Throwable e) {
   // Channel's shutdown process:
   // 1. shutdown(): stop accepting new calls from applications
   //   1a shutdown <- true
-  //   1b subchannelPicker <- null
-  //   1c delayedTransport.shutdown()
+  //   1b delayedTransport.shutdown()
   // 2. delayedTransport terminated: stop stream-creation functionality
   //   2a terminating <- true
   //   2b loadBalancer.shutdown()
@@ -295,6 +296,8 @@ public void uncaughtException(Thread t, Throwable e) {
   // 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();
@@ -305,9 +308,6 @@ private void maybeShutdownNowSubchannels() {
       for (InternalSubchannel subchannel : subchannels) {
         subchannel.shutdownNow(SHUTDOWN_NOW_STATUS);
       }
-      for (OobChannel oobChannel : oobChannels) {
-        oobChannel.getInternalSubchannel().shutdownNow(SHUTDOWN_NOW_STATUS);
-      }
     }
   }
 
@@ -327,7 +327,6 @@ public void run() {
         builder.setTarget(target).setState(channelStateManager.getState());
         List<InternalWithLogId> children = new ArrayList<>();
         children.addAll(subchannels);
-        children.addAll(oobChannels);
         builder.setSubchannels(children);
         ret.set(builder.build());
       }
@@ -348,6 +347,12 @@ private class IdleModeTimer implements Runnable {
 
     @Override
     public void run() {
+      // 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;
+      }
       enterIdleMode();
     }
   }
@@ -360,12 +365,11 @@ private void shutdownNameResolverAndLoadBalancer(boolean channelIsActive) {
       checkState(lbHelper != null, "lbHelper is null");
     }
     if (nameResolver != null) {
-      cancelNameResolverBackoff();
       nameResolver.shutdown();
       nameResolverStarted = false;
       if (channelIsActive) {
         nameResolver = getNameResolver(
-            target, authorityOverride, nameResolverFactory, nameResolverArgs);
+            targetUri, authorityOverride, nameResolverProvider, nameResolverArgs);
       } else {
         nameResolver = null;
       }
@@ -374,7 +378,6 @@ private void shutdownNameResolverAndLoadBalancer(boolean channelIsActive) {
       lbHelper.lb.shutdown();
       lbHelper = null;
     }
-    subchannelPicker = null;
   }
 
   /**
@@ -404,9 +407,10 @@ void exitIdleMode() {
     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 will enter panic mode.
+    // 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;
@@ -422,7 +426,10 @@ private void enterIdleMode() {
     delayedTransport.reprocess(null);
     channelLogger.log(ChannelLogLevel.INFO, "Entering IDLE state");
     channelStateManager.gotoState(IDLE);
-    if (inUseStateAggregator.isInUse()) {
+    // 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();
     }
   }
@@ -440,42 +447,10 @@ private void rescheduleIdleTimer() {
     idleTimer.reschedule(idleTimeoutMillis, TimeUnit.MILLISECONDS);
   }
 
-  // Run from syncContext
-  @VisibleForTesting
-  class DelayedNameResolverRefresh implements Runnable {
-    @Override
-    public void run() {
-      scheduledNameResolverRefresh = null;
-      refreshNameResolution();
-    }
-  }
-
-  // Must be used from syncContext
-  @Nullable private ScheduledHandle scheduledNameResolverRefresh;
-  // The policy to control backoff between name resolution attempts. Non-null when an attempt is
-  // scheduled. Must be used from syncContext
-  @Nullable private BackoffPolicy nameResolverBackoffPolicy;
-
-  // Must be run from syncContext
-  private void cancelNameResolverBackoff() {
-    syncContext.throwIfNotInThisSynchronizationContext();
-    if (scheduledNameResolverRefresh != null) {
-      scheduledNameResolverRefresh.cancel();
-      scheduledNameResolverRefresh = null;
-      nameResolverBackoffPolicy = null;
-    }
-  }
-
   /**
-   * Force name resolution refresh to happen immediately and reset refresh back-off. Must be run
+   * Force name resolution refresh to happen immediately. Must be run
    * from syncContext.
    */
-  private void refreshAndResetNameResolution() {
-    syncContext.throwIfNotInThisSynchronizationContext();
-    cancelNameResolverBackoff();
-    refreshNameResolution();
-  }
-
   private void refreshNameResolution() {
     syncContext.throwIfNotInThisSynchronizationContext();
     if (nameResolverStarted) {
@@ -484,42 +459,7 @@ private void refreshNameResolution() {
   }
 
   private final class ChannelStreamProvider implements ClientStreamProvider {
-    private ClientTransport getTransport(PickSubchannelArgs args) {
-      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) {
-        final class ExitIdleModeForTransport implements Runnable {
-          @Override
-          public void run() {
-            exitIdleMode();
-          }
-        }
-
-        syncContext.execute(new ExitIdleModeForTransport());
-        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(args);
-      ClientTransport transport = GrpcUtil.getTransportFromPickResult(
-          pickResult, args.getCallOptions().isWaitForReady());
-      if (transport != null) {
-        return transport;
-      }
-      return delayedTransport;
-    }
+    volatile Throttle throttle;
 
     @Override
     public ClientStream newStream(
@@ -527,17 +467,19 @@ public ClientStream newStream(
         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) {
-        ClientTransport transport =
-            getTransport(new PickSubchannelArgsImpl(method, headers, callOptions));
+        ClientStreamTracer[] tracers = GrpcUtil.getClientStreamTracers(
+            callOptions, headers, 0, /* isTransparentRetry= */ false,
+            /* isHedging= */false);
         Context origContext = context.attach();
         try {
-          return transport.newStream(method, headers, callOptions);
+          return delayedTransport.newStream(method, headers, callOptions, tracers);
         } finally {
           context.detach(origContext);
         }
       } else {
-        final Throttle throttle = lastServiceConfig.getRetryThrottling();
         MethodInfo methodInfo = callOptions.getOption(MethodInfo.KEY);
         final RetryPolicy retryPolicy = methodInfo == null ? null : methodInfo.retryPolicy;
         final HedgingPolicy hedgingPolicy = methodInfo == null ? null : methodInfo.hedgingPolicy;
@@ -568,13 +510,15 @@ void postCommit() {
           }
 
           @Override
-          ClientStream newSubstream(ClientStreamTracer.Factory tracerFactory, Metadata newHeaders) {
-            CallOptions newOptions = callOptions.withStreamTracerFactory(tracerFactory);
-            ClientTransport transport =
-                getTransport(new PickSubchannelArgsImpl(method, newHeaders, newOptions));
+          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 transport.newStream(method, newHeaders, newOptions);
+              return delayedTransport.newStream(method, newHeaders, newOptions, tracers);
             } finally {
               context.detach(origContext);
             }
@@ -586,13 +530,16 @@ ClientStream newSubstream(ClientStreamTracer.Factory tracerFactory, Metadata new
     }
   }
 
-  private final ClientStreamProvider transportProvider = new ChannelStreamProvider();
+  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,
@@ -605,10 +552,10 @@ ClientStream newSubstream(ClientStreamTracer.Factory tracerFactory, Metadata new
     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.executor);
-    this.oobTransportFactory = new CallCredentialsApplyingTransportFactory(
-        clientTransportFactory, null, this.executor);
+        clientTransportFactory, builder.callCredentials, this.offloadExecutorHolder);
     this.scheduledExecutor =
         new RestrictedScheduledExecutor(transportFactory.getScheduledExecutorService());
     maxTraceEvents = builder.maxTraceEvents;
@@ -618,41 +565,37 @@ ClientStream newSubstream(ClientStreamTracer.Factory tracerFactory, Metadata new
     channelLogger = new ChannelLoggerImpl(channelTracer, timeProvider);
     ProxyDetector proxyDetector =
         builder.proxyDetector != null ? builder.proxyDetector : GrpcUtil.DEFAULT_PROXY_DETECTOR;
-    this.retryEnabled = builder.retryEnabled && !builder.temporarilyDisableRetry;
+    this.retryEnabled = builder.retryEnabled;
     this.loadBalancerFactory = new AutoConfiguredLoadBalancerFactory(builder.defaultLbPolicy);
-    this.offloadExecutorHolder =
-        new ExecutorHolder(
-            checkNotNull(builder.offloadExecutorPool, "offloadExecutorPool"));
     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.nameResolverArgs =
-        NameResolver.Args.newBuilder()
+    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(
-                // Avoid creating the offloadExecutor until it is first used
-                new Executor() {
-                  @Override
-                  public void execute(Runnable command) {
-                    offloadExecutorHolder.getExecutor().execute(command);
-                  }
-                })
-            .build();
-    this.authorityOverride = builder.authorityOverride;
-    this.nameResolverFactory = builder.nameResolverFactory;
+            .setOffloadExecutor(this.offloadExecutorHolder)
+            .setOverrideAuthority(this.authorityOverride)
+            .setMetricRecorder(this.metricRecorder)
+            .setNameResolverRegistry(builder.nameResolverRegistry);
+    builder.copyAllNameResolverCustomArgsTo(nameResolverArgsBuilder);
+    this.nameResolverArgs = nameResolverArgsBuilder.build();
     this.nameResolver = getNameResolver(
-        target, authorityOverride, nameResolverFactory, nameResolverArgs);
-    this.balancerRpcExecutorPool = checkNotNull(balancerRpcExecutorPool, "balancerRpcExecutorPool");
-    this.balancerRpcExecutorHolder = new ExecutorHolder(balancerRpcExecutorPool);
+        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;
@@ -666,7 +609,7 @@ public void execute(Runnable command) {
           parsedDefaultServiceConfig.getError());
       this.defaultServiceConfig =
           (ManagedChannelServiceConfig) parsedDefaultServiceConfig.getConfig();
-      this.lastServiceConfig = this.defaultServiceConfig;
+      this.transportProvider.throttle = this.defaultServiceConfig.getRetryThrottling();
     } else {
       this.defaultServiceConfig = null;
     }
@@ -677,6 +620,7 @@ public void execute(Runnable command) {
       channel = builder.binlog.wrapChannel(channel);
     }
     this.interceptorChannel = ClientInterceptors.intercept(channel, interceptors);
+    this.transportFilters = new ArrayList<>(builder.transportFilters);
     this.stopwatchSupplier = checkNotNull(stopwatchSupplier, "stopwatchSupplier");
     if (builder.idleTimeoutMillis == IDLE_TIMEOUT_MILLIS_DISABLE) {
       this.idleTimeoutMillis = builder.idleTimeoutMillis;
@@ -721,59 +665,25 @@ public CallTracer create() {
     }
   }
 
-  private static NameResolver getNameResolver(
-      String target, NameResolver.Factory nameResolverFactory, NameResolver.Args nameResolverArgs) {
-    // 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, nameResolverArgs);
-      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, nameResolverArgs);
-      if (resolver != null) {
-        return resolver;
-      }
-    }
-    throw new IllegalArgumentException(String.format(
-        "cannot find a NameResolver for %s%s",
-        target, uriSyntaxErrors.length() > 0 ? " (" + uriSyntaxErrors + ")" : ""));
-  }
-
   @VisibleForTesting
   static NameResolver getNameResolver(
-      String target, @Nullable final String overrideAuthority,
-      NameResolver.Factory nameResolverFactory, NameResolver.Args nameResolverArgs) {
-    NameResolver resolver = getNameResolver(target, nameResolverFactory, nameResolverArgs);
+      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);
+    }
+
+    // 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 resolver;
+      return usedNameResolver;
     }
-    return new ForwardingNameResolver(resolver) {
+
+    return new ForwardingNameResolver(usedNameResolver) {
       @Override
       public String getServiceAuthority() {
         return overrideAuthority;
@@ -785,6 +695,11 @@ public String getServiceAuthority() {
   InternalConfigSelector getConfigSelector() {
     return realChannel.configSelector.get();
   }
+  
+  @VisibleForTesting
+  boolean hasThrottle() {
+    return this.transportProvider.throttle != null;
+  }
 
   /**
    * Initiates an orderly shutdown in which preexisting calls continue but new calls are immediately
@@ -850,29 +765,16 @@ void panic(final Throwable t) {
       return;
     }
     panicMode = true;
-    cancelIdleTimer(/* permanent= */ true);
-    shutdownNameResolverAndLoadBalancer(false);
-    final class PanicSubchannelPicker extends SubchannelPicker {
-      private final PickResult panicPickResult =
-          PickResult.withDrop(
-              Status.INTERNAL.withDescription("Panic! This is a bug!").withCause(t));
-
-      @Override
-      public PickResult pickSubchannel(PickSubchannelArgs args) {
-        return panicPickResult;
-      }
-
-      @Override
-      public String toString() {
-        return MoreObjects.toStringHelper(PanicSubchannelPicker.class)
-            .add("panicPickResult", panicPickResult)
-            .toString();
-      }
+    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);
     }
-
-    updateSubchannelPicker(new PanicSubchannelPicker());
-    channelLogger.log(ChannelLogLevel.ERROR, "PANIC! Entering TRANSIENT_FAILURE");
-    channelStateManager.gotoState(TRANSIENT_FAILURE);
   }
 
   @VisibleForTesting
@@ -882,7 +784,6 @@ boolean isInPanicMode() {
 
   // Called from syncContext
   private void updateSubchannelPicker(SubchannelPicker newPicker) {
-    subchannelPicker = newPicker;
     delayedTransport.reprocess(newPicker);
   }
 
@@ -1027,7 +928,15 @@ void updateConfigSelector(@Nullable InternalConfigSelector config) {
     // Must run in SynchronizationContext.
     void onConfigError() {
       if (configSelector.get() == INITIAL_PENDING_SELECTOR) {
-        updateConfigSelector(null);
+        // 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);
+        }
       }
     }
 
@@ -1075,6 +984,7 @@ private final class PendingCall<ReqT, RespT> extends DelayedClientCall<ReqT, Res
       final Context context;
       final MethodDescriptor<ReqT, RespT> method;
       final CallOptions callOptions;
+      private final long callCreationTime;
 
       PendingCall(
           Context context, MethodDescriptor<ReqT, RespT> method, CallOptions callOptions) {
@@ -1082,26 +992,32 @@ private final class PendingCall<ReqT, RespT> extends DelayedClientCall<ReqT, Res
         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() {
-        getCallExecutor(callOptions).execute(
-            new Runnable() {
-              @Override
-              public void run() {
-                ClientCall<ReqT, RespT> realCall;
-                Context previous = context.attach();
-                try {
-                  realCall = newClientCall(method, callOptions);
-                } finally {
-                  context.detach(previous);
-                }
-                setCall(realCall);
-                syncContext.execute(new PendingCallRemoval());
-              }
+        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
@@ -1179,13 +1095,17 @@ protected ClientCall<ReqT, RespT> delegate() {
       return delegate;
     }
 
+    @SuppressWarnings("unchecked")
     @Override
     public void start(Listener<RespT> observer, Metadata headers) {
-      PickSubchannelArgs args = new PickSubchannelArgsImpl(method, headers, callOptions);
+      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, status);
+        executeCloseObserverInContext(observer,
+            GrpcUtil.replaceInappropriateControlPlaneStatus(status));
+        delegate = (ClientCall<ReqT, RespT>) NOOP_CALL;
         return;
       }
       ClientInterceptor interceptor = result.getInterceptor();
@@ -1226,6 +1146,29 @@ public void cancel(@Nullable String message, @Nullable Throwable cause) {
     }
   }
 
+  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;
+    }
+  };
+
   /**
    * Terminate the channel if termination conditions are met.
    */
@@ -1234,7 +1177,7 @@ private void maybeTerminateChannel() {
     if (terminated) {
       return;
     }
-    if (shutdown.get() && subchannels.isEmpty() && oobChannels.isEmpty()) {
+    if (shutdown.get() && subchannels.isEmpty()) {
       channelLogger.log(ChannelLogLevel.INFO, "Terminated");
       channelz.removeRootChannel(this);
       executorPool.returnObject(executor);
@@ -1248,15 +1191,7 @@ private void maybeTerminateChannel() {
     }
   }
 
-  // Must be called from syncContext
-  private void handleInternalSubchannelState(ConnectivityStateInfo newState) {
-    if (newState.getState() == TRANSIENT_FAILURE || newState.getState() == IDLE) {
-      refreshAndResetNameResolution();
-    }
-  }
-
   @Override
-  @SuppressWarnings("deprecation")
   public ConnectivityState getState(boolean requestConnection) {
     ConnectivityState savedChannelState = channelStateManager.getState();
     if (requestConnection && savedChannelState == IDLE) {
@@ -1264,9 +1199,6 @@ final class RequestConnection implements Runnable {
         @Override
         public void run() {
           exitIdleMode();
-          if (subchannelPicker != null) {
-            subchannelPicker.requestConnection();
-          }
           if (lbHelper != null) {
             lbHelper.lb.requestConnection();
           }
@@ -1298,16 +1230,12 @@ public void run() {
         if (shutdown.get()) {
           return;
         }
-        if (scheduledNameResolverRefresh != null && scheduledNameResolverRefresh.isPending()) {
-          checkState(nameResolverStarted, "name resolver must be started");
-          refreshAndResetNameResolution();
+        if (nameResolverStarted) {
+          refreshNameResolution();
         }
         for (InternalSubchannel subchannel : subchannels) {
           subchannel.resetConnectBackoff();
         }
-        for (OobChannel oobChannel : oobChannels) {
-          oobChannel.resetConnectBackoff();
-        }
       }
     }
 
@@ -1414,14 +1342,14 @@ void remove(RetriableStream<?> retriableStream) {
   }
 
   private final class LbHelperImpl extends LoadBalancer.Helper {
-    AutoConfiguredLoadBalancer lb;
+    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, this);
+      return new SubchannelImpl(args);
     }
 
     @Override
@@ -1430,24 +1358,18 @@ public void updateBalancingState(
       syncContext.throwIfNotInThisSynchronizationContext();
       checkNotNull(newState, "newState");
       checkNotNull(newPicker, "newPicker");
-      final class UpdateBalancingState implements Runnable {
-        @Override
-        public void run() {
-          if (LbHelperImpl.this != lbHelper) {
-            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);
-          }
-        }
-      }
 
-      syncContext.execute(new UpdateBalancingState());
+      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
@@ -1456,7 +1378,7 @@ public void refreshNameResolution() {
       final class LoadBalancerRefreshNameResolution implements Runnable {
         @Override
         public void run() {
-          refreshAndResetNameResolution();
+          ManagedChannelImpl.this.refreshNameResolution();
         }
       }
 
@@ -1465,81 +1387,34 @@ public void run() {
 
     @Override
     public ManagedChannel createOobChannel(EquivalentAddressGroup addressGroup, String authority) {
-      // TODO(ejona): can we be even stricter? Like terminating?
-      checkState(!terminated, "Channel is terminated");
-      long oobChannelCreationTime = timeProvider.currentTimeNanos();
-      InternalLogId oobLogId = InternalLogId.allocate("OobChannel", /*details=*/ null);
-      InternalLogId subchannelLogId =
-          InternalLogId.allocate("Subchannel-OOB", /*details=*/ authority);
-      ChannelTracer oobChannelTracer =
-          new ChannelTracer(
-              oobLogId, maxTraceEvents, oobChannelCreationTime,
-              "OobChannel for " + addressGroup);
-      final OobChannel oobChannel = new OobChannel(
-          authority, balancerRpcExecutorPool, oobTransportFactory.getScheduledExecutorService(),
-          syncContext, callTracerFactory.create(), oobChannelTracer, channelz, timeProvider);
-      channelTracer.reportEvent(new ChannelTrace.Event.Builder()
-          .setDescription("Child OobChannel created")
-          .setSeverity(ChannelTrace.Event.Severity.CT_INFO)
-          .setTimestampNanos(oobChannelCreationTime)
-          .setChannelRef(oobChannel)
-          .build());
-      ChannelTracer subchannelTracer =
-          new ChannelTracer(subchannelLogId, maxTraceEvents, oobChannelCreationTime,
-              "Subchannel for " + addressGroup);
-      ChannelLogger subchannelLogger = new ChannelLoggerImpl(subchannelTracer, timeProvider);
-      final class ManagedOobChannelCallback extends InternalSubchannel.Callback {
-        @Override
-        void onTerminated(InternalSubchannel is) {
-          oobChannels.remove(oobChannel);
-          channelz.removeSubchannel(is);
-          oobChannel.handleSubchannelTerminated();
-          maybeTerminateChannel();
-        }
-
-        @Override
-        void onStateChange(InternalSubchannel is, ConnectivityStateInfo newState) {
-          handleInternalSubchannelState(newState);
-          oobChannel.handleSubchannelStateChange(newState);
-        }
-      }
+      return createOobChannel(Collections.singletonList(addressGroup), authority);
+    }
 
-      final InternalSubchannel internalSubchannel = new InternalSubchannel(
-          Collections.singletonList(addressGroup),
-          authority, userAgent, backoffPolicyProvider, oobTransportFactory,
-          oobTransportFactory.getScheduledExecutorService(), stopwatchSupplier, syncContext,
-          // All callback methods are run from syncContext
-          new ManagedOobChannelCallback(),
-          channelz,
-          callTracerFactory.create(),
-          subchannelTracer,
-          subchannelLogId,
-          subchannelLogger);
-      oobChannelTracer.reportEvent(new ChannelTrace.Event.Builder()
-          .setDescription("Child Subchannel created")
-          .setSeverity(ChannelTrace.Event.Severity.CT_INFO)
-          .setTimestampNanos(oobChannelCreationTime)
-          .setSubchannelRef(internalSubchannel)
-          .build());
-      channelz.addSubchannel(oobChannel);
-      channelz.addSubchannel(internalSubchannel);
-      oobChannel.setSubchannel(internalSubchannel);
-      final class AddOobChannel implements 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(oobChannel);
-          }
-        }
+    @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);
       }
-
-      syncContext.execute(new AddOobChannel());
-      return oobChannel;
+      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
@@ -1551,15 +1426,21 @@ public ManagedChannelBuilder<?> createResolvingOobChannelBuilder(String target)
           .overrideAuthority(getAuthority());
     }
 
-    // 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.
     @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 ForwardingChannelBuilder<ResolvingOobChannelBuilder> {
+          extends ForwardingChannelBuilder2<ResolvingOobChannelBuilder> {
         final ManagedChannelBuilder<?> delegate;
 
         ResolvingOobChannelBuilder() {
@@ -1591,7 +1472,8 @@ public ClientTransportFactory buildClientTransportFactory() {
               channelCreds,
               callCredentials,
               transportFactoryBuilder,
-              new FixedPortProvider(nameResolverArgs.getDefaultPort()));
+              new FixedPortProvider(nameResolverArgs.getDefaultPort()))
+              .nameResolverRegistry(nameResolverRegistry);
         }
 
         @Override
@@ -1602,9 +1484,7 @@ protected ManagedChannelBuilder<?> delegate() {
 
       checkState(!terminated, "Channel is terminated");
 
-      @SuppressWarnings("deprecation")
-      ResolvingOobChannelBuilder builder = new ResolvingOobChannelBuilder()
-          .nameResolverFactory(nameResolverFactory);
+      ResolvingOobChannelBuilder builder = new ResolvingOobChannelBuilder();
 
       return builder
           // TODO(zdapeng): executors should not outlive the parent channel.
@@ -1625,6 +1505,12 @@ public ChannelCredentials getUnsafeChannelCredentials() {
 
     @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);
@@ -1635,6 +1521,11 @@ public String getAuthority() {
       return ManagedChannelImpl.this.authority();
     }
 
+    @Override
+    public String getChannelTarget() {
+      return targetUri.toString();
+    }
+
     @Override
     public SynchronizationContext getSynchronizationContext() {
       return syncContext;
@@ -1660,6 +1551,11 @@ 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.
      */
@@ -1673,7 +1569,20 @@ public ChannelCredentials withoutBearerTokens() {
     }
   }
 
-  private final class NameResolverListener extends NameResolver.Listener2 {
+  static final class OobChannel extends ForwardingManagedChannel {
+    private final OobNameResolverProvider resolverProvider;
+
+    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;
 
@@ -1684,135 +1593,145 @@ private final class NameResolverListener extends NameResolver.Listener2 {
 
     @Override
     public void onResult(final ResolutionResult resolutionResult) {
-      final class NamesResolved implements Runnable {
+      syncContext.execute(() -> onResult2(resolutionResult));
+    }
 
-        @SuppressWarnings("ReferenceEquality")
-        @Override
-        public void run() {
+    @SuppressWarnings("ReferenceEquality")
+    @Override
+    public Status onResult2(final ResolutionResult resolutionResult) {
+      syncContext.throwIfNotInThisSynchronizationContext();
+      if (ManagedChannelImpl.this.nameResolver != resolver) {
+        return Status.OK;
+      }
 
-          List<EquivalentAddressGroup> servers = resolutionResult.getAddresses();
+      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.DEBUG,
-              "Resolved address: {0}, config={1}",
-              servers,
-              resolutionResult.getAttributes());
-
-          if (lastResolutionState != ResolutionState.SUCCESS) {
-            channelLogger.log(ChannelLogLevel.INFO, "Address resolved: {0}", servers);
-            lastResolutionState = ResolutionState.SUCCESS;
-          }
-
-          nameResolverBackoffPolicy = null;
-          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) {
+              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.INFO,
-                  "Config selector from name resolver discarded by channel settings");
+                  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 {
-            // 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");
-                onError(configOrError.getError());
-                return;
-              } else {
-                effectiveServiceConfig = lastServiceConfig;
-              }
-            } else {
-              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;
-            }
-
-            try {
-              // TODO(creamsoup): when `servers` 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);
-            }
+            effectiveServiceConfig = lastServiceConfig;
           }
+        } else {
+          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();
+        }
 
-          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();
-            }
-
-            Status handleResult = helper.lb.tryHandleResolvedAddresses(
-                ResolvedAddresses.newBuilder()
-                    .setAddresses(servers)
-                    .setAttributes(attrBuilder.build())
-                    .setLoadBalancingPolicyConfig(effectiveServiceConfig.getLoadBalancingConfig())
-                    .build());
-
-            if (!handleResult.isOk()) {
-              handleErrorInSyncContext(handleResult.augmentDescription(resolver + " was used"));
-            }
-          }
+        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);
         }
       }
 
-      syncContext.execute(new NamesResolved());
+      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
@@ -1842,35 +1761,11 @@ private void handleErrorInSyncContext(Status error) {
       }
 
       helper.lb.handleNameResolutionError(error);
-
-      scheduleExponentialBackOffInSyncContext();
-    }
-
-    private void scheduleExponentialBackOffInSyncContext() {
-      if (scheduledNameResolverRefresh != null && scheduledNameResolverRefresh.isPending()) {
-        // The name resolver may invoke onError multiple times, but we only want to
-        // schedule one backoff attempt
-        // TODO(ericgribkoff) Update contract of NameResolver.Listener or decide if we
-        // want to reset the backoff interval upon repeated onError() calls
-        return;
-      }
-      if (nameResolverBackoffPolicy == null) {
-        nameResolverBackoffPolicy = backoffPolicyProvider.get();
-      }
-      long delayNanos = nameResolverBackoffPolicy.nextBackoffNanos();
-      channelLogger.log(
-          ChannelLogLevel.DEBUG,
-          "Scheduling DNS resolution backoff for {0} ns", delayNanos);
-      scheduledNameResolverRefresh =
-          syncContext.schedule(
-              new DelayedNameResolverRefresh(), delayNanos, TimeUnit.NANOSECONDS,
-              transportFactory .getScheduledExecutorService());
     }
   }
 
   private final class SubchannelImpl extends AbstractSubchannel {
     final CreateSubchannelArgs args;
-    final LbHelperImpl helper;
     final InternalLogId subchannelLogId;
     final ChannelLoggerImpl subchannelLogger;
     final ChannelTracer subchannelTracer;
@@ -1880,15 +1775,15 @@ private final class SubchannelImpl extends AbstractSubchannel {
     boolean shutdown;
     ScheduledHandle delayedShutdownTask;
 
-    SubchannelImpl(CreateSubchannelArgs args, LbHelperImpl helper) {
+    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 = checkNotNull(args, "args");
-      this.helper = checkNotNull(helper, "helper");
+      this.args = args;
       subchannelLogId = InternalLogId.allocate("Subchannel", /*details=*/ authority());
       subchannelTracer = new ChannelTracer(
           subchannelLogId, maxTraceEvents, timeProvider.currentTimeNanos(),
@@ -1914,7 +1809,6 @@ void onTerminated(InternalSubchannel is) {
 
         @Override
         void onStateChange(InternalSubchannel is, ConnectivityStateInfo newState) {
-          handleInternalSubchannelState(newState);
           checkState(listener != null, "listener is null");
           listener.onSubchannelState(newState);
         }
@@ -1931,7 +1825,7 @@ void onNotInUse(InternalSubchannel is) {
       }
 
       final InternalSubchannel internalSubchannel = new InternalSubchannel(
-          args.getAddresses(),
+          args,
           authority(),
           userAgent,
           backoffPolicyProvider,
@@ -1944,7 +1838,9 @@ void onNotInUse(InternalSubchannel is) {
           callTracerFactory.create(),
           subchannelTracer,
           subchannelLogId,
-          subchannelLogger);
+          subchannelLogger,
+          transportFilters, target,
+          lbHelper.getMetricRecorder());
 
       channelTracer.reportEvent(new ChannelTrace.Event.Builder()
           .setDescription("Child Subchannel started")
@@ -2016,6 +1912,9 @@ public void run() {
     public void requestConnection() {
       syncContext.throwIfNotInThisSynchronizationContext();
       checkState(started, "not started");
+      if (shutdown) {
+        return;
+      }
       subchannel.obtainActiveTransport();
     }
 
@@ -2067,6 +1966,11 @@ public void updateAddresses(List<EquivalentAddressGroup> addrs) {
       subchannel.updateAddresses(addrs);
     }
 
+    @Override
+    public Attributes getConnectedAddressAttributes() {
+      return subchannel.getConnectedAddressAttributes();
+    }
+
     private List<EquivalentAddressGroup> stripOverrideAuthorityAttributes(
         List<EquivalentAddressGroup> eags) {
       List<EquivalentAddressGroup> eagsWithoutOverrideAttr = new ArrayList<>();
@@ -2093,7 +1997,7 @@ public String toString() {
    */
   private final class DelayedTransportListener implements ManagedClientTransport.Listener {
     @Override
-    public void transportShutdown(Status s) {
+    public void transportShutdown(Status s, DisconnectError e) {
       checkState(shutdown.get(), "Channel must have been shut down");
     }
 
@@ -2102,9 +2006,20 @@ 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();
+      }
     }
 
     @Override
@@ -2140,8 +2055,10 @@ protected void handleNotInUse() {
 
   /**
    * Lazily request for Executor from an executor pool.
+   * Also act as an Executor directly to simply run a cmd
    */
-  private static final class ExecutorHolder {
+  @VisibleForTesting
+  static final class ExecutorHolder implements Executor {
     private final ObjectPool<? extends Executor> pool;
     private Executor executor;
 
@@ -2161,6 +2078,11 @@ synchronized void release() {
         executor = pool.returnObject(executor);
       }
     }
+
+    @Override
+    public void execute(Runnable command) {
+      getExecutor().execute(command);
+    }
   }
 
   private static final class RestrictedScheduledExecutor implements ScheduledExecutorService {
@@ -2219,7 +2141,7 @@ public <T> T invokeAny(Collection<? extends Callable<T>> tasks)
 
     @Override
     public <T> T invokeAny(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)
-      throws InterruptedException, ExecutionException, TimeoutException {
+        throws InterruptedException, ExecutionException, TimeoutException {
       return delegate.invokeAny(tasks, timeout, unit);
     }
 
@@ -2264,53 +2186,6 @@ public void execute(Runnable command) {
     }
   }
 
-  @VisibleForTesting
-  static final class ScParser extends NameResolver.ServiceConfigParser {
-
-    private final boolean retryEnabled;
-    private final int maxRetryAttemptsLimit;
-    private final int maxHedgedAttemptsLimit;
-    private final AutoConfiguredLoadBalancerFactory autoLoadBalancerFactory;
-
-    ScParser(
-        boolean retryEnabled,
-        int maxRetryAttemptsLimit,
-        int maxHedgedAttemptsLimit,
-        AutoConfiguredLoadBalancerFactory autoLoadBalancerFactory) {
-      this.retryEnabled = retryEnabled;
-      this.maxRetryAttemptsLimit = maxRetryAttemptsLimit;
-      this.maxHedgedAttemptsLimit = maxHedgedAttemptsLimit;
-      this.autoLoadBalancerFactory =
-          checkNotNull(autoLoadBalancerFactory, "autoLoadBalancerFactory");
-    }
-
-    @Override
-    public ConfigOrError parseServiceConfig(Map<String, ?> rawServiceConfig) {
-      try {
-        Object loadBalancingPolicySelection;
-        ConfigOrError choiceFromLoadBalancer =
-            autoLoadBalancerFactory.parseLoadBalancerPolicy(rawServiceConfig);
-        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) {
-        return ConfigOrError.fromError(
-            Status.UNKNOWN.withDescription("failed to parse service config").withCause(e));
-      }
-    }
-  }
-
   /**
    * A ResolutionState indicates the status of last name resolution.
    */
diff --git a/core/src/main/java/io/grpc/internal/ManagedChannelImplBuilder.java b/core/src/main/java/io/grpc/internal/ManagedChannelImplBuilder.java
index c74eed6df7f..128c929ec0e 100644
--- a/core/src/main/java/io/grpc/internal/ManagedChannelImplBuilder.java
+++ b/core/src/main/java/io/grpc/internal/ManagedChannelImplBuilder.java
@@ -17,24 +17,38 @@
 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.InternalFeatureFlags;
 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;
@@ -42,7 +56,9 @@
 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;
@@ -50,6 +66,7 @@
 import java.util.concurrent.TimeUnit;
 import java.util.logging.Level;
 import java.util.logging.Logger;
+import java.util.regex.Pattern;
 import javax.annotation.Nullable;
 
 /**
@@ -61,11 +78,13 @@ public final class ManagedChannelImplBuilder
 
   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");
@@ -100,21 +119,52 @@ public static ManagedChannelBuilder<?> forTarget(String target) {
   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<>();
-  final NameResolverRegistry nameResolverRegistry = NameResolverRegistry.getDefaultRegistry();
+  NameResolverRegistry nameResolverRegistry = NameResolverRegistry.getDefaultRegistry();
 
-  // Access via getter, which may perform authority override as needed
-  NameResolver.Factory nameResolverFactory = nameResolverRegistry.asFactory();
+  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;
@@ -139,11 +189,7 @@ public static ManagedChannelBuilder<?> forTarget(String target) {
   int maxHedgedAttempts = 5;
   long retryBufferSize = DEFAULT_RETRY_BUFFER_SIZE_IN_BYTES;
   long perRpcBufferLimit = DEFAULT_PER_RPC_BUFFER_LIMIT_IN_BYTES;
-  boolean retryEnabled = false; // TODO(zdapeng): default to true
-  // 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): delete me
-  boolean temporarilyDisableRetry;
+  boolean retryEnabled = true;
 
   InternalChannelz channelz = InternalChannelz.instance();
   int maxTraceEvents;
@@ -163,7 +209,9 @@ public static ManagedChannelBuilder<?> forTarget(String target) {
   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}
@@ -243,11 +291,11 @@ public ManagedChannelImplBuilder(
       String target, @Nullable ChannelCredentials channelCreds, @Nullable CallCredentials callCreds,
       ClientTransportFactoryBuilder clientTransportFactoryBuilder,
       @Nullable ChannelBuilderDefaultPortProvider channelBuilderDefaultPortProvider) {
-    this.target = Preconditions.checkNotNull(target, "target");
+    this.target = checkNotNull(target, "target");
     this.channelCredentials = channelCreds;
     this.callCredentials = callCreds;
-    this.clientTransportFactoryBuilder = Preconditions
-        .checkNotNull(clientTransportFactoryBuilder, "clientTransportFactoryBuilder");
+    this.clientTransportFactoryBuilder = checkNotNull(clientTransportFactoryBuilder,
+        "clientTransportFactoryBuilder");
     this.directServerAddress = null;
 
     if (channelBuilderDefaultPortProvider != null) {
@@ -255,11 +303,13 @@ public ManagedChannelImplBuilder(
     } 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
-   * DirectAddressNameResolverFactory will not actually try to use it. However, it must be a valid
+   * DirectAddressNameResolverProvider will not actually try to use it. However, it must be a valid
    * URI.
    */
   @VisibleForTesting
@@ -280,19 +330,40 @@ static String makeTargetStringForDirectAddress(SocketAddress address) {
   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 = null;
-    this.callCredentials = null;
-    this.clientTransportFactoryBuilder = Preconditions
-        .checkNotNull(clientTransportFactoryBuilder, "clientTransportFactoryBuilder");
+    this.channelCredentials = channelCreds;
+    this.callCredentials = callCreds;
+    this.clientTransportFactoryBuilder = checkNotNull(clientTransportFactoryBuilder,
+        "clientTransportFactoryBuilder");
     this.directServerAddress = directServerAddress;
-    this.nameResolverFactory = new DirectAddressNameResolverFactory(directServerAddress, authority);
+    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
@@ -331,6 +402,20 @@ 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) {
@@ -338,13 +423,24 @@ public ManagedChannelImplBuilder nameResolverFactory(NameResolver.Factory resolv
         "directServerAddress is set (%s), which forbids the use of NameResolverFactory",
         directServerAddress);
     if (resolverFactory != null) {
-      this.nameResolverFactory = resolverFactory;
+      NameResolverRegistry reg = new NameResolverRegistry();
+      if (resolverFactory instanceof NameResolverProvider) {
+        reg.register((NameResolverProvider) resolverFactory);
+      } else {
+        reg.register(new NameResolverFactoryToProviderFacade(resolverFactory));
+      }
+      this.nameResolverRegistry = reg;
     } else {
-      this.nameResolverFactory = nameResolverRegistry.asFactory();
+      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,
@@ -355,12 +451,6 @@ public ManagedChannelImplBuilder defaultLoadBalancingPolicy(String policy) {
     return this;
   }
 
-  @Override
-  public ManagedChannelImplBuilder enableFullStreamDecompression() {
-    this.fullStreamDecompression = true;
-    return this;
-  }
-
   @Override
   public ManagedChannelImplBuilder decompressorRegistry(DecompressorRegistry registry) {
     if (registry != null) {
@@ -441,8 +531,6 @@ public ManagedChannelImplBuilder disableRetry() {
   @Override
   public ManagedChannelImplBuilder enableRetry() {
     retryEnabled = true;
-    statsEnabled = false;
-    tracingEnabled = false;
     return this;
   }
 
@@ -531,6 +619,24 @@ private static List<?> checkListEntryTypes(List<?> list) {
     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;
@@ -570,12 +676,13 @@ public void setStatsRecordFinishedRpcs(boolean value) {
   public void setStatsRecordRealTimeMetrics(boolean value) {
     recordRealTimeMetrics = value;
   }
+  
+  public void setStatsRecordRetryMetrics(boolean value) {
+    recordRetryMetrics = value;
+  }
 
   /**
    * Disable or enable tracing features.  Enabled by default.
-   *
-   * <p>For the current release, calling {@code setTracingEnabled(true)} may have a side effect that
-   * disables retry.
    */
   public void setTracingEnabled(boolean value) {
     tracingEnabled = value;
@@ -604,15 +711,30 @@ public ManagedChannelImplBuilder enableCheckAuthority() {
     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 =
+        InternalFeatureFlags.getRfc3986UrisEnabled()
+            ? getNameResolverProviderRfc3986(target, nameResolverRegistry)
+            : getNameResolverProvider(target, nameResolverRegistry);
+    resolvedResolver.checkAddressTypes(clientTransportFactory.getSupportedSocketAddressTypes());
     return new ManagedChannelOrphanWrapper(new ManagedChannelImpl(
         this,
-        clientTransportFactoryBuilder.buildClientTransportFactory(),
+        clientTransportFactory,
+        resolvedResolver.targetUri,
+        resolvedResolver.provider,
         new ExponentialBackoffPolicy.Provider(),
         SharedResourcePool.forResource(GrpcUtil.SHARED_CHANNEL_EXECUTOR),
         GrpcUtil.STOPWATCH_SUPPLIER,
-        getEffectiveInterceptors(),
+        getEffectiveInterceptors(resolvedResolver.targetUri.toString()),
         TimeProvider.SYSTEM_TIME_PROVIDER));
   }
 
@@ -620,39 +742,43 @@ public ManagedChannel build() {
   // what should be the desired behavior for retry + stats/tracing.
   // TODO(zdapeng): FIX IT
   @VisibleForTesting
-  List<ClientInterceptor> getEffectiveInterceptors() {
-    List<ClientInterceptor> effectiveInterceptors =
-        new ArrayList<>(this.interceptors);
-    temporarilyDisableRetry = false;
+  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) {
-      temporarilyDisableRetry = true;
       ClientInterceptor statsInterceptor = null;
-      try {
-        Class<?> censusStatsAccessor =
-            Class.forName("io.grpc.census.InternalCensusStatsAccessor");
-        Method getClientInterceptorMethod =
-            censusStatsAccessor.getDeclaredMethod(
-                "getClientInterceptor",
-                boolean.class,
-                boolean.class,
-                boolean.class);
-        statsInterceptor =
-            (ClientInterceptor) getClientInterceptorMethod
-                .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 (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.
@@ -660,7 +786,6 @@ List<ClientInterceptor> getEffectiveInterceptors() {
       }
     }
     if (tracingEnabled) {
-      temporarilyDisableRetry = true;
       ClientInterceptor tracingInterceptor = null;
       try {
         Class<?> censusTracingAccessor =
@@ -693,13 +818,124 @@ int getDefaultPort() {
     return channelBuilderDefaultPortProvider.getDefaultPort();
   }
 
-  private static class DirectAddressNameResolverFactory extends NameResolver.Factory {
+  @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;
 
-    DirectAddressNameResolverFactory(SocketAddress address, String authority) {
+    DirectAddressNameResolverProvider(SocketAddress address, String authority) {
       this.address = address;
       this.authority = authority;
+      this.producedSocketAddressTypes
+          = Collections.singleton(address.getClass());
     }
 
     @Override
@@ -712,9 +948,11 @@ public String getServiceAuthority() {
 
         @Override
         public void start(Listener2 listener) {
-          listener.onResult(
+          listener.onResult2(
               ResolutionResult.newBuilder()
-                  .setAddresses(Collections.singletonList(new EquivalentAddressGroup(address)))
+                  .setAddressesOrError(
+                      StatusOr.fromValue(
+                          Collections.singletonList(new EquivalentAddressGroup(address))))
                   .setAttributes(Attributes.EMPTY)
                   .build());
         }
@@ -728,6 +966,35 @@ public void shutdown() {}
     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");
+    }
   }
 
   /**
diff --git a/core/src/main/java/io/grpc/internal/ManagedChannelOrphanWrapper.java b/core/src/main/java/io/grpc/internal/ManagedChannelOrphanWrapper.java
index 542e84b9c8b..790d5bd297f 100644
--- a/core/src/main/java/io/grpc/internal/ManagedChannelOrphanWrapper.java
+++ b/core/src/main/java/io/grpc/internal/ManagedChannelOrphanWrapper.java
@@ -29,6 +29,13 @@
 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<>();
@@ -56,12 +63,20 @@ final class ManagedChannelOrphanWrapper extends ForwardingManagedChannel {
   @Override
   public ManagedChannel shutdown() {
     phantom.clearSafely();
+    // This dummy check prevents the JIT from collecting 'this' too early
+    if (this.getClass() == null) {
+      throw new AssertionError();
+    }
     return super.shutdown();
   }
 
   @Override
   public ManagedChannel shutdownNow() {
     phantom.clearSafely();
+    // This dummy check prevents the JIT from collecting 'this' too early
+    if (this.getClass() == null) {
+      throw new AssertionError();
+    }
     return super.shutdownNow();
   }
 
@@ -73,6 +88,8 @@ static final class ManagedChannelReference extends WeakReference<ManagedChannelO
 
     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;
@@ -142,16 +159,16 @@ static int cleanQueue(ReferenceQueue<ManagedChannelOrphanWrapper> refqueue) {
       int orphanedChannels = 0;
       while ((ref = (ManagedChannelReference) refqueue.poll()) != null) {
         RuntimeException maybeAllocationSite = ref.allocationSite.get();
+        boolean wasShutdown = ref.shutdown.get();
         ref.clearInternal(); // technically the reference is gone already.
-        if (!ref.shutdown.get()) {
+        if (!wasShutdown) {
           orphanedChannels++;
           Level level = Level.SEVERE;
           if (logger.isLoggable(level)) {
             String fmt =
-                "*~*~*~ Channel {0} was not shutdown properly!!! ~*~*~*"
+                "*~*~*~ Previous channel {0} was garbage collected without being shut down! ~*~*~*"
                     + System.getProperty("line.separator")
-                    + "    Make sure to call shutdown()/shutdownNow() and wait "
-                    + "until awaitTermination() returns true.";
+                    + "    Make sure to call shutdown()/shutdownNow()";
             LogRecord lr = new LogRecord(level, fmt);
             lr.setLoggerName(logger.getName());
             lr.setParameters(new Object[] {ref.channelStr});
diff --git a/core/src/main/java/io/grpc/internal/ManagedChannelServiceConfig.java b/core/src/main/java/io/grpc/internal/ManagedChannelServiceConfig.java
index 7e6768f36e6..e5512dc8df4 100644
--- a/core/src/main/java/io/grpc/internal/ManagedChannelServiceConfig.java
+++ b/core/src/main/java/io/grpc/internal/ManagedChannelServiceConfig.java
@@ -27,11 +27,13 @@
 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;
 
 /**
@@ -216,7 +218,8 @@ public boolean equals(Object o) {
       return false;
     }
     ManagedChannelServiceConfig that = (ManagedChannelServiceConfig) o;
-    return Objects.equal(serviceMethodMap, that.serviceMethodMap)
+    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);
@@ -224,12 +227,14 @@ public boolean equals(Object o) {
 
   @Override
   public int hashCode() {
-    return Objects.hashCode(serviceMethodMap, serviceMap, retryThrottling, loadBalancingConfig);
+    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)
@@ -354,9 +359,22 @@ private static RetryPolicy retryPolicy(Map<String, ?> retryPolicy, int maxAttemp
           "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,
-          ServiceConfigUtil.getRetryableStatusCodesFromRetryPolicy(retryPolicy));
+          perAttemptRecvTimeout, retryableCodes);
     }
 
     private static HedgingPolicy hedgingPolicy(
diff --git a/core/src/main/java/io/grpc/internal/ManagedClientTransport.java b/core/src/main/java/io/grpc/internal/ManagedClientTransport.java
index 47cf53a7251..8350a005409 100644
--- a/core/src/main/java/io/grpc/internal/ManagedClientTransport.java
+++ b/core/src/main/java/io/grpc/internal/ManagedClientTransport.java
@@ -16,8 +16,9 @@
 
 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;
 
@@ -38,9 +39,7 @@ 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
@@ -78,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
@@ -94,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();
 
@@ -102,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/netty/src/main/java/io/grpc/netty/MaxConnectionIdleManager.java b/core/src/main/java/io/grpc/internal/MaxConnectionIdleManager.java
similarity index 77%
rename from netty/src/main/java/io/grpc/netty/MaxConnectionIdleManager.java
rename to core/src/main/java/io/grpc/internal/MaxConnectionIdleManager.java
index 964ae44b178..4d4a36dda01 100644
--- a/netty/src/main/java/io/grpc/netty/MaxConnectionIdleManager.java
+++ b/core/src/main/java/io/grpc/internal/MaxConnectionIdleManager.java
@@ -14,11 +14,9 @@
  * limitations under the License.
  */
 
-package io.grpc.netty;
+package io.grpc.internal;
 
 import com.google.common.annotations.VisibleForTesting;
-import io.grpc.internal.LogExceptionRunnable;
-import io.netty.channel.ChannelHandlerContext;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.ScheduledFuture;
 import java.util.concurrent.TimeUnit;
@@ -27,7 +25,7 @@
 /**
  * Monitors connection idle time; shutdowns the connection if the max connection idle is reached.
  */
-abstract class MaxConnectionIdleManager {
+public final class MaxConnectionIdleManager {
   private static final Ticker systemTicker = new Ticker() {
     @Override
     public long nanoTime() {
@@ -46,23 +44,23 @@ public long nanoTime() {
   private boolean shutdownDelayed;
   private boolean isActive;
 
-  MaxConnectionIdleManager(long maxConnectionIdleInNanos) {
+  public MaxConnectionIdleManager(long maxConnectionIdleInNanos) {
     this(maxConnectionIdleInNanos, systemTicker);
   }
 
   @VisibleForTesting
-  MaxConnectionIdleManager(long maxConnectionIdleInNanos, Ticker ticker) {
+  public MaxConnectionIdleManager(long maxConnectionIdleInNanos, Ticker ticker) {
     this.maxConnectionIdleInNanos = maxConnectionIdleInNanos;
     this.ticker = ticker;
   }
 
-  /** A {@link NettyServerHandler} was added to the transport. */
-  void start(ChannelHandlerContext ctx) {
-    start(ctx, ctx.executor());
-  }
-
-  @VisibleForTesting
-  void start(final ChannelHandlerContext ctx, final ScheduledExecutorService scheduler) {
+  /**
+   * 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;
 
@@ -78,7 +76,7 @@ public void run() {
           }
           // if isActive, exit. Will schedule a new shutdownFuture once onTransportIdle
         } else {
-          close(ctx);
+          closeJob.run();
           shutdownFuture = null;
         }
       }
@@ -88,20 +86,15 @@ public void run() {
         scheduler.schedule(shutdownTask, maxConnectionIdleInNanos, TimeUnit.NANOSECONDS);
   }
 
-  /**
-   * 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.
-   */
-  abstract void close(ChannelHandlerContext ctx);
 
   /** There are outstanding RPCs on the transport. */
-  void onTransportActive() {
+  public void onTransportActive() {
     isActive = true;
     shutdownDelayed = true;
   }
 
   /** There are no outstanding RPCs on the transport. */
-  void onTransportIdle() {
+  public void onTransportIdle() {
     isActive = false;
     if (shutdownFuture == null) {
       return;
@@ -116,7 +109,7 @@ void onTransportIdle() {
   }
 
   /** Transport is being terminated. */
-  void onTransportTermination() {
+  public void onTransportTermination() {
     if (shutdownFuture != null) {
       shutdownFuture.cancel(false);
       shutdownFuture = null;
@@ -124,7 +117,7 @@ void onTransportTermination() {
   }
 
   @VisibleForTesting
-  interface Ticker {
+  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 9a523746e50..f388c006e97 100644
--- a/core/src/main/java/io/grpc/internal/MessageDeframer.java
+++ b/core/src/main/java/io/grpc/internal/MessageDeframer.java
@@ -28,6 +28,7 @@
 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;
@@ -111,7 +112,7 @@ private enum State {
    *
    * @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.
    */
   public MessageDeframer(
@@ -313,6 +314,12 @@ private boolean readRequiredBytes() {
     int totalBytesRead = 0;
     int deflatedBytesRead = 0;
     try {
+      // Avoid allocating nextFrame when idle
+      if (requiredLength > 0 && fullStreamDecompressor == null
+          && unprocessed.readableBytes() == 0) {
+        return false;
+      }
+
       if (nextFrame == null) {
         nextFrame = new CompositeReadableBuffer();
       }
@@ -386,7 +393,7 @@ private void processHeader() {
     requiredLength = nextFrame.readInt();
     if (requiredLength < 0 || requiredLength > maxInboundMessageSize) {
       throw Status.RESOURCE_EXHAUSTED.withDescription(
-          String.format("gRPC message exceeds maximum size %d: %d",
+          String.format(Locale.US, "gRPC message exceeds maximum size %d: %d",
               maxInboundMessageSize, requiredLength))
           .asRuntimeException();
     }
@@ -405,9 +412,11 @@ 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, -1);
+    statsTraceCtx.inboundMessageRead(currentMessageSeqNo, inboundBodyWireSize,
+        (compressedFlag || fullStreamDecompressor != null) ? -1 : inboundBodyWireSize);
     inboundBodyWireSize = 0;
     InputStream stream = compressedFlag ? getCompressedBody() : getUncompressedBody();
+    nextFrame.touch();
     nextFrame = null;
     listener.messagesAvailable(new SingleMessageProducer(stream));
 
@@ -516,9 +525,9 @@ private void reportCount() {
 
     private void verifySize() {
       if (count > maxMessageSize) {
-        throw Status.RESOURCE_EXHAUSTED.withDescription(String.format(
-                "Compressed gRPC message exceeds maximum size %d: %d bytes read",
-                maxMessageSize, count)).asRuntimeException();
+        throw Status.RESOURCE_EXHAUSTED
+            .withDescription("Decompressed gRPC message exceeds maximum size " + maxMessageSize)
+            .asRuntimeException();
       }
     }
   }
diff --git a/core/src/main/java/io/grpc/internal/MessageFramer.java b/core/src/main/java/io/grpc/internal/MessageFramer.java
index 83592e691a9..8b5ccb864a4 100644
--- a/core/src/main/java/io/grpc/internal/MessageFramer.java
+++ b/core/src/main/java/io/grpc/internal/MessageFramer.java
@@ -27,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;
@@ -34,6 +35,7 @@
 import java.nio.ByteBuffer;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Locale;
 import javax.annotation.Nullable;
 
 /**
@@ -73,6 +75,10 @@ void deliverFrame(
   // 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();
@@ -146,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")
@@ -169,12 +177,6 @@ private int writeUncompressed(InputStream message, int messageLength) throws IOE
     }
     BufferChainOutputStream bufferChain = new BufferChainOutputStream();
     int written = writeToOutputStream(message, bufferChain);
-    if (maxOutboundMessageSize >= 0 && written > maxOutboundMessageSize) {
-      throw Status.RESOURCE_EXHAUSTED
-          .withDescription(
-              String.format("message too large %d > %d", written , maxOutboundMessageSize))
-          .asRuntimeException();
-    }
     writeBufferChain(bufferChain, false);
     return written;
   }
@@ -192,7 +194,8 @@ private int writeCompressed(InputStream message, int unusedMessageLength) throws
     if (maxOutboundMessageSize >= 0 && written > maxOutboundMessageSize) {
       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();
     }
 
@@ -215,16 +218,15 @@ private int writeKnownLengthUncompressed(InputStream message, int messageLength)
     if (maxOutboundMessageSize >= 0 && messageLength > maxOutboundMessageSize) {
       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();
     }
     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(headerScratch.position() + messageLength);
-    }
+    knownLengthPendingAllocation = HEADER_LENGTH + messageLength;
     writeRaw(headerScratch.array(), 0, headerScratch.position());
     return writeToOutputStream(message, outputStreamAdapter);
   }
@@ -234,6 +236,13 @@ private int writeKnownLengthUncompressed(InputStream message, int messageLength)
    */
   private void writeBufferChain(BufferChainOutputStream bufferChain, boolean compressed) {
     int messageLength = bufferChain.readableBytes();
+    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);
@@ -267,7 +276,7 @@ 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);
@@ -281,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);
@@ -381,6 +391,8 @@ public void write(byte[] b, int off, int len) {
    * {@link OutputStream}.
    */
   private final class BufferChainOutputStream extends OutputStream {
+    private static final int FIRST_BUFFER_SIZE = 4096;
+
     private final List<WritableBuffer> bufferList = new ArrayList<>();
     private WritableBuffer current;
 
@@ -390,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;
@@ -403,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 76d280b2d00..166f97b78f5 100644
--- a/core/src/main/java/io/grpc/internal/MetadataApplierImpl.java
+++ b/core/src/main/java/io/grpc/internal/MetadataApplierImpl.java
@@ -20,14 +20,15 @@
 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 extends MetadataApplier {
   private final ClientTransport transport;
@@ -36,7 +37,7 @@ final class MetadataApplierImpl extends MetadataApplier {
   private final CallOptions callOptions;
   private final Context ctx;
   private final MetadataApplierListener listener;
-
+  private final ClientStreamTracer[] tracers;
   private final Object lock = new Object();
 
   // null if neither apply() or returnStream() are called.
@@ -52,13 +53,14 @@ final class MetadataApplierImpl extends MetadataApplier {
 
   MetadataApplierImpl(
       ClientTransport transport, MethodDescriptor<?, ?> method, Metadata origHeaders,
-      CallOptions callOptions, MetadataApplierListener listener) {
+      CallOptions callOptions, MetadataApplierListener listener, ClientStreamTracer[] tracers) {
     this.transport = transport;
     this.method = method;
     this.origHeaders = origHeaders;
     this.callOptions = callOptions;
     this.ctx = Context.current();
     this.listener = listener;
+    this.tracers = tracers;
   }
 
   @Override
@@ -69,7 +71,7 @@ public void apply(Metadata headers) {
     ClientStream realStream;
     Context origCtx = ctx.attach();
     try {
-      realStream = transport.newStream(method, origHeaders, callOptions);
+      realStream = transport.newStream(method, origHeaders, callOptions, tracers);
     } finally {
       ctx.detach(origCtx);
     }
@@ -80,7 +82,8 @@ 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) {
@@ -117,7 +120,7 @@ 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;
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..6a12a38d677
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/MetricRecorderImpl.java
@@ -0,0 +1,235 @@
+/*
+ * 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 com.google.common.collect.ImmutableList;
+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 = ImmutableList.copyOf(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
index f820e7ff156..e4f499ab483 100644
--- a/core/src/main/java/io/grpc/internal/MigratingThreadDeframer.java
+++ b/core/src/main/java/io/grpc/internal/MigratingThreadDeframer.java
@@ -18,14 +18,15 @@
 
 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;
-import javax.annotation.concurrent.GuardedBy;
 
 /**
  * A deframer that moves decoding between the transport and app threads based on which is more
@@ -107,11 +108,9 @@ private boolean runWhereAppropriate(Op op, boolean currentThreadIsTransportThrea
     } else {
       if (!alreadyEnqueued) {
         if (currentThreadIsTransportThread) {
-          PerfMark.startTask("MigratingThreadDeframer.messageAvailable");
-          try {
+          try (TaskCloseable ignore =
+                   PerfMark.traceTask("MigratingThreadDeframer.messageAvailable")) {
             transportListener.messagesAvailable(messageProducer);
-          } finally {
-            PerfMark.stopTask("MigratingThreadDeframer.messageAvailable");
           }
         } else {
           final Link link = PerfMark.linkOut();
@@ -119,12 +118,10 @@ private boolean runWhereAppropriate(Op op, boolean currentThreadIsTransportThrea
           // MigratingThreadDeframer
           transportExecutor.runOnTransportThread(new Runnable() {
             @Override public void run() {
-              PerfMark.startTask("MigratingThreadDeframer.messageAvailable");
-              PerfMark.linkIn(link);
-              try {
+              try (TaskCloseable ignore =
+                       PerfMark.traceTask("MigratingThreadDeframer.messageAvailable")) {
+                PerfMark.linkIn(link);
                 transportListener.messagesAvailable(messageProducer);
-              } finally {
-                PerfMark.stopTask("MigratingThreadDeframer.messageAvailable");
               }
             }
           });
@@ -145,28 +142,22 @@ class RequestOp implements Op {
           // necessary processing
           transportExecutor.runOnTransportThread(new Runnable() {
             @Override public void run() {
-              PerfMark.startTask("MigratingThreadDeframer.request");
-              PerfMark.linkIn(link);
-              try {
+              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);
-              } finally {
-                PerfMark.stopTask("MigratingThreadDeframer.request");
               }
             }
           });
           return;
         }
-        PerfMark.startTask("MigratingThreadDeframer.request");
-        try {
+        try (TaskCloseable ignore = PerfMark.traceTask("MigratingThreadDeframer.request")) {
           deframer.request(numMessages);
         } catch (Throwable t) {
           appListener.deframeFailed(t);
           deframer.close(); // unrecoverable state
-        } finally {
-          PerfMark.stopTask("MigratingThreadDeframer.request");
         }
       }
     }
@@ -205,8 +196,7 @@ class RequestAgainOp implements Op {
   public void deframe(final ReadableBuffer data) {
     class DeframeOp implements Op, Closeable {
       @Override public void run(boolean isDeframerOnTransportThread) {
-        PerfMark.startTask("MigratingThreadDeframer.deframe");
-        try {
+        try (TaskCloseable ignore = PerfMark.traceTask("MigratingThreadDeframer.deframe")) {
           if (isDeframerOnTransportThread) {
             deframer.deframe(data);
             return;
@@ -218,8 +208,6 @@ class DeframeOp implements Op, Closeable {
             appListener.deframeFailed(t);
             deframer.close(); // unrecoverable state
           }
-        } finally {
-          PerfMark.stopTask("MigratingThreadDeframer.deframe");
         }
       }
 
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..e52eb5e38d4
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/NameResolverFactoryToProviderFacade.java
@@ -0,0 +1,57 @@
+/*
+ * 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 io.grpc.Uri;
+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 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 d44170f69fa..d77d72a5412 100644
--- a/core/src/main/java/io/grpc/internal/NoopClientStream.java
+++ b/core/src/main/java/io/grpc/internal/NoopClientStream.java
@@ -45,7 +45,9 @@ public Attributes getAttributes() {
   public void request(int numMessages) {}
 
   @Override
-  public void writeMessage(InputStream message) {}
+  public void writeMessage(InputStream message) {
+    GrpcUtil.closeQuietly(message);
+  }
 
   @Override
   public void flush() {}
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/OobChannel.java b/core/src/main/java/io/grpc/internal/OobChannel.java
deleted file mode 100644
index 5e0dd12b2ae..00000000000
--- a/core/src/main/java/io/grpc/internal/OobChannel.java
+++ /dev/null
@@ -1,336 +0,0 @@
-/*
- * 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 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.CallOptions;
-import io.grpc.ClientCall;
-import io.grpc.ConnectivityState;
-import io.grpc.ConnectivityStateInfo;
-import io.grpc.Context;
-import io.grpc.EquivalentAddressGroup;
-import io.grpc.InternalChannelz;
-import io.grpc.InternalChannelz.ChannelStats;
-import io.grpc.InternalChannelz.ChannelTrace;
-import io.grpc.InternalInstrumented;
-import io.grpc.InternalLogId;
-import io.grpc.InternalWithLogId;
-import io.grpc.LoadBalancer;
-import io.grpc.LoadBalancer.PickResult;
-import io.grpc.LoadBalancer.PickSubchannelArgs;
-import io.grpc.LoadBalancer.Subchannel;
-import io.grpc.LoadBalancer.SubchannelPicker;
-import io.grpc.ManagedChannel;
-import io.grpc.Metadata;
-import io.grpc.MethodDescriptor;
-import io.grpc.Status;
-import io.grpc.SynchronizationContext;
-import io.grpc.internal.ClientCallImpl.ClientStreamProvider;
-import java.util.Collections;
-import java.util.List;
-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 LoadBalancer}
- * to its own RPC needs.
- */
-@ThreadSafe
-final class OobChannel extends ManagedChannel implements InternalInstrumented<ChannelStats> {
-  private static final Logger log = Logger.getLogger(OobChannel.class.getName());
-
-  private InternalSubchannel subchannel;
-  private AbstractSubchannel subchannelImpl;
-  private SubchannelPicker subchannelPicker;
-
-  private final InternalLogId logId;
-  private final String authority;
-  private final DelayedClientTransport delayedTransport;
-  private final InternalChannelz channelz;
-  private final ObjectPool<? extends Executor> executorPool;
-  private final Executor executor;
-  private final ScheduledExecutorService deadlineCancellationExecutor;
-  private final CountDownLatch terminatedLatch = new CountDownLatch(1);
-  private volatile boolean shutdown;
-  private final CallTracer channelCallsTracer;
-  private final ChannelTracer channelTracer;
-  private final TimeProvider timeProvider;
-
-  private final ClientStreamProvider transportProvider = new ClientStreamProvider() {
-    @Override
-    public ClientStream newStream(MethodDescriptor<?, ?> method,
-        CallOptions callOptions, Metadata headers, Context context) {
-      Context origContext = context.attach();
-      // 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.
-      try {
-        return delayedTransport.newStream(method, headers, callOptions);
-      } finally {
-        context.detach(origContext);
-      }
-    }
-  };
-
-  OobChannel(
-      String authority, ObjectPool<? extends Executor> executorPool,
-      ScheduledExecutorService deadlineCancellationExecutor, SynchronizationContext syncContext,
-      CallTracer callsTracer, ChannelTracer channelTracer, InternalChannelz channelz,
-      TimeProvider timeProvider) {
-    this.authority = checkNotNull(authority, "authority");
-    this.logId = InternalLogId.allocate(getClass(), authority);
-    this.executorPool = checkNotNull(executorPool, "executorPool");
-    this.executor = checkNotNull(executorPool.getObject(), "executor");
-    this.deadlineCancellationExecutor = checkNotNull(
-        deadlineCancellationExecutor, "deadlineCancellationExecutor");
-    this.delayedTransport = new DelayedClientTransport(executor, syncContext);
-    this.channelz = Preconditions.checkNotNull(channelz);
-    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
-        }
-      });
-    this.channelCallsTracer = callsTracer;
-    this.channelTracer = checkNotNull(channelTracer, "channelTracer");
-    this.timeProvider = checkNotNull(timeProvider, "timeProvider");
-  }
-
-  // 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});
-    this.subchannel = subchannel;
-    subchannelImpl = new AbstractSubchannel() {
-        @Override
-        public void shutdown() {
-          subchannel.shutdown(Status.UNAVAILABLE.withDescription("OobChannel is shutdown"));
-        }
-
-        @Override
-        InternalInstrumented<ChannelStats> getInstrumentedInternalSubchannel() {
-          return subchannel;
-        }
-
-        @Override
-        public void requestConnection() {
-          subchannel.obtainActiveTransport();
-        }
-
-        @Override
-        public List<EquivalentAddressGroup> getAllAddresses() {
-          return subchannel.getAddressGroups();
-        }
-
-        @Override
-        public Attributes getAttributes() {
-          return Attributes.EMPTY;
-        }
-
-        @Override
-        public Object getInternalSubchannel() {
-          return subchannel;
-        }
-    };
-
-    final class OobSubchannelPicker extends SubchannelPicker {
-      final PickResult result = PickResult.withSubchannel(subchannelImpl);
-
-      @Override
-      public PickResult pickSubchannel(PickSubchannelArgs args) {
-        return result;
-      }
-
-      @Override
-      public String toString() {
-        return MoreObjects.toStringHelper(OobSubchannelPicker.class)
-            .add("result", result)
-            .toString();
-      }
-    }
-
-    subchannelPicker = new OobSubchannelPicker();
-    delayedTransport.reprocess(subchannelPicker);
-  }
-
-  void updateAddresses(EquivalentAddressGroup eag) {
-    subchannel.updateAddresses(Collections.singletonList(eag));
-  }
-
-  @Override
-  public <RequestT, ResponseT> ClientCall<RequestT, ResponseT> newCall(
-      MethodDescriptor<RequestT, ResponseT> methodDescriptor, CallOptions callOptions) {
-    return new ClientCallImpl<>(methodDescriptor,
-        callOptions.getExecutor() == null ? executor : callOptions.getExecutor(),
-        callOptions, transportProvider, deadlineCancellationExecutor, channelCallsTracer, null);
-  }
-
-  @Override
-  public String authority() {
-    return authority;
-  }
-
-  @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 ConnectivityState getState(boolean requestConnectionIgnored) {
-    if (subchannel == null) {
-      return ConnectivityState.IDLE;
-    }
-    return subchannel.getState();
-  }
-
-  @Override
-  public ManagedChannel shutdown() {
-    shutdown = true;
-    delayedTransport.shutdown(Status.UNAVAILABLE.withDescription("OobChannel.shutdown() called"));
-    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) {
-    channelTracer.reportEvent(
-        new ChannelTrace.Event.Builder()
-            .setDescription("Entering " + newState.getState() + " state")
-            .setSeverity(ChannelTrace.Event.Severity.CT_INFO)
-            .setTimestampNanos(timeProvider.currentTimeNanos())
-            .build());
-    switch (newState.getState()) {
-      case READY:
-      case IDLE:
-        delayedTransport.reprocess(subchannelPicker);
-        break;
-      case TRANSIENT_FAILURE:
-        final class OobErrorPicker extends SubchannelPicker {
-          final PickResult errorResult = PickResult.withError(newState.getStatus());
-
-          @Override
-          public PickResult pickSubchannel(PickSubchannelArgs args) {
-            return errorResult;
-          }
-
-          @Override
-          public String toString() {
-            return MoreObjects.toStringHelper(OobErrorPicker.class)
-                .add("errorResult", errorResult)
-                .toString();
-          }
-        }
-
-        delayedTransport.reprocess(new OobErrorPicker());
-        break;
-      default:
-        // Do nothing
-    }
-  }
-
-  // must be run from channel executor
-  void handleSubchannelTerminated() {
-    channelz.removeSubchannel(this);
-    // When delayedTransport is terminated, it shuts down subchannel.  Therefore, at this point
-    // both delayedTransport and subchannel have terminated.
-    executorPool.returnObject(executor);
-    terminatedLatch.countDown();
-  }
-
-  @VisibleForTesting
-  Subchannel getSubchannel() {
-    return subchannelImpl;
-  }
-
-  InternalSubchannel getInternalSubchannel() {
-    return subchannel;
-  }
-
-  @Override
-  public ListenableFuture<ChannelStats> getStats() {
-    final SettableFuture<ChannelStats> ret = SettableFuture.create();
-    final ChannelStats.Builder builder = new ChannelStats.Builder();
-    channelCallsTracer.updateBuilder(builder);
-    channelTracer.updateBuilder(builder);
-    builder
-        .setTarget(authority)
-        .setState(subchannel.getState())
-        .setSubchannels(Collections.<InternalWithLogId>singletonList(subchannel));
-    ret.set(builder.build());
-    return ret;
-  }
-
-  @Override
-  public InternalLogId getLogId() {
-    return logId;
-  }
-
-  @Override
-  public String toString() {
-    return MoreObjects.toStringHelper(this)
-        .add("logId", logId.getId())
-        .add("authority", authority)
-        .toString();
-  }
-
-  @Override
-  public void resetConnectBackoff() {
-    subchannel.resetConnectBackoff();
-  }
-}
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..f8f5c94f5ba
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/PickFirstLeafLoadBalancer.java
@@ -0,0 +1,900 @@
+/*
+ * 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 com.google.errorprone.annotations.CheckReturnValue;
+import io.grpc.Attributes;
+import io.grpc.ConnectivityState;
+import io.grpc.ConnectivityStateInfo;
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.InternalEquivalentAddressGroup;
+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();
+  static boolean weightedShuffling =
+      GrpcUtil.getFlag("GRPC_EXPERIMENTAL_PF_WEIGHTED_SHUFFLING", true);
+  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) {
+        cleanServers = shuffle(
+            cleanServers, config.randomSeed != null ? new Random(config.randomSeed) : new Random());
+      }
+    }
+
+    final ImmutableList<EquivalentAddressGroup> newImmutableAddressGroups =
+        ImmutableList.copyOf(cleanServers);
+
+    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;
+  }
+
+  // Also used by PickFirstLoadBalancer
+  @CheckReturnValue
+  static List<EquivalentAddressGroup> shuffle(List<EquivalentAddressGroup> eags, Random random) {
+    if (weightedShuffling) {
+      List<WeightEntry> weightedEntries = new ArrayList<>(eags.size());
+      for (EquivalentAddressGroup eag : eags) {
+        weightedEntries.add(new WeightEntry(eag, eagToWeight(eag, random)));
+      }
+      Collections.sort(weightedEntries, Collections.reverseOrder() /* descending */);
+      return Lists.transform(weightedEntries, entry -> entry.eag);
+    } else {
+      List<EquivalentAddressGroup> eagsCopy = new ArrayList<>(eags);
+      Collections.shuffle(eagsCopy, random);
+      return eagsCopy;
+    }
+  }
+
+  private static double eagToWeight(EquivalentAddressGroup eag, Random random) {
+    Long weight = eag.getAttributes().get(InternalEquivalentAddressGroup.ATTR_WEIGHT);
+    if (weight == null) {
+      weight = 1L;
+    }
+    return Math.pow(random.nextDouble(), 1.0 / weight);
+  }
+
+  private static final class WeightEntry implements Comparable<WeightEntry> {
+    final EquivalentAddressGroup eag;
+    final double weight;
+
+    public WeightEntry(EquivalentAddressGroup eag, double weight) {
+      this.eag = eag;
+      this.weight = weight;
+    }
+
+    @Override
+    public int compareTo(WeightEntry entry) {
+      return Double.compare(this.weight, entry.weight);
+    }
+  }
+
+  @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 || reconnectTask != null) {
+      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
index 535b34b015d..cf4b4c94e04 100644
--- a/core/src/main/java/io/grpc/internal/PickFirstLoadBalancer.java
+++ b/core/src/main/java/io/grpc/internal/PickFirstLoadBalancer.java
@@ -18,17 +18,19 @@
 
 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.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
@@ -38,14 +40,34 @@
 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 void handleResolvedAddresses(ResolvedAddresses resolvedAddresses) {
+  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 = PickFirstLeafLoadBalancer.shuffle(
+            servers, config.randomSeed != null ? new Random(config.randomSeed) : new Random());
+      }
+    }
+
     if (subchannel == null) {
       final Subchannel subchannel = helper.createSubchannel(
           CreateSubchannelArgs.newBuilder()
@@ -61,11 +83,13 @@ public void onSubchannelState(ConnectivityStateInfo stateInfo) {
 
       // 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.
-      helper.updateBalancingState(CONNECTING, new Picker(PickResult.withSubchannel(subchannel)));
+      updateBalancingState(CONNECTING, new FixedResultPicker(PickResult.withNoResult()));
       subchannel.requestConnection();
     } else {
       subchannel.updateAddresses(servers);
     }
+
+    return Status.OK;
   }
 
   @Override
@@ -74,37 +98,61 @@ public void handleNameResolutionError(Status error) {
       subchannel.shutdown();
       subchannel = null;
     }
+
     // NB(lukaszx0) Whether we should propagate the error unconditionally is arguable. It's fine
     // for time being.
-    helper.updateBalancingState(TRANSIENT_FAILURE, new Picker(PickResult.withError(error)));
+    updateBalancingState(TRANSIENT_FAILURE, new FixedResultPicker(PickResult.withError(error)));
   }
 
   private void processSubchannelState(Subchannel subchannel, ConnectivityStateInfo stateInfo) {
-    ConnectivityState currentState = stateInfo.getState();
-    if (currentState == SHUTDOWN) {
+    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 (currentState) {
+    switch (newState) {
       case IDLE:
-        picker = new RequestConnectionPicker(subchannel);
+        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 Picker(PickResult.withNoResult());
+        picker = new FixedResultPicker(PickResult.withNoResult());
         break;
       case READY:
-        picker = new Picker(PickResult.withSubchannel(subchannel));
+        picker = new FixedResultPicker(PickResult.withSubchannel(subchannel));
         break;
       case TRANSIENT_FAILURE:
-        picker = new Picker(PickResult.withError(stateInfo.getStatus()));
+        picker = new FixedResultPicker(PickResult.withError(stateInfo.getStatus()));
         break;
       default:
-        throw new IllegalArgumentException("Unsupported state:" + currentState);
+        throw new IllegalArgumentException("Unsupported state:" + newState);
     }
-    helper.updateBalancingState(currentState, picker);
+
+    updateBalancingState(newState, picker);
+  }
+
+  private void updateBalancingState(ConnectivityState state, SubchannelPicker picker) {
+    currentState = state;
+    helper.updateBalancingState(state, picker);
   }
 
   @Override
@@ -121,48 +169,34 @@ public void requestConnection() {
     }
   }
 
-  /**
-   * No-op picker which doesn't add any custom picking logic. It just passes already known result
-   * received in constructor.
-   */
-  private static final class Picker extends SubchannelPicker {
-    private final PickResult result;
-
-    Picker(PickResult result) {
-      this.result = checkNotNull(result, "result");
-    }
-
-    @Override
-    public PickResult pickSubchannel(PickSubchannelArgs args) {
-      return result;
-    }
-
-    @Override
-    public String toString() {
-      return MoreObjects.toStringHelper(Picker.class).add("result", result).toString();
-    }
-  }
-
   /** Picker that requests connection during the first pick, and returns noResult. */
   private final class RequestConnectionPicker extends SubchannelPicker {
-    private final Subchannel subchannel;
     private final AtomicBoolean connectionRequested = new AtomicBoolean(false);
 
-    RequestConnectionPicker(Subchannel subchannel) {
-      this.subchannel = checkNotNull(subchannel, "subchannel");
-    }
-
     @Override
     public PickResult pickSubchannel(PickSubchannelArgs args) {
       if (connectionRequested.compareAndSet(false, true)) {
-        helper.getSynchronizationContext().execute(new Runnable() {
-            @Override
-            public void run() {
-              subchannel.requestConnection();
-            }
-          });
+        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
index 0b11af94e2d..83b3fb7d8e6 100644
--- a/core/src/main/java/io/grpc/internal/PickFirstLoadBalancerProvider.java
+++ b/core/src/main/java/io/grpc/internal/PickFirstLoadBalancerProvider.java
@@ -16,9 +16,14 @@
 
 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;
 
 /**
@@ -28,7 +33,16 @@
  * down the address list and sticks to the first that works.
  */
 public final class PickFirstLoadBalancerProvider extends LoadBalancerProvider {
-  private static final String NO_CONFIG = "no service config";
+  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() {
@@ -47,12 +61,36 @@ public String getPolicyName() {
 
   @Override
   public LoadBalancer newLoadBalancer(LoadBalancer.Helper helper) {
-    return new PickFirstLoadBalancer(helper);
+    if (enableNewPickFirst) {
+      return new PickFirstLeafLoadBalancer(helper);
+    } else {
+      return new PickFirstLoadBalancer(helper);
+    }
   }
 
   @Override
-  public ConfigOrError parseLoadBalancingPolicyConfig(
-      Map<String, ?> rawLoadBalancingPolicyConfig) {
-    return ConfigOrError.fromConfig(NO_CONFIG);
+  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
index dd938303dee..c61fcac6f69 100644
--- a/core/src/main/java/io/grpc/internal/PickSubchannelArgsImpl.java
+++ b/core/src/main/java/io/grpc/internal/PickSubchannelArgsImpl.java
@@ -20,6 +20,7 @@
 
 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;
@@ -29,15 +30,18 @@ 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) {
+      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
@@ -55,6 +59,11 @@ public CallOptions getCallOptions() {
     return method;
   }
 
+  @Override
+  public PickDetailsConsumer getPickDetailsConsumer() {
+    return pickDetailsConsumer;
+  }
+
   @Override
   public boolean equals(Object o) {
     if (this == o) {
@@ -66,12 +75,13 @@ public boolean equals(Object o) {
     PickSubchannelArgsImpl that = (PickSubchannelArgsImpl) o;
     return Objects.equal(callOptions, that.callOptions)
         && Objects.equal(headers, that.headers)
-        && Objects.equal(method, that.method);
+        && Objects.equal(method, that.method)
+        && Objects.equal(pickDetailsConsumer, that.pickDetailsConsumer);
   }
 
   @Override
   public int hashCode() {
-    return Objects.hashCode(callOptions, headers, method);
+    return Objects.hashCode(callOptions, headers, method, pickDetailsConsumer);
   }
 
   @Override
diff --git a/core/src/main/java/io/grpc/internal/ProxyDetectorImpl.java b/core/src/main/java/io/grpc/internal/ProxyDetectorImpl.java
index 3e7dd010e22..58c7803346f 100644
--- a/core/src/main/java/io/grpc/internal/ProxyDetectorImpl.java
+++ b/core/src/main/java/io/grpc/internal/ProxyDetectorImpl.java
@@ -133,9 +133,8 @@ public PasswordAuthentication requestPasswordAuthentication(
         // let url be null
         log.log(
             Level.WARNING,
-            String.format("failed to create URL for Authenticator: %s %s", protocol, host));
+            "failed to create URL for Authenticator: {0} {1}", new Object[] {protocol, host});
       }
-      // TODO(spencerfang): consider using java.security.AccessController here
       return Authenticator.requestPasswordAuthentication(
           host, addr, port, protocol, prompt, scheme, url, Authenticator.RequestorType.PROXY);
     }
@@ -144,21 +143,13 @@ public PasswordAuthentication requestPasswordAuthentication(
       new Supplier<ProxySelector>() {
         @Override
         public ProxySelector get() {
-          // TODO(spencerfang): consider using java.security.AccessController here
           return ProxySelector.getDefault();
         }
       };
 
-  /**
-   * @deprecated Use the standard Java proxy configuration instead with flags such as:
-   *     -Dhttps.proxyHost=HOST -Dhttps.proxyPort=PORT
-   */
-  @Deprecated
-  private static final String GRPC_PROXY_ENV_VAR = "GRPC_PROXY_EXP";
   // Do not hard code a ProxySelector because the global default ProxySelector can change
   private final Supplier<ProxySelector> proxySelector;
   private final AuthenticationProvider authenticationProvider;
-  private final InetSocketAddress overrideProxyAddress;
 
   // We want an HTTPS proxy, which operates on the entire data stream (See IETF rfc2817).
   static final String PROXY_SCHEME = "https";
@@ -168,21 +159,15 @@ public ProxySelector get() {
    * {@link ProxyDetectorImpl.AuthenticationProvider} to detect proxy parameters.
    */
   public ProxyDetectorImpl() {
-    this(DEFAULT_PROXY_SELECTOR, DEFAULT_AUTHENTICATOR, System.getenv(GRPC_PROXY_ENV_VAR));
+    this(DEFAULT_PROXY_SELECTOR, DEFAULT_AUTHENTICATOR);
   }
 
   @VisibleForTesting
   ProxyDetectorImpl(
       Supplier<ProxySelector> proxySelector,
-      AuthenticationProvider authenticationProvider,
-      @Nullable String proxyEnvString) {
+      AuthenticationProvider authenticationProvider) {
     this.proxySelector = checkNotNull(proxySelector);
     this.authenticationProvider = checkNotNull(authenticationProvider);
-    if (proxyEnvString != null) {
-      overrideProxyAddress = overrideProxy(proxyEnvString);
-    } else {
-      overrideProxyAddress = null;
-    }
   }
 
   @Nullable
@@ -191,25 +176,12 @@ public ProxiedSocketAddress proxyFor(SocketAddress targetServerAddress) throws I
     if (!(targetServerAddress instanceof InetSocketAddress)) {
       return null;
     }
-    if (overrideProxyAddress != null) {
-      return HttpConnectProxiedSocketAddress.newBuilder()
-          .setProxyAddress(overrideProxyAddress)
-          .setTargetAddress((InetSocketAddress) targetServerAddress)
-          .build();
-    }
     return detectProxy((InetSocketAddress) targetServerAddress);
   }
 
   private ProxiedSocketAddress detectProxy(InetSocketAddress targetAddr) throws IOException {
     URI uri;
-    String host;
-    try {
-      host = GrpcUtil.getHost(targetAddr);
-    } catch (Throwable t) {
-      // Workaround for Android API levels < 19 if getHostName causes a NetworkOnMainThreadException
-      log.log(Level.WARNING, "Failed to get host for proxy lookup, proceeding without proxy", t);
-      return null;
-    }
+    String host = targetAddr.getHostString();
     try {
       uri =
           new URI(
@@ -247,13 +219,14 @@ private ProxiedSocketAddress detectProxy(InetSocketAddress targetAddr) throws IO
     // 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(
-        GrpcUtil.getHost(proxyAddr),
-        proxyAddr.getAddress(),
-        proxyAddr.getPort(),
-        PROXY_SCHEME,
-        promptString,
-        null);
+    PasswordAuthentication auth =
+        authenticationProvider.requestPasswordAuthentication(
+            proxyAddr.getHostString(),
+            proxyAddr.getAddress(),
+            proxyAddr.getPort(),
+            PROXY_SCHEME,
+            promptString,
+            null);
 
     final InetSocketAddress resolvedProxyAddr;
     if (proxyAddr.isUnresolved()) {
@@ -278,27 +251,6 @@ private ProxiedSocketAddress detectProxy(InetSocketAddress targetAddr) throws IO
         .build();
   }
 
-  /**
-   * GRPC_PROXY_EXP is deprecated but let's maintain compatibility for now.
-   */
-  private static InetSocketAddress overrideProxy(String proxyHostPort) {
-    if (proxyHostPort == null) {
-      return null;
-    }
-
-    String[] parts = proxyHostPort.split(":", 2);
-    int port = 80;
-    if (parts.length > 1) {
-      port = Integer.parseInt(parts[1]);
-    }
-    log.warning(
-        "Detected GRPC_PROXY_EXP and will honor it, but this feature will "
-            + "be removed in a future release. Use the JVM flags "
-            + "\"-Dhttps.proxyHost=HOST -Dhttps.proxyPort=PORT\" to set the https proxy for "
-            + "this JVM.");
-    return new InetSocketAddress(parts[0], port);
-  }
-
   /**
    * This interface makes unit testing easier by avoiding direct calls to static methods.
    */
diff --git a/core/src/main/java/io/grpc/internal/ReadableBuffer.java b/core/src/main/java/io/grpc/internal/ReadableBuffer.java
index 7d2ca7ebba5..20f64719875 100644
--- a/core/src/main/java/io/grpc/internal/ReadableBuffer.java
+++ b/core/src/main/java/io/grpc/internal/ReadableBuffer.java
@@ -20,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
@@ -70,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
@@ -123,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 cfe5542a573..439745e29b2 100644
--- a/core/src/main/java/io/grpc/internal/ReadableBuffers.java
+++ b/core/src/main/java/io/grpc/internal/ReadableBuffers.java
@@ -16,16 +16,20 @@
 
 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.
@@ -128,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);
@@ -166,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);
@@ -204,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;
+    }
   }
 
   /**
@@ -239,21 +253,6 @@ 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();
-      ((Buffer) 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);
@@ -291,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");
@@ -329,6 +354,47 @@ public int read(byte[] dest, int destOffset, int length) throws IOException {
       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();
diff --git a/core/src/main/java/io/grpc/internal/RetriableStream.java b/core/src/main/java/io/grpc/internal/RetriableStream.java
index 4540538b40f..0c37a0beaca 100644
--- a/core/src/main/java/io/grpc/internal/RetriableStream.java
+++ b/core/src/main/java/io/grpc/internal/RetriableStream.java
@@ -22,6 +22,8 @@
 
 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;
@@ -30,7 +32,10 @@
 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;
@@ -44,9 +49,7 @@
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicLong;
 import javax.annotation.CheckForNull;
-import javax.annotation.CheckReturnValue;
 import javax.annotation.Nullable;
-import javax.annotation.concurrent.GuardedBy;
 
 /** A logical {@link ClientStream} that is retriable. */
 abstract class RetriableStream<ReqT> implements ClientStream {
@@ -63,6 +66,16 @@ abstract class RetriableStream<ReqT> implements ClientStream {
 
   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;
@@ -88,9 +101,14 @@ abstract class RetriableStream<ReqT> implements ClientStream {
       false, 0);
 
   /**
-   * Either transparent retry happened or reached server's application logic.
+   * 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.
@@ -103,6 +121,8 @@ abstract class RetriableStream<ReqT> implements ClientStream {
   @GuardedBy("lock")
   private FutureCanceller scheduledHedging;
   private long nextBackoffIntervalNanos;
+  private Status cancellationStatus;
+  private boolean isClosed;
 
   RetriableStream(
       MethodDescriptor<ReqT, ?> method, Metadata headers,
@@ -129,11 +149,10 @@ abstract class RetriableStream<ReqT> implements ClientStream {
     this.throttle = throttle;
   }
 
-  @SuppressWarnings("GuardedBy")
+  @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;
@@ -145,10 +164,10 @@ private Runnable commit(final Substream 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) {
-        // TODO(b/145386688): This access should be guarded by 'this.scheduledRetry.lock'; instead
-        // found: 'this.lock'
+      final boolean retryWasScheduled = scheduledRetry != null;
+      if (retryWasScheduled) {
         retryFuture = scheduledRetry.markCancelled();
         scheduledRetry = null;
       } else {
@@ -157,8 +176,6 @@ private Runnable commit(final Substream winningSubstream) {
       // cancel the scheduled hedging if it is scheduled prior to the commitment
       final Future<?> hedgingFuture;
       if (scheduledHedging != null) {
-        // TODO(b/145386688): This access should be guarded by 'this.scheduledHedging.lock'; instead
-        // found: 'this.lock'
         hedgingFuture = scheduledHedging.markCancelled();
         scheduledHedging = null;
       } else {
@@ -174,9 +191,25 @@ public void run() {
               substream.stream.cancel(CANCELLED_BECAUSE_COMMITTED);
             }
           }
-          if (retryFuture != null) {
-            retryFuture.cancel(false);
+          if (retryWasScheduled) {
+            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);
           }
@@ -192,17 +225,38 @@ public void run() {
   abstract void postCommit();
 
   /**
-   * Calls commit() and if successful runs the post commit task.
+   * 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) {
-      postCommitTask.run();
+      callExecutor.execute(postCommitTask);
     }
   }
 
-  private Substream createSubstream(int previousAttemptCount) {
+  // 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);
@@ -216,7 +270,8 @@ public ClientStreamTracer newClientStreamTracer(
 
     Metadata newHeaders = updateHeaders(headers, previousAttemptCount);
     // NOTICE: This set _must_ be done before stream.start() and it actually is.
-    sub.stream = newSubstream(tracerFactory, newHeaders);
+    sub.stream = newSubstream(newHeaders, tracerFactory, previousAttemptCount, isTransparentRetry,
+        isHedgedStream);
     return sub;
   }
 
@@ -225,7 +280,8 @@ public ClientStreamTracer newClientStreamTracer(
    * Client stream is not yet started.
    */
   abstract ClientStream newSubstream(
-      ClientStreamTracer.Factory tracerFactory, Metadata headers);
+      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
@@ -243,6 +299,8 @@ 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;
@@ -250,12 +308,26 @@ private void drain(Substream substream) {
       synchronized (lock) {
         savedState = state;
         if (savedState.winningSubstream != null && savedState.winningSubstream != substream) {
-          // committed but not me
+          // committed but not me, to be cancelled
+          break;
+        }
+        if (savedState.cancelled) {
           break;
         }
         if (index == savedState.buffer.size()) { // I'm drained
           state = savedState.substreamDrained(substream);
-          return;
+          if (!isReady()) {
+            return;
+          }
+          onReadyRunnable = new Runnable() {
+            @Override
+            public void run() {
+              if (!isClosed) {
+                masterListener.onReady();
+              }
+            }
+          };
+          break;
         }
 
         if (substream.closed) {
@@ -273,22 +345,32 @@ private void drain(Substream substream) {
       }
 
       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
+          // committed but not me, to be cancelled
           break;
         }
         if (savedState.cancelled) {
-          checkState(
-              savedState.winningSubstream == substream,
-              "substream should be CANCELLED_BECAUSE_COMMITTED already");
-          return;
+          break;
         }
-        bufferEntry.runWith(substream);
       }
     }
 
-    substream.stream.cancel(CANCELLED_BECAUSE_COMMITTED);
+    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);
   }
 
   /**
@@ -298,7 +380,14 @@ private void drain(Substream substream) {
   @Nullable
   abstract Status prestart();
 
-  /** Starts the first PRC attempt. */
+  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;
@@ -310,18 +399,14 @@ public final void start(ClientStreamListener listener) {
       return;
     }
 
-    class StartEntry implements BufferEntry {
-      @Override
-      public void runWith(Substream substream) {
-        substream.stream.start(new Sublistener(substream));
-      }
-    }
-
     synchronized (lock) {
       state.buffer.add(new StartEntry());
     }
 
-    Substream substream = createSubstream(0);
+    Substream substream = createSubstream(0, false, false);
+    if (substream == null) {
+      return;
+    }
     if (isHedging) {
       FutureCanceller scheduledHedgingRef = null;
 
@@ -345,7 +430,7 @@ public void runWith(Substream substream) {
     drain(substream);
   }
 
-  @SuppressWarnings("GuardedBy")
+  @SuppressWarnings("GuardedBy")  // TODO(b/145386688) this.lock==ScheduledCancellor.lock so ok
   private void pushbackHedging(@Nullable Integer delayMillis) {
     if (delayMillis == null) {
       return;
@@ -364,8 +449,6 @@ private void pushbackHedging(@Nullable Integer delayMillis) {
         return;
       }
 
-      // TODO(b/145386688): This access should be guarded by 'this.scheduledHedging.lock'; instead
-      // found: 'this.lock'
       futureToBeCancelled = scheduledHedging.markCancelled();
       scheduledHedging = future = new FutureCanceller(lock);
     }
@@ -389,23 +472,23 @@ private final class HedgingRunnable implements Runnable {
 
     @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")
+            @SuppressWarnings("GuardedBy")  //TODO(b/145386688) lock==ScheduledCancellor.lock so ok
             @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);
               boolean cancelled = false;
               FutureCanceller future = null;
 
               synchronized (lock) {
-                // TODO(b/145386688): This access should be guarded by
-                // 'HedgingRunnable.this.scheduledHedgingRef.lock'; instead found:
-                // 'RetriableStream.this.lock'
                 if (scheduledHedgingRef.isCancelled()) {
                   cancelled = true;
                 } else {
@@ -421,6 +504,8 @@ public void run() {
               }
 
               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;
               }
@@ -438,22 +523,32 @@ public void run() {
   }
 
   @Override
-  public final void cancel(Status reason) {
+  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) {
-      masterListener.closed(reason, new Metadata());
+      synchronized (lock) {
+        state = state.substreamDrained(noopSubstream);
+      }
       runnable.run();
+      safeCloseMasterListener(reason, RpcProgress.PROCESSED, new Metadata());
       return;
     }
 
-    state.winningSubstream.stream.cancel(reason);
+    Substream winningSubstreamToCancel = null;
     synchronized (lock) {
-      // This is not required, but causes a short-circuit in the draining process.
+      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) {
@@ -490,6 +585,10 @@ 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();
       }
     }
 
@@ -721,13 +820,11 @@ private boolean hasPotentialHedging(State state) {
         && !state.hedgingFrozen;
   }
 
-  @SuppressWarnings("GuardedBy")
+  @SuppressWarnings("GuardedBy")  // TODO(b/145386688) this.lock==ScheduledCancellor.lock so ok
   private void freezeHedging() {
     Future<?> futureToBeCancelled = null;
     synchronized (lock) {
       if (scheduledHedging != null) {
-        // TODO(b/145386688): This access should be guarded by 'this.scheduledHedging.lock'; instead
-        // found: 'this.lock'
         futureToBeCancelled = scheduledHedging.markCancelled();
         scheduledHedging = null;
       }
@@ -739,6 +836,42 @@ private void freezeHedging() {
     }
   }
 
+  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.4 * random.nextDouble() + 0.8 : 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);
@@ -752,68 +885,89 @@ private final class Sublistener implements ClientStreamListener {
     }
 
     @Override
-    public void headersRead(Metadata headers) {
+    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) {
-        masterListener.headersRead(headers);
         if (throttle != null) {
           throttle.onSuccess();
         }
+        listenerSerializeExecutor.execute(
+            new Runnable() {
+              @Override
+              public void run() {
+                masterListener.headersRead(headers);
+              }
+            });
       }
     }
 
     @Override
-    public void closed(Status status, Metadata trailers) {
-      closed(status, RpcProgress.PROCESSED, trailers);
-    }
-
-    @Override
-    public void closed(Status status, RpcProgress rpcProgress, Metadata trailers) {
+    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) {
-          masterListener.closed(status, trailers);
+          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.REFUSED
-            && noMoreTransparentRetry.compareAndSet(false, true)) {
+        if (rpcProgress == RpcProgress.MISCARRIED
+            || (rpcProgress == RpcProgress.REFUSED
+                && noMoreTransparentRetry.compareAndSet(false, true))) {
           // transparent retry
-          final Substream newSubstream = createSubstream(
-              substream.previousAttemptCount);
+          final Substream newSubstream = createSubstream(substream.previousAttemptCount,
+              true, false);
+          if (newSubstream == null) {
+            return;
+          }
           if (isHedging) {
-            boolean commit = false;
             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);
-
-              // optimization for early commit
-              if (!hasPotentialHedging(state)
-                  && state.activeHedges.size() == 1) {
-                commit = true;
-              }
-            }
-            if (commit) {
-              commitAndRun(newSubstream);
-            }
-          } else {
-            if (retryPolicy == null || retryPolicy.maxAttempts == 1) {
-              // optimization for early commit
-              commitAndRun(newSubstream);
             }
           }
+
           callExecutor.execute(new Runnable() {
             @Override
             public void run() {
@@ -851,29 +1005,44 @@ public void run() {
           } 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);
               }
-              scheduledRetryCopy.setFuture(
-                  scheduledExecutorService.schedule(
+
+              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() {
-                          callExecutor.execute(
-                              new Runnable() {
-                                @Override
-                                public void run() {
-                                  // retry
-                                  Substream newSubstream =
-                                      createSubstream(substream.previousAttemptCount + 1);
-                                  drain(newSubstream);
-                                }
-                              });
+                          drain(newSubstream);
                         }
-                      },
+                      });
+                }
+              }
+
+              scheduledRetryCopy.setFuture(
+                  scheduledExecutorService.schedule(
+                      new RetryBackoffRunnable(),
                       retryPlan.backoffNanos,
                       TimeUnit.NANOSECONDS));
               return;
@@ -884,7 +1053,7 @@ public void run() {
 
       commitAndRun(substream);
       if (state.winningSubstream == substream) {
-        masterListener.closed(status, trailers);
+        safeCloseMasterListener(status, rpcProgress, trailers);
       }
     }
 
@@ -912,7 +1081,7 @@ private RetryPlan makeRetryDecision(Status status, Metadata trailer) {
         if (pushbackMillis == null) {
           if (isRetryableStatusCode) {
             shouldRetry = true;
-            backoffNanos = (long) (nextBackoffIntervalNanos * random.nextDouble());
+            backoffNanos = intervalWithJitter(nextBackoffIntervalNanos);
             nextBackoffIntervalNanos = Math.min(
                 (long) (nextBackoffIntervalNanos * retryPolicy.backoffMultiplier),
                 retryPolicy.maxBackoffNanos);
@@ -936,6 +1105,10 @@ private HedgingPlan makeHedgingDecision(Status status, Metadata trailer) {
           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);
     }
 
@@ -954,22 +1127,38 @@ private Integer getPushbackMills(Metadata trailer) {
     }
 
     @Override
-    public void messagesAvailable(MessageProducer producer) {
+    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;
       }
-      masterListener.messagesAvailable(producer);
+      listenerSerializeExecutor.execute(
+          new Runnable() {
+            @Override
+            public void run() {
+              masterListener.messagesAvailable(producer);
+            }
+          });
     }
 
     @Override
     public void onReady() {
       // FIXME(#7089): hedging case is broken.
-      // TODO(zdapeng): optimization: if the substream is not drained yet, delay onReady() once
-      // drained and if is still ready.
-      masterListener.onReady();
+      if (!isReady()) {
+        return;
+      }
+      listenerSerializeExecutor.execute(
+          new Runnable() {
+            @Override
+            public void run() {
+              if (!isClosed) {
+                masterListener.onReady();
+              }
+            }
+          });
     }
   }
 
@@ -1402,11 +1591,16 @@ private static final class FutureCanceller {
     }
 
     void setFuture(Future<?> future) {
+      boolean wasCancelled;
       synchronized (lock) {
-        if (!cancelled) {
+        wasCancelled = cancelled;
+        if (!wasCancelled) {
           this.future = future;
         }
       }
+      if (wasCancelled) {
+        future.cancel(false);
+      }
     }
 
     @GuardedBy("lock")
diff --git a/core/src/main/java/io/grpc/internal/RetryPolicy.java b/core/src/main/java/io/grpc/internal/RetryPolicy.java
index 36ab3a0ca27..84267bee433 100644
--- a/core/src/main/java/io/grpc/internal/RetryPolicy.java
+++ b/core/src/main/java/io/grpc/internal/RetryPolicy.java
@@ -22,6 +22,7 @@
 import io.grpc.Status.Code;
 import java.util.Set;
 import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
 import javax.annotation.concurrent.Immutable;
 
 /**
@@ -33,6 +34,8 @@ final class RetryPolicy {
   final long initialBackoffNanos;
   final long maxBackoffNanos;
   final double backoffMultiplier;
+  @Nullable
+  final Long perAttemptRecvTimeoutNanos;
   final Set<Code> retryableStatusCodes;
 
   /**
@@ -44,11 +47,13 @@ final class RetryPolicy {
       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);
   }
 
@@ -59,6 +64,7 @@ public int hashCode() {
         initialBackoffNanos,
         maxBackoffNanos,
         backoffMultiplier,
+        perAttemptRecvTimeoutNanos,
         retryableStatusCodes);
   }
 
@@ -72,6 +78,7 @@ public boolean equals(Object other) {
         && 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);
   }
 
@@ -82,6 +89,7 @@ public String toString() {
         .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/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/SerializingExecutor.java b/core/src/main/java/io/grpc/internal/SerializingExecutor.java
index 6ac57635cfb..7044b4e17fc 100644
--- a/core/src/main/java/io/grpc/internal/SerializingExecutor.java
+++ b/core/src/main/java/io/grpc/internal/SerializingExecutor.java
@@ -59,7 +59,7 @@ private static AtomicHelper getAtomicHelper() {
   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. */
   private final Queue<Runnable> runQueue = new ConcurrentLinkedQueue<>();
@@ -76,6 +76,15 @@ public SerializingExecutor(Executor executor) {
     this.executor = executor;
   }
 
+  /**
+   * 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
    * before it, and using the {@code executor} passed to the constructor.     .
@@ -104,7 +113,7 @@ private void schedule(@Nullable Runnable removable) {
             // 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 RejectedExectuionException, so that future calls
+            // 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);
           }
@@ -118,7 +127,8 @@ private void schedule(@Nullable Runnable removable) {
   public void run() {
     Runnable r;
     try {
-      while ((r = runQueue.poll()) != null) {
+      Executor oldExecutor = executor;
+      while (oldExecutor == executor && (r = runQueue.poll()) != null ) {
         try {
           r.run();
         } catch (RuntimeException e) {
diff --git a/core/src/main/java/io/grpc/internal/ServerCallImpl.java b/core/src/main/java/io/grpc/internal/ServerCallImpl.java
index 6f123e76678..e224384ce8f 100644
--- a/core/src/main/java/io/grpc/internal/ServerCallImpl.java
+++ b/core/src/main/java/io/grpc/internal/ServerCallImpl.java
@@ -19,7 +19,9 @@
 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;
 
@@ -33,12 +35,16 @@
 import io.grpc.Context;
 import io.grpc.DecompressorRegistry;
 import io.grpc.InternalDecompressorRegistry;
+import io.grpc.InternalStatus;
 import io.grpc.Metadata;
 import io.grpc.MethodDescriptor;
+import io.grpc.SecurityLevel;
 import io.grpc.ServerCall;
 import io.grpc.Status;
+import io.grpc.StatusRuntimeException;
 import io.perfmark.PerfMark;
 import io.perfmark.Tag;
+import io.perfmark.TaskCloseable;
 import java.io.InputStream;
 import java.util.logging.Level;
 import java.util.logging.Logger;
@@ -85,21 +91,17 @@ final class ServerCallImpl<ReqT, RespT> extends ServerCall<ReqT, RespT> {
 
   @Override
   public void request(int numMessages) {
-    PerfMark.startTask("ServerCall.request", tag);
-    try {
+    try (TaskCloseable ignore = PerfMark.traceTask("ServerCall.request")) {
+      PerfMark.attachTag(tag);
       stream.request(numMessages);
-    } finally {
-      PerfMark.stopTask("ServerCall.request", tag);
     }
   }
 
   @Override
   public void sendHeaders(Metadata headers) {
-    PerfMark.startTask("ServerCall.sendHeaders", tag);
-    try {
+    try (TaskCloseable ignore = PerfMark.traceTask("ServerCall.sendHeaders")) {
+      PerfMark.attachTag(tag);
       sendHeadersInternal(headers);
-    } finally {
-      PerfMark.stopTask("ServerCall.sendHeaders", tag);
     }
   }
 
@@ -107,6 +109,7 @@ 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;
@@ -139,16 +142,14 @@ private void sendHeadersInternal(Metadata headers) {
     // 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) {
-    PerfMark.startTask("ServerCall.sendMessage", tag);
-    try {
+    try (TaskCloseable ignore = PerfMark.traceTask("ServerCall.sendMessage")) {
+      PerfMark.attachTag(tag);
       sendMessageInternal(message);
-    } finally {
-      PerfMark.stopTask("ServerCall.sendMessage", tag);
     }
   }
 
@@ -157,7 +158,7 @@ private void sendMessageInternal(RespT message) {
     checkState(!closeCalled, "call is closed");
 
     if (method.getType().serverSendsOneMessage() && messageSent) {
-      internalClose(Status.INTERNAL.withDescription(TOO_MANY_RESPONSES));
+      handleInternalError(Status.INTERNAL.withDescription(TOO_MANY_RESPONSES).asRuntimeException());
       return;
     }
 
@@ -165,9 +166,11 @@ private void sendMessageInternal(RespT message) {
     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"),
@@ -181,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.
@@ -192,16 +200,17 @@ public void setCompression(String compressorName) {
 
   @Override
   public boolean isReady() {
+    if (closeCalled) {
+      return false;
+    }
     return stream.isReady();
   }
 
   @Override
   public void close(Status status, Metadata trailers) {
-    PerfMark.startTask("ServerCall.close", tag);
-    try {
+    try (TaskCloseable ignore = PerfMark.traceTask("ServerCall.close")) {
+      PerfMark.attachTag(tag);
       closeInternal(status, trailers);
-    } finally {
-      PerfMark.stopTask("ServerCall.close", tag);
     }
   }
 
@@ -211,7 +220,7 @@ private void closeInternal(Status status, Metadata trailers) {
       closeCalled = true;
 
       if (status.isOk() && method.getType().serverSendsOneMessage() && !messageSent) {
-        internalClose(Status.INTERNAL.withDescription(MISSING_RESPONSE));
+        handleInternalError(Status.INTERNAL.withDescription(MISSING_RESPONSE).asRuntimeException());
         return;
       }
 
@@ -245,15 +254,29 @@ 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 internalClose(Status internalError) {
-    log.log(Level.WARNING, "Cancelling the stream with status {0}", new Object[] {internalError});
-    stream.cancel(internalError);
-    serverCallTracer.reportCallEnded(internalError.isOk()); // error so always false
+  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
   }
 
   /**
@@ -279,7 +302,11 @@ public ServerStreamListenerImpl(
           new Context.CancellationListener() {
             @Override
             public void cancelled(Context context) {
-              ServerStreamListenerImpl.this.call.cancelled = true;
+              // 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());
@@ -287,11 +314,9 @@ public void cancelled(Context context) {
 
     @Override
     public void messagesAvailable(MessageProducer producer) {
-      PerfMark.startTask("ServerStreamListener.messagesAvailable", call.tag);
-      try {
+      try (TaskCloseable ignore = PerfMark.traceTask("ServerStreamListener.messagesAvailable")) {
+        PerfMark.attachTag(call.tag);
         messagesAvailableInternal(producer);
-      } finally {
-        PerfMark.stopTask("ServerStreamListener.messagesAvailable", call.tag);
       }
     }
 
@@ -322,53 +347,52 @@ private void messagesAvailableInternal(final MessageProducer producer) {
 
     @Override
     public void halfClosed() {
-      PerfMark.startTask("ServerStreamListener.halfClosed", call.tag);
-      try {
+      try (TaskCloseable ignore = PerfMark.traceTask("ServerStreamListener.halfClosed")) {
+        PerfMark.attachTag(call.tag);
         if (call.cancelled) {
           return;
         }
 
         listener.onHalfClose();
-      } finally {
-        PerfMark.stopTask("ServerStreamListener.halfClosed", call.tag);
       }
     }
 
     @Override
     public void closed(Status status) {
-      PerfMark.startTask("ServerStreamListener.closed", call.tag);
-      try {
+      try (TaskCloseable ignore = PerfMark.traceTask("ServerStreamListener.closed")) {
+        PerfMark.attachTag(call.tag);
         closedInternal(status);
-      } finally {
-        PerfMark.stopTask("ServerStreamListener.closed", call.tag);
       }
     }
 
     private void closedInternal(Status status) {
+      Throwable cancelCause = null;
       try {
         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() {
-      PerfMark.startTask("ServerStreamListener.onReady", call.tag);
-      try {
+      try (TaskCloseable ignore = PerfMark.traceTask("ServerStreamListener.onReady")) {
+        PerfMark.attachTag(call.tag);
         if (call.cancelled) {
           return;
         }
         listener.onReady();
-      } finally {
-        PerfMark.stopTask("ServerCall.closed", call.tag);
       }
     }
   }
diff --git a/core/src/main/java/io/grpc/internal/ServerImpl.java b/core/src/main/java/io/grpc/internal/ServerImpl.java
index 6c66aac07ac..d9f64c2d473 100644
--- a/core/src/main/java/io/grpc/internal/ServerImpl.java
+++ b/core/src/main/java/io/grpc/internal/ServerImpl.java
@@ -28,8 +28,10 @@
 import com.google.common.annotations.VisibleForTesting;
 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 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;
@@ -44,8 +46,10 @@
 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;
@@ -55,6 +59,7 @@
 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;
@@ -71,7 +76,6 @@
 import java.util.concurrent.TimeUnit;
 import java.util.logging.Level;
 import java.util.logging.Logger;
-import javax.annotation.concurrent.GuardedBy;
 
 /**
  * Default implementation of {@link io.grpc.Server}, for creation by transports.
@@ -95,7 +99,7 @@ public final class ServerImpl extends io.grpc.Server implements InternalInstrume
   private final ObjectPool<? extends Executor> executorPool;
   /** Executor for application processing. Safe to read after {@link #start()}. */
   private Executor executor;
-  private final HandlerRegistry registry;
+  private final InternalHandlerRegistry registry;
   private final HandlerRegistry fallbackRegistry;
   private final List<ServerTransportFilter> transportFilters;
   // This is iterated on a per-call basis.  Use an array instead of a Collection to avoid iterator
@@ -125,6 +129,7 @@ public final class ServerImpl extends io.grpc.Server implements InternalInstrume
   private final InternalChannelz channelz;
   private final CallTracer serverCallTracer;
   private final Deadline.Ticker ticker;
+  private final ServerCallExecutorSupplier executorSupplier;
 
   /**
    * Construct a server.
@@ -146,7 +151,9 @@ public final class ServerImpl extends io.grpc.Server implements InternalInstrume
         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.rootContext = Preconditions.checkNotNull(rootContext, "rootContext")
+        .fork()
+        .withValue(io.grpc.InternalServer.SERVER_CONTEXT_KEY, ServerImpl.this);
     this.decompressorRegistry = builder.decompressorRegistry;
     this.compressorRegistry = builder.compressorRegistry;
     this.transportFilters = Collections.unmodifiableList(
@@ -159,6 +166,7 @@ public final class ServerImpl extends io.grpc.Server implements InternalInstrume
     this.serverCallTracer = builder.callTracerFactory.create();
     this.ticker = checkNotNull(builder.ticker, "ticker");
     channelz.addServer(this);
+    this.executorSupplier = builder.executorSupplier;
   }
 
   /**
@@ -456,11 +464,9 @@ public void transportTerminated() {
     @Override
     public void streamCreated(ServerStream stream, String methodName, Metadata headers) {
       Tag tag = PerfMark.createTag(methodName, stream.streamId());
-      PerfMark.startTask("ServerTransportListener.streamCreated", tag);
-      try {
+      try (TaskCloseable ignore = PerfMark.traceTask("ServerTransportListener.streamCreated")) {
+        PerfMark.attachTag(tag);
         streamCreatedInternal(stream, methodName, headers, tag);
-      } finally {
-        PerfMark.stopTask("ServerTransportListener.streamCreated", tag);
       }
     }
 
@@ -469,11 +475,11 @@ private void streamCreatedInternal(
       final Executor wrappedExecutor;
       // This is a performance optimization that avoids the synchronization and queuing overhead
       // that comes with SerializingExecutor.
-      if (executor == directExecutor()) {
+      if (executorSupplier != null || executor != directExecutor()) {
+        wrappedExecutor = new SerializingExecutor(executor);
+      } else {
         wrappedExecutor = new SerializeReentrantCallsDirectExecutor();
         stream.optimizeForDirectExecutor();
-      } else {
-        wrappedExecutor = new SerializingExecutor(executor);
       }
 
       if (headers.containsKey(MESSAGE_ENCODING_KEY)) {
@@ -492,59 +498,129 @@ private void streamCreatedInternal(
 
       final StatsTraceContext statsTraceCtx = Preconditions.checkNotNull(
           stream.statsTraceContext(), "statsTraceCtx not present from stream");
+      final ServerMethodDefinition<?, ?> primaryMethod = registry.lookupMethod(methodName, null);
 
       final Context.CancellableContext context = createContext(headers, statsTraceCtx);
+      if (primaryMethod != null) {
+        statsTraceCtx.serverCallMethodResolved(primaryMethod.getMethodDescriptor());
+      }
 
       final Link link = PerfMark.linkOut();
 
       final JumpToApplicationThreadServerStreamListener jumpListener
           = new JumpToApplicationThreadServerStreamListener(
-          wrappedExecutor, executor, stream, context, tag);
+                  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.
-
-      final class StreamCreated extends ContextRunnable {
-        StreamCreated() {
+      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() {
-          PerfMark.startTask("ServerTransportListener$StreamCreated.startCall", tag);
-          PerfMark.linkIn(link);
-          try {
+          try (TaskCloseable ignore =
+                   PerfMark.traceTask("ServerTransportListener$MethodLookup.startCall")) {
+            PerfMark.attachTag(tag);
+            PerfMark.linkIn(link);
             runInternal();
-          } finally {
-            PerfMark.stopTask("ServerTransportListener$StreamCreated.startCall", tag);
           }
         }
 
         private void runInternal() {
-          ServerStreamListener listener = NOOP_LISTENER;
+          ServerMethodDefinition<?, ?> wrapMethod;
+          ServerCallParameters<?, ?> callParams;
           try {
-            ServerMethodDefinition<?, ?> method = registry.lookupMethod(methodName);
+            ServerMethodDefinition<?, ?> method = primaryMethod;
             if (method == null) {
               method = fallbackRegistry.lookupMethod(methodName, stream.getAuthority());
             }
             if (method == null) {
               Status status = Status.UNIMPLEMENTED.withDescription(
-                  "Method not found: " + methodName);
+                      "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);
+              future.cancel(false);
               return;
             }
-            listener = startCall(stream, methodName, method, headers, context, statsTraceCtx, tag);
+            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);
           }
@@ -552,23 +628,12 @@ private void runInternal() {
           // 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());
+          context.addListener(new ServerStreamCancellationListener(stream), directExecutor());
         }
       }
 
-      wrappedExecutor.execute(new StreamCreated());
+      wrappedExecutor.execute(new MethodLookup());
+      wrappedExecutor.execute(new HandleServerCall());
     }
 
     private Context.CancellableContext createContext(
@@ -577,8 +642,7 @@ private Context.CancellableContext createContext(
 
       Context baseContext =
           statsTraceCtx
-              .serverFilterContext(rootContext)
-              .withValue(io.grpc.InternalServer.SERVER_CONTEXT_KEY, ServerImpl.this);
+              .serverFilterContext(rootContext);
 
       if (timeoutNanos == null) {
         return baseContext.withCancellation();
@@ -593,9 +657,8 @@ private Context.CancellableContext createContext(
     }
 
     /** Never returns {@code null}. */
-    private <ReqT, RespT> ServerStreamListener startCall(ServerStream stream, String fullMethodName,
-        ServerMethodDefinition<ReqT, RespT> methodDef, Metadata headers,
-        Context.CancellableContext context, StatsTraceContext statsTraceCtx, Tag tag) {
+    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?
       statsTraceCtx.serverCallStarted(
           new ServerCallInfoImpl<>(
@@ -604,39 +667,61 @@ private <ReqT, RespT> ServerStreamListener startCall(ServerStream stream, String
               stream.getAuthority()));
       ServerCallHandler<ReqT, RespT> handler = methodDef.getServerCallHandler();
       for (ServerInterceptor interceptor : interceptors) {
-        handler = InternalServerInterceptors.interceptCallHandler(interceptor, handler);
+        handler = InternalServerInterceptors.interceptCallHandlerCreate(interceptor, handler);
       }
       ServerMethodDefinition<ReqT, RespT> interceptedDef = methodDef.withServerCallHandler(handler);
       ServerMethodDefinition<?, ?> wMethodDef = binlog == null
           ? interceptedDef : binlog.wrapMethodDefinition(interceptedDef);
-      return startWrappedCall(fullMethodName, wMethodDef, stream, headers, context, tag);
+      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,
-        ServerMethodDefinition<WReqT, WRespT> methodDef,
-        ServerStream stream,
-        Metadata headers,
-        Context.CancellableContext context,
-        Tag tag) {
-
-      ServerCallImpl<WReqT, WRespT> call = new ServerCallImpl<>(
-          stream,
-          methodDef.getMethodDescriptor(),
-          headers,
-          context,
-          decompressorRegistry,
-          compressorRegistry,
-          serverCallTracer,
-          tag);
-
-      ServerCall.Listener<WReqT> listener =
-          methodDef.getServerCallHandler().startCall(call, headers);
-      if (listener == null) {
+        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 params.call.newServerStreamListener(callListener);
+    }
+  }
+
+  /**
+   * Propagates context cancellation to the ServerStream.
+   *
+   * <p>This is outside of HandleServerCall because that class holds Metadata and other state needed
+   * only when starting the RPC. The cancellation listener will live for the life of the call, so we
+   * avoid that useless state being retained.
+   */
+  static final class ServerStreamCancellationListener implements Context.CancellationListener {
+    private final ServerStream stream;
+
+    ServerStreamCancellationListener(ServerStream stream) {
+      this.stream = checkNotNull(stream, "stream");
+    }
+
+    @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);
       }
-      return call.newServerStreamListener(listener);
     }
   }
 
@@ -743,81 +828,71 @@ void setListener(ServerStreamListener listener) {
      */
     private void internalClose(Throwable t) {
       // TODO(ejona86): this is not thread-safe :)
-      stream.close(Status.UNKNOWN.withCause(t), new Metadata());
+      String description = "Application error processing RPC";
+      stream.close(Status.UNKNOWN.withDescription(description).withCause(t), new Metadata());
     }
 
     @Override
     public void messagesAvailable(final MessageProducer producer) {
-      PerfMark.startTask("ServerStreamListener.messagesAvailable", tag);
-      final Link link = PerfMark.linkOut();
-
-      final class MessagesAvailable extends ContextRunnable {
+      try (TaskCloseable ignore = PerfMark.traceTask("ServerStreamListener.messagesAvailable")) {
+        PerfMark.attachTag(tag);
+        final Link link = PerfMark.linkOut();
+        final class MessagesAvailable extends ContextRunnable {
 
-        MessagesAvailable() {
-          super(context);
-        }
+          MessagesAvailable() {
+            super(context);
+          }
 
-        @Override
-        public void runInContext() {
-          PerfMark.startTask("ServerCallListener(app).messagesAvailable", tag);
-          PerfMark.linkIn(link);
-          try {
-            getListener().messagesAvailable(producer);
-          } catch (Throwable t) {
-            internalClose(t);
-            throw t;
-          } finally {
-            PerfMark.stopTask("ServerCallListener(app).messagesAvailable", tag);
+          @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;
+            }
           }
         }
-      }
 
-      try {
         callExecutor.execute(new MessagesAvailable());
-      } finally {
-        PerfMark.stopTask("ServerStreamListener.messagesAvailable", tag);
       }
     }
 
     @Override
     public void halfClosed() {
-      PerfMark.startTask("ServerStreamListener.halfClosed", tag);
-      final Link link = PerfMark.linkOut();
-
-      final class HalfClosed extends ContextRunnable {
-        HalfClosed() {
-          super(context);
-        }
+      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() {
-          PerfMark.startTask("ServerCallListener(app).halfClosed", tag);
-          PerfMark.linkIn(link);
-          try {
-            getListener().halfClosed();
-          } catch (Throwable t) {
-            internalClose(t);
-            throw t;
-          } finally {
-            PerfMark.stopTask("ServerCallListener(app).halfClosed", tag);
+          @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;
+            }
           }
         }
-      }
 
-      try {
         callExecutor.execute(new HalfClosed());
-      } finally {
-        PerfMark.stopTask("ServerStreamListener.halfClosed", tag);
       }
     }
 
     @Override
     public void closed(final Status status) {
-      PerfMark.startTask("ServerStreamListener.closed", tag);
-      try {
+      try (TaskCloseable ignore = PerfMark.traceTask("ServerStreamListener.closed")) {
+        PerfMark.attachTag(tag);
         closedInternal(status);
-      } finally {
-        PerfMark.stopTask("ServerStreamListener.closed", tag);
       }
     }
 
@@ -825,9 +900,18 @@ 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, status.getCause()));
+        cancelExecutor.execute(new ContextCloser(context, cancelCause));
       }
       final Link link = PerfMark.linkOut();
 
@@ -838,12 +922,10 @@ final class Closed extends ContextRunnable {
 
         @Override
         public void runInContext() {
-          PerfMark.startTask("ServerCallListener(app).closed", tag);
-          PerfMark.linkIn(link);
-          try {
+          try (TaskCloseable ignore = PerfMark.traceTask("ServerCallListener(app).closed")) {
+            PerfMark.attachTag(tag);
+            PerfMark.linkIn(link);
             getListener().closed(status);
-          } finally {
-            PerfMark.stopTask("ServerCallListener(app).closed", tag);
           }
         }
       }
@@ -853,32 +935,29 @@ public void runInContext() {
 
     @Override
     public void onReady() {
-      PerfMark.startTask("ServerStreamListener.onReady", tag);
-      final Link link = PerfMark.linkOut();
-      final class OnReady extends ContextRunnable {
-        OnReady() {
-          super(context);
-        }
+      try (TaskCloseable ignore = PerfMark.traceTask("ServerStreamListener.onReady")) {
+        PerfMark.attachTag(tag);
+        final Link link = PerfMark.linkOut();
 
-        @Override
-        public void runInContext() {
-          PerfMark.startTask("ServerCallListener(app).onReady", tag);
-          PerfMark.linkIn(link);
-          try {
-            getListener().onReady();
-          } catch (Throwable t) {
-            internalClose(t);
-            throw t;
-          } finally {
-            PerfMark.stopTask("ServerCallListener(app).onReady", tag);
+        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;
+            }
           }
         }
-      }
 
-      try {
         callExecutor.execute(new OnReady());
-      } finally {
-        PerfMark.stopTask("ServerStreamListener.onReady", tag);
       }
     }
   }
diff --git a/core/src/main/java/io/grpc/internal/ServerImplBuilder.java b/core/src/main/java/io/grpc/internal/ServerImplBuilder.java
index 04e6059d13f..62a0e66f314 100644
--- a/core/src/main/java/io/grpc/internal/ServerImplBuilder.java
+++ b/core/src/main/java/io/grpc/internal/ServerImplBuilder.java
@@ -21,6 +21,7 @@
 
 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;
@@ -29,8 +30,13 @@
 import io.grpc.DecompressorRegistry;
 import io.grpc.HandlerRegistry;
 import io.grpc.InternalChannelz;
+import io.grpc.InternalConfiguratorRegistry;
+import io.grpc.MetricInstrumentRegistry;
+import io.grpc.MetricRecorder;
+import io.grpc.MetricSink;
 import io.grpc.Server;
 import io.grpc.ServerBuilder;
+import io.grpc.ServerCallExecutorSupplier;
 import io.grpc.ServerInterceptor;
 import io.grpc.ServerMethodDefinition;
 import io.grpc.ServerServiceDefinition;
@@ -55,6 +61,7 @@ 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");
@@ -76,6 +83,7 @@ public static ServerBuilder<?> forPort(int port) {
   final List<ServerTransportFilter> transportFilters = new ArrayList<>();
   final List<ServerInterceptor> interceptors = new ArrayList<>();
   private final List<ServerStreamTracer.Factory> streamTracerFactories = new ArrayList<>();
+  final List<MetricSink> metricSinks = new ArrayList<>();
   private final ClientTransportServersBuilder clientTransportServersBuilder;
   HandlerRegistry fallbackRegistry = DEFAULT_FALLBACK_REGISTRY;
   ObjectPool<? extends Executor> executorPool = DEFAULT_EXECUTOR_POOL;
@@ -91,14 +99,17 @@ public static ServerBuilder<?> forPort(int port) {
   @Nullable BinaryLog binlog;
   InternalChannelz channelz = InternalChannelz.instance();
   CallTracer.Factory callTracerFactory = CallTracer.getDefaultFactory();
+  @Nullable
+  ServerCallExecutorSupplier executorSupplier;
 
   /**
-   * An interface to provide to provide transport specific information for the server. This method
+   * 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);
+        List<? extends ServerStreamTracer.Factory> streamTracerFactories,
+        MetricRecorder metricRecorder);
   }
 
   /**
@@ -107,6 +118,8 @@ InternalServer buildClientTransportServers(
   public ServerImplBuilder(ClientTransportServersBuilder clientTransportServersBuilder) {
     this.clientTransportServersBuilder = checkNotNull(clientTransportServersBuilder,
         "clientTransportServersBuilder");
+    // TODO(dnvindhya): Move configurator to all the individual builders
+    InternalConfiguratorRegistry.configureServerBuilder(this);
   }
 
   @Override
@@ -120,6 +133,12 @@ public ServerImplBuilder executor(@Nullable Executor executor) {
     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"));
@@ -143,6 +162,15 @@ public ServerImplBuilder intercept(ServerInterceptor interceptor) {
     return this;
   }
 
+  /**
+   * Adds a MetricSink to the server.
+   */
+  @Override
+  public ServerImplBuilder addMetricSink(MetricSink metricSink) {
+    metricSinks.add(checkNotNull(metricSink, "metricSink"));
+    return this;
+  }
+
   @Override
   public ServerImplBuilder addStreamTracerFactory(ServerStreamTracer.Factory factory) {
     streamTracerFactories.add(checkNotNull(factory, "factory"));
@@ -227,13 +255,20 @@ public void setDeadlineTicker(Deadline.Ticker ticker) {
 
   @Override
   public Server build() {
+    MetricRecorder metricRecorder = new MetricRecorderImpl(metricSinks,
+        MetricInstrumentRegistry.getDefaultRegistry());
     return new ServerImpl(this,
-        clientTransportServersBuilder.buildClientTransportServers(getTracerFactories()),
+        clientTransportServersBuilder.buildClientTransportServers(
+                getTracerFactories(), metricRecorder),
         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;
diff --git a/core/src/main/java/io/grpc/internal/ServerStream.java b/core/src/main/java/io/grpc/internal/ServerStream.java
index 658511939e8..aa5ba10329c 100644
--- a/core/src/main/java/io/grpc/internal/ServerStream.java
+++ b/core/src/main/java/io/grpc/internal/ServerStream.java
@@ -36,7 +36,7 @@ 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
@@ -96,4 +96,15 @@ public interface ServerStream extends Stream {
    * 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/ServiceConfigState.java b/core/src/main/java/io/grpc/internal/ServiceConfigState.java
index 73486bb0bd9..d916c2d0e9f 100644
--- a/core/src/main/java/io/grpc/internal/ServiceConfigState.java
+++ b/core/src/main/java/io/grpc/internal/ServiceConfigState.java
@@ -35,6 +35,8 @@ final class ServiceConfigState {
   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.
    */
diff --git a/core/src/main/java/io/grpc/internal/ServiceConfigUtil.java b/core/src/main/java/io/grpc/internal/ServiceConfigUtil.java
index e6df6240d19..34d44f7f549 100644
--- a/core/src/main/java/io/grpc/internal/ServiceConfigUtil.java
+++ b/core/src/main/java/io/grpc/internal/ServiceConfigUtil.java
@@ -113,8 +113,8 @@ static Throttle getThrottlePolicy(@Nullable Map<String, ?> serviceConfig) {
     }
 
     // TODO(dapengzhang0): check if this is null.
-    float maxTokens = JsonUtil.getNumber(throttling, "maxTokens").floatValue();
-    float tokenRatio = JsonUtil.getNumber(throttling, "tokenRatio").floatValue();
+    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);
@@ -137,7 +137,12 @@ static Long getMaxBackoffNanosFromRetryPolicy(Map<String, ?> retryPolicy) {
 
   @Nullable
   static Double getBackoffMultiplierFromRetryPolicy(Map<String, ?> retryPolicy) {
-    return JsonUtil.getNumber(retryPolicy, "backoffMultiplier");
+    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) {
@@ -178,7 +183,6 @@ static Set<Status.Code> getRetryableStatusCodesFromRetryPolicy(Map<String, ?> re
     String retryableStatusCodesKey = "retryableStatusCodes";
     Set<Status.Code> codes = getListOfStatusCodesAsSet(retryPolicy, retryableStatusCodesKey);
     verify(codes != null, "%s is required in retry policy", retryableStatusCodesKey);
-    verify(!codes.isEmpty(), "%s must not be empty", retryableStatusCodesKey);
     verify(!codes.contains(Status.Code.OK), "%s must not contain OK", retryableStatusCodesKey);
     return codes;
   }
diff --git a/core/src/main/java/io/grpc/internal/SharedResourceHolder.java b/core/src/main/java/io/grpc/internal/SharedResourceHolder.java
index 67d1a98b545..1dfa1f90718 100644
--- a/core/src/main/java/io/grpc/internal/SharedResourceHolder.java
+++ b/core/src/main/java/io/grpc/internal/SharedResourceHolder.java
@@ -134,18 +134,16 @@ synchronized <T> T releaseInternal(final Resource<T> resource, final T instance)
         public void run() {
           synchronized (SharedResourceHolder.this) {
             // Refcount may have gone up since the task was scheduled. Re-check it.
-            if (cached.refcount == 0) {
-              try {
-                resource.close(instance);
-              } finally {
-                instances.remove(resource);
-                if (instances.isEmpty()) {
-                  destroyer.shutdown();
-                  destroyer = null;
-                }
-              }
+            if (cached.refcount != 0) {
+              return;
+            }
+            instances.remove(resource);
+            if (instances.isEmpty()) {
+              destroyer.shutdown();
+              destroyer = null;
             }
           }
+          resource.close(instance);
         }
       }), DESTROY_DELAY_SECONDS, TimeUnit.SECONDS);
     }
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/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/StatsTraceContext.java b/core/src/main/java/io/grpc/internal/StatsTraceContext.java
index adb0b63ec8a..007aefc0fb8 100644
--- a/core/src/main/java/io/grpc/internal/StatsTraceContext.java
+++ b/core/src/main/java/io/grpc/internal/StatsTraceContext.java
@@ -20,10 +20,10 @@
 
 import com.google.common.annotations.VisibleForTesting;
 import io.grpc.Attributes;
-import io.grpc.CallOptions;
 import io.grpc.ClientStreamTracer;
 import io.grpc.Context;
 import io.grpc.Metadata;
+import io.grpc.MethodDescriptor;
 import io.grpc.ServerStreamTracer;
 import io.grpc.ServerStreamTracer.ServerCallInfo;
 import io.grpc.Status;
@@ -39,6 +39,14 @@
  */
 @ThreadSafe
 public final class StatsTraceContext {
+  /**
+   * Internal hook for server tracers that can use the resolved method descriptor before
+   * {@link ServerStreamTracer#serverCallStarted(ServerCallInfo)} runs.
+   */
+  public interface ServerCallMethodListener {
+    void serverCallMethodResolved(MethodDescriptor<?, ?> method);
+  }
+
   public static final StatsTraceContext NOOP = new StatsTraceContext(new StreamTracer[0]);
 
   private final StreamTracer[] tracers;
@@ -48,21 +56,12 @@ public final class StatsTraceContext {
    * Factory method for the client-side.
    */
   public static StatsTraceContext newClientContext(
-      final CallOptions callOptions, final Attributes transportAttrs, Metadata headers) {
-    List<ClientStreamTracer.Factory> factories = callOptions.getStreamTracerFactories();
-    if (factories.isEmpty()) {
-      return NOOP;
+      ClientStreamTracer[] tracers, Attributes transportAtts, Metadata headers) {
+    StatsTraceContext ctx = new StatsTraceContext(tracers);
+    for (ClientStreamTracer tracer : tracers) {
+      tracer.streamCreated(transportAtts, headers);
     }
-    ClientStreamTracer.StreamInfo info =
-        ClientStreamTracer.StreamInfo.newBuilder()
-            .setTransportAttrs(transportAttrs).setCallOptions(callOptions).build();
-    // This array will be iterated multiple times per RPC. Use primitive array instead of Collection
-    // so that for-each doesn't create an Iterator every time.
-    StreamTracer[] tracers = new StreamTracer[factories.size()];
-    for (int i = 0; i < tracers.length; i++) {
-      tracers[i] = factories.get(i).newClientStreamTracer(info, headers);
-    }
-    return new StatsTraceContext(tracers);
+    return ctx;
   }
 
   /**
@@ -111,9 +110,9 @@ public void clientOutboundHeaders() {
    *
    * <p>Called from abstract stream implementations.
    */
-  public void clientInboundHeaders() {
+  public void clientInboundHeaders(Metadata headers) {
     for (StreamTracer tracer : tracers) {
-      ((ClientStreamTracer) tracer).inboundHeaders();
+      ((ClientStreamTracer) tracer).inboundHeaders(headers);
     }
   }
 
@@ -129,10 +128,11 @@ public void clientInboundTrailers(Metadata trailers) {
   }
 
   /**
-   * See {@link ServerStreamTracer#filterContext}.  For server-side only.
+   * 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) {
@@ -153,6 +153,20 @@ public void serverCallStarted(ServerCallInfo<?, ?> callInfo) {
     }
   }
 
+  /**
+   * Notifies server tracers that a primary-registry method descriptor was resolved before
+   * {@link ServerStreamTracer#serverCallStarted(ServerCallInfo)}.
+   *
+   * <p>Called from {@link io.grpc.internal.ServerImpl}.
+   */
+  public void serverCallMethodResolved(MethodDescriptor<?, ?> method) {
+    for (StreamTracer tracer : tracers) {
+      if (tracer instanceof ServerCallMethodListener) {
+        ((ServerCallMethodListener) tracer).serverCallMethodResolved(method);
+      }
+    }
+  }
+
   /**
    * See {@link StreamTracer#streamClosed}. This may be called multiple times, and only the first
    * value will be taken.
diff --git a/core/src/main/java/io/grpc/internal/StreamListener.java b/core/src/main/java/io/grpc/internal/StreamListener.java
index 090c0555b0a..a893a9c84b6 100644
--- a/core/src/main/java/io/grpc/internal/StreamListener.java
+++ b/core/src/main/java/io/grpc/internal/StreamListener.java
@@ -59,6 +59,6 @@ interface MessageProducer {
      * messages until the producer returns null, at which point the producer may be discarded.
      */
     @Nullable
-    public InputStream next();
+    InputStream next();
   }
 }
diff --git a/core/src/main/java/io/grpc/internal/SubchannelChannel.java b/core/src/main/java/io/grpc/internal/SubchannelChannel.java
index 6c316e4f185..ced4272afe3 100644
--- a/core/src/main/java/io/grpc/internal/SubchannelChannel.java
+++ b/core/src/main/java/io/grpc/internal/SubchannelChannel.java
@@ -22,6 +22,7 @@
 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;
@@ -42,7 +43,7 @@ final class SubchannelChannel extends Channel {
       Status.UNAVAILABLE.withDescription(
           "wait-for-ready RPC is not supported on Subchannel.asChannel()");
   private static final FailingClientTransport notReadyTransport =
-      new FailingClientTransport(NOT_READY_ERROR, RpcProgress.REFUSED);
+      new FailingClientTransport(NOT_READY_ERROR, RpcProgress.MISCARRIED);
   private final InternalSubchannel subchannel;
   private final Executor executor;
   private final ScheduledExecutorService deadlineCancellationExecutor;
@@ -57,9 +58,12 @@ public ClientStream newStream(MethodDescriptor<?, ?> method,
         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);
+          return transport.newStream(method, headers, callOptions, tracers);
         } finally {
           context.detach(origContext);
         }
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/TimeProvider.java b/core/src/main/java/io/grpc/internal/TimeProvider.java
index b0ea147ada1..3bd052ab3e0 100644
--- a/core/src/main/java/io/grpc/internal/TimeProvider.java
+++ b/core/src/main/java/io/grpc/internal/TimeProvider.java
@@ -16,8 +16,6 @@
 
 package io.grpc.internal;
 
-import java.util.concurrent.TimeUnit;
-
 /**
  * Time source representing the current system time in nanos. Used to inject a fake clock
  * into unit tests.
@@ -26,10 +24,5 @@ public 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());
-    }
-  };
+  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 51854410843..3bd7ee72239 100644
--- a/core/src/main/java/io/grpc/internal/TransportFrameUtil.java
+++ b/core/src/main/java/io/grpc/internal/TransportFrameUtil.java
@@ -16,16 +16,16 @@
 
 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;
-import javax.annotation.CheckReturnValue;
 
 /**
  * Utility functions for transport layer framing.
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/util/ForwardingClientStreamTracer.java b/core/src/main/java/io/grpc/util/ForwardingClientStreamTracer.java
deleted file mode 100644
index de7d12e397c..00000000000
--- a/core/src/main/java/io/grpc/util/ForwardingClientStreamTracer.java
+++ /dev/null
@@ -1,94 +0,0 @@
-/*
- * 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.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 outboundHeaders() {
-    delegate().outboundHeaders();
-  }
-
-  @Override
-  public void inboundHeaders() {
-    delegate().inboundHeaders();
-  }
-
-  @Override
-  public void inboundTrailers(Metadata trailers) {
-    delegate().inboundTrailers(trailers);
-  }
-
-  @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/util/GracefulSwitchLoadBalancer.java b/core/src/main/java/io/grpc/util/GracefulSwitchLoadBalancer.java
deleted file mode 100644
index 7cba3098ca6..00000000000
--- a/core/src/main/java/io/grpc/util/GracefulSwitchLoadBalancer.java
+++ /dev/null
@@ -1,197 +0,0 @@
-/*
- * 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.annotations.VisibleForTesting;
-import com.google.common.base.MoreObjects;
-import io.grpc.ConnectivityState;
-import io.grpc.ConnectivityStateInfo;
-import io.grpc.ExperimentalApi;
-import io.grpc.LoadBalancer;
-import io.grpc.Status;
-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 reports READY or the old policy exits READY.
- *
- * <p>The balancer must {@link #switchTo(LoadBalancer.Factory) switch to} a policy prior to {@link
- * LoadBalancer#handleResolvedAddresses(ResolvedAddresses) handling resolved addresses} for the
- * first time.
- */
-@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 void handleResolvedAddresses(ResolvedAddresses resolvedAddresses) {
-      //  Most LB policies using this class will receive child policy configuration within the
-      //  service config, so they are naturally calling switchTo() just before
-      //  handleResolvedAddresses(), within their own handleResolvedAddresses(). If switchTo() is
-      //  not called immediately after construction that does open up potential for bugs in the
-      //  parent policies, where they fail to call switchTo(). So we will use the exception to try
-      //  to notice those bugs quickly, as it will fail very loudly.
-      throw new IllegalStateException(
-          "GracefulSwitchLoadBalancer must switch to a load balancing policy before handling"
-              + " ResolvedAddresses");
-    }
-
-    @Override
-    public void handleNameResolutionError(final Status error) {
-      class ErrorPicker extends SubchannelPicker {
-        @Override
-        public PickResult pickSubchannel(PickSubchannelArgs args) {
-          return PickResult.withError(error);
-        }
-
-        @Override
-        public String toString() {
-          return MoreObjects.toStringHelper(ErrorPicker.class).add("error", error).toString();
-        }
-      }
-
-      helper.updateBalancingState(
-          ConnectivityState.TRANSIENT_FAILURE,
-          new ErrorPicker());
-    }
-
-    @Override
-    public void shutdown() {}
-  };
-
-  @VisibleForTesting
-  static final SubchannelPicker BUFFER_PICKER = new SubchannelPicker() {
-    @Override
-    public PickResult pickSubchannel(PickSubchannelArgs args) {
-      return PickResult.withNoResult();
-    }
-
-    @Override
-    public String toString() {
-      return "BUFFER_PICKER";
-    }
-  };
-
-  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");
-  }
-
-  /**
-   * Gracefully switch to a new policy defined by the given factory, if the given factory isn't
-   * equal to the current one.
-   */
-  public void switchTo(LoadBalancer.Factory newBalancerFactory) {
-    checkNotNull(newBalancerFactory, "newBalancerFactory");
-
-    if (newBalancerFactory.equals(pendingBalancerFactory)) {
-      return;
-    }
-    pendingLb.shutdown();
-    pendingLb = defaultBalancer;
-    pendingBalancerFactory = null;
-    pendingState = ConnectivityState.CONNECTING;
-    pendingPicker = BUFFER_PICKER;
-
-    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.READY) {
-            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();
-  }
-}
diff --git a/core/src/main/java/io/grpc/util/RoundRobinLoadBalancer.java b/core/src/main/java/io/grpc/util/RoundRobinLoadBalancer.java
deleted file mode 100644
index 179755cbf8e..00000000000
--- a/core/src/main/java/io/grpc/util/RoundRobinLoadBalancer.java
+++ /dev/null
@@ -1,359 +0,0 @@
-/*
- * 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.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.base.MoreObjects;
-import com.google.common.base.Objects;
-import com.google.common.base.Preconditions;
-import io.grpc.Attributes;
-import io.grpc.ConnectivityState;
-import io.grpc.ConnectivityStateInfo;
-import io.grpc.EquivalentAddressGroup;
-import io.grpc.LoadBalancer;
-import io.grpc.NameResolver;
-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.Random;
-import java.util.Set;
-import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
-import javax.annotation.Nonnull;
-
-/**
- * A {@link LoadBalancer} that provides round-robin load-balancing over the {@link
- * EquivalentAddressGroup}s from the {@link NameResolver}.
- */
-final class RoundRobinLoadBalancer extends LoadBalancer {
-  @VisibleForTesting
-  static final Attributes.Key<Ref<ConnectivityStateInfo>> STATE_INFO =
-      Attributes.Key.create("state-info");
-
-  private final Helper helper;
-  private final Map<EquivalentAddressGroup, Subchannel> subchannels =
-      new HashMap<>();
-  private final Random random;
-
-  private ConnectivityState currentState;
-  private RoundRobinPicker currentPicker = new EmptyPicker(EMPTY_OK);
-
-  RoundRobinLoadBalancer(Helper helper) {
-    this.helper = checkNotNull(helper, "helper");
-    this.random = new Random();
-  }
-
-  @Override
-  public void handleResolvedAddresses(ResolvedAddresses resolvedAddresses) {
-    List<EquivalentAddressGroup> servers = resolvedAddresses.getAddresses();
-    Set<EquivalentAddressGroup> currentAddrs = subchannels.keySet();
-    Map<EquivalentAddressGroup, EquivalentAddressGroup> latestAddrs = stripAttrs(servers);
-    Set<EquivalentAddressGroup> removedAddrs = setsDifference(currentAddrs, latestAddrs.keySet());
-
-    for (Map.Entry<EquivalentAddressGroup, EquivalentAddressGroup> latestEntry :
-        latestAddrs.entrySet()) {
-      EquivalentAddressGroup strippedAddressGroup = latestEntry.getKey();
-      EquivalentAddressGroup originalAddressGroup = latestEntry.getValue();
-      Subchannel existingSubchannel = subchannels.get(strippedAddressGroup);
-      if (existingSubchannel != null) {
-        // EAG's Attributes may have changed.
-        existingSubchannel.updateAddresses(Collections.singletonList(originalAddressGroup));
-        continue;
-      }
-      // Create new subchannels for new addresses.
-
-      // 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.Builder 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 leverage that and set
-          // AtomicReference which will allow mutating state info for given channel.
-          .set(STATE_INFO,
-              new Ref<>(ConnectivityStateInfo.forNonError(IDLE)));
-
-      final Subchannel subchannel = checkNotNull(
-          helper.createSubchannel(CreateSubchannelArgs.newBuilder()
-              .setAddresses(originalAddressGroup)
-              .setAttributes(subchannelAttrs.build())
-              .build()),
-          "subchannel");
-      subchannel.start(new SubchannelStateListener() {
-          @Override
-          public void onSubchannelState(ConnectivityStateInfo state) {
-            processSubchannelState(subchannel, state);
-          }
-        });
-      subchannels.put(strippedAddressGroup, subchannel);
-      subchannel.requestConnection();
-    }
-
-    ArrayList<Subchannel> removedSubchannels = new ArrayList<>();
-    for (EquivalentAddressGroup addressGroup : removedAddrs) {
-      removedSubchannels.add(subchannels.remove(addressGroup));
-    }
-
-    // Update the picker before shutting down the subchannels, to reduce the chance of the race
-    // between picking a subchannel and shutting it down.
-    updateBalancingState();
-
-    // Shutdown removed subchannels
-    for (Subchannel removedSubchannel : removedSubchannels) {
-      shutdownSubchannel(removedSubchannel);
-    }
-  }
-
-  @Override
-  public void handleNameResolutionError(Status error) {
-    if (currentState != READY)  {
-      updateBalancingState(TRANSIENT_FAILURE, new EmptyPicker(error));
-    }
-  }
-
-  private void processSubchannelState(Subchannel subchannel, ConnectivityStateInfo stateInfo) {
-    if (subchannels.get(stripAttrs(subchannel.getAddresses())) != subchannel) {
-      return;
-    }
-    if (stateInfo.getState() == IDLE) {
-      subchannel.requestConnection();
-    }
-    Ref<ConnectivityStateInfo> subchannelStateRef = getSubchannelStateInfoRef(subchannel);
-    if (subchannelStateRef.value.getState().equals(TRANSIENT_FAILURE)) {
-      if (stateInfo.getState().equals(CONNECTING) || stateInfo.getState().equals(IDLE)) {
-        return;
-      }
-    }
-    subchannelStateRef.value = stateInfo;
-    updateBalancingState();
-  }
-
-  private void shutdownSubchannel(Subchannel subchannel) {
-    subchannel.shutdown();
-    getSubchannelStateInfoRef(subchannel).value =
-        ConnectivityStateInfo.forNonError(SHUTDOWN);
-  }
-
-  @Override
-  public void shutdown() {
-    for (Subchannel subchannel : getSubchannels()) {
-      shutdownSubchannel(subchannel);
-    }
-  }
-
-  private static final Status EMPTY_OK = Status.OK.withDescription("no subchannels ready");
-
-  /**
-   * Updates picker with the list of active subchannels (state == READY).
-   */
-  @SuppressWarnings("ReferenceEquality")
-  private void updateBalancingState() {
-    List<Subchannel> activeList = filterNonFailingSubchannels(getSubchannels());
-    if (activeList.isEmpty()) {
-      // No READY subchannels, determine aggregate state and error status
-      boolean isConnecting = false;
-      Status aggStatus = EMPTY_OK;
-      for (Subchannel subchannel : getSubchannels()) {
-        ConnectivityStateInfo stateInfo = getSubchannelStateInfoRef(subchannel).value;
-        // This subchannel IDLE is not because of channel IDLE_TIMEOUT,
-        // in which case LB is already shutdown.
-        // RRLB will request connection immediately on subchannel IDLE.
-        if (stateInfo.getState() == CONNECTING || stateInfo.getState() == IDLE) {
-          isConnecting = true;
-        }
-        if (aggStatus == EMPTY_OK || !aggStatus.isOk()) {
-          aggStatus = stateInfo.getStatus();
-        }
-      }
-      updateBalancingState(isConnecting ? CONNECTING : TRANSIENT_FAILURE,
-          // If all subchannels are TRANSIENT_FAILURE, return the Status associated with
-          // an arbitrary subchannel, otherwise return OK.
-          new EmptyPicker(aggStatus));
-    } else {
-      // initialize the Picker to a random start index to ensure that a high frequency of Picker
-      // churn does not skew subchannel selection.
-      int startIndex = random.nextInt(activeList.size());
-      updateBalancingState(READY, new ReadyPicker(activeList, startIndex));
-    }
-  }
-
-  private void updateBalancingState(ConnectivityState state, RoundRobinPicker picker) {
-    if (state != currentState || !picker.isEquivalentTo(currentPicker)) {
-      helper.updateBalancingState(state, picker);
-      currentState = state;
-      currentPicker = picker;
-    }
-  }
-
-  /**
-   * Filters out non-ready subchannels.
-   */
-  private static List<Subchannel> filterNonFailingSubchannels(
-      Collection<Subchannel> subchannels) {
-    List<Subchannel> readySubchannels = new ArrayList<>(subchannels.size());
-    for (Subchannel subchannel : subchannels) {
-      if (isReady(subchannel)) {
-        readySubchannels.add(subchannel);
-      }
-    }
-    return readySubchannels;
-  }
-
-  /**
-   * Converts list of {@link EquivalentAddressGroup} to {@link EquivalentAddressGroup} set and
-   * remove all attributes. The values are the original EAGs.
-   */
-  private static Map<EquivalentAddressGroup, EquivalentAddressGroup> stripAttrs(
-      List<EquivalentAddressGroup> groupList) {
-    Map<EquivalentAddressGroup, EquivalentAddressGroup> addrs = new HashMap<>(groupList.size() * 2);
-    for (EquivalentAddressGroup group : groupList) {
-      addrs.put(stripAttrs(group), group);
-    }
-    return addrs;
-  }
-
-  private static EquivalentAddressGroup stripAttrs(EquivalentAddressGroup eag) {
-    return new EquivalentAddressGroup(eag.getAddresses());
-  }
-
-  @VisibleForTesting
-  Collection<Subchannel> getSubchannels() {
-    return subchannels.values();
-  }
-
-  private static Ref<ConnectivityStateInfo> getSubchannelStateInfoRef(
-      Subchannel subchannel) {
-    return checkNotNull(subchannel.getAttributes().get(STATE_INFO), "STATE_INFO");
-  }
-    
-  // package-private to avoid synthetic access
-  static boolean isReady(Subchannel subchannel) {
-    return getSubchannelStateInfoRef(subchannel).value.getState() == READY;
-  }
-
-  private static <T> Set<T> setsDifference(Set<T> a, Set<T> b) {
-    Set<T> aCopy = new HashSet<>(a);
-    aCopy.removeAll(b);
-    return aCopy;
-  }
-
-  // Only subclasses are ReadyPicker or EmptyPicker
-  private abstract static class RoundRobinPicker extends SubchannelPicker {
-    abstract boolean isEquivalentTo(RoundRobinPicker picker);
-  }
-
-  @VisibleForTesting
-  static final class ReadyPicker extends RoundRobinPicker {
-    private static final AtomicIntegerFieldUpdater<ReadyPicker> indexUpdater =
-        AtomicIntegerFieldUpdater.newUpdater(ReadyPicker.class, "index");
-
-    private final List<Subchannel> list; // non-empty
-    @SuppressWarnings("unused")
-    private volatile int index;
-
-    ReadyPicker(List<Subchannel> list, int startIndex) {
-      Preconditions.checkArgument(!list.isEmpty(), "empty list");
-      this.list = list;
-      this.index = startIndex - 1;
-    }
-
-    @Override
-    public PickResult pickSubchannel(PickSubchannelArgs args) {
-      return PickResult.withSubchannel(nextSubchannel());
-    }
-
-    @Override
-    public String toString() {
-      return MoreObjects.toStringHelper(ReadyPicker.class).add("list", list).toString();
-    }
-
-    private Subchannel nextSubchannel() {
-      int size = list.size();
-      int i = indexUpdater.incrementAndGet(this);
-      if (i >= size) {
-        int oldi = i;
-        i %= size;
-        indexUpdater.compareAndSet(this, oldi, i);
-      }
-      return list.get(i);
-    }
-
-    @VisibleForTesting
-    List<Subchannel> getList() {
-      return list;
-    }
-
-    @Override
-    boolean isEquivalentTo(RoundRobinPicker picker) {
-      if (!(picker instanceof ReadyPicker)) {
-        return false;
-      }
-      ReadyPicker other = (ReadyPicker) picker;
-      // the lists cannot contain duplicate subchannels
-      return other == this
-          || (list.size() == other.list.size() && new HashSet<>(list).containsAll(other.list));
-    }
-  }
-
-  @VisibleForTesting
-  static final class EmptyPicker extends RoundRobinPicker {
-
-    private final Status status;
-
-    EmptyPicker(@Nonnull Status status) {
-      this.status = Preconditions.checkNotNull(status, "status");
-    }
-
-    @Override
-    public PickResult pickSubchannel(PickSubchannelArgs args) {
-      return status.isOk() ? PickResult.withNoResult() : PickResult.withError(status);
-    }
-
-    @Override
-    boolean isEquivalentTo(RoundRobinPicker picker) {
-      return picker instanceof EmptyPicker && (Objects.equal(status, ((EmptyPicker) picker).status)
-          || (status.isOk() && ((EmptyPicker) picker).status.isOk()));
-    }
-
-    @Override
-    public String toString() {
-      return MoreObjects.toStringHelper(EmptyPicker.class).add("status", status).toString();
-    }
-  }
-
-  /**
-   * A lighter weight Reference than AtomicReference.
-   */
-  @VisibleForTesting
-  static final class Ref<T> {
-    T value;
-
-    Ref(T value) {
-      this.value = value;
-    }
-  }
-}
diff --git a/core/src/main/resources/META-INF/services/io.grpc.LoadBalancerProvider b/core/src/main/resources/META-INF/services/io.grpc.LoadBalancerProvider
index cb200d5f044..bbc367f8fc5 100644
--- a/core/src/main/resources/META-INF/services/io.grpc.LoadBalancerProvider
+++ b/core/src/main/resources/META-INF/services/io.grpc.LoadBalancerProvider
@@ -1,2 +1 @@
 io.grpc.internal.PickFirstLoadBalancerProvider
-io.grpc.util.SecretRoundRobinLoadBalancerProvider$Provider
diff --git a/core/src/test/java/io/grpc/ClientStreamTracerTest.java b/core/src/test/java/io/grpc/ClientStreamTracerTest.java
deleted file mode 100644
index 2008a3de5c7..00000000000
--- a/core/src/test/java/io/grpc/ClientStreamTracerTest.java
+++ /dev/null
@@ -1,70 +0,0 @@
-/*
- * 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 static final Attributes.Key<String> TRANSPORT_ATTR_KEY =
-      Attributes.Key.create("transport-attr-key");
-  private final CallOptions callOptions = CallOptions.DEFAULT.withDeadlineAfter(1, MINUTES);
-  private final Attributes transportAttrs =
-      Attributes.newBuilder().set(TRANSPORT_ATTR_KEY, "value").build();
-
-  @Test
-  public void streamInfo_empty() {
-    StreamInfo info = StreamInfo.newBuilder().build();
-    assertThat(info.getCallOptions()).isSameInstanceAs(CallOptions.DEFAULT);
-    assertThat(info.getTransportAttrs()).isSameInstanceAs(Attributes.EMPTY);
-  }
-
-  @Test
-  public void streamInfo_withInfo() {
-    StreamInfo info = StreamInfo.newBuilder()
-        .setCallOptions(callOptions).setTransportAttrs(transportAttrs).build();
-    assertThat(info.getCallOptions()).isSameInstanceAs(callOptions);
-    assertThat(info.getTransportAttrs()).isSameInstanceAs(transportAttrs);
-  }
-
-  @Test
-  public void streamInfo_noEquality() {
-    StreamInfo info1 = StreamInfo.newBuilder()
-        .setCallOptions(callOptions).setTransportAttrs(transportAttrs).build();
-    StreamInfo info2 = StreamInfo.newBuilder()
-        .setCallOptions(callOptions).setTransportAttrs(transportAttrs).build();
-
-    assertThat(info1).isNotSameInstanceAs(info2);
-    assertThat(info1).isNotEqualTo(info2);
-  }
-
-  @Test
-  public void streamInfo_toBuilder() {
-    StreamInfo info1 = StreamInfo.newBuilder()
-        .setCallOptions(callOptions).setTransportAttrs(transportAttrs).build();
-    StreamInfo info2 = info1.toBuilder().build();
-    assertThat(info2.getCallOptions()).isSameInstanceAs(callOptions);
-    assertThat(info2.getTransportAttrs()).isSameInstanceAs(transportAttrs);
-  }
-}
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 a9879375929..00000000000
--- a/core/src/test/java/io/grpc/inprocess/InProcessTransportTest.java
+++ /dev/null
@@ -1,134 +0,0 @@
-/*
- * 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.fail;
-
-import io.grpc.CallOptions;
-import io.grpc.ManagedChannel;
-import io.grpc.Metadata;
-import io.grpc.Server;
-import io.grpc.ServerCall;
-import io.grpc.ServerCallHandler;
-import io.grpc.ServerServiceDefinition;
-import io.grpc.ServerStreamTracer;
-import io.grpc.Status;
-import io.grpc.StatusRuntimeException;
-import io.grpc.internal.AbstractTransportTest;
-import io.grpc.internal.GrpcUtil;
-import io.grpc.internal.InternalServer;
-import io.grpc.internal.ManagedClientTransport;
-import io.grpc.stub.ClientCalls;
-import io.grpc.testing.GrpcCleanupRule;
-import io.grpc.testing.TestMethodDescriptors;
-import java.util.List;
-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";
-  private static final String USER_AGENT = "a-testing-user-agent";
-
-  @Rule
-  public final GrpcCleanupRule grpcCleanupRule = new GrpcCleanupRule();
-
-  @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 InternalServer newServer(
-      int port, List<ServerStreamTracer.Factory> streamTracerFactories) {
-    return newServer(streamTracerFactories);
-  }
-
-  @Override
-  protected String testAuthority(InternalServer server) {
-    return AUTHORITY;
-  }
-
-  @Override
-  protected ManagedClientTransport newClientTransport(InternalServer server) {
-    return new InProcessTransport(
-        TRANSPORT_NAME, GrpcUtil.DEFAULT_MAX_HEADER_LIST_SIZE, testAuthority(server), USER_AGENT,
-        eagAttrs(), false);
-  }
-
-  @Override
-  protected boolean sizesReported() {
-    // TODO(zhangkun83): InProcessTransport doesn't record metrics for now
-    // (https://github.com/grpc/grpc-java/issues/2284)
-    return false;
-  }
-
-  @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());
-    }
-  }
-}
diff --git a/core/src/test/java/io/grpc/inprocess/StandaloneInProcessTransportTest.java b/core/src/test/java/io/grpc/inprocess/StandaloneInProcessTransportTest.java
deleted file mode 100644
index 152fdf2252a..00000000000
--- a/core/src/test/java/io/grpc/inprocess/StandaloneInProcessTransportTest.java
+++ /dev/null
@@ -1,170 +0,0 @@
-/*
- * 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.InternalChannelz.SocketStats;
-import io.grpc.InternalInstrumented;
-import io.grpc.ServerStreamTracer;
-import io.grpc.internal.AbstractTransportTest;
-import io.grpc.internal.GrpcUtil;
-import io.grpc.internal.InternalServer;
-import io.grpc.internal.ManagedClientTransport;
-import io.grpc.internal.ObjectPool;
-import io.grpc.internal.ServerListener;
-import io.grpc.internal.ServerTransport;
-import io.grpc.internal.ServerTransportListener;
-import io.grpc.internal.SharedResourcePool;
-import java.io.IOException;
-import java.net.SocketAddress;
-import java.util.Collections;
-import java.util.List;
-import java.util.concurrent.ScheduledExecutorService;
-import javax.annotation.Nullable;
-import org.junit.Ignore;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-
-/** Unit tests for {@link InProcessTransport} when used with a separate {@link InternalServer}. */
-@RunWith(JUnit4.class)
-public final class StandaloneInProcessTransportTest extends AbstractTransportTest {
-  private static final String TRANSPORT_NAME = "perfect-for-testing";
-  private static final String AUTHORITY = "a-testing-authority";
-  private static final String USER_AGENT = "a-testing-user-agent";
-
-  private final ObjectPool<ScheduledExecutorService> schedulerPool =
-      SharedResourcePool.forResource(GrpcUtil.TIMER_SERVICE);
-
-  private TestServer currentServer;
-
-  @Override
-  protected InternalServer newServer(
-      List<ServerStreamTracer.Factory> streamTracerFactories) {
-    return new TestServer(streamTracerFactories);
-  }
-
-  @Override
-  protected InternalServer newServer(
-      int port, List<ServerStreamTracer.Factory> streamTracerFactories) {
-    return newServer(streamTracerFactories);
-  }
-
-  @Override
-  protected String testAuthority(InternalServer server) {
-    return AUTHORITY;
-  }
-
-  @Override
-  protected ManagedClientTransport newClientTransport(InternalServer server) {
-    TestServer testServer = (TestServer) server;
-    return InternalInProcess.createInProcessTransport(
-        TRANSPORT_NAME,
-        GrpcUtil.DEFAULT_MAX_HEADER_LIST_SIZE,
-        testAuthority(server),
-        USER_AGENT,
-        eagAttrs(),
-        schedulerPool,
-        testServer.streamTracerFactories,
-        testServer.serverListener);
-  }
-
-  @Override
-  protected boolean sizesReported() {
-    // TODO(zhangkun83): InProcessTransport doesn't record metrics for now
-    // (https://github.com/grpc/grpc-java/issues/2284)
-    return false;
-  }
-
-  @Test
-  @Ignore
-  @Override
-  public void socketStats() throws Exception {
-    // test does not apply to in-process
-  }
-
-  /** An internalserver just for this test. */
-  private final class TestServer implements InternalServer {
-
-    final List<ServerStreamTracer.Factory> streamTracerFactories;
-    ServerListener serverListener;
-
-    TestServer(List<ServerStreamTracer.Factory> streamTracerFactories) {
-      this.streamTracerFactories = streamTracerFactories;
-    }
-
-    @Override
-    public void start(ServerListener serverListener) throws IOException {
-      if (currentServer != null) {
-        throw new IOException("Server already present");
-      }
-      currentServer = this;
-      this.serverListener = new ServerListenerWrapper(serverListener);
-    }
-
-    @Override
-    public void shutdown() {
-      currentServer = null;
-      serverListener.serverShutdown();
-    }
-
-    @Override
-    public SocketAddress getListenSocketAddress() {
-      return new SocketAddress() {};
-    }
-
-    @Override
-    public List<SocketAddress> getListenSocketAddresses() {
-      return Collections.singletonList(getListenSocketAddress());
-    }
-
-    @Override
-    @Nullable
-    public InternalInstrumented<SocketStats> getListenSocketStats() {
-      return null;
-    }
-
-    @Override
-    @Nullable
-    public List<InternalInstrumented<SocketStats>> getListenSocketStatsList() {
-      return null;
-    }
-  }
-
-  /** Wraps the server listener to ensure we don't accept new transports after shutdown. */
-  private static final class ServerListenerWrapper implements ServerListener {
-    private final ServerListener delegateListener;
-    private boolean shutdown;
-
-    ServerListenerWrapper(ServerListener delegateListener) {
-      this.delegateListener = delegateListener;
-    }
-
-    @Override
-    public ServerTransportListener transportCreated(ServerTransport transport) {
-      if (shutdown) {
-        return null;
-      }
-      return delegateListener.transportCreated(transport);
-    }
-
-    @Override
-    public void serverShutdown() {
-      shutdown = true;
-      delegateListener.serverShutdown();
-    }
-  }
-}
diff --git a/core/src/test/java/io/grpc/internal/AbstractClientStreamTest.java b/core/src/test/java/io/grpc/internal/AbstractClientStreamTest.java
index 4ce8a467d9f..8f14b74035c 100644
--- a/core/src/test/java/io/grpc/internal/AbstractClientStreamTest.java
+++ b/core/src/test/java/io/grpc/internal/AbstractClientStreamTest.java
@@ -20,8 +20,10 @@
 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.AdditionalAnswers.delegatesTo;
@@ -56,7 +58,6 @@
 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;
@@ -75,8 +76,6 @@
 public class AbstractClientStreamTest {
 
   @Rule public final MockitoRule mocks = MockitoJUnit.rule();
-  @SuppressWarnings("deprecation") // https://github.com/grpc/grpc-java/issues/7467
-  @Rule public final ExpectedException thrown = ExpectedException.none();
 
   private final StatsTraceContext statsTraceCtx = StatsTraceContext.NOOP;
   private final TransportTracer transportTracer = new TransportTracer();
@@ -135,9 +134,7 @@ public void cancel_failsOnNull() {
     AbstractClientStream stream =
         new BaseAbstractClientStream(allocator, statsTraceCtx, transportTracer);
     stream.start(listener);
-    thrown.expect(NullPointerException.class);
-
-    stream.cancel(null);
+    assertThrows(NullPointerException.class, () -> stream.cancel(null));
   }
 
   @Test
@@ -163,9 +160,7 @@ public void startFailsOnNullListener() {
     AbstractClientStream stream =
         new BaseAbstractClientStream(allocator, statsTraceCtx, transportTracer);
 
-    thrown.expect(NullPointerException.class);
-
-    stream.start(null);
+    assertThrows(NullPointerException.class, () -> stream.start(null));
   }
 
   @Test
@@ -173,9 +168,7 @@ public void cantCallStartTwice() {
     AbstractClientStream stream =
         new BaseAbstractClientStream(allocator, statsTraceCtx, transportTracer);
     stream.start(mockListener);
-    thrown.expect(IllegalStateException.class);
-
-    stream.start(mockListener);
+    assertThrows(IllegalStateException.class, () -> stream.start(mockListener));
   }
 
   @Test
@@ -187,8 +180,7 @@ public void inboundDataReceived_failsOnNullFrame() {
 
     TransportState state = stream.transportState();
 
-    thrown.expect(NullPointerException.class);
-    state.inboundDataReceived(null);
+    assertThrows(NullPointerException.class, () -> state.inboundDataReceived(null));
   }
 
   @Test
@@ -211,8 +203,8 @@ public void inboundHeadersReceived_failsIfStatusReported() {
 
     TransportState state = stream.transportState();
 
-    thrown.expect(IllegalStateException.class);
-    state.inboundHeadersReceived(new Metadata());
+    Metadata headers = new Metadata();
+    assertThrows(IllegalStateException.class, () -> state.inboundHeadersReceived(headers));
   }
 
   @Test
@@ -473,6 +465,24 @@ allocator, new BaseTransportState(statsTraceCtx, transportTracer), sink, statsTr
         .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();
@@ -482,6 +492,41 @@ public void appendTimeoutInsight() {
     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.
    */
@@ -517,9 +562,23 @@ public BaseAbstractClientStream(
         StatsTraceContext statsTraceCtx,
         TransportTracer transportTracer,
         boolean useGet) {
-      super(allocator, statsTraceCtx, transportTracer, new Metadata(), CallOptions.DEFAULT, 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
@@ -567,7 +626,7 @@ private Throwable getDeframeFailedCause() {
     }
 
     public BaseTransportState(StatsTraceContext statsTraceCtx, TransportTracer transportTracer) {
-      super(DEFAULT_MAX_MESSAGE_SIZE, statsTraceCtx, transportTracer);
+      super(DEFAULT_MAX_MESSAGE_SIZE, statsTraceCtx, transportTracer, CallOptions.DEFAULT);
     }
 
     @Override
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 8643165eec6..00000000000
--- a/core/src/test/java/io/grpc/internal/AbstractManagedChannelImplBuilderTest.java
+++ /dev/null
@@ -1,100 +0,0 @@
-/*
- * 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.Mockito.doReturn;
-import static org.mockito.Mockito.mock;
-
-import com.google.common.base.Defaults;
-import io.grpc.ForwardingTestUtil;
-import io.grpc.ManagedChannel;
-import io.grpc.ManagedChannelBuilder;
-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 AbstractManagedChannelImplBuilder}.
- */
-@RunWith(JUnit4.class)
-public class AbstractManagedChannelImplBuilderTest {
-  private final ManagedChannelBuilder<?> mockDelegate = mock(ManagedChannelBuilder.class);
-
-  private final AbstractManagedChannelImplBuilder<?> testChannelBuilder = new TestBuilder();
-
-  private final class TestBuilder extends AbstractManagedChannelImplBuilder<TestBuilder> {
-    @Override
-    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/core/src/test/java/io/grpc/internal/AbstractServerImplBuilderTest.java b/core/src/test/java/io/grpc/internal/AbstractServerImplBuilderTest.java
deleted file mode 100644
index 9f6859a8420..00000000000
--- a/core/src/test/java/io/grpc/internal/AbstractServerImplBuilderTest.java
+++ /dev/null
@@ -1,87 +0,0 @@
-/*
- * 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.Mockito.doReturn;
-import static org.mockito.Mockito.mock;
-
-import com.google.common.base.Defaults;
-import io.grpc.ForwardingTestUtil;
-import io.grpc.Server;
-import io.grpc.ServerBuilder;
-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 AbstractServerImplBuilderTest}.
- */
-@RunWith(JUnit4.class)
-public class AbstractServerImplBuilderTest {
-  private final ServerBuilder<?> mockDelegate = mock(ServerBuilder.class);
-
-  private final AbstractServerImplBuilder<?> testServerBuilder = new TestBuilder();
-
-  private final class TestBuilder extends AbstractServerImplBuilder<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())) {
-        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/core/src/test/java/io/grpc/internal/AbstractServerStreamTest.java b/core/src/test/java/io/grpc/internal/AbstractServerStreamTest.java
index 65fc89be231..137ba19bfea 100644
--- a/core/src/test/java/io/grpc/internal/AbstractServerStreamTest.java
+++ b/core/src/test/java/io/grpc/internal/AbstractServerStreamTest.java
@@ -18,6 +18,8 @@
 
 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.AdditionalAnswers.delegatesTo;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.anyBoolean;
@@ -28,11 +30,13 @@
 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 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;
@@ -42,9 +46,7 @@
 import java.util.Queue;
 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;
@@ -57,9 +59,6 @@ public class AbstractServerStreamTest {
   private static final int TIMEOUT_MS = 1000;
   private static final int MAX_MESSAGE_SIZE = 100;
 
-  @SuppressWarnings("deprecation") // https://github.com/grpc/grpc-java/issues/7467
-  @Rule public final ExpectedException thrown = ExpectedException.none();
-
   private final WritableBufferAllocator allocator = new WritableBufferAllocator() {
     @Override
     public WritableBuffer allocate(int capacityHint) {
@@ -82,7 +81,7 @@ public void setUp() {
   }
 
   /**
-   * 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() {
@@ -108,6 +107,43 @@ public void messagesAvailable(MessageProducer producer) {
     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();
@@ -172,7 +208,7 @@ public void closed(Status status) {
   }
 
   /**
-   * 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() {
@@ -186,9 +222,9 @@ public void completeWithoutClose() {
   public void setListener_setOnlyOnce() {
     TransportState state = stream.transportState();
     state.setListener(new ServerStreamListenerBase());
-    thrown.expect(IllegalStateException.class);
 
-    state.setListener(new ServerStreamListenerBase());
+    ServerStreamListenerBase listener2 = new ServerStreamListenerBase();
+    assertThrows(IllegalStateException.class, () -> state.setListener(listener2));
   }
 
   @Test
@@ -198,8 +234,7 @@ public void listenerReady_onlyOnce() {
 
     TransportState state = stream.transportState();
 
-    thrown.expect(IllegalStateException.class);
-    state.onStreamAllocated();
+    assertThrows(IllegalStateException.class, state::onStreamAllocated);
   }
 
   @Test
@@ -215,8 +250,7 @@ public void listenerReady_readyCalled() {
   public void setListener_failsOnNull() {
     TransportState state = stream.transportState();
 
-    thrown.expect(NullPointerException.class);
-    state.setListener(null);
+    assertThrows(NullPointerException.class, () -> state.setListener(null));
   }
 
   // TODO(ericgribkoff) This test is only valid if deframeInTransportThread=true, as otherwise the
@@ -244,30 +278,28 @@ public void messagesAvailable(MessageProducer producer) {
 
   @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);
 
@@ -278,7 +310,7 @@ public void writeMessage_ignoreIfFramerClosed() {
 
   @Test
   public void writeMessage() {
-    stream.writeHeaders(new Metadata());
+    stream.writeHeaders(new Metadata(), true);
 
     stream.writeMessage(new ByteArrayInputStream(new byte[]{}));
     stream.flush();
@@ -288,7 +320,7 @@ public void writeMessage() {
 
   @Test
   public void writeMessage_closesStream() throws Exception {
-    stream.writeHeaders(new Metadata());
+    stream.writeHeaders(new Metadata(), true);
     InputStream input = mock(InputStream.class, delegatesTo(new ByteArrayInputStream(new byte[1])));
     stream.writeMessage(input);
     verify(input).close();
@@ -296,16 +328,13 @@ public void writeMessage_closesStream() throws Exception {
 
   @Test
   public void close_failsOnNullStatus() {
-    thrown.expect(NullPointerException.class);
-
-    stream.close(null, new Metadata());
+    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
@@ -332,6 +361,15 @@ public void close_sendTrailersClearsReservedFields() {
     assertEquals("bad", metadataCaptor.getValue().get(InternalStatus.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 messagesAvailable(MessageProducer producer) {
@@ -402,4 +440,3 @@ public int streamId() {
     }
   }
 }
-
diff --git a/core/src/test/java/io/grpc/internal/AtomicBackoffTest.java b/core/src/test/java/io/grpc/internal/AtomicBackoffTest.java
index 780db5258ee..3c0277a7c79 100644
--- a/core/src/test/java/io/grpc/internal/AtomicBackoffTest.java
+++ b/core/src/test/java/io/grpc/internal/AtomicBackoffTest.java
@@ -17,6 +17,7 @@
 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;
@@ -25,9 +26,13 @@
 /** Unit tests for {@link AtomicBackoff}. */
 @RunWith(JUnit4.class)
 public class AtomicBackoffTest {
-  @Test(expected = IllegalArgumentException.class)
+  @Test
   public void mustBePositive() {
-    new AtomicBackoff("test", 0);
+    try {
+      new AtomicBackoff("test", 0);
+      fail();
+    } catch (IllegalArgumentException expected) {
+    }
   }
 
   @Test
diff --git a/core/src/test/java/io/grpc/internal/AutoConfiguredLoadBalancerFactoryTest.java b/core/src/test/java/io/grpc/internal/AutoConfiguredLoadBalancerFactoryTest.java
index bf7c63818cf..07d19d41a86 100644
--- a/core/src/test/java/io/grpc/internal/AutoConfiguredLoadBalancerFactoryTest.java
+++ b/core/src/test/java/io/grpc/internal/AutoConfiguredLoadBalancerFactoryTest.java
@@ -21,8 +21,8 @@
 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.mock;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
@@ -48,8 +48,10 @@
 import io.grpc.LoadBalancerRegistry;
 import io.grpc.NameResolver.ConfigOrError;
 import io.grpc.Status;
-import io.grpc.grpclb.GrpclbLoadBalancerProvider;
+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;
@@ -57,6 +59,7 @@
 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;
@@ -95,11 +98,17 @@ public class AutoConfiguredLoadBalancerFactoryTest {
           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.canHandleEmptyAddressListFromNameResolution()).thenCallRealMethod();
-    assertThat(testLbBalancer.canHandleEmptyAddressListFromNameResolution()).isFalse();
-    when(testLbBalancer2.canHandleEmptyAddressListFromNameResolution()).thenReturn(true);
+    when(testLbBalancer.acceptResolvedAddresses(isA(ResolvedAddresses.class))).thenReturn(
+        Status.OK);
+    when(testLbBalancer2.acceptResolvedAddresses(isA(ResolvedAddresses.class))).thenReturn(
+        Status.OK);
     defaultRegistry.register(testLbBalancerProvider);
     defaultRegistry.register(testLbBalancerProvider2);
   }
@@ -171,7 +180,7 @@ public void shutdown() {
   }
 
   @Test
-  public void handleResolvedAddressGroups_keepOldBalancer() {
+  public void acceptResolvedAddresses_keepOldBalancer() {
     final List<EquivalentAddressGroup> servers =
         Collections.singletonList(new EquivalentAddressGroup(new SocketAddress(){}));
     Helper helper = new TestHelper() {
@@ -184,22 +193,22 @@ public Subchannel createSubchannel(CreateSubchannelArgs args) {
     AutoConfiguredLoadBalancer lb = lbf.newLoadBalancer(helper);
     LoadBalancer oldDelegate = lb.getDelegate();
 
-    Status handleResult = lb.tryHandleResolvedAddresses(
+    Status addressAcceptanceStatus = lb.acceptResolvedAddresses(
         ResolvedAddresses.newBuilder()
             .setAddresses(servers)
             .setAttributes(Attributes.EMPTY)
             .setLoadBalancingPolicyConfig(null)
             .build());
 
-    assertThat(handleResult.getCode()).isEqualTo(Status.Code.OK);
+    assertThat(addressAcceptanceStatus.isOk()).isTrue();
     assertThat(lb.getDelegate()).isSameInstanceAs(oldDelegate);
   }
 
   @Test
-  public void handleResolvedAddressGroups_shutsDownOldBalancer() throws Exception {
+  public void acceptResolvedAddresses_shutsDownOldBalancer() throws Exception {
     Map<String, ?> serviceConfig =
         parseConfig("{\"loadBalancingConfig\": [ {\"round_robin\": { } } ] }");
-    ConfigOrError lbConfigs = lbf.parseLoadBalancerPolicy(serviceConfig);
+    ConfigOrError lbConfigs = lbf.parseLoadBalancingPolicyConfig(serviceConfig);
 
     final List<EquivalentAddressGroup> servers =
         Collections.singletonList(new EquivalentAddressGroup(new SocketAddress(){}));
@@ -226,13 +235,13 @@ public void shutdown() {
     };
     lb.setDelegate(testlb);
 
-    Status handleResult = lb.tryHandleResolvedAddresses(
+    Status addressesAcceptanceStatus = lb.acceptResolvedAddresses(
         ResolvedAddresses.newBuilder()
             .setAddresses(servers)
             .setLoadBalancingPolicyConfig(lbConfigs.getConfig())
             .build());
 
-    assertThat(handleResult.getCode()).isEqualTo(Status.Code.OK);
+    assertThat(addressesAcceptanceStatus.isOk()).isTrue();
     assertThat(lb.getDelegateProvider().getClass().getName()).isEqualTo(
         "io.grpc.util.SecretRoundRobinLoadBalancerProvider$Provider");
     assertTrue(shutdown.get());
@@ -240,10 +249,10 @@ public void shutdown() {
 
   @Test
   @SuppressWarnings("unchecked")
-  public void handleResolvedAddressGroups_propagateLbConfigToDelegate() throws Exception {
+  public void acceptResolvedAddresses_propagateLbConfigToDelegate() throws Exception {
     Map<String, ?> rawServiceConfig =
         parseConfig("{\"loadBalancingConfig\": [ {\"test_lb\": { \"setting1\": \"high\" } } ] }");
-    ConfigOrError lbConfigs = lbf.parseLoadBalancerPolicy(rawServiceConfig);
+    ConfigOrError lbConfigs = lbf.parseLoadBalancingPolicyConfig(rawServiceConfig);
     assertThat(lbConfigs.getConfig()).isNotNull();
 
     final List<EquivalentAddressGroup> servers =
@@ -251,20 +260,19 @@ public void handleResolvedAddressGroups_propagateLbConfigToDelegate() throws Exc
     Helper helper = new TestHelper();
     AutoConfiguredLoadBalancer lb = lbf.newLoadBalancer(helper);
 
-    Status handleResult = lb.tryHandleResolvedAddresses(
+    Status addressesAcceptanceStatus = lb.acceptResolvedAddresses(
         ResolvedAddresses.newBuilder()
             .setAddresses(servers)
             .setLoadBalancingPolicyConfig(lbConfigs.getConfig())
             .build());
 
     verify(testLbBalancerProvider).newLoadBalancer(same(helper));
-    assertThat(handleResult.getCode()).isEqualTo(Status.Code.OK);
+    assertThat(addressesAcceptanceStatus.isOk()).isTrue();
     assertThat(lb.getDelegate()).isSameInstanceAs(testLbBalancer);
     ArgumentCaptor<ResolvedAddresses> resultCaptor =
         ArgumentCaptor.forClass(ResolvedAddresses.class);
-    verify(testLbBalancer).handleResolvedAddresses(resultCaptor.capture());
+    verify(testLbBalancer).acceptResolvedAddresses(resultCaptor.capture());
     assertThat(resultCaptor.getValue().getAddresses()).containsExactlyElementsIn(servers).inOrder();
-    verify(testLbBalancer, atLeast(0)).canHandleEmptyAddressListFromNameResolution();
     ArgumentCaptor<Map<String, ?>> lbConfigCaptor = ArgumentCaptor.forClass(Map.class);
     verify(testLbBalancerProvider).parseLoadBalancingPolicyConfig(lbConfigCaptor.capture());
     assertThat(lbConfigCaptor.getValue()).containsExactly("setting1", "high");
@@ -272,9 +280,9 @@ public void handleResolvedAddressGroups_propagateLbConfigToDelegate() throws Exc
 
     rawServiceConfig =
         parseConfig("{\"loadBalancingConfig\": [ {\"test_lb\": { \"setting1\": \"low\" } } ] }");
-    lbConfigs = lbf.parseLoadBalancerPolicy(rawServiceConfig);
+    lbConfigs = lbf.parseLoadBalancingPolicyConfig(rawServiceConfig);
 
-    handleResult = lb.tryHandleResolvedAddresses(
+    addressesAcceptanceStatus = lb.acceptResolvedAddresses(
         ResolvedAddresses.newBuilder()
             .setAddresses(servers)
             .setLoadBalancingPolicyConfig(lbConfigs.getConfig())
@@ -282,8 +290,8 @@ public void handleResolvedAddressGroups_propagateLbConfigToDelegate() throws Exc
 
     resultCaptor =
         ArgumentCaptor.forClass(ResolvedAddresses.class);
-    verify(testLbBalancer, times(2)).handleResolvedAddresses(resultCaptor.capture());
-    assertThat(handleResult.getCode()).isEqualTo(Status.Code.OK);
+    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());
@@ -294,10 +302,10 @@ public void handleResolvedAddressGroups_propagateLbConfigToDelegate() throws Exc
   }
 
   @Test
-  public void handleResolvedAddressGroups_propagateAddrsToDelegate() throws Exception {
+  public void acceptResolvedAddresses_propagateAddrsToDelegate() throws Exception {
     Map<String, ?> rawServiceConfig =
         parseConfig("{\"loadBalancingConfig\": [ {\"test_lb\": { \"setting1\": \"high\" } } ] }");
-    ConfigOrError lbConfigs = lbf.parseLoadBalancerPolicy(rawServiceConfig);
+    ConfigOrError lbConfigs = lbf.parseLoadBalancingPolicyConfig(rawServiceConfig);
     assertThat(lbConfigs.getConfig()).isNotNull();
 
     Helper helper = new TestHelper();
@@ -305,56 +313,59 @@ public void handleResolvedAddressGroups_propagateAddrsToDelegate() throws Except
     List<EquivalentAddressGroup> servers =
         Collections.singletonList(new EquivalentAddressGroup(new InetSocketAddress(8080){}));
 
-    Status handleResult = lb.tryHandleResolvedAddresses(
+    Status addressesAcceptanceStatus = lb.acceptResolvedAddresses(
         ResolvedAddresses.newBuilder()
             .setAddresses(servers)
             .setLoadBalancingPolicyConfig(lbConfigs.getConfig())
             .build());
 
     verify(testLbBalancerProvider).newLoadBalancer(same(helper));
-    assertThat(handleResult.getCode()).isEqualTo(Status.Code.OK);
+    assertThat(addressesAcceptanceStatus.isOk()).isTrue();
     assertThat(lb.getDelegate()).isSameInstanceAs(testLbBalancer);
     ArgumentCaptor<ResolvedAddresses> resultCaptor =
         ArgumentCaptor.forClass(ResolvedAddresses.class);
-    verify(testLbBalancer).handleResolvedAddresses(resultCaptor.capture());
+    verify(testLbBalancer).acceptResolvedAddresses(resultCaptor.capture());
     assertThat(resultCaptor.getValue().getAddresses()).containsExactlyElementsIn(servers).inOrder();
 
     servers =
         Collections.singletonList(new EquivalentAddressGroup(new InetSocketAddress(9090){}));
-    handleResult = lb.tryHandleResolvedAddresses(
+    addressesAcceptanceStatus = lb.acceptResolvedAddresses(
         ResolvedAddresses.newBuilder()
             .setAddresses(servers)
             .setLoadBalancingPolicyConfig(lbConfigs.getConfig())
             .build());
 
-    assertThat(handleResult.getCode()).isEqualTo(Status.Code.OK);
-    verify(testLbBalancer, times(2)).handleResolvedAddresses(resultCaptor.capture());
+    assertThat(addressesAcceptanceStatus.isOk()).isTrue();
+    verify(testLbBalancer, times(2)).acceptResolvedAddresses(resultCaptor.capture());
     assertThat(resultCaptor.getValue().getAddresses()).containsExactlyElementsIn(servers).inOrder();
   }
 
   @Test
-  public void handleResolvedAddressGroups_delegateDoNotAcceptEmptyAddressList_nothing()
+  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.parseLoadBalancerPolicy(serviceConfig);
-    Status handleResult = lb.tryHandleResolvedAddresses(
+    ConfigOrError lbConfig = lbf.parseLoadBalancingPolicyConfig(serviceConfig);
+    Status addressesAcceptanceStatus = lb.acceptResolvedAddresses(
         ResolvedAddresses.newBuilder()
             .setAddresses(Collections.<EquivalentAddressGroup>emptyList())
             .setLoadBalancingPolicyConfig(lbConfig.getConfig())
             .build());
 
-    assertThat(testLbBalancer.canHandleEmptyAddressListFromNameResolution()).isFalse();
-    assertThat(handleResult.getCode()).isEqualTo(Status.Code.UNAVAILABLE);
-    assertThat(handleResult.getDescription()).startsWith("NameResolver returned no usable address");
+    assertThat(addressesAcceptanceStatus.isOk()).isFalse();
     assertThat(lb.getDelegate()).isSameInstanceAs(testLbBalancer);
   }
 
   @Test
-  public void handleResolvedAddressGroups_delegateAcceptsEmptyAddressList()
+  public void acceptResolvedAddresses_delegateAcceptsEmptyAddressList()
       throws Exception {
     Helper helper = new TestHelper();
     AutoConfiguredLoadBalancer lb = lbf.newLoadBalancer(helper);
@@ -362,29 +373,28 @@ public void handleResolvedAddressGroups_delegateAcceptsEmptyAddressList()
     Map<String, ?> rawServiceConfig =
         parseConfig("{\"loadBalancingConfig\": [ {\"test_lb2\": { \"setting1\": \"high\" } } ] }");
     ConfigOrError lbConfigs =
-        lbf.parseLoadBalancerPolicy(rawServiceConfig);
-    Status handleResult = lb.tryHandleResolvedAddresses(
+        lbf.parseLoadBalancingPolicyConfig(rawServiceConfig);
+    Status addressesAcceptanceStatus = lb.acceptResolvedAddresses(
         ResolvedAddresses.newBuilder()
             .setAddresses(Collections.<EquivalentAddressGroup>emptyList())
             .setLoadBalancingPolicyConfig(lbConfigs.getConfig())
             .build());
 
-    assertThat(handleResult.getCode()).isEqualTo(Status.Code.OK);
+    assertThat(addressesAcceptanceStatus.isOk()).isTrue();
     assertThat(lb.getDelegate()).isSameInstanceAs(testLbBalancer2);
-    assertThat(testLbBalancer2.canHandleEmptyAddressListFromNameResolution()).isTrue();
     ArgumentCaptor<ResolvedAddresses> resultCaptor =
         ArgumentCaptor.forClass(ResolvedAddresses.class);
-    verify(testLbBalancer2).handleResolvedAddresses(resultCaptor.capture());
+    verify(testLbBalancer2).acceptResolvedAddresses(resultCaptor.capture());
     assertThat(resultCaptor.getValue().getAddresses()).isEmpty();
     assertThat(resultCaptor.getValue().getLoadBalancingPolicyConfig())
         .isEqualTo(nextParsedConfigOrError2.get().getConfig());
   }
 
   @Test
-  public void handleResolvedAddressGroups_useSelectedLbPolicy() throws Exception {
+  public void acceptResolvedAddresses_useSelectedLbPolicy() throws Exception {
     Map<String, ?> rawServiceConfig =
         parseConfig("{\"loadBalancingConfig\": [{\"round_robin\": {}}]}");
-    ConfigOrError lbConfigs = lbf.parseLoadBalancerPolicy(rawServiceConfig);
+    ConfigOrError lbConfigs = lbf.parseLoadBalancingPolicyConfig(rawServiceConfig);
     assertThat(lbConfigs.getConfig()).isNotNull();
     assertThat(((PolicySelection) lbConfigs.getConfig()).provider.getClass().getName())
         .isEqualTo("io.grpc.util.SecretRoundRobinLoadBalancerProvider$Provider");
@@ -399,18 +409,18 @@ public Subchannel createSubchannel(CreateSubchannelArgs args) {
       }
     };
     AutoConfiguredLoadBalancer lb = lbf.newLoadBalancer(helper);
-    Status handleResult = lb.tryHandleResolvedAddresses(
+    Status addressesAcceptanceStatus = lb.acceptResolvedAddresses(
         ResolvedAddresses.newBuilder()
             .setAddresses(servers)
             .setLoadBalancingPolicyConfig(lbConfigs.getConfig())
             .build());
-    assertThat(handleResult.getCode()).isEqualTo(Status.Code.OK);
+    assertThat(addressesAcceptanceStatus.isOk()).isTrue();
     assertThat(lb.getDelegate().getClass().getName())
         .isEqualTo("io.grpc.util.RoundRobinLoadBalancer");
   }
 
   @Test
-  public void handleResolvedAddressGroups_noLbPolicySelected_defaultToPickFirst() {
+  public void acceptResolvedAddresses_noLbPolicySelected_defaultToPickFirst() {
     final List<EquivalentAddressGroup> servers =
         Collections.singletonList(new EquivalentAddressGroup(new SocketAddress(){}));
     Helper helper = new TestHelper() {
@@ -421,27 +431,27 @@ public Subchannel createSubchannel(CreateSubchannelArgs args) {
       }
     };
     AutoConfiguredLoadBalancer lb = lbf.newLoadBalancer(helper);
-    Status handleResult = lb.tryHandleResolvedAddresses(
+    Status addressesAcceptanceStatus = lb.acceptResolvedAddresses(
         ResolvedAddresses.newBuilder()
             .setAddresses(servers)
             .setLoadBalancingPolicyConfig(null)
             .build());
-    assertThat(handleResult.getCode()).isEqualTo(Status.Code.OK);
-    assertThat(lb.getDelegate()).isInstanceOf(PickFirstLoadBalancer.class);
+    assertThat(addressesAcceptanceStatus.isOk()).isTrue();
+    assertThat(lb.getDelegate()).isInstanceOf(pfLbClass);
   }
 
   @Test
-  public void handleResolvedAddressGroups_noLbPolicySelected_defaultToCustomDefault() {
+  public void acceptResolvedAddresses_noLbPolicySelected_defaultToCustomDefault() {
     AutoConfiguredLoadBalancer lb = new AutoConfiguredLoadBalancerFactory("test_lb")
         .newLoadBalancer(new TestHelper());
     List<EquivalentAddressGroup> servers =
         Collections.singletonList(new EquivalentAddressGroup(new SocketAddress(){}));
-    Status handleResult = lb.tryHandleResolvedAddresses(
+    Status addressesAcceptanceStatus = lb.acceptResolvedAddresses(
         ResolvedAddresses.newBuilder()
             .setAddresses(servers)
             .setLoadBalancingPolicyConfig(null)
             .build());
-    assertThat(handleResult.getCode()).isEqualTo(Status.Code.OK);
+    assertThat(addressesAcceptanceStatus.isOk()).isTrue();
     assertThat(lb.getDelegate()).isSameInstanceAs(testLbBalancer);
   }
 
@@ -458,31 +468,31 @@ public Subchannel createSubchannel(CreateSubchannelArgs args) {
 
     AutoConfiguredLoadBalancer lb =
         new AutoConfiguredLoadBalancerFactory(GrpcUtil.DEFAULT_LB_POLICY).newLoadBalancer(helper);
-    Status handleResult = lb.tryHandleResolvedAddresses(
+    Status addressesAcceptanceStatus = lb.acceptResolvedAddresses(
         ResolvedAddresses.newBuilder()
             .setAddresses(servers)
             .setAttributes(Attributes.EMPTY)
             .build());
 
-    assertThat(handleResult.getCode()).isEqualTo(Status.Code.OK);
+    assertThat(addressesAcceptanceStatus.isOk()).isTrue();
     verifyNoMoreInteractions(channelLogger);
 
     ConfigOrError testLbParsedConfig = ConfigOrError.fromConfig("foo");
     nextParsedConfigOrError.set(testLbParsedConfig);
     Map<String, ?> serviceConfig =
         parseConfig("{\"loadBalancingConfig\": [ {\"test_lb\": { } } ] }");
-    ConfigOrError lbConfigs = lbf.parseLoadBalancerPolicy(serviceConfig);
-    handleResult = lb.tryHandleResolvedAddresses(
+    ConfigOrError lbConfigs = lbf.parseLoadBalancingPolicyConfig(serviceConfig);
+    addressesAcceptanceStatus = lb.acceptResolvedAddresses(
         ResolvedAddresses.newBuilder()
             .setAddresses(servers)
             .setLoadBalancingPolicyConfig(lbConfigs.getConfig())
             .build());
 
-    assertThat(handleResult.getCode()).isEqualTo(Status.Code.OK);
+    assertThat(addressesAcceptanceStatus.isOk()).isTrue();
     verify(channelLogger).log(
         eq(ChannelLogLevel.INFO),
         eq("Load balancer changed from {0} to {1}"),
-        eq("PickFirstLoadBalancer"),
+        eq(pfLbClass.getSimpleName()),
         eq(testLbBalancer.getClass().getSimpleName()));
 
     verify(channelLogger).log(
@@ -494,13 +504,13 @@ public Subchannel createSubchannel(CreateSubchannelArgs args) {
     testLbParsedConfig = ConfigOrError.fromConfig("bar");
     nextParsedConfigOrError.set(testLbParsedConfig);
     serviceConfig = parseConfig("{\"loadBalancingConfig\": [ {\"test_lb\": { } } ] }");
-    lbConfigs = lbf.parseLoadBalancerPolicy(serviceConfig);
-    handleResult = lb.tryHandleResolvedAddresses(
+    lbConfigs = lbf.parseLoadBalancingPolicyConfig(serviceConfig);
+    addressesAcceptanceStatus = lb.acceptResolvedAddresses(
         ResolvedAddresses.newBuilder()
             .setAddresses(servers)
             .setLoadBalancingPolicyConfig(lbConfigs.getConfig())
             .build());
-    assertThat(handleResult.getCode()).isEqualTo(Status.Code.OK);
+    assertThat(addressesAcceptanceStatus.isOk()).isTrue();
     verify(channelLogger).log(
         eq(ChannelLogLevel.DEBUG),
         eq("Load-balancing config: {0}"),
@@ -509,33 +519,33 @@ public Subchannel createSubchannel(CreateSubchannelArgs args) {
   }
 
   @Test
-  public void parseLoadBalancerConfig_failedOnUnknown() throws Exception {
+  public void parseLoadBalancingConfig_failedOnUnknown() throws Exception {
     Map<String, ?> serviceConfig =
         parseConfig("{\"loadBalancingConfig\": [ {\"magic_balancer\": {} } ] }");
-    ConfigOrError parsed = lbf.parseLoadBalancerPolicy(serviceConfig);
+    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 parseLoadBalancerPolicy_failedOnUnknown() throws Exception {
+  public void parseLoadBalancingPolicy_failedOnUnknown() throws Exception {
     Map<String, ?> serviceConfig =
         parseConfig("{\"loadBalancingPolicy\": \"magic_balancer\"}");
-    ConfigOrError parsed = lbf.parseLoadBalancerPolicy(serviceConfig);
+    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 parseLoadBalancerConfig_multipleValidPolicies() throws Exception {
+  public void parseLoadBalancingConfig_multipleValidPolicies() throws Exception {
     Map<String, ?> serviceConfig =
         parseConfig(
             "{\"loadBalancingConfig\": ["
                 + "{\"round_robin\": {}},"
                 + "{\"test_lb\": {} } ] }");
-    ConfigOrError parsed = lbf.parseLoadBalancerPolicy(serviceConfig);
+    ConfigOrError parsed = lbf.parseLoadBalancingPolicyConfig(serviceConfig);
     assertThat(parsed).isNotNull();
     assertThat(parsed.getError()).isNull();
     assertThat(parsed.getConfig()).isInstanceOf(PolicySelection.class);
@@ -544,12 +554,12 @@ public void parseLoadBalancerConfig_multipleValidPolicies() throws Exception {
   }
 
   @Test
-  public void parseLoadBalancerConfig_policyShouldBeIgnoredIfConfigExists() throws Exception {
+  public void parseLoadBalancingConfig_policyShouldBeIgnoredIfConfigExists() throws Exception {
     Map<String, ?> serviceConfig =
         parseConfig(
             "{\"loadBalancingConfig\": [{\"round_robin\": {} } ],"
                 + "\"loadBalancingPolicy\": \"pick_first\" }");
-    ConfigOrError parsed = lbf.parseLoadBalancerPolicy(serviceConfig);
+    ConfigOrError parsed = lbf.parseLoadBalancingPolicyConfig(serviceConfig);
     assertThat(parsed).isNotNull();
     assertThat(parsed.getError()).isNull();
     assertThat(parsed.getConfig()).isInstanceOf(PolicySelection.class);
@@ -558,13 +568,13 @@ public void parseLoadBalancerConfig_policyShouldBeIgnoredIfConfigExists() throws
   }
 
   @Test
-  public void parseLoadBalancerConfig_policyShouldBeIgnoredEvenIfUnknownPolicyExists()
+  public void parseLoadBalancingConfig_policyShouldBeIgnoredEvenIfUnknownPolicyExists()
       throws Exception {
     Map<String, ?> serviceConfig =
         parseConfig(
             "{\"loadBalancingConfig\": [{\"magic_balancer\": {} } ],"
                 + "\"loadBalancingPolicy\": \"round_robin\" }");
-    ConfigOrError parsed = lbf.parseLoadBalancerPolicy(serviceConfig);
+    ConfigOrError parsed = lbf.parseLoadBalancingPolicyConfig(serviceConfig);
     assertThat(parsed.getError()).isNotNull();
     assertThat(parsed.getError().getDescription())
         .isEqualTo("None of [magic_balancer] specified by Service Config are available.");
@@ -572,7 +582,7 @@ public void parseLoadBalancerConfig_policyShouldBeIgnoredEvenIfUnknownPolicyExis
 
   @Test
   @SuppressWarnings("unchecked")
-  public void parseLoadBalancerConfig_firstInvalidPolicy() throws Exception {
+  public void parseLoadBalancingConfig_firstInvalidPolicy() throws Exception {
     when(testLbBalancerProvider.parseLoadBalancingPolicyConfig(any(Map.class)))
         .thenReturn(ConfigOrError.fromError(Status.UNKNOWN));
     Map<String, ?> serviceConfig =
@@ -580,7 +590,7 @@ public void parseLoadBalancerConfig_firstInvalidPolicy() throws Exception {
             "{\"loadBalancingConfig\": ["
                 + "{\"test_lb\": {}},"
                 + "{\"round_robin\": {} } ] }");
-    ConfigOrError parsed = lbf.parseLoadBalancerPolicy(serviceConfig);
+    ConfigOrError parsed = lbf.parseLoadBalancingPolicyConfig(serviceConfig);
     assertThat(parsed).isNotNull();
     assertThat(parsed.getConfig()).isNull();
     assertThat(parsed.getError()).isEqualTo(Status.UNKNOWN);
@@ -588,7 +598,7 @@ public void parseLoadBalancerConfig_firstInvalidPolicy() throws Exception {
 
   @Test
   @SuppressWarnings("unchecked")
-  public void parseLoadBalancerConfig_firstValidSecondInvalidPolicy() throws Exception {
+  public void parseLoadBalancingConfig_firstValidSecondInvalidPolicy() throws Exception {
     when(testLbBalancerProvider.parseLoadBalancingPolicyConfig(any(Map.class)))
         .thenReturn(ConfigOrError.fromError(Status.UNKNOWN));
     Map<String, ?> serviceConfig =
@@ -596,37 +606,45 @@ public void parseLoadBalancerConfig_firstValidSecondInvalidPolicy() throws Excep
             "{\"loadBalancingConfig\": ["
                 + "{\"round_robin\": {}},"
                 + "{\"test_lb\": {} } ] }");
-    ConfigOrError parsed = lbf.parseLoadBalancerPolicy(serviceConfig);
+    ConfigOrError parsed = lbf.parseLoadBalancingPolicyConfig(serviceConfig);
     assertThat(parsed).isNotNull();
     assertThat(parsed.getConfig()).isNotNull();
     assertThat(((PolicySelection) parsed.getConfig()).config).isNotNull();
   }
 
   @Test
-  public void parseLoadBalancerConfig_someProvidesAreNotAvailable() throws Exception {
+  public void parseLoadBalancingConfig_someProvidesAreNotAvailable() throws Exception {
     Map<String, ?> serviceConfig =
         parseConfig("{\"loadBalancingConfig\": [ "
             + "{\"magic_balancer\": {} },"
             + "{\"round_robin\": {}} ] }");
-    ConfigOrError parsed = lbf.parseLoadBalancerPolicy(serviceConfig);
+    ConfigOrError parsed = lbf.parseLoadBalancingPolicyConfig(serviceConfig);
     assertThat(parsed).isNotNull();
     assertThat(parsed.getConfig()).isNotNull();
     assertThat(((PolicySelection) parsed.getConfig()).config).isNotNull();
   }
 
   @Test
-  public void parseLoadBalancerConfig_lbConfigPropagated() throws Exception {
+  public void parseLoadBalancingConfig_lbConfigPropagated() throws Exception {
     Map<String, ?> rawServiceConfig =
         parseConfig(
             "{\"loadBalancingConfig\": ["
-                + "{\"grpclb\": {\"childPolicy\": [ {\"pick_first\": {} } ] } }"
+                + "{\"pick_first\": {\"shuffleAddressList\": true } }"
                 + "] }");
-    ConfigOrError parsed = lbf.parseLoadBalancerPolicy(rawServiceConfig);
+    ConfigOrError parsed = lbf.parseLoadBalancingPolicyConfig(rawServiceConfig);
     assertThat(parsed).isNotNull();
     assertThat(parsed.getConfig()).isNotNull();
     PolicySelection policySelection = (PolicySelection) parsed.getConfig();
-    assertThat(policySelection.config).isNotNull();
-    assertThat(policySelection.provider).isInstanceOf(GrpclbLoadBalancerProvider.class);
+    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);
   }
 
@@ -643,14 +661,13 @@ protected LoadBalancer delegate() {
 
     @Override
     @Deprecated
-    public void handleResolvedAddressGroups(
-        List<EquivalentAddressGroup> servers, Attributes attributes) {
-      delegate().handleResolvedAddressGroups(servers, attributes);
+    public void handleResolvedAddresses(ResolvedAddresses resolvedAddresses) {
+      delegate().acceptResolvedAddresses(resolvedAddresses);
     }
 
     @Override
-    public void handleResolvedAddresses(ResolvedAddresses resolvedAddresses) {
-      delegate().handleResolvedAddresses(resolvedAddresses);
+    public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
+      return delegate().acceptResolvedAddresses(resolvedAddresses);
     }
 
     @Override
@@ -676,6 +693,16 @@ private static class TestLoadBalancer extends ForwardingLoadBalancer {
   }
 
   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;
@@ -690,6 +717,16 @@ public ChannelLogger getChannelLogger() {
     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 {
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/CallCredentials2ApplyingTest.java b/core/src/test/java/io/grpc/internal/CallCredentials2ApplyingTest.java
deleted file mode 100644
index 7725c46726b..00000000000
--- a/core/src/test/java/io/grpc/internal/CallCredentials2ApplyingTest.java
+++ /dev/null
@@ -1,332 +0,0 @@
-/*
- * 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 org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertSame;
-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.verify;
-import static org.mockito.Mockito.when;
-
-import io.grpc.Attributes;
-import io.grpc.CallCredentials.MetadataApplier;
-import io.grpc.CallCredentials.RequestInfo;
-import io.grpc.CallOptions;
-import io.grpc.ChannelLogger;
-import io.grpc.IntegerMarshaller;
-import io.grpc.Metadata;
-import io.grpc.MethodDescriptor;
-import io.grpc.SecurityLevel;
-import io.grpc.Status;
-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.Mock;
-import org.mockito.invocation.InvocationOnMock;
-import org.mockito.junit.MockitoJUnit;
-import org.mockito.junit.MockitoRule;
-import org.mockito.stubbing.Answer;
-
-/**
- * Unit test for {@link CallCredentials2} applying functionality implemented by {@link
- * CallCredentialsApplyingTransportFactory} and {@link MetadataApplierImpl}.
- */
-@SuppressWarnings("deprecation")
-@RunWith(JUnit4.class)
-public class CallCredentials2ApplyingTest {
-  @Rule
-  public final MockitoRule mocks = MockitoJUnit.rule();
-
-  @Mock
-  private ClientTransportFactory mockTransportFactory;
-
-  @Mock
-  private ConnectionClientTransport mockTransport;
-
-  @Mock
-  private ClientStream mockStream;
-
-  @Mock
-  private io.grpc.CallCredentials2 mockCreds;
-
-  @Mock
-  private Executor mockExecutor;
-
-  @Mock
-  private SocketAddress address;
-
-  // Noop logger;
-  @Mock
-  private ChannelLogger channelLogger;
-
-  private static final String AUTHORITY = "testauthority";
-  private static final String USER_AGENT = "testuseragent";
-  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")
-          .setRequestMarshaller(new StringMarshaller())
-          .setResponseMarshaller(new IntegerMarshaller())
-          .build();
-  private static final Metadata.Key<String> ORIG_HEADER_KEY =
-      Metadata.Key.of("header1", Metadata.ASCII_STRING_MARSHALLER);
-  private static final String ORIG_HEADER_VALUE = "some original header value";
-  private static final Metadata.Key<String> CREDS_KEY =
-      Metadata.Key.of("test-creds", Metadata.ASCII_STRING_MARSHALLER);
-  private static final String CREDS_VALUE = "some credentials";
-
-  private final Metadata origHeaders = new Metadata();
-  private ForwardingConnectionClientTransport transport;
-  private CallOptions callOptions;
-
-  @Before
-  public void setUp() {
-    ClientTransportFactory.ClientTransportOptions clientTransportOptions =
-        new ClientTransportFactory.ClientTransportOptions()
-          .setAuthority(AUTHORITY)
-          .setUserAgent(USER_AGENT);
-
-    origHeaders.put(ORIG_HEADER_KEY, ORIG_HEADER_VALUE);
-    when(mockTransportFactory.newClientTransport(address, clientTransportOptions, channelLogger))
-        .thenReturn(mockTransport);
-    when(mockTransport.newStream(same(method), any(Metadata.class), any(CallOptions.class)))
-        .thenReturn(mockStream);
-    ClientTransportFactory transportFactory = new CallCredentialsApplyingTransportFactory(
-        mockTransportFactory, null, mockExecutor);
-    transport = (ForwardingConnectionClientTransport)
-        transportFactory.newClientTransport(address, clientTransportOptions, channelLogger);
-    callOptions = CallOptions.DEFAULT.withCallCredentials(mockCreds);
-    verify(mockTransportFactory).newClientTransport(address, clientTransportOptions, channelLogger);
-    assertSame(mockTransport, transport.delegate());
-  }
-
-  @Test
-  public void parameterPropagation_base() {
-    Attributes transportAttrs = Attributes.newBuilder().set(ATTR_KEY, ATTR_VALUE).build();
-    when(mockTransport.getAttributes()).thenReturn(transportAttrs);
-
-    transport.newStream(method, origHeaders, callOptions);
-
-    ArgumentCaptor<RequestInfo> infoCaptor = ArgumentCaptor.forClass(null);
-    verify(mockCreds).applyRequestMetadata(
-        infoCaptor.capture(), same(mockExecutor),
-        any(io.grpc.CallCredentials2.MetadataApplier.class));
-    RequestInfo info = infoCaptor.getValue();
-    assertSame(method, info.getMethodDescriptor());
-    assertSame(ATTR_VALUE, info.getTransportAttrs().get(ATTR_KEY));
-    assertSame(AUTHORITY, info.getAuthority());
-    assertSame(SecurityLevel.NONE, info.getSecurityLevel());
-  }
-
-  @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);
-
-    transport.newStream(method, origHeaders, callOptions);
-
-    ArgumentCaptor<RequestInfo> infoCaptor = ArgumentCaptor.forClass(null);
-    verify(mockCreds).applyRequestMetadata(
-        infoCaptor.capture(), same(mockExecutor),
-        any(io.grpc.CallCredentials2.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_callOptionsSetAuthority() {
-    Attributes transportAttrs = Attributes.newBuilder()
-        .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));
-
-    ArgumentCaptor<RequestInfo> infoCaptor = ArgumentCaptor.forClass(null);
-    verify(mockCreds).applyRequestMetadata(
-        infoCaptor.capture(), same(anotherExecutor),
-        any(io.grpc.CallCredentials2.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(io.grpc.CallCredentials2.MetadataApplier.class));
-
-    FailingClientStream stream =
-        (FailingClientStream) transport.newStream(method, origHeaders, callOptions);
-
-    verify(mockTransport, never()).newStream(method, origHeaders, callOptions);
-    assertEquals(Status.Code.UNAUTHENTICATED, stream.getError().getCode());
-    assertSame(ex, stream.getError().getCause());
-    transport.shutdown(Status.UNAVAILABLE);
-    assertTrue(transport.newStream(method, origHeaders, callOptions)
-        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()[2];
-          Metadata headers = new Metadata();
-          headers.put(CREDS_KEY, CREDS_VALUE);
-          applier.apply(headers);
-          return null;
-        }
-      }).when(mockCreds).applyRequestMetadata(
-          any(RequestInfo.class), same(mockExecutor),
-          any(io.grpc.CallCredentials2.MetadataApplier.class));
-
-    ClientStream stream = transport.newStream(method, origHeaders, callOptions);
-
-    verify(mockTransport).newStream(method, origHeaders, callOptions);
-    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)
-        instanceof FailingClientStream);
-    verify(mockTransport).shutdown(Status.UNAVAILABLE);
-  }
-
-  @Test
-  public void fail_inline() {
-    final Status error = Status.FAILED_PRECONDITION.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()[2];
-          applier.fail(error);
-          return null;
-        }
-      }).when(mockCreds).applyRequestMetadata(
-          any(RequestInfo.class), same(mockExecutor),
-          any(io.grpc.CallCredentials2.MetadataApplier.class));
-
-    FailingClientStream stream =
-        (FailingClientStream) transport.newStream(method, origHeaders, callOptions);
-
-    verify(mockTransport, never()).newStream(method, origHeaders, callOptions);
-    assertSame(error, stream.getError());
-    transport.shutdownNow(Status.UNAVAILABLE);
-    assertTrue(transport.newStream(method, origHeaders, callOptions)
-        instanceof FailingClientStream);
-    verify(mockTransport).shutdownNow(Status.UNAVAILABLE);
-  }
-
-  @Test
-  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);
-
-    ArgumentCaptor<MetadataApplier> applierCaptor = ArgumentCaptor.forClass(null);
-    verify(mockCreds).applyRequestMetadata(
-        any(RequestInfo.class), same(mockExecutor), applierCaptor.capture());
-    verify(mockTransport, never()).newStream(method, origHeaders, callOptions);
-
-    transport.shutdown(Status.UNAVAILABLE);
-    verify(mockTransport, never()).shutdown(Status.UNAVAILABLE);
-
-    Metadata headers = new Metadata();
-    headers.put(CREDS_KEY, CREDS_VALUE);
-    applierCaptor.getValue().apply(headers);
-
-    verify(mockTransport).newStream(method, origHeaders, callOptions);
-    assertSame(mockStream, stream.getRealStream());
-    assertEquals(CREDS_VALUE, origHeaders.get(CREDS_KEY));
-    assertEquals(ORIG_HEADER_VALUE, origHeaders.get(ORIG_HEADER_KEY));
-    assertTrue(transport.newStream(method, origHeaders, callOptions)
-        instanceof FailingClientStream);
-    verify(mockTransport).shutdown(Status.UNAVAILABLE);
-  }
-
-  @Test
-  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);
-
-    ArgumentCaptor<MetadataApplier> applierCaptor = ArgumentCaptor.forClass(null);
-    verify(mockCreds).applyRequestMetadata(
-        any(RequestInfo.class), same(mockExecutor), applierCaptor.capture());
-
-    Status error = Status.FAILED_PRECONDITION.withDescription("channel not secure for creds");
-    applierCaptor.getValue().fail(error);
-
-    verify(mockTransport, never()).newStream(method, origHeaders, callOptions);
-    FailingClientStream failingStream = (FailingClientStream) stream.getRealStream();
-    assertSame(error, failingStream.getError());
-    transport.shutdown(Status.UNAVAILABLE);
-    assertTrue(transport.newStream(method, origHeaders, callOptions)
-        instanceof FailingClientStream);
-    verify(mockTransport).shutdown(Status.UNAVAILABLE);
-  }
-
-  @Test
-  public void noCreds() {
-    callOptions = callOptions.withCallCredentials(null);
-    ClientStream stream = transport.newStream(method, origHeaders, callOptions);
-
-    verify(mockTransport).newStream(method, origHeaders, callOptions);
-    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)
-        instanceof FailingClientStream);
-    verify(mockTransport).shutdown(Status.UNAVAILABLE);
-  }
-}
diff --git a/core/src/test/java/io/grpc/internal/CallCredentialsApplyingTest.java b/core/src/test/java/io/grpc/internal/CallCredentialsApplyingTest.java
index 61a221f73de..bb64bbae188 100644
--- a/core/src/test/java/io/grpc/internal/CallCredentialsApplyingTest.java
+++ b/core/src/test/java/io/grpc/internal/CallCredentialsApplyingTest.java
@@ -16,6 +16,7 @@
 
 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;
@@ -35,11 +36,13 @@
 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;
@@ -49,6 +52,7 @@
 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.invocation.InvocationOnMock;
 import org.mockito.junit.MockitoJUnit;
@@ -86,6 +90,9 @@ public class CallCredentialsApplyingTest {
   @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.create("somekey");
@@ -117,7 +124,9 @@ public void setUp() {
     origHeaders.put(ORIG_HEADER_KEY, ORIG_HEADER_VALUE);
     when(mockTransportFactory.newClientTransport(address, clientTransportOptions, channelLogger))
         .thenReturn(mockTransport);
-    when(mockTransport.newStream(same(method), any(Metadata.class), any(CallOptions.class)))
+    when(mockTransport.newStream(
+            same(method), any(Metadata.class), any(CallOptions.class),
+            ArgumentMatchers.<ClientStreamTracer[]>any()))
         .thenReturn(mockStream);
     ClientTransportFactory transportFactory = new CallCredentialsApplyingTransportFactory(
         mockTransportFactory, null, mockExecutor);
@@ -133,14 +142,15 @@ public void parameterPropagation_base() {
     Attributes transportAttrs = Attributes.newBuilder().set(ATTR_KEY, ATTR_VALUE).build();
     when(mockTransport.getAttributes()).thenReturn(transportAttrs);
 
-    transport.newStream(method, origHeaders, callOptions);
+    transport.newStream(method, origHeaders, callOptions, tracers);
 
-    ArgumentCaptor<RequestInfo> infoCaptor = ArgumentCaptor.forClass(null);
+    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());
   }
@@ -154,12 +164,14 @@ public void parameterPropagation_overrideByCallOptions() {
     when(mockTransport.getAttributes()).thenReturn(transportAttrs);
     Executor anotherExecutor = mock(Executor.class);
 
-    transport.newStream(method, origHeaders,
-        callOptions.withAuthority("calloptions-authority").withExecutor(anotherExecutor));
+    transport.newStream(
+        method, origHeaders,
+        callOptions.withAuthority("calloptions-authority").withExecutor(anotherExecutor),
+        tracers);
 
-    ArgumentCaptor<RequestInfo> infoCaptor = ArgumentCaptor.forClass(null);
+    ArgumentCaptor<RequestInfo> infoCaptor = ArgumentCaptor.forClass(RequestInfo.class);
     verify(mockCreds).applyRequestMetadata(infoCaptor.capture(),
-        same(anotherExecutor), any(CallCredentials.MetadataApplier.class));
+        same(mockExecutor), any(CallCredentials.MetadataApplier.class));
     RequestInfo info = infoCaptor.getValue();
     assertSame(transportAttrs, info.getTransportAttrs());
     assertSame(method, info.getMethodDescriptor());
@@ -167,6 +179,51 @@ public void parameterPropagation_overrideByCallOptions() {
     assertSame(SecurityLevel.INTEGRITY, info.getSecurityLevel());
   }
 
+  @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);
+
+    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_callOptionsSetAuthority() {
+    Attributes transportAttrs = Attributes.newBuilder()
+            .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),
+            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();
@@ -175,15 +232,17 @@ public void credentialThrows() {
         any(RequestInfo.class), same(mockExecutor),
         any(CallCredentials.MetadataApplier.class));
 
-    FailingClientStream stream =
-        (FailingClientStream) transport.newStream(method, origHeaders, callOptions);
+    FailingClientStream stream = (FailingClientStream) transport.newStream(
+        method, origHeaders, callOptions, tracers);
 
-    verify(mockTransport, never()).newStream(method, origHeaders, callOptions);
+    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)
+    assertTrue(transport.newStream(method, origHeaders, callOptions, tracers)
         instanceof FailingClientStream);
     verify(mockTransport).shutdown(Status.UNAVAILABLE);
   }
@@ -193,21 +252,22 @@ public void applyMetadata_inline() {
     when(mockTransport.getAttributes()).thenReturn(Attributes.EMPTY);
 
     callOptions = callOptions.withCallCredentials(new FakeCallCredentials(CREDS_KEY, CREDS_VALUE));
-    ClientStream stream = transport.newStream(method, origHeaders, callOptions);
+    ClientStream stream = transport.newStream(
+        method, origHeaders, callOptions, tracers);
 
-    verify(mockTransport).newStream(method, origHeaders, callOptions);
+    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)
+    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
@@ -220,13 +280,47 @@ public Void answer(InvocationOnMock invocation) throws Throwable {
       }).when(mockCreds).applyRequestMetadata(any(RequestInfo.class),
           same(mockExecutor), any(CallCredentials.MetadataApplier.class));
 
-    FailingClientStream stream =
-        (FailingClientStream) transport.newStream(method, origHeaders, callOptions);
+    FailingClientStream stream = (FailingClientStream) transport.newStream(
+        method, origHeaders, callOptions, tracers);
 
-    verify(mockTransport, never()).newStream(method, origHeaders, callOptions);
+    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)
+    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);
   }
@@ -236,23 +330,27 @@ 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);
+    DelayedStream stream = (DelayedStream) transport.newStream(
+        method, origHeaders, callOptions, tracers);
 
-    ArgumentCaptor<CallCredentials.MetadataApplier> applierCaptor = ArgumentCaptor.forClass(null);
+    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);
+    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)
+    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);
+    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));
@@ -261,20 +359,21 @@ public void applyMetadata_delayed() {
 
   @Test
   public void delayedShutdown_shutdownShutdownNowThenApply() {
-    transport.newStream(method, origHeaders, callOptions);
-    ArgumentCaptor<CallCredentials.MetadataApplier> applierCaptor = ArgumentCaptor.forClass(null);
+    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)
+    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)
+    assertTrue(transport.newStream(method, origHeaders, callOptions, tracers)
         instanceof FailingClientStream);
     verify(mockTransport).shutdown(Status.UNAVAILABLE);
     verify(mockTransport).shutdownNow(Status.ABORTED);
@@ -282,12 +381,13 @@ public void delayedShutdown_shutdownShutdownNowThenApply() {
 
   @Test
   public void delayedShutdown_shutdownThenApplyThenShutdownNow() {
-    transport.newStream(method, origHeaders, callOptions);
-    ArgumentCaptor<CallCredentials.MetadataApplier> applierCaptor = ArgumentCaptor.forClass(null);
+    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)
+    assertTrue(transport.newStream(method, origHeaders, callOptions, tracers)
         instanceof FailingClientStream);
     verify(mockTransport, never()).shutdown(any(Status.class));
     Metadata headers = new Metadata();
@@ -308,25 +408,26 @@ public void delayedShutdown_shutdownMulti() {
     Metadata headers = new Metadata();
     headers.put(CREDS_KEY, CREDS_VALUE);
 
-    transport.newStream(method, origHeaders, callOptions);
-    transport.newStream(method, origHeaders, callOptions);
-    transport.newStream(method, origHeaders, callOptions);
-    ArgumentCaptor<CallCredentials.MetadataApplier> applierCaptor = ArgumentCaptor.forClass(null);
+    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)
+    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)
+    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)
+    assertTrue(transport.newStream(method, origHeaders, callOptions, tracers)
         instanceof FailingClientStream);
     verify(mockTransport).shutdown(Status.UNAVAILABLE);
   }
@@ -336,20 +437,24 @@ 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);
+    DelayedStream stream = (DelayedStream) transport.newStream(
+        method, origHeaders, callOptions, tracers);
 
-    ArgumentCaptor<CallCredentials.MetadataApplier> applierCaptor = ArgumentCaptor.forClass(null);
+    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);
+    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)
+    assertTrue(transport.newStream(method, origHeaders, callOptions, tracers)
         instanceof FailingClientStream);
     verify(mockTransport).shutdown(Status.UNAVAILABLE);
   }
@@ -357,14 +462,15 @@ public void fail_delayed() {
   @Test
   public void noCreds() {
     callOptions = callOptions.withCallCredentials(null);
-    ClientStream stream = transport.newStream(method, origHeaders, callOptions);
+    ClientStream stream = transport.newStream(
+        method, origHeaders, callOptions, tracers);
 
-    verify(mockTransport).newStream(method, origHeaders, callOptions);
+    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)
+    assertTrue(transport.newStream(method, origHeaders, callOptions, tracers)
         instanceof FailingClientStream);
     verify(mockTransport).shutdown(Status.UNAVAILABLE);
   }
@@ -373,7 +479,8 @@ public void noCreds() {
   public void justCallOptionCreds() {
     callOptions = callOptions.withCallCredentials(new FakeCallCredentials(CREDS_KEY, CREDS_VALUE));
 
-    ClientStream stream = transport.newStream(method, origHeaders, callOptions);
+    ClientStream stream = transport.newStream(
+        method, origHeaders, callOptions, tracers);
 
     assertSame(mockStream, stream);
     assertEquals(CREDS_VALUE, origHeaders.get(CREDS_KEY));
@@ -388,7 +495,8 @@ public void justChannelCreds() {
         transportFactory.newClientTransport(address, clientTransportOptions, channelLogger);
     callOptions = callOptions.withCallCredentials(null);
 
-    ClientStream stream = transport.newStream(method, origHeaders, callOptions);
+    ClientStream stream = transport.newStream(
+        method, origHeaders, callOptions, tracers);
 
     assertSame(mockStream, stream);
     assertEquals(CREDS_VALUE, origHeaders.get(CREDS_KEY));
@@ -406,7 +514,8 @@ public void callOptionAndChanelCreds() {
     String creds2Value = "some more credentials";
     callOptions = callOptions.withCallCredentials(new FakeCallCredentials(creds2Key, creds2Value));
 
-    ClientStream stream = transport.newStream(method, origHeaders, callOptions);
+    ClientStream stream = transport.newStream(
+        method, origHeaders, callOptions, tracers);
 
     assertSame(mockStream, stream);
     assertEquals(CREDS_VALUE, origHeaders.get(CREDS_KEY));
diff --git a/core/src/test/java/io/grpc/internal/ChannelLoggerImplTest.java b/core/src/test/java/io/grpc/internal/ChannelLoggerImplTest.java
index 486d96fd7b9..afe8e9828c9 100644
--- a/core/src/test/java/io/grpc/internal/ChannelLoggerImplTest.java
+++ b/core/src/test/java/io/grpc/internal/ChannelLoggerImplTest.java
@@ -100,7 +100,7 @@ public void logging() {
         .setTimestampNanos(200)
         .build();
     assertThat(stats.channelTrace.events).containsExactly(event);
-    assertThat(logs).contains("FINER: " + logPrefix + "Warning message");
+    assertThat(logs).contains("FINE: " + logPrefix + "Warning message");
 
     clock.forwardNanos(100);
     logger.log(ChannelLogLevel.INFO, "Info message");
@@ -112,7 +112,7 @@ public void logging() {
         .setTimestampNanos(300)
         .build();
     assertThat(stats.channelTrace.events).containsExactly(event);
-    assertThat(logs).contains("FINEST: " + logPrefix + "Info message");
+    assertThat(logs).contains("FINER: " + logPrefix + "Info message");
 
     clock.forwardNanos(100);
     logger.log(ChannelLogLevel.DEBUG, "Debug message");
@@ -154,7 +154,7 @@ public void formatLogging() {
         .setTimestampNanos(200)
         .build();
     assertThat(stats.channelTrace.events).containsExactly(event);
-    assertThat(logs).contains("FINER: " + logPrefix + "Warning message foo, bar");
+    assertThat(logs).contains("FINE: " + logPrefix + "Warning message foo, bar");
 
     clock.forwardNanos(100);
     logger.log(ChannelLogLevel.INFO, "Info message {0}", "bar");
@@ -166,7 +166,7 @@ public void formatLogging() {
         .setTimestampNanos(300)
         .build();
     assertThat(stats.channelTrace.events).containsExactly(event);
-    assertThat(logs).contains("FINEST: " + logPrefix + "Info message bar");
+    assertThat(logs).contains("FINER: " + logPrefix + "Info message bar");
 
     clock.forwardNanos(100);
     logger.log(ChannelLogLevel.DEBUG, "Debug message {0}", "foo");
diff --git a/core/src/test/java/io/grpc/internal/ClientCallImplTest.java b/core/src/test/java/io/grpc/internal/ClientCallImplTest.java
index d6f0abbdbeb..03e613e13d9 100644
--- a/core/src/test/java/io/grpc/internal/ClientCallImplTest.java
+++ b/core/src/test/java/io/grpc/internal/ClientCallImplTest.java
@@ -17,6 +17,8 @@
 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;
@@ -36,6 +38,7 @@
 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;
@@ -46,6 +49,7 @@
 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;
@@ -55,10 +59,11 @@
 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.ClientStreamProvider;
 import io.grpc.internal.ManagedChannelServiceConfig.MethodInfo;
-import io.grpc.internal.testing.SingleMessageProducer;
+import io.grpc.internal.SingleMessageProducer;
 import io.grpc.testing.TestMethodDescriptors;
 import java.io.ByteArrayInputStream;
 import java.io.IOException;
@@ -142,6 +147,8 @@ public void setUp() {
             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) {
@@ -155,7 +162,7 @@ public Void answer(InvocationOnMock in) {
 
   @After
   public void tearDown() {
-    verifyNoInteractions(streamTracerFactory);
+    verifyNoMoreInteractions(streamTracerFactory);
   }
 
   @Test
@@ -173,7 +180,7 @@ public void statusPropagatedFromStreamToCallListener() {
     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(same(status), ArgumentMatchers.isA(Metadata.class));
@@ -205,7 +212,7 @@ public void exceptionInOnMessageTakesPrecedenceOverServer() {
      */
     streamListener
         .messagesAvailable(new SingleMessageProducer(new ByteArrayInputStream(new byte[]{})));
-    streamListener.closed(Status.OK, new Metadata());
+    streamListener.closed(Status.OK, PROCESSED, new Metadata());
     executor.release();
 
     verify(callListener).onClose(statusArgumentCaptor.capture(),
@@ -240,7 +247,7 @@ 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(),
@@ -292,7 +299,7 @@ class PointOfNoReturnExecutor implements Executor {
     final ClientStreamListener streamListener = listenerArgumentCaptor.getValue();
 
     streamListener.headersRead(new Metadata());
-    streamListener.closed(Status.OK, new Metadata());
+    streamListener.closed(Status.OK, PROCESSED, new Metadata());
   }
 
   @Test
@@ -319,7 +326,7 @@ 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(),
@@ -390,7 +397,7 @@ public void callOptionsPropagatedToTransport() {
 
   @Test
   public void methodInfoDeadlinePropagatedToStream() {
-    ArgumentCaptor<CallOptions> callOptionsCaptor = ArgumentCaptor.forClass(null);
+    ArgumentCaptor<CallOptions> callOptionsCaptor = ArgumentCaptor.forClass(CallOptions.class);
     CallOptions callOptions = baseCallOptions.withDeadline(Deadline.after(2000, SECONDS));
 
     // Case: config Deadline expires later than CallOptions Deadline
@@ -464,6 +471,15 @@ public void prepareHeaders_ignoreIdentityEncoding() {
     assertNull(m.get(GrpcUtil.MESSAGE_ENCODING_KEY));
   }
 
+  @Test
+  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();
@@ -664,7 +680,7 @@ private void checkContext() {
     listener.headersRead(new Metadata());
     listener.messagesAvailable(new SingleMessageProducer(new ByteArrayInputStream(new byte[0])));
     listener.messagesAvailable(new SingleMessageProducer(new ByteArrayInputStream(new byte[0])));
-    listener.closed(Status.OK, new Metadata());
+    listener.closed(Status.OK, PROCESSED, new Metadata());
 
     assertTrue(latch.await(5, TimeUnit.SECONDS));
 
@@ -751,7 +767,18 @@ public void onClose(Status status, Metadata trailers) {
 
   @Test
   public void deadlineExceededBeforeCallStarted() {
-    CallOptions callOptions = baseCallOptions.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<>(
         method,
@@ -762,6 +789,7 @@ public void deadlineExceededBeforeCallStarted() {
         channelCallTracer, configSelector)
             .setDecompressorRegistry(decompressorRegistry);
     call.start(callListener, new Metadata());
+    verify(streamTracerFactory).newClientStreamTracer(any(StreamInfo.class), any(Metadata.class));
     verify(clientStreamProvider, never())
         .newStream(
             (MethodDescriptor<?, ?>) any(MethodDescriptor.class),
@@ -770,15 +798,17 @@ public void deadlineExceededBeforeCallStarted() {
             any(Context.class));
     verify(callListener, timeout(1000)).onClose(statusCaptor.capture(), any(Metadata.class));
     assertEquals(Status.Code.DEADLINE_EXCEEDED, statusCaptor.getValue().getCode());
-    assertThat(statusCaptor.getValue().getDescription())
-        .startsWith("ClientCall started after deadline exceeded");
+    String deadlineExceedDescription = statusCaptor.getValue().getDescription();
+    assertThat(deadlineExceedDescription)
+        .startsWith("ClientCall started after CallOptions deadline was exceeded");
+    assertThat(deadlineExceedDescription).endsWith(descriptionSuffix);
     verifyNoInteractions(clientStreamProvider);
   }
 
   @Test
   public void contextDeadlineShouldBePropagatedToStream() {
-    Context context = Context.current()
-        .withDeadlineAfter(1000, TimeUnit.MILLISECONDS, deadlineCancellationExecutor);
+    Deadline deadline = Deadline.after(1000, TimeUnit.MILLISECONDS);
+    Context context = Context.current().withDeadline(deadline, deadlineCancellationExecutor);
     Context origContext = context.attach();
 
     ClientCallImpl<Void, Void> call = new ClientCallImpl<>(
@@ -792,16 +822,13 @@ public void contextDeadlineShouldBePropagatedToStream() {
 
     context.detach(origContext);
 
-    ArgumentCaptor<Deadline> deadlineCaptor = ArgumentCaptor.forClass(Deadline.class);
-    verify(stream).setDeadline(deadlineCaptor.capture());
-
-    assertTimeoutBetween(deadlineCaptor.getValue().timeRemaining(TimeUnit.MILLISECONDS), 600, 1000);
+    verify(stream).setDeadline(eq(deadline));
   }
 
   @Test
   public void contextDeadlineShouldOverrideLargerCallOptionsDeadline() {
-    Context context = Context.current()
-        .withDeadlineAfter(1000, TimeUnit.MILLISECONDS, deadlineCancellationExecutor);
+    Deadline deadline = Deadline.after(1000, TimeUnit.MILLISECONDS);
+    Context context = Context.current().withDeadline(deadline, deadlineCancellationExecutor);
     Context origContext = context.attach();
 
     CallOptions callOpts = baseCallOptions.withDeadlineAfter(2000, TimeUnit.MILLISECONDS);
@@ -816,19 +843,18 @@ public void contextDeadlineShouldOverrideLargerCallOptionsDeadline() {
 
     context.detach(origContext);
 
-    ArgumentCaptor<Deadline> deadlineCaptor = ArgumentCaptor.forClass(Deadline.class);
-    verify(stream).setDeadline(deadlineCaptor.capture());
-
-    assertTimeoutBetween(deadlineCaptor.getValue().timeRemaining(TimeUnit.MILLISECONDS), 600, 1000);
+    verify(stream).setDeadline(eq(deadline));
   }
 
   @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.withDeadlineAfter(1000, TimeUnit.MILLISECONDS);
+    CallOptions callOpts = baseCallOptions.withDeadline(deadline)
+        .withOption(NAME_RESOLUTION_DELAYED, 1200000000L);
     ClientCallImpl<Void, Void> call = new ClientCallImpl<>(
         method,
         MoreExecutors.directExecutor(),
@@ -840,15 +866,19 @@ public void contextDeadlineShouldNotOverrideSmallerCallOptionsDeadline() {
 
     context.detach(origContext);
 
-    ArgumentCaptor<Deadline> deadlineCaptor = ArgumentCaptor.forClass(Deadline.class);
-    verify(stream).setDeadline(deadlineCaptor.capture());
+    verify(stream).setDeadline(eq(deadline));
 
-    assertTimeoutBetween(deadlineCaptor.getValue().timeRemaining(TimeUnit.MILLISECONDS), 600, 1000);
+    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 callOptionsDeadlineShouldBePropagatedToStream() {
-    CallOptions callOpts = baseCallOptions.withDeadlineAfter(1000, TimeUnit.MILLISECONDS);
+    Deadline deadline = Deadline.after(1000, TimeUnit.MILLISECONDS);
+    CallOptions callOpts = baseCallOptions.withDeadline(deadline);
     ClientCallImpl<Void, Void> call = new ClientCallImpl<>(
         method,
         MoreExecutors.directExecutor(),
@@ -858,10 +888,7 @@ public void callOptionsDeadlineShouldBePropagatedToStream() {
         channelCallTracer, configSelector);
     call.start(callListener, new Metadata());
 
-    ArgumentCaptor<Deadline> deadlineCaptor = ArgumentCaptor.forClass(Deadline.class);
-    verify(stream).setDeadline(deadlineCaptor.capture());
-
-    assertTimeoutBetween(deadlineCaptor.getValue().timeRemaining(TimeUnit.MILLISECONDS), 600, 1000);
+    verify(stream).setDeadline(eq(deadline));
   }
 
   @Test
@@ -899,7 +926,8 @@ public void expiredDeadlineCancelsStream_CallOptions() {
     verify(stream, times(1)).cancel(statusCaptor.capture());
     assertEquals(Status.Code.DEADLINE_EXCEEDED, statusCaptor.getValue().getCode());
     assertThat(statusCaptor.getValue().getDescription())
-        .matches("deadline exceeded after [0-9]+\\.[0-9]+s. \\[remote_addr=127\\.0\\.0\\.1:443\\]");
+        .matches("CallOptions deadline exceeded after [0-9]+\\.[0-9]+s. "
+            + "Name resolution delay 0.000000000 seconds. \\[remote_addr=127\\.0\\.0\\.1:443\\]");
   }
 
   @Test
@@ -926,7 +954,24 @@ public void expiredDeadlineCancelsStream_Context() {
 
     verify(stream, times(1)).cancel(statusCaptor.capture());
     assertEquals(Status.Code.DEADLINE_EXCEEDED, statusCaptor.getValue().getCode());
-    assertThat(statusCaptor.getValue().getDescription()).isEqualTo("context timed out");
+    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
@@ -1007,6 +1052,24 @@ 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 =
@@ -1042,9 +1105,30 @@ public void getAttributes() {
     assertEquals(attrs, call.getAttributes());
   }
 
-  private static void assertTimeoutBetween(long timeout, long from, long to) {
-    assertTrue("timeout: " + timeout + " ns", timeout <= to);
-    assertTrue("timeout: " + timeout + " ns", timeout >= from);
+  @Test
+  public void onCloseExceptionCaughtAndLogged() {
+    DelayedExecutor executor = new DelayedExecutor();
+    ClientCallImpl<Void, Void> call = new ClientCallImpl<>(
+        method,
+        executor,
+        baseCallOptions,
+        clientStreamProvider,
+        deadlineCancellationExecutor,
+        channelCallTracer, configSelector);
+
+    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 {
diff --git a/core/src/test/java/io/grpc/internal/CompositeReadableBufferTest.java b/core/src/test/java/io/grpc/internal/CompositeReadableBufferTest.java
index 660aa116317..749b71d681e 100644
--- a/core/src/test/java/io/grpc/internal/CompositeReadableBufferTest.java
+++ b/core/src/test/java/io/grpc/internal/CompositeReadableBufferTest.java
@@ -16,15 +16,19 @@
 
 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.Buffer;
-import java.nio.ByteBuffer;
+import java.nio.InvalidMarkException;
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
@@ -116,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();
 
-    ((Buffer) byteBuffer).limit(1);
-    composite.readBytes(byteBuffer);
+    composite.readBytes(bos, 1);
     remaining--;
     assertEquals(remaining, composite.readableBytes());
 
-    ((Buffer) byteBuffer).limit(byteBuffer.limit() + 5);
-    composite.readBytes(byteBuffer);
+    composite.readBytes(bos, 5);
     remaining -= 5;
     assertEquals(remaining, composite.readableBytes());
 
-    ((Buffer) 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
index 33f2e014e62..eda265e0ff9 100644
--- a/core/src/test/java/io/grpc/internal/ConfigSelectingClientCallTest.java
+++ b/core/src/test/java/io/grpc/internal/ConfigSelectingClientCallTest.java
@@ -31,6 +31,7 @@
 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;
@@ -121,6 +122,31 @@ 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);
       }
     };
@@ -132,9 +158,13 @@ public Result selectConfig(PickSubchannelArgs args) {
         method,
         CallOptions.DEFAULT);
     configSelectingClientCall.start(callListener, new Metadata());
-    ArgumentCaptor<Status> statusCaptor = ArgumentCaptor.forClass(null);
+    ArgumentCaptor<Status> statusCaptor = ArgumentCaptor.forClass(Status.class);
     verify(callListener).onClose(statusCaptor.capture(), any(Metadata.class));
-    assertThat(statusCaptor.getValue().getCode()).isEqualTo(Status.Code.FAILED_PRECONDITION);
+    // ... 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 {
diff --git a/core/src/test/java/io/grpc/internal/ConnectivityStateManagerTest.java b/core/src/test/java/io/grpc/internal/ConnectivityStateManagerTest.java
index 2a759a4f386..dfd6ed56a1e 100644
--- a/core/src/test/java/io/grpc/internal/ConnectivityStateManagerTest.java
+++ b/core/src/test/java/io/grpc/internal/ConnectivityStateManagerTest.java
@@ -27,9 +27,7 @@
 import io.grpc.ConnectivityState;
 import java.util.LinkedList;
 import java.util.concurrent.Executor;
-import org.junit.Rule;
 import org.junit.Test;
-import org.junit.rules.ExpectedException;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 
@@ -38,10 +36,6 @@
  */
 @RunWith(JUnit4.class)
 public class ConnectivityStateManagerTest {
-  @SuppressWarnings("deprecation") // https://github.com/grpc/grpc-java/issues/7467
-  @Rule
-  public final ExpectedException thrown = ExpectedException.none();
-
   private final FakeClock executor = new FakeClock();
   private final ConnectivityStateManager state = new ConnectivityStateManager();
   private final LinkedList<ConnectivityState> sink = new LinkedList<>();
@@ -75,7 +69,7 @@ public void run() {
     assertEquals(1, sink.size());
     assertEquals(TRANSIENT_FAILURE, sink.poll());
   }
-  
+
   @Test
   public void registerCallbackAfterStateChanged() {
     state.gotoState(CONNECTING);
diff --git a/core/src/test/java/io/grpc/internal/DelayedClientCallTest.java b/core/src/test/java/io/grpc/internal/DelayedClientCallTest.java
index 290e2b9de65..0d30e947b0c 100644
--- a/core/src/test/java/io/grpc/internal/DelayedClientCallTest.java
+++ b/core/src/test/java/io/grpc/internal/DelayedClientCallTest.java
@@ -21,19 +21,24 @@
 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;
@@ -63,12 +68,13 @@ public class DelayedClientCallTest {
   public void allMethodsForwarded() throws Exception {
     DelayedClientCall<String, Integer> delayedClientCall =
         new DelayedClientCall<>(callExecutor, fakeClock.getScheduledExecutorService(), null);
-    delayedClientCall.setCall(mockRealCall);
+    callMeMaybe(delayedClientCall.setCall(mockRealCall));
     ForwardingTestUtil.testMethodsForwarded(
         ClientCall.class,
         mockRealCall,
         delayedClientCall,
-        Arrays.asList(ClientCall.class.getMethod("toString")),
+        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) {
@@ -101,8 +107,9 @@ public void listenerEventsPropagated() {
     DelayedClientCall<String, Integer> delayedClientCall = new DelayedClientCall<>(
         callExecutor, fakeClock.getScheduledExecutorService(), Deadline.after(10, SECONDS));
     delayedClientCall.start(listener, new Metadata());
-    delayedClientCall.setCall(mockRealCall);
-    ArgumentCaptor<Listener<Integer>> listenerCaptor = ArgumentCaptor.forClass(null);
+    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();
@@ -119,4 +126,338 @@ public void listenerEventsPropagated() {
     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);
+  }
+
+  @Test
+  public void listenerThrowsInPendingCallback_cancelsRealCall() {
+    DelayedClientCall<String, Integer> delayedClientCall = new DelayedClientCall<>(
+        callExecutor, fakeClock.getScheduledExecutorService(), null);
+    final RuntimeException boom = new RuntimeException("boom");
+    ClientCall.Listener<Integer> throwingListener = new ClientCall.Listener<Integer>() {
+      @Override
+      public void onMessage(Integer msg) {
+        throw boom;
+      }
+    };
+    delayedClientCall.start(throwingListener, new Metadata());
+    // Deliver onMessage while the wrapping DelayedListener is still buffering, by firing
+    // it from within realCall.start() — drainPendingCalls has not yet flipped the listener
+    // to pass-through. The queued onMessage is then drained and throws; the fix must catch
+    // the throwable and cancel the real call rather than let it escape.
+    Runnable r = delayedClientCall.setCall(new SimpleForwardingClientCall<String, Integer>(
+        mockRealCall) {
+      @Override
+      public void start(Listener<Integer> listener, Metadata metadata) {
+        super.start(listener, metadata);
+        listener.onMessage(42);
+      }
+    });
+    assertThat(r).isNotNull();
+    r.run(); // Must not propagate `boom`.
+    verify(mockRealCall).cancel(eq("Failed to read message."), eq(boom));
+  }
+
+  @Test
+  public void listenerThrowsInPendingOnHeaders_cancelsRealCall() {
+    DelayedClientCall<String, Integer> delayedClientCall = new DelayedClientCall<>(
+        callExecutor, fakeClock.getScheduledExecutorService(), null);
+    final RuntimeException boom = new RuntimeException("boom");
+    ClientCall.Listener<Integer> throwingListener = new ClientCall.Listener<Integer>() {
+      @Override
+      public void onHeaders(Metadata headers) {
+        throw boom;
+      }
+    };
+    delayedClientCall.start(throwingListener, new Metadata());
+    Runnable r = delayedClientCall.setCall(new SimpleForwardingClientCall<String, Integer>(
+        mockRealCall) {
+      @Override
+      public void start(Listener<Integer> listener, Metadata metadata) {
+        super.start(listener, metadata);
+        listener.onHeaders(new Metadata());
+      }
+    });
+    assertThat(r).isNotNull();
+    r.run();
+    verify(mockRealCall).cancel(eq("Failed to read headers"), eq(boom));
+  }
+
+  @Test
+  public void listenerThrowsInPendingOnReady_cancelsRealCall() {
+    DelayedClientCall<String, Integer> delayedClientCall = new DelayedClientCall<>(
+        callExecutor, fakeClock.getScheduledExecutorService(), null);
+    final RuntimeException boom = new RuntimeException("boom");
+    ClientCall.Listener<Integer> throwingListener = new ClientCall.Listener<Integer>() {
+      @Override
+      public void onReady() {
+        throw boom;
+      }
+    };
+    delayedClientCall.start(throwingListener, new Metadata());
+    Runnable r = delayedClientCall.setCall(new SimpleForwardingClientCall<String, Integer>(
+        mockRealCall) {
+      @Override
+      public void start(Listener<Integer> listener, Metadata metadata) {
+        super.start(listener, metadata);
+        listener.onReady();
+      }
+    });
+    assertThat(r).isNotNull();
+    r.run();
+    verify(mockRealCall).cancel(eq("Failed to call onReady."), eq(boom));
+  }
+
+  @Test
+  public void onCloseExceptionCaughtAndLogged() {
+    DelayedClientCall<String, Integer> delayedClientCall = new DelayedClientCall<>(
+        callExecutor, fakeClock.getScheduledExecutorService(), null);
+    final RuntimeException boom = new RuntimeException("boom");
+    final AtomicReference<Status> observed = new AtomicReference<>();
+    ClientCall.Listener<Integer> throwingListener = new ClientCall.Listener<Integer>() {
+      @Override
+      public void onClose(Status status, Metadata trailers) {
+        observed.set(status);
+        throw boom;
+      }
+    };
+    delayedClientCall.start(throwingListener, new Metadata());
+    Runnable r = delayedClientCall.setCall(new SimpleForwardingClientCall<String, Integer>(
+        mockRealCall) {
+      @Override
+      public void start(Listener<Integer> listener, Metadata metadata) {
+        super.start(listener, metadata);
+        listener.onClose(Status.DATA_LOSS, new Metadata());
+      }
+    });
+    assertThat(r).isNotNull();
+    r.run(); // Must not propagate `boom`.
+    assertThat(observed.get().getCode()).isEqualTo(Status.Code.DATA_LOSS);
+    verify(mockRealCall, never()).cancel(any(), any());
+  }
+
+  @Test
+  public void listenerThrowsInPassThroughOnMessage_cancelsRealCall() {
+    DelayedClientCall<String, Integer> delayedClientCall = new DelayedClientCall<>(
+        callExecutor, fakeClock.getScheduledExecutorService(), null);
+    final RuntimeException boom = new RuntimeException("boom");
+    ClientCall.Listener<Integer> throwingListener = new ClientCall.Listener<Integer>() {
+      @Override
+      public void onMessage(Integer msg) {
+        throw boom;
+      }
+    };
+    delayedClientCall.start(throwingListener, new Metadata());
+    Runnable r = delayedClientCall.setCall(mockRealCall);
+    assertThat(r).isNotNull();
+    r.run(); // drain completes, listener transitions to passThrough
+    @SuppressWarnings("unchecked")
+    ArgumentCaptor<Listener<Integer>> listenerCaptor = ArgumentCaptor.forClass(Listener.class);
+    verify(mockRealCall).start(listenerCaptor.capture(), any(Metadata.class));
+    Listener<Integer> realCallListener = listenerCaptor.getValue();
+    realCallListener.onMessage(42); // dispatched on passThrough fast path
+    verify(mockRealCall).cancel(eq("Failed to read message."), eq(boom));
+  }
+
+  @Test
+  public void listenerThrowsInPassThroughOnHeaders_cancelsRealCall() {
+    DelayedClientCall<String, Integer> delayedClientCall = new DelayedClientCall<>(
+        callExecutor, fakeClock.getScheduledExecutorService(), null);
+    final RuntimeException boom = new RuntimeException("boom");
+    ClientCall.Listener<Integer> throwingListener = new ClientCall.Listener<Integer>() {
+      @Override
+      public void onHeaders(Metadata headers) {
+        throw boom;
+      }
+    };
+    delayedClientCall.start(throwingListener, new Metadata());
+    Runnable r = delayedClientCall.setCall(mockRealCall);
+    assertThat(r).isNotNull();
+    r.run();
+    @SuppressWarnings("unchecked")
+    ArgumentCaptor<Listener<Integer>> listenerCaptor = ArgumentCaptor.forClass(Listener.class);
+    verify(mockRealCall).start(listenerCaptor.capture(), any(Metadata.class));
+    Listener<Integer> realCallListener = listenerCaptor.getValue();
+    realCallListener.onHeaders(new Metadata());
+    verify(mockRealCall).cancel(eq("Failed to read headers"), eq(boom));
+  }
+
+  @Test
+  public void listenerThrowsInPassThroughOnReady_cancelsRealCall() {
+    DelayedClientCall<String, Integer> delayedClientCall = new DelayedClientCall<>(
+        callExecutor, fakeClock.getScheduledExecutorService(), null);
+    final RuntimeException boom = new RuntimeException("boom");
+    ClientCall.Listener<Integer> throwingListener = new ClientCall.Listener<Integer>() {
+      @Override
+      public void onReady() {
+        throw boom;
+      }
+    };
+    delayedClientCall.start(throwingListener, new Metadata());
+    Runnable r = delayedClientCall.setCall(mockRealCall);
+    assertThat(r).isNotNull();
+    r.run();
+    @SuppressWarnings("unchecked")
+    ArgumentCaptor<Listener<Integer>> listenerCaptor = ArgumentCaptor.forClass(Listener.class);
+    verify(mockRealCall).start(listenerCaptor.capture(), any(Metadata.class));
+    Listener<Integer> realCallListener = listenerCaptor.getValue();
+    realCallListener.onReady();
+    verify(mockRealCall).cancel(eq("Failed to call onReady."), eq(boom));
+  }
+
+  @Test
+  public void listenerThrowsInPassThrough_subsequentCallbacksSwallowedAndOnCloseOverridden() {
+    DelayedClientCall<String, Integer> delayedClientCall = new DelayedClientCall<>(
+        callExecutor, fakeClock.getScheduledExecutorService(), null);
+    final RuntimeException boom = new RuntimeException("boom");
+    final AtomicReference<Integer> lastMessage = new AtomicReference<>();
+    final AtomicReference<Status> closeStatus = new AtomicReference<>();
+    final AtomicReference<Metadata> closeTrailers = new AtomicReference<>();
+    ClientCall.Listener<Integer> throwingListener = new ClientCall.Listener<Integer>() {
+      @Override
+      public void onMessage(Integer msg) {
+        lastMessage.set(msg);
+        if (msg == 1) {
+          throw boom;
+        }
+      }
+
+      @Override
+      public void onClose(Status status, Metadata trailers) {
+        closeStatus.set(status);
+        closeTrailers.set(trailers);
+      }
+    };
+    delayedClientCall.start(throwingListener, new Metadata());
+    Runnable r = delayedClientCall.setCall(mockRealCall);
+    assertThat(r).isNotNull();
+    r.run();
+    @SuppressWarnings("unchecked")
+    ArgumentCaptor<Listener<Integer>> listenerCaptor = ArgumentCaptor.forClass(Listener.class);
+    verify(mockRealCall).start(listenerCaptor.capture(), any(Metadata.class));
+    Listener<Integer> realCallListener = listenerCaptor.getValue();
+
+    realCallListener.onMessage(1); // throws -> exceptionStatus captured
+    assertThat(lastMessage.get()).isEqualTo(1);
+    verify(mockRealCall).cancel(eq("Failed to read message."), eq(boom));
+
+    // Later callbacks are swallowed — the listener must not see message 2.
+    realCallListener.onMessage(2);
+    assertThat(lastMessage.get()).isEqualTo(1);
+
+    // Transport onClose with OK must be overridden by the captured CANCELLED status.
+    Metadata serverTrailers = new Metadata();
+    serverTrailers.put(Metadata.Key.of("k", Metadata.ASCII_STRING_MARSHALLER), "v");
+    realCallListener.onClose(Status.OK, serverTrailers);
+    assertThat(closeStatus.get().getCode()).isEqualTo(Status.Code.CANCELLED);
+    assertThat(closeStatus.get().getCause()).isEqualTo(boom);
+    // Trailers replaced to avoid mixing sources.
+    assertThat(closeTrailers.get()).isNotSameInstanceAs(serverTrailers);
+  }
+
+  private void callMeMaybe(Runnable r) {
+    if (r != null) {
+      r.run();
+    }
+  }
 }
diff --git a/core/src/test/java/io/grpc/internal/DelayedClientTransportTest.java b/core/src/test/java/io/grpc/internal/DelayedClientTransportTest.java
index 89655a7d7b5..d7e1d4ca4f6 100644
--- a/core/src/test/java/io/grpc/internal/DelayedClientTransportTest.java
+++ b/core/src/test/java/io/grpc/internal/DelayedClientTransportTest.java
@@ -17,12 +17,14 @@
 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.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;
@@ -36,6 +38,7 @@
 import static org.mockito.Mockito.when;
 
 import io.grpc.CallOptions;
+import io.grpc.ClientStreamTracer;
 import io.grpc.IntegerMarshaller;
 import io.grpc.LoadBalancer.PickResult;
 import io.grpc.LoadBalancer.PickSubchannelArgs;
@@ -43,6 +46,7 @@
 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 io.grpc.SynchronizationContext;
@@ -57,6 +61,7 @@
 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;
@@ -89,6 +94,9 @@ public class DelayedClientTransportTest {
       = 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()
@@ -122,9 +130,13 @@ public void uncaughtException(Thread t, Throwable e) {
         .thenReturn(PickResult.withSubchannel(mockSubchannel));
     when(mockSubchannel.getInternalSubchannel()).thenReturn(mockInternalSubchannel);
     when(mockInternalSubchannel.obtainActiveTransport()).thenReturn(mockRealTransport);
-    when(mockRealTransport.newStream(same(method), same(headers), same(callOptions)))
+    when(mockRealTransport.newStream(
+            same(method), same(headers), same(callOptions),
+            ArgumentMatchers.<ClientStreamTracer[]>any()))
         .thenReturn(mockRealStream);
-    when(mockRealTransport2.newStream(same(method2), same(headers2), same(callOptions2)))
+    when(mockRealTransport2.newStream(
+            same(method2), same(headers2), same(callOptions2),
+            ArgumentMatchers.<ClientStreamTracer[]>any()))
         .thenReturn(mockRealStream2);
     delayedTransport.start(transportListener);
   }
@@ -135,7 +147,8 @@ public void uncaughtException(Thread t, Throwable e) {
 
   @Test public void streamStartThenAssignTransport() {
     assertFalse(delayedTransport.hasPendingStreams());
-    ClientStream stream = delayedTransport.newStream(method, headers, callOptions);
+    ClientStream stream = delayedTransport.newStream(
+        method, headers, callOptions, tracers);
     stream.start(streamListener);
     assertEquals(1, delayedTransport.getPendingStreamsCount());
     assertTrue(delayedTransport.hasPendingStreams());
@@ -145,7 +158,9 @@ public void uncaughtException(Thread t, Throwable e) {
     assertEquals(0, delayedTransport.getPendingStreamsCount());
     assertFalse(delayedTransport.hasPendingStreams());
     assertEquals(1, fakeExecutor.runDueTasks());
-    verify(mockRealTransport).newStream(same(method), same(headers), same(callOptions));
+    verify(mockRealTransport).newStream(
+        same(method), same(headers), same(callOptions),
+        ArgumentMatchers.<ClientStreamTracer[]>any());
     verify(mockRealStream).start(listenerCaptor.capture());
     verifyNoMoreInteractions(streamListener);
     listenerCaptor.getValue().onReady();
@@ -154,23 +169,27 @@ public void uncaughtException(Thread t, Throwable e) {
   }
 
   @Test public void newStreamThenAssignTransportThenShutdown() {
-    ClientStream stream = delayedTransport.newStream(method, headers, callOptions);
+    ClientStream stream = delayedTransport.newStream(method, headers, callOptions, tracers);
     assertEquals(1, delayedTransport.getPendingStreamsCount());
     assertTrue(stream instanceof DelayedStream);
     delayedTransport.reprocess(mockPicker);
     assertEquals(0, delayedTransport.getPendingStreamsCount());
     delayedTransport.shutdown(SHUTDOWN_STATUS);
-    verify(transportListener).transportShutdown(same(SHUTDOWN_STATUS));
+    verify(transportListener).transportShutdown(same(SHUTDOWN_STATUS),
+        eq(SimpleDisconnectError.SUBCHANNEL_SHUTDOWN));
     verify(transportListener).transportTerminated();
     assertEquals(0, fakeExecutor.runDueTasks());
-    verify(mockRealTransport).newStream(same(method), same(headers), same(callOptions));
+    verify(mockRealTransport).newStream(
+        same(method), same(headers), same(callOptions),
+        ArgumentMatchers.<ClientStreamTracer[]>any());
     stream.start(streamListener);
     verify(mockRealStream).start(same(streamListener));
   }
 
   @Test public void transportTerminatedThenAssignTransport() {
     delayedTransport.shutdown(SHUTDOWN_STATUS);
-    verify(transportListener).transportShutdown(same(SHUTDOWN_STATUS));
+    verify(transportListener).transportShutdown(same(SHUTDOWN_STATUS),
+        eq(SimpleDisconnectError.SUBCHANNEL_SHUTDOWN));
     verify(transportListener).transportTerminated();
     delayedTransport.reprocess(mockPicker);
     verifyNoMoreInteractions(transportListener);
@@ -179,52 +198,63 @@ public void uncaughtException(Thread t, Throwable e) {
   @Test public void assignTransportThenShutdownThenNewStream() {
     delayedTransport.reprocess(mockPicker);
     delayedTransport.shutdown(SHUTDOWN_STATUS);
-    verify(transportListener).transportShutdown(same(SHUTDOWN_STATUS));
+    verify(transportListener).transportShutdown(same(SHUTDOWN_STATUS),
+        eq(SimpleDisconnectError.SUBCHANNEL_SHUTDOWN));
     verify(transportListener).transportTerminated();
-    ClientStream stream = delayedTransport.newStream(method, headers, callOptions);
+    ClientStream stream = delayedTransport.newStream(
+        method, headers, callOptions, tracers);
     assertEquals(0, delayedTransport.getPendingStreamsCount());
     assertTrue(stream instanceof FailingClientStream);
     verify(mockRealTransport, never()).newStream(
-        any(MethodDescriptor.class), any(Metadata.class), any(CallOptions.class));
+        any(MethodDescriptor.class), any(Metadata.class), any(CallOptions.class),
+        ArgumentMatchers.<ClientStreamTracer[]>any());
   }
 
   @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);
+    ClientStream stream = delayedTransport.newStream(
+        method, headers, callOptions, tracers);
     assertEquals(0, delayedTransport.getPendingStreamsCount());
     assertTrue(stream instanceof FailingClientStream);
     verify(mockRealTransport, never()).newStream(
-        any(MethodDescriptor.class), any(Metadata.class), any(CallOptions.class));
+        any(MethodDescriptor.class), any(Metadata.class), any(CallOptions.class),
+        ArgumentMatchers.<ClientStreamTracer[]>any());
   }
 
   @Test public void startThenCancelStreamWithoutSetTransport() {
-    ClientStream stream = delayedTransport.newStream(method, new Metadata(), CallOptions.DEFAULT);
+    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), any(Metadata.class));
+    verify(streamListener).closed(
+        same(Status.CANCELLED), same(RpcProgress.PROCESSED), any(Metadata.class));
     verifyNoMoreInteractions(mockRealTransport);
     verifyNoMoreInteractions(mockRealStream);
   }
 
   @Test public void newStreamThenShutdownTransportThenAssignTransport() {
-    ClientStream stream = delayedTransport.newStream(method, headers, callOptions);
+    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));
+    verify(transportListener).transportShutdown(same(SHUTDOWN_STATUS),
+        eq(SimpleDisconnectError.SUBCHANNEL_SHUTDOWN));
     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);
+    verify(mockRealTransport).newStream(
+        method, headers, callOptions, tracers);
     verify(mockRealStream).start(any(ClientStreamListener.class));
 
     // Since no more streams are pending, delayed transport is now terminated
@@ -232,8 +262,10 @@ public void uncaughtException(Thread t, Throwable e) {
     verify(transportListener).transportTerminated();
 
     // Further newStream() will return a failing stream
-    stream = delayedTransport.newStream(method, new Metadata(), CallOptions.DEFAULT);
-    verify(streamListener, never()).closed(any(Status.class), any(Metadata.class));
+    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));
@@ -245,9 +277,11 @@ public void uncaughtException(Thread t, Throwable e) {
   }
 
   @Test public void newStreamThenShutdownTransportThenCancelStream() {
-    ClientStream stream = delayedTransport.newStream(method, new Metadata(), CallOptions.DEFAULT);
+    ClientStream stream = delayedTransport.newStream(
+        method, new Metadata(), CallOptions.DEFAULT, tracers);
     delayedTransport.shutdown(SHUTDOWN_STATUS);
-    verify(transportListener).transportShutdown(same(SHUTDOWN_STATUS));
+    verify(transportListener).transportShutdown(same(SHUTDOWN_STATUS),
+        eq(SimpleDisconnectError.SUBCHANNEL_SHUTDOWN));
     verify(transportListener, times(0)).transportTerminated();
     assertEquals(1, delayedTransport.getPendingStreamsCount());
     stream.start(streamListener);
@@ -260,9 +294,11 @@ public void uncaughtException(Thread t, Throwable e) {
 
   @Test public void shutdownThenNewStream() {
     delayedTransport.shutdown(SHUTDOWN_STATUS);
-    verify(transportListener).transportShutdown(same(SHUTDOWN_STATUS));
+    verify(transportListener).transportShutdown(same(SHUTDOWN_STATUS),
+        eq(SimpleDisconnectError.SUBCHANNEL_SHUTDOWN));
     verify(transportListener).transportTerminated();
-    ClientStream stream = delayedTransport.newStream(method, new Metadata(), CallOptions.DEFAULT);
+    ClientStream stream = delayedTransport.newStream(
+        method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream.start(streamListener);
     verify(streamListener).closed(
         statusCaptor.capture(), any(RpcProgress.class), any(Metadata.class));
@@ -270,10 +306,12 @@ public void uncaughtException(Thread t, Throwable e) {
   }
 
   @Test public void startStreamThenShutdownNow() {
-    ClientStream stream = delayedTransport.newStream(method, new Metadata(), CallOptions.DEFAULT);
+    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(), eq(RpcProgress.REFUSED), any(Metadata.class));
@@ -282,9 +320,11 @@ public void uncaughtException(Thread t, Throwable e) {
 
   @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(), CallOptions.DEFAULT);
+    ClientStream stream = delayedTransport.newStream(
+        method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream.start(streamListener);
     verify(streamListener).closed(
         statusCaptor.capture(), any(RpcProgress.class), any(Metadata.class));
@@ -299,56 +339,60 @@ public void uncaughtException(Thread t, Throwable e) {
     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))).thenReturn(mockRealStream);
-    when(mockRealTransport2.newStream(any(MethodDescriptor.class), any(Metadata.class),
-        any(CallOptions.class))).thenReturn(mockRealStream2);
+    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);
+        method, headers, failFastCallOptions, tracers);
     ff1.start(mock(ClientStreamListener.class));
     ff1.halfClose();
-    PickSubchannelArgsImpl ff1args = new PickSubchannelArgsImpl(method, headers,
+    PickSubchannelArgsMatcher ff1args = new PickSubchannelArgsMatcher(method, headers,
         failFastCallOptions);
     verify(transportListener).transportInUse(true);
     DelayedStream ff2 = (DelayedStream) delayedTransport.newStream(
-        method2, headers2, failFastCallOptions);
-    PickSubchannelArgsImpl ff2args = new PickSubchannelArgsImpl(method2, headers2,
+        method2, headers2, failFastCallOptions, tracers);
+    PickSubchannelArgsMatcher ff2args = new PickSubchannelArgsMatcher(method2, headers2,
         failFastCallOptions);
     DelayedStream ff3 = (DelayedStream) delayedTransport.newStream(
-        method, headers, failFastCallOptions);
-    PickSubchannelArgsImpl ff3args = new PickSubchannelArgsImpl(method, headers,
+        method, headers, failFastCallOptions, tracers);
+    PickSubchannelArgsMatcher ff3args = new PickSubchannelArgsMatcher(method, headers,
         failFastCallOptions);
     DelayedStream ff4 = (DelayedStream) delayedTransport.newStream(
-        method2, headers2, failFastCallOptions);
-    PickSubchannelArgsImpl ff4args = new PickSubchannelArgsImpl(method2, headers2,
+        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);
-    PickSubchannelArgsImpl wfr1args = new PickSubchannelArgsImpl(method, headers,
+        method, headers, waitForReadyCallOptions, tracers);
+    PickSubchannelArgsMatcher wfr1args = new PickSubchannelArgsMatcher(method, headers,
         waitForReadyCallOptions);
     DelayedStream wfr2 = (DelayedStream) delayedTransport.newStream(
-        method2, headers2, waitForReadyCallOptions);
-    PickSubchannelArgsImpl wfr2args = new PickSubchannelArgsImpl(method2, headers2,
+        method2, headers2, waitForReadyCallOptions, tracers);
+    PickSubchannelArgsMatcher wfr2args = new PickSubchannelArgsMatcher(method2, headers2,
         waitForReadyCallOptions);
     CallOptions wfr3callOptions = waitForReadyCallOptions.withExecutor(
         wfr3Executor.getScheduledExecutorService());
     DelayedStream wfr3 = (DelayedStream) delayedTransport.newStream(
-        method, headers, wfr3callOptions);
+        method, headers, wfr3callOptions, tracers);
     wfr3.start(mock(ClientStreamListener.class));
     wfr3.halfClose();
-    PickSubchannelArgsImpl wfr3args = new PickSubchannelArgsImpl(method, headers,
+    PickSubchannelArgsMatcher wfr3args = new PickSubchannelArgsMatcher(method, headers,
         wfr3callOptions);
     DelayedStream wfr4 = (DelayedStream) delayedTransport.newStream(
-        method2, headers2, waitForReadyCallOptions);
-    PickSubchannelArgsImpl wfr4args = new PickSubchannelArgsImpl(method2, headers2,
+        method2, headers2, waitForReadyCallOptions, tracers);
+    PickSubchannelArgsMatcher wfr4args = new PickSubchannelArgsMatcher(method2, headers2,
         waitForReadyCallOptions);
 
     assertEquals(8, delayedTransport.getPendingStreamsCount());
@@ -369,14 +413,14 @@ public void uncaughtException(Thread t, Throwable e) {
     delayedTransport.reprocess(picker);
 
     assertEquals(5, delayedTransport.getPendingStreamsCount());
-    inOrder.verify(picker).pickSubchannel(ff1args);
-    inOrder.verify(picker).pickSubchannel(ff2args);
-    inOrder.verify(picker).pickSubchannel(ff3args);
-    inOrder.verify(picker).pickSubchannel(ff4args);
-    inOrder.verify(picker).pickSubchannel(wfr1args);
-    inOrder.verify(picker).pickSubchannel(wfr2args);
-    inOrder.verify(picker).pickSubchannel(wfr3args);
-    inOrder.verify(picker).pickSubchannel(wfr4args);
+    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 streams are created and started immediately, not in any executor. This is
@@ -384,8 +428,10 @@ public void uncaughtException(Thread t, Throwable e) {
     // 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);
-    verify(mockRealTransport2).newStream(method, headers, waitForReadyCallOptions);
+    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));
@@ -420,11 +466,11 @@ public void uncaughtException(Thread t, Throwable e) {
     delayedTransport.reprocess(picker);
     assertEquals(0, delayedTransport.getPendingStreamsCount());
     verify(transportListener).transportInUse(false);
-    inOrder.verify(picker).pickSubchannel(ff3args);  // ff3
-    inOrder.verify(picker).pickSubchannel(ff4args);  // ff4
-    inOrder.verify(picker).pickSubchannel(wfr2args);  // wfr2
-    inOrder.verify(picker).pickSubchannel(wfr3args);  // wfr3
-    inOrder.verify(picker).pickSubchannel(wfr4args);  // 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());
@@ -441,16 +487,17 @@ public void uncaughtException(Thread t, Throwable e) {
 
     // New streams will use the last picker
     DelayedStream wfr5 = (DelayedStream) delayedTransport.newStream(
-        method, headers, waitForReadyCallOptions);
+        method, headers, waitForReadyCallOptions, tracers);
     assertNull(wfr5.getRealStream());
     inOrder.verify(picker).pickSubchannel(
-        new PickSubchannelArgsImpl(method, headers, waitForReadyCallOptions));
+        eqPickSubchannelArgs(method, headers, waitForReadyCallOptions));
     inOrder.verifyNoMoreInteractions();
     assertEquals(1, delayedTransport.getPendingStreamsCount());
 
     // wfr5 will stop delayed transport from terminating
     delayedTransport.shutdown(SHUTDOWN_STATUS);
-    verify(transportListener).transportShutdown(same(SHUTDOWN_STATUS));
+    verify(transportListener).transportShutdown(same(SHUTDOWN_STATUS),
+        eq(SimpleDisconnectError.SUBCHANNEL_SHUTDOWN));
     verify(transportListener, never()).transportTerminated();
     // ... until it's gone
     picker = mock(SubchannelPicker.class);
@@ -458,13 +505,38 @@ public void uncaughtException(Thread t, Throwable e) {
         PickResult.withSubchannel(subchannel1));
     delayedTransport.reprocess(picker);
     verify(picker).pickSubchannel(
-        new PickSubchannelArgsImpl(method, headers, waitForReadyCallOptions));
+        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);
@@ -472,19 +544,69 @@ public void reprocess_NoPendingStream() {
     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))).thenReturn(mockRealStream);
+    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);
-    verify(picker).pickSubchannel(new PickSubchannelArgsImpl(method, headers, CallOptions.DEFAULT));
+    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);
@@ -517,21 +639,21 @@ public PickResult answer(InvocationOnMock invocation) throws Throwable {
         @Override
         public void run() {
           // Will call pickSubchannel and wait on barrier
-          delayedTransport.newStream(method, headers, callOptions);
+          delayedTransport.newStream(method, headers, callOptions, tracers);
         }
       };
     sideThread.start();
 
-    PickSubchannelArgsImpl args = new PickSubchannelArgsImpl(method, headers, callOptions);
-    PickSubchannelArgsImpl args2 = new PickSubchannelArgsImpl(method, headers2, callOptions);
+    PickSubchannelArgsMatcher args = new PickSubchannelArgsMatcher(method, headers, callOptions);
+    PickSubchannelArgsMatcher args2 = new PickSubchannelArgsMatcher(method, headers2, callOptions);
 
     // Is called from sideThread
-    verify(picker, timeout(5000)).pickSubchannel(args);
+    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(args);
+    verify(picker).pickSubchannel(argThat(args));
 
     // Now let the stuck newStream() through
     barrier.await(5, TimeUnit.SECONDS);
@@ -539,7 +661,7 @@ public void run() {
     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(args);
+    verify(picker, times(2)).pickSubchannel(argThat(args));
 
     barrier.reset();
     nextPickShouldWait.set(true);
@@ -550,14 +672,14 @@ public void run() {
         @Override
         public void run() {
           // Will call pickSubchannel and wait on barrier
-          delayedTransport.newStream(method, headers2, callOptions);
+          delayedTransport.newStream(method, headers2, callOptions, tracers);
         }
       };
     sideThread2.start();
     // The second stream will see the first picker
-    verify(picker, timeout(5000)).pickSubchannel(args2);
+    verify(picker, timeout(5000)).pickSubchannel(argThat(args2));
     // While the first stream won't use the first picker any more.
-    verify(picker, times(2)).pickSubchannel(args);
+    verify(picker, times(2)).pickSubchannel(argThat(args));
 
     // Now use a different picker
     SubchannelPicker picker2 = mock(SubchannelPicker.class);
@@ -565,9 +687,9 @@ public void run() {
         .thenReturn(PickResult.withNoResult());
     delayedTransport.reprocess(picker2);
     // The pending first stream uses the new picker
-    verify(picker2).pickSubchannel(args);
+    verify(picker2).pickSubchannel(argThat(args));
     // The second stream is still pending in creation, doesn't use the new picker.
-    verify(picker2, never()).pickSubchannel(args2);
+    verify(picker2, never()).pickSubchannel(argThat(args2));
 
     // Now let the second stream finish creation
     barrier.await(5, TimeUnit.SECONDS);
@@ -575,13 +697,30 @@ public void run() {
     sideThread2.join(5000);
     assertFalse("sideThread2 should've exited", sideThread2.isAlive());
     // The second stream should see the new picker
-    verify(picker2, timeout(5000)).pickSubchannel(args2);
+    verify(picker2, timeout(5000)).pickSubchannel(argThat(args2));
 
     // Wrapping up
-    verify(picker, times(2)).pickSubchannel(args);
-    verify(picker).pickSubchannel(args2);
-    verify(picker2).pickSubchannel(args);
-    verify(picker2).pickSubchannel(args);
+    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
@@ -598,7 +737,8 @@ public void newStream_racesWithReprocessIdleMode() throws Exception {
     // 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);
+    ClientStream stream = delayedTransport.newStream(
+        method, headers, callOptions, tracers);
     stream.start(streamListener);
     assertTrue(delayedTransport.hasPendingStreams());
     verify(transportListener).transportInUse(true);
@@ -607,12 +747,29 @@ public void newStream_racesWithReprocessIdleMode() throws Exception {
   @Test
   public void pendingStream_appendTimeoutInsight_waitForReady() {
     ClientStream stream = delayedTransport.newStream(
-        method, headers, callOptions.withWaitForReady());
+        method, headers, callOptions.withWaitForReady(), tracers);
     stream.start(streamListener);
     InsightBuilder insight = new InsightBuilder();
     stream.appendTimeoutInsight(insight);
     assertThat(insight.toString())
-        .matches("\\[wait_for_ready, buffered_nanos=[0-9]+\\, waiting_for_connection]");
+        .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) {
diff --git a/core/src/test/java/io/grpc/internal/DelayedStreamTest.java b/core/src/test/java/io/grpc/internal/DelayedStreamTest.java
index 0dbd01b6472..12c32fcf126 100644
--- a/core/src/test/java/io/grpc/internal/DelayedStreamTest.java
+++ b/core/src/test/java/io/grpc/internal/DelayedStreamTest.java
@@ -41,7 +41,8 @@
 import io.grpc.DecompressorRegistry;
 import io.grpc.Metadata;
 import io.grpc.Status;
-import io.grpc.internal.testing.SingleMessageProducer;
+import io.grpc.internal.ClientStreamListener.RpcProgress;
+import io.grpc.internal.SingleMessageProducer;
 import java.io.ByteArrayInputStream;
 import java.io.InputStream;
 import java.util.concurrent.TimeUnit;
@@ -70,7 +71,7 @@ public class DelayedStreamTest {
   @Mock private ClientStreamListener listener;
   @Mock private ClientStream realStream;
   @Captor private ArgumentCaptor<ClientStreamListener> listenerCaptor;
-  private DelayedStream stream = new DelayedStream();
+  private DelayedStream stream = new DelayedStream("test_op");
 
   @Test
   public void setStream_setAuthority() {
@@ -83,12 +84,6 @@ public void setStream_setAuthority() {
     inOrder.verify(realStream).start(any(ClientStreamListener.class));
   }
 
-  @Test(expected = IllegalStateException.class)
-  public void setAuthority_afterStart() {
-    stream.start(listener);
-    stream.setAuthority("notgonnawork");
-  }
-
   @Test(expected = IllegalStateException.class)
   public void start_afterStart() {
     stream.start(listener);
@@ -312,7 +307,7 @@ 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
@@ -408,7 +403,7 @@ public void start(ClientStreamListener passedListener) {
         passedListener.messagesAvailable(producer1);
         passedListener.onReady();
         passedListener.messagesAvailable(producer2);
-        passedListener.closed(status, trailers);
+        passedListener.closed(status, RpcProgress.PROCESSED, trailers);
 
         verifyNoMoreInteractions(listener);
       }
@@ -418,7 +413,7 @@ public void start(ClientStreamListener passedListener) {
     inOrder.verify(listener).messagesAvailable(producer1);
     inOrder.verify(listener).onReady();
     inOrder.verify(listener).messagesAvailable(producer2);
-    inOrder.verify(listener).closed(status, trailers);
+    inOrder.verify(listener).closed(status, RpcProgress.PROCESSED, trailers);
   }
 
   @Test
@@ -439,8 +434,8 @@ public void listener_noQueued() {
     verify(listener).headersRead(headers);
     delayedListener.messagesAvailable(producer);
     verify(listener).messagesAvailable(producer);
-    delayedListener.closed(status, trailers);
-    verify(listener).closed(status, trailers);
+    delayedListener.closed(status, RpcProgress.PROCESSED, trailers);
+    verify(listener).closed(status, RpcProgress.PROCESSED, trailers);
   }
 
   @Test
@@ -455,7 +450,7 @@ public void appendTimeoutInsight_realStreamNotSet() {
     InsightBuilder insight = new InsightBuilder();
     stream.start(listener);
     stream.appendTimeoutInsight(insight);
-    assertThat(insight.toString()).matches("\\[buffered_nanos=[0-9]+\\, waiting_for_connection]");
+    assertThat(insight.toString()).matches("\\[test_op_delay=[0-9]+ns\\, was_still_waiting]");
   }
 
   @Test
@@ -474,7 +469,7 @@ public Void answer(InvocationOnMock in) {
     InsightBuilder insight = new InsightBuilder();
     stream.appendTimeoutInsight(insight);
     assertThat(insight.toString())
-        .matches("\\[buffered_nanos=[0-9]+, remote_addr=127\\.0\\.0\\.1:443\\]");
+        .matches("\\[test_op_delay=[0-9]+ns, remote_addr=127\\.0\\.0\\.1:443\\]");
   }
 
   private void callMeMaybe(Runnable r) {
diff --git a/core/src/test/java/io/grpc/internal/DnsNameResolverProviderTest.java b/core/src/test/java/io/grpc/internal/DnsNameResolverProviderTest.java
index 5d127b72d10..75b82df544f 100644
--- a/core/src/test/java/io/grpc/internal/DnsNameResolverProviderTest.java
+++ b/core/src/test/java/io/grpc/internal/DnsNameResolverProviderTest.java
@@ -16,8 +16,9 @@
 
 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.mockito.Mockito.mock;
 
@@ -25,14 +26,27 @@
 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
@@ -46,6 +60,7 @@ public void uncaughtException(Thread t, Throwable e) {
       .setSynchronizationContext(syncContext)
       .setServiceConfigParser(mock(ServiceConfigParser.class))
       .setChannelLogger(mock(ChannelLogger.class))
+      .setScheduledExecutorService(fakeClock.getScheduledExecutorService())
       .build();
 
   private DnsNameResolverProvider provider = new DnsNameResolverProvider();
@@ -56,10 +71,75 @@ public void isAvailable() {
   }
 
   @Test
-  public void newNameResolver() {
-    assertSame(DnsNameResolver.class,
-        provider.newNameResolver(URI.create("dns:///localhost:443"), args).getClass());
-    assertNull(
-        provider.newNameResolver(URI.create("notdns:///localhost:443"), args));
+  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 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 newNameResolver_rejectsNonDnsScheme() {
+    NameResolver nameResolver = newNameResolver("notdns:///localhost:443", args);
+    assertThat(nameResolver).isNull();
+  }
+
+  @Test
+  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 c7c00994cfd..c53863dcf5d 100644
--- a/core/src/test/java/io/grpc/internal/DnsNameResolverTest.java
+++ b/core/src/test/java/io/grpc/internal/DnsNameResolverTest.java
@@ -17,14 +17,18 @@
 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.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;
@@ -33,13 +37,14 @@
 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 com.google.common.net.InetAddresses;
 import com.google.common.testing.FakeTicker;
-import io.grpc.Attributes;
 import io.grpc.ChannelLogger;
 import io.grpc.EquivalentAddressGroup;
+import io.grpc.FlagResetRule;
 import io.grpc.HttpConnectProxiedSocketAddress;
 import io.grpc.NameResolver;
 import io.grpc.NameResolver.ConfigOrError;
@@ -60,7 +65,6 @@
 import java.net.InetAddress;
 import java.net.InetSocketAddress;
 import java.net.SocketAddress;
-import java.net.URI;
 import java.net.UnknownHostException;
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -75,13 +79,10 @@
 import java.util.logging.Level;
 import java.util.logging.Logger;
 import java.util.regex.Pattern;
-import javax.annotation.Nullable;
-import org.junit.After;
 import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.DisableOnDebug;
-import org.junit.rules.ExpectedException;
 import org.junit.rules.TestRule;
 import org.junit.rules.Timeout;
 import org.junit.runner.RunWith;
@@ -98,8 +99,7 @@ public class DnsNameResolverTest {
 
   @Rule public final TestRule globalTimeout = new DisableOnDebug(Timeout.seconds(10));
   @Rule public final MockitoRule mocks = MockitoJUnit.rule();
-  @SuppressWarnings("deprecation") // https://github.com/grpc/grpc-java/issues/7467
-  @Rule public final ExpectedException thrown = ExpectedException.none();
+  @Rule public final FlagResetRule flagResetRule = new FlagResetRule();
 
   private final Map<String, ?> serviceConfig = new LinkedHashMap<>();
 
@@ -111,17 +111,17 @@ public void uncaughtException(Thread t, Throwable 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))
-      .build();
-
-  private final DnsNameResolverProvider provider = new DnsNameResolverProvider();
+
   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 boolean shouldAccept(Runnable command) {
+          return command.toString().contains(
+              RetryingNameResolver.DelayedNameResolverRefresh.class.getName());
+        }
+      };
 
   private final FakeExecutorResource fakeExecutorResource = new FakeExecutorResource();
 
@@ -142,25 +142,16 @@ public void close(Executor instance) {}
   private NameResolver.Listener2 mockListener;
   @Captor
   private ArgumentCaptor<ResolutionResult> resultCaptor;
-  @Captor
-  private ArgumentCaptor<Status> errorCaptor;
-  @Nullable
-  private String networkaddressCacheTtlPropertyValue;
   @Mock
   private RecordFetcher recordFetcher;
+  @Mock private ProxyDetector mockProxyDetector;
 
-  private DnsNameResolver newResolver(String name, int defaultPort) {
+  private RetryingNameResolver newResolver(String name, int defaultPort) {
     return newResolver(
         name, defaultPort, GrpcUtil.NOOP_PROXY_DETECTOR, Stopwatch.createUnstarted());
   }
 
-  private DnsNameResolver newResolver(String name, int defaultPort, boolean isAndroid) {
-    return newResolver(
-        name, defaultPort, GrpcUtil.NOOP_PROXY_DETECTOR, Stopwatch.createUnstarted(),
-        isAndroid);
-  }
-
-  private DnsNameResolver newResolver(
+  private RetryingNameResolver newResolver(
       String name,
       int defaultPort,
       ProxyDetector proxyDetector,
@@ -168,7 +159,7 @@ private DnsNameResolver newResolver(
     return newResolver(name, defaultPort, proxyDetector, stopwatch, false);
   }
 
-  private DnsNameResolver newResolver(
+  private RetryingNameResolver newResolver(
       String name,
       final int defaultPort,
       final ProxyDetector proxyDetector,
@@ -181,67 +172,32 @@ private DnsNameResolver newResolver(
             .setSynchronizationContext(syncContext)
             .setServiceConfigParser(mock(ServiceConfigParser.class))
             .setChannelLogger(mock(ChannelLogger.class))
+            .setScheduledExecutorService(fakeExecutor.getScheduledExecutorService())
             .build();
     return newResolver(name, stopwatch, isAndroid, args);
   }
 
-  private DnsNameResolver newResolver(
+  private RetryingNameResolver newResolver(
       String name,
       Stopwatch stopwatch,
       boolean isAndroid,
       NameResolver.Args args) {
-    DnsNameResolver dnsResolver =
-        new DnsNameResolver(
-            null, name, args, fakeExecutorResource, stopwatch, isAndroid);
+    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));
-    return dnsResolver;
+
+    // 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() {
     DnsNameResolver.enableJndi = true;
-    networkaddressCacheTtlPropertyValue =
-        System.getProperty(DnsNameResolver.NETWORKADDRESS_CACHE_TTL_PROPERTY);
-  }
-
-  @After
-  public void restoreSystemProperty() {
-    if (networkaddressCacheTtlPropertyValue == null) {
-      System.clearProperty(DnsNameResolver.NETWORKADDRESS_CACHE_TTL_PROPERTY);
-    } else {
-      System.setProperty(
-          DnsNameResolver.NETWORKADDRESS_CACHE_TTL_PROPERTY,
-          networkaddressCacheTtlPropertyValue);
-    }
-  }
-
-  @After
-  public void noMorePendingTasks() {
-    assertEquals(0, fakeClock.numPendingTasks());
-    assertEquals(0, fakeExecutor.numPendingTasks());
-  }
 
-  @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), "[::1]", DEFAULT_PORT);
-  }
-
-  @Test
-  public void validDnsNameWithoutPort() throws Exception {
-    testValidUri(new URI("dns", null, "/foo.googleapis.com", null),
-        "foo.googleapis.com", DEFAULT_PORT);
-  }
-
-  @Test
-  public void validDnsNameWithPort() throws Exception {
-    testValidUri(new URI("dns", null, "/foo.googleapis.com:456", null),
-        "foo.googleapis.com:456", 456);
+    // By default the mock listener processes the result successfully.
+    when(mockListener.onResult2(isA(ResolutionResult.class))).thenReturn(Status.OK);
   }
 
   @Test
@@ -264,47 +220,33 @@ public void invalidDnsName_containsUnderscore() {
     }
   }
 
-  @Test
-  public void resolve_androidIgnoresPropertyValue() throws Exception {
-    System.setProperty(DnsNameResolver.NETWORKADDRESS_CACHE_TTL_PROPERTY, Long.toString(2));
-    resolveNeverCache(true);
-  }
-
-  @Test
-  public void resolve_androidIgnoresPropertyValueCacheForever() throws Exception {
-    System.setProperty(DnsNameResolver.NETWORKADDRESS_CACHE_TTL_PROPERTY, Long.toString(-1));
-    resolveNeverCache(true);
-  }
-
   @Test
   public void resolve_neverCache() throws Exception {
-    System.setProperty(DnsNameResolver.NETWORKADDRESS_CACHE_TTL_PROPERTY, "0");
-    resolveNeverCache(false);
-  }
-
-  private void resolveNeverCache(boolean isAndroid) throws Exception {
+    flagResetRule.setSystemPropertyForTest(NETWORKADDRESS_CACHE_TTL_PROPERTY, "0");
     final List<InetAddress> answer1 = createAddressList(2);
     final List<InetAddress> answer2 = createAddressList(1);
     String name = "foo.googleapis.com";
 
-    DnsNameResolver resolver = newResolver(name, 81, isAndroid);
+    RetryingNameResolver resolver = newResolver(name, 81);
+    DnsNameResolver dnsResolver = (DnsNameResolver) resolver.getRetriedNameResolver();
     AddressResolver mockResolver = mock(AddressResolver.class);
     when(mockResolver.resolveAddress(anyString())).thenReturn(answer1).thenReturn(answer2);
-    resolver.setAddressResolver(mockResolver);
+    dnsResolver.setAddressResolver(mockResolver);
 
     resolver.start(mockListener);
     assertEquals(1, fakeExecutor.runDueTasks());
-    verify(mockListener).onResult(resultCaptor.capture());
+    verify(mockListener).onResult2(resultCaptor.capture());
     assertAnswerMatches(answer1, 81, resultCaptor.getValue());
     assertEquals(0, fakeClock.numPendingTasks());
 
     resolver.refresh();
     assertEquals(1, fakeExecutor.runDueTasks());
-    verify(mockListener, times(2)).onResult(resultCaptor.capture());
+    verify(mockListener, times(2)).onResult2(resultCaptor.capture());
     assertAnswerMatches(answer2, 81, resultCaptor.getValue());
     assertEquals(0, fakeClock.numPendingTasks());
+    assertEquals(0, fakeExecutor.numPendingTasks());
 
-    resolver.shutdown();
+    syncContext.execute(() -> resolver.shutdown());
 
     verify(mockResolver, times(2)).resolveAddress(anyString());
   }
@@ -313,18 +255,20 @@ private void resolveNeverCache(boolean isAndroid) throws Exception {
   public void testExecutor_default() throws Exception {
     final List<InetAddress> answer = createAddressList(2);
 
-    DnsNameResolver resolver = newResolver("foo.googleapis.com", 81);
+    RetryingNameResolver resolver = newResolver("foo.googleapis.com", 81);
+    DnsNameResolver dnsResolver = (DnsNameResolver) resolver.getRetriedNameResolver();
     AddressResolver mockResolver = mock(AddressResolver.class);
     when(mockResolver.resolveAddress(anyString())).thenReturn(answer);
-    resolver.setAddressResolver(mockResolver);
+    dnsResolver.setAddressResolver(mockResolver);
 
     resolver.start(mockListener);
     assertEquals(1, fakeExecutor.runDueTasks());
-    verify(mockListener).onResult(resultCaptor.capture());
+    verify(mockListener).onResult2(resultCaptor.capture());
     assertAnswerMatches(answer, 81, resultCaptor.getValue());
     assertEquals(0, fakeClock.numPendingTasks());
+    assertEquals(0, fakeExecutor.numPendingTasks());
 
-    resolver.shutdown();
+    syncContext.execute(() -> resolver.shutdown());
 
     assertThat(fakeExecutorResource.createCount.get()).isEqualTo(1);
   }
@@ -341,6 +285,7 @@ public void testExecutor_custom() throws Exception {
             .setSynchronizationContext(syncContext)
             .setServiceConfigParser(mock(ServiceConfigParser.class))
             .setChannelLogger(mock(ChannelLogger.class))
+            .setScheduledExecutorService(fakeExecutor.getScheduledExecutorService())
             .setOffloadExecutor(
                 new Executor() {
                   @Override
@@ -351,19 +296,21 @@ public void execute(Runnable command) {
                 })
             .build();
 
-    DnsNameResolver resolver =
-        newResolver("foo.googleapis.com", Stopwatch.createUnstarted(), false, args);
+    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);
-    resolver.setAddressResolver(mockResolver);
+    dnsResolver.setAddressResolver(mockResolver);
 
     resolver.start(mockListener);
     assertEquals(0, fakeExecutor.runDueTasks());
-    verify(mockListener).onResult(resultCaptor.capture());
+    verify(mockListener).onResult2(resultCaptor.capture());
     assertAnswerMatches(answer, 81, resultCaptor.getValue());
     assertEquals(0, fakeClock.numPendingTasks());
+    assertEquals(0, fakeExecutor.numPendingTasks());
 
-    resolver.shutdown();
+    syncContext.execute(() -> resolver.shutdown());
 
     assertThat(fakeExecutorResource.createCount.get()).isEqualTo(0);
     assertThat(executions.get()).isEqualTo(1);
@@ -371,22 +318,23 @@ public void execute(Runnable command) {
 
   @Test
   public void resolve_cacheForever() throws Exception {
-    System.setProperty(DnsNameResolver.NETWORKADDRESS_CACHE_TTL_PROPERTY, "-1");
+    flagResetRule.setSystemPropertyForTest(NETWORKADDRESS_CACHE_TTL_PROPERTY, "-1");
     final List<InetAddress> answer1 = createAddressList(2);
     String name = "foo.googleapis.com";
     FakeTicker fakeTicker = new FakeTicker();
 
-    DnsNameResolver resolver =
-        newResolver(name, 81, GrpcUtil.NOOP_PROXY_DETECTOR, Stopwatch.createUnstarted(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"));
-    resolver.setAddressResolver(mockResolver);
+    dnsResolver.setAddressResolver(mockResolver);
 
     resolver.start(mockListener);
     assertEquals(1, fakeExecutor.runDueTasks());
-    verify(mockListener).onResult(resultCaptor.capture());
+    verify(mockListener).onResult2(resultCaptor.capture());
     assertAnswerMatches(answer1, 81, resultCaptor.getValue());
     assertEquals(0, fakeClock.numPendingTasks());
 
@@ -396,7 +344,7 @@ public void resolve_cacheForever() throws Exception {
     assertEquals(0, fakeClock.numPendingTasks());
     verifyNoMoreInteractions(mockListener);
 
-    resolver.shutdown();
+    syncContext.execute(() -> resolver.shutdown());
 
     verify(mockResolver).resolveAddress(anyString());
   }
@@ -404,22 +352,23 @@ public void resolve_cacheForever() throws Exception {
   @Test
   public void resolve_usingCache() throws Exception {
     long ttl = 60;
-    System.setProperty(DnsNameResolver.NETWORKADDRESS_CACHE_TTL_PROPERTY, Long.toString(ttl));
+    flagResetRule.setSystemPropertyForTest(NETWORKADDRESS_CACHE_TTL_PROPERTY, Long.toString(ttl));
     final List<InetAddress> answer = createAddressList(2);
     String name = "foo.googleapis.com";
     FakeTicker fakeTicker = new FakeTicker();
 
-    DnsNameResolver resolver =
-        newResolver(name, 81, GrpcUtil.NOOP_PROXY_DETECTOR, Stopwatch.createUnstarted(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."));
-    resolver.setAddressResolver(mockResolver);
+    dnsResolver.setAddressResolver(mockResolver);
 
     resolver.start(mockListener);
     assertEquals(1, fakeExecutor.runDueTasks());
-    verify(mockListener).onResult(resultCaptor.capture());
+    verify(mockListener).onResult2(resultCaptor.capture());
     assertAnswerMatches(answer, 81, resultCaptor.getValue());
     assertEquals(0, fakeClock.numPendingTasks());
 
@@ -430,7 +379,7 @@ public void resolve_usingCache() throws Exception {
     assertEquals(0, fakeClock.numPendingTasks());
     verifyNoMoreInteractions(mockListener);
 
-    resolver.shutdown();
+    syncContext.execute(() -> resolver.shutdown());
 
     verify(mockResolver).resolveAddress(anyString());
   }
@@ -438,64 +387,79 @@ public void resolve_usingCache() throws Exception {
   @Test
   public void resolve_cacheExpired() throws Exception {
     long ttl = 60;
-    System.setProperty(DnsNameResolver.NETWORKADDRESS_CACHE_TTL_PROPERTY, Long.toString(ttl));
+    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";
     FakeTicker fakeTicker = new FakeTicker();
 
-    DnsNameResolver resolver =
-        newResolver(name, 81, GrpcUtil.NOOP_PROXY_DETECTOR, Stopwatch.createUnstarted(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);
-    resolver.setAddressResolver(mockResolver);
+    dnsResolver.setAddressResolver(mockResolver);
 
     resolver.start(mockListener);
     assertEquals(1, fakeExecutor.runDueTasks());
-    verify(mockListener).onResult(resultCaptor.capture());
+    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)).onResult(resultCaptor.capture());
+    verify(mockListener, times(2)).onResult2(resultCaptor.capture());
     assertAnswerMatches(answer2, 81, resultCaptor.getValue());
     assertEquals(0, fakeClock.numPendingTasks());
+    assertEquals(0, fakeExecutor.numPendingTasks());
 
-    resolver.shutdown();
+    syncContext.execute(() -> resolver.shutdown());
 
     verify(mockResolver, times(2)).resolveAddress(anyString());
   }
 
+  @Test
+  public void resolve_androidIgnoresPropertyValue() throws Exception {
+    flagResetRule.setSystemPropertyForTest(NETWORKADDRESS_CACHE_TTL_PROPERTY, "2");
+    resolveDefaultValue(true);
+  }
+
+  @Test
+  public void resolve_androidIgnoresPropertyValueCacheForever() throws Exception {
+    flagResetRule.setSystemPropertyForTest(NETWORKADDRESS_CACHE_TTL_PROPERTY, "-1");
+    resolveDefaultValue(true);
+  }
+
   @Test
   public void resolve_invalidTtlPropertyValue() throws Exception {
-    System.setProperty(DnsNameResolver.NETWORKADDRESS_CACHE_TTL_PROPERTY, "not_a_number");
-    resolveDefaultValue();
+    flagResetRule.setSystemPropertyForTest(NETWORKADDRESS_CACHE_TTL_PROPERTY, "not_a_number");
+    resolveDefaultValue(false);
   }
 
   @Test
   public void resolve_noPropertyValue() throws Exception {
-    System.clearProperty(DnsNameResolver.NETWORKADDRESS_CACHE_TTL_PROPERTY);
-    resolveDefaultValue();
+    flagResetRule.clearSystemPropertyForTest(NETWORKADDRESS_CACHE_TTL_PROPERTY);
+    resolveDefaultValue(false);
   }
 
-  private void resolveDefaultValue() throws Exception {
+  private void resolveDefaultValue(boolean isAndroid) throws Exception {
     final List<InetAddress> answer1 = createAddressList(2);
     final List<InetAddress> answer2 = createAddressList(1);
     String name = "foo.googleapis.com";
     FakeTicker fakeTicker = new FakeTicker();
 
-    DnsNameResolver resolver =
-        newResolver(name, 81, GrpcUtil.NOOP_PROXY_DETECTOR, Stopwatch.createUnstarted(fakeTicker));
+    RetryingNameResolver resolver = newResolver(
+        name, 81, GrpcUtil.NOOP_PROXY_DETECTOR, Stopwatch.createUnstarted(fakeTicker), isAndroid);
+    DnsNameResolver dnsResolver = (DnsNameResolver) resolver.getRetriedNameResolver();
     AddressResolver mockResolver = mock(AddressResolver.class);
     when(mockResolver.resolveAddress(anyString())).thenReturn(answer1).thenReturn(answer2);
-    resolver.setAddressResolver(mockResolver);
+    dnsResolver.setAddressResolver(mockResolver);
 
     resolver.start(mockListener);
     assertEquals(1, fakeExecutor.runDueTasks());
-    verify(mockListener).onResult(resultCaptor.capture());
+    verify(mockListener).onResult2(resultCaptor.capture());
     assertAnswerMatches(answer1, 81, resultCaptor.getValue());
     assertEquals(0, fakeClock.numPendingTasks());
 
@@ -508,11 +472,12 @@ private void resolveDefaultValue() throws Exception {
     fakeTicker.advance(1, TimeUnit.SECONDS);
     resolver.refresh();
     assertEquals(1, fakeExecutor.runDueTasks());
-    verify(mockListener, times(2)).onResult(resultCaptor.capture());
+    verify(mockListener, times(2)).onResult2(resultCaptor.capture());
     assertAnswerMatches(answer2, 81, resultCaptor.getValue());
     assertEquals(0, fakeClock.numPendingTasks());
+    assertEquals(0, fakeExecutor.numPendingTasks());
 
-    resolver.shutdown();
+    syncContext.execute(() -> resolver.shutdown());
 
     verify(mockResolver, times(2)).resolveAddress(anyString());
   }
@@ -520,8 +485,9 @@ private void resolveDefaultValue() throws Exception {
   @Test
   public void resolve_emptyResult() throws Exception {
     DnsNameResolver.enableTxt = true;
-    DnsNameResolver nr = newResolver("dns:///addr.fake:1234", 443);
-    nr.setAddressResolver(new AddressResolver() {
+    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();
@@ -531,18 +497,88 @@ public List<InetAddress> resolveAddress(String host) throws Exception {
     when(mockResourceResolver.resolveTxt(anyString()))
         .thenReturn(Collections.<String>emptyList());
 
-    nr.setResourceResolver(mockResourceResolver);
+    dnsResolver.setResourceResolver(mockResourceResolver);
 
-    nr.start(mockListener);
+    resolver.start(mockListener);
     assertThat(fakeExecutor.runDueTasks()).isEqualTo(1);
 
     ArgumentCaptor<ResolutionResult> ac = ArgumentCaptor.forClass(ResolutionResult.class);
-    verify(mockListener).onResult(ac.capture());
+    verify(mockListener).onResult2(ac.capture());
     verifyNoMoreInteractions(mockListener);
-    assertThat(ac.getValue().getAddresses()).isEmpty();
-    assertThat(ac.getValue().getAttributes()).isEqualTo(Attributes.EMPTY);
+    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
@@ -554,20 +590,23 @@ public void resolve_nullResourceResolver() throws Exception {
         .thenReturn(Collections.singletonList(backendAddr));
     String name = "foo.googleapis.com";
 
-    DnsNameResolver resolver = newResolver(name, 81);
-    resolver.setAddressResolver(mockAddressResolver);
-    resolver.setResourceResolver(null);
+    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).onResult(resultCaptor.capture());
+    verify(mockListener).onResult2(resultCaptor.capture());
     ResolutionResult result = resultCaptor.getValue();
     InetSocketAddress resolvedBackendAddr =
         (InetSocketAddress) Iterables.getOnlyElement(
-            Iterables.getOnlyElement(result.getAddresses()).getAddresses());
+            Iterables.getOnlyElement(result.getAddressesOrError().getValue()).getAddresses());
     assertThat(resolvedBackendAddr.getAddress()).isEqualTo(backendAddr);
     verify(mockAddressResolver).resolveAddress(name);
-    assertThat(result.getAttributes()).isEqualTo(Attributes.EMPTY);
     assertThat(result.getServiceConfig()).isNull();
+
+    assertEquals(0, fakeClock.numPendingTasks());
+    assertEquals(0, fakeExecutor.numPendingTasks());
   }
 
   @Test
@@ -576,17 +615,23 @@ public void resolve_nullResourceResolver_addressFailure() throws Exception {
     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";
 
-    DnsNameResolver resolver = newResolver(name, 81);
-    resolver.setAddressResolver(mockAddressResolver);
-    resolver.setResourceResolver(null);
+    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(errorCaptor.capture());
-    Status errorStatus = errorCaptor.getValue();
+    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());
+    // A retry should be scheduled
+    assertThat(fakeExecutor.numPendingTasks(NAME_RESOLVER_REFRESH_TASK_FILTER)).isEqualTo(1);
   }
 
   @Test
@@ -613,45 +658,56 @@ public ConfigOrError parseServiceConfig(Map<String, ?> rawServiceConfig) {
             .setProxyDetector(GrpcUtil.NOOP_PROXY_DETECTOR)
             .setSynchronizationContext(syncContext)
             .setServiceConfigParser(serviceConfigParser)
+            .setScheduledExecutorService(fakeClock.getScheduledExecutorService())
             .build();
 
     String name = "foo.googleapis.com";
-    DnsNameResolver resolver = newResolver(name, Stopwatch.createUnstarted(), false, args);
-    resolver.setAddressResolver(mockAddressResolver);
-    resolver.setResourceResolver(mockResourceResolver);
+    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).onResult(resultCaptor.capture());
+    verify(mockListener).onResult2(resultCaptor.capture());
     ResolutionResult result = resultCaptor.getValue();
     InetSocketAddress resolvedBackendAddr =
         (InetSocketAddress) Iterables.getOnlyElement(
-            Iterables.getOnlyElement(result.getAddresses()).getAddresses());
+            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 resolve_addressFailure_neverLookUpServiceConfig() throws Exception {
+  public void resolve_addressFailure_stillLookUpServiceConfig() 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";
 
     ResourceResolver mockResourceResolver = mock(ResourceResolver.class);
-    DnsNameResolver resolver = newResolver(name, 81);
-    resolver.setAddressResolver(mockAddressResolver);
-    resolver.setResourceResolver(mockResourceResolver);
+    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).onError(errorCaptor.capture());
-    Status errorStatus = errorCaptor.getValue();
+    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());
+    verify(mockResourceResolver).resolveTxt("_grpc_config." + name);
+
+    assertEquals(0, fakeClock.numPendingTasks());
+    // A retry should be scheduled
+    assertThat(fakeExecutor.numPendingTasks(NAME_RESOLVER_REFRESH_TASK_FILTER)).isEqualTo(1);
   }
 
   @Test
@@ -666,21 +722,24 @@ public void resolve_serviceConfigLookupFails_nullServiceConfig() throws Exceptio
     when(mockResourceResolver.resolveTxt(anyString()))
         .thenThrow(new Exception("something like javax.naming.NamingException"));
 
-    DnsNameResolver resolver = newResolver(name, 81);
-    resolver.setAddressResolver(mockAddressResolver);
-    resolver.setResourceResolver(mockResourceResolver);
+    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).onResult(resultCaptor.capture());
+    verify(mockListener).onResult2(resultCaptor.capture());
     ResolutionResult result = resultCaptor.getValue();
     InetSocketAddress resolvedBackendAddr =
         (InetSocketAddress) Iterables.getOnlyElement(
-            Iterables.getOnlyElement(result.getAddresses()).getAddresses());
+            Iterables.getOnlyElement(result.getAddressesOrError().getValue()).getAddresses());
     assertThat(resolvedBackendAddr.getAddress()).isEqualTo(backendAddr);
     verify(mockAddressResolver).resolveAddress(name);
-    assertThat(result.getAttributes()).isEqualTo(Attributes.EMPTY);
     assertThat(result.getServiceConfig()).isNull();
     verify(mockResourceResolver).resolveTxt(anyString());
+
+    assertEquals(0, fakeClock.numPendingTasks());
+    assertEquals(0, fakeExecutor.numPendingTasks());
   }
 
   @Test
@@ -695,22 +754,25 @@ public void resolve_serviceConfigMalformed_serviceConfigError() throws Exception
     when(mockResourceResolver.resolveTxt(anyString()))
         .thenReturn(Collections.singletonList("grpc_config=something invalid"));
 
-    DnsNameResolver resolver = newResolver(name, 81);
-    resolver.setAddressResolver(mockAddressResolver);
-    resolver.setResourceResolver(mockResourceResolver);
+    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).onResult(resultCaptor.capture());
+    verify(mockListener).onResult2(resultCaptor.capture());
     ResolutionResult result = resultCaptor.getValue();
     InetSocketAddress resolvedBackendAddr =
         (InetSocketAddress) Iterables.getOnlyElement(
-            Iterables.getOnlyElement(result.getAddresses()).getAddresses());
+            Iterables.getOnlyElement(result.getAddressesOrError().getValue()).getAddresses());
     assertThat(resolvedBackendAddr.getAddress()).isEqualTo(backendAddr);
     verify(mockAddressResolver).resolveAddress(name);
-    assertThat(result.getAttributes()).isEqualTo(Attributes.EMPTY);
     assertThat(result.getServiceConfig()).isNotNull();
     assertThat(result.getServiceConfig().getError()).isNotNull();
     verify(mockResourceResolver).resolveTxt(anyString());
+
+    assertEquals(0, fakeClock.numPendingTasks());
+    assertEquals(0, fakeExecutor.numPendingTasks());
   }
 
   @Test
@@ -757,16 +819,17 @@ public HttpConnectProxiedSocketAddress proxyFor(SocketAddress targetAddress) {
               .setPassword("password").build();
         }
       };
-    DnsNameResolver resolver =
-        newResolver(name, port, alwaysDetectProxy, Stopwatch.createUnstarted());
+    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());
-    resolver.setAddressResolver(mockAddressResolver);
+    dnsResolver.setAddressResolver(mockAddressResolver);
     resolver.start(mockListener);
     assertEquals(1, fakeExecutor.runDueTasks());
 
-    verify(mockListener).onResult(resultCaptor.capture());
-    List<EquivalentAddressGroup> result = resultCaptor.getValue().getAddresses();
+    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);
@@ -777,15 +840,19 @@ public HttpConnectProxiedSocketAddress proxyFor(SocketAddress targetAddress) {
     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);
-    thrown.expectMessage("Bad key");
-
-    DnsNameResolver.maybeChooseServiceConfig(bad, new Random(), "host");
+    Random random = new Random();
+    VerifyException e = assertThrows(VerifyException.class,
+        () -> DnsNameResolver.maybeChooseServiceConfig(bad, random, "host"));
+    assertThat(e).hasMessageThat().isEqualTo("Bad key: parcentage=1.0");
   }
 
   @Test
@@ -822,7 +889,7 @@ public void maybeChooseServiceConfig_clientLanguageCaseInsensitive() {
   }
 
   @Test
-  public void maybeChooseServiceConfig_clientLanguageMatchesEmtpy() {
+  public void maybeChooseServiceConfig_clientLanguageMatchesEmpty() {
     Map<String, Object> choice = new LinkedHashMap<>();
     List<String> langs = new ArrayList<>();
     choice.put("clientLanguage", langs);
@@ -991,7 +1058,7 @@ public void maybeChooseServiceConfig_clientLanguageCaseSensitive() {
   }
 
   @Test
-  public void maybeChooseServiceConfig_hostnameMatchesEmtpy() {
+  public void maybeChooseServiceConfig_hostnameMatchesEmpty() {
     Map<String, Object> choice = new LinkedHashMap<>();
     List<String> hosts = new ArrayList<>();
     choice.put("clientHostname", hosts);
@@ -1024,25 +1091,25 @@ public void parseTxtResults_misspelledName() throws Exception {
   }
 
   @Test
-  public void parseTxtResults_badTypeFails() throws Exception {
+  public void parseTxtResults_badTypeFails() {
     List<String> txtRecords = new ArrayList<>();
     txtRecords.add("some_record");
     txtRecords.add("grpc_config={}");
 
-    thrown.expect(ClassCastException.class);
-    thrown.expectMessage("wrong type");
-    DnsNameResolver.parseTxtResults(txtRecords);
+    ClassCastException e = assertThrows(ClassCastException.class,
+        () -> DnsNameResolver.parseTxtResults(txtRecords));
+    assertThat(e).hasMessageThat().isEqualTo("wrong type {}");
   }
 
   @Test
-  public void parseTxtResults_badInnerTypeFails() throws Exception {
+  public void parseTxtResults_badInnerTypeFails() {
     List<String> txtRecords = new ArrayList<>();
     txtRecords.add("some_record");
     txtRecords.add("grpc_config=[\"bogus\"]");
 
-    thrown.expect(ClassCastException.class);
-    thrown.expectMessage("not object");
-    DnsNameResolver.parseTxtResults(txtRecords);
+    ClassCastException e = assertThrows(ClassCastException.class,
+        () -> DnsNameResolver.parseTxtResults(txtRecords));
+    assertThat(e).hasMessageThat().isEqualTo("value bogus for idx 0 in [bogus] is not object");
   }
 
   @Test
@@ -1083,7 +1150,7 @@ public void shouldUseJndi_falseIfDisabledForLocalhost() {
   }
 
   @Test
-  public void shouldUseJndi_trueIfLocalhostOverriden() {
+  public void shouldUseJndi_trueIfLocalhostOverridden() {
     boolean enableJndi = true;
     boolean enableJndiLocalhost = true;
     String host = "localhost";
@@ -1175,22 +1242,6 @@ public void parseServiceConfig_matches() {
     assertThat(result.getConfig()).isEqualTo(ImmutableMap.of());
   }
 
-  private void testInvalidUri(URI uri) {
-    try {
-      provider.newNameResolver(uri, args);
-      fail("Should have failed");
-    } catch (IllegalArgumentException e) {
-      // expected
-    }
-  }
-
-  private void testValidUri(URI uri, String exportedAuthority, int expectedPort) {
-    DnsNameResolver resolver = provider.newNameResolver(uri, args);
-    assertNotNull(resolver);
-    assertEquals(expectedPort, resolver.getPort());
-    assertEquals(exportedAuthority, resolver.getServiceAuthority());
-  }
-
   private byte lastByte = 0;
 
   private List<InetAddress> createAddressList(int n) throws UnknownHostException {
@@ -1203,9 +1254,9 @@ private List<InetAddress> createAddressList(int n) throws UnknownHostException {
 
   private static void assertAnswerMatches(
       List<InetAddress> addrs, int port, ResolutionResult resolutionResult) {
-    assertThat(resolutionResult.getAddresses()).hasSize(addrs.size());
+    assertThat(resolutionResult.getAddressesOrError().getValue()).hasSize(addrs.size());
     for (int i = 0; i < addrs.size(); i++) {
-      EquivalentAddressGroup addrGroup = resolutionResult.getAddresses().get(i);
+      EquivalentAddressGroup addrGroup = resolutionResult.getAddressesOrError().getValue().get(i);
       InetSocketAddress socketAddr =
           (InetSocketAddress) Iterables.getOnlyElement(addrGroup.getAddresses());
       assertEquals("Addr " + i, port, socketAddr.getPort());
diff --git a/core/src/test/java/io/grpc/internal/FailingClientStreamTest.java b/core/src/test/java/io/grpc/internal/FailingClientStreamTest.java
index dad82902395..c07812577d5 100644
--- a/core/src/test/java/io/grpc/internal/FailingClientStreamTest.java
+++ b/core/src/test/java/io/grpc/internal/FailingClientStreamTest.java
@@ -21,6 +21,7 @@
 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;
@@ -33,13 +34,16 @@
  */
 @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);
+    ClientStream stream = new FailingClientStream(status, RpcProgress.PROCESSED, tracers);
     stream.start(listener);
     verify(listener).closed(eq(status), eq(RpcProgress.PROCESSED), any(Metadata.class));
   }
@@ -49,7 +53,7 @@ public void droppedRpcProgressPopulatedToListener() {
     ClientStreamListener listener = mock(ClientStreamListener.class);
     Status status = Status.UNAVAILABLE;
 
-    ClientStream stream = new FailingClientStream(status, RpcProgress.DROPPED);
+    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
index ff15ef7ff02..98749d74910 100644
--- a/core/src/test/java/io/grpc/internal/FailingClientTransportTest.java
+++ b/core/src/test/java/io/grpc/internal/FailingClientTransportTest.java
@@ -22,6 +22,7 @@
 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;
@@ -41,8 +42,9 @@ 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);
+    ClientStream stream = transport.newStream(
+        TestMethodDescriptors.voidMethod(), new Metadata(), CallOptions.DEFAULT,
+        new ClientStreamTracer[] { new ClientStreamTracer() {} });
     ClientStreamListener listener = mock(ClientStreamListener.class);
     stream.start(listener);
 
diff --git a/core/src/test/java/io/grpc/internal/FakeCallCredentials.java b/core/src/test/java/io/grpc/internal/FakeCallCredentials.java
index e307495697c..8161aacccdd 100644
--- a/core/src/test/java/io/grpc/internal/FakeCallCredentials.java
+++ b/core/src/test/java/io/grpc/internal/FakeCallCredentials.java
@@ -38,6 +38,4 @@ public void applyRequestMetadata(
       CallCredentials.MetadataApplier applier) {
     applier.apply(headers);
   }
-
-  @Override public void thisUsesUnstableApi() {}
 }
diff --git a/core/src/test/java/io/grpc/internal/ForwardingClientStreamListenerTest.java b/core/src/test/java/io/grpc/internal/ForwardingClientStreamListenerTest.java
index 544c6c07547..fd7b6108c2c 100644
--- a/core/src/test/java/io/grpc/internal/ForwardingClientStreamListenerTest.java
+++ b/core/src/test/java/io/grpc/internal/ForwardingClientStreamListenerTest.java
@@ -23,6 +23,7 @@
 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;
@@ -61,8 +62,8 @@ public void headersReadTest() {
   public void closedTest() {
     Status status = Status.UNKNOWN;
     Metadata trailers = new Metadata();
-    forward.closed(status, trailers);
-    verify(mock).closed(same(status), same(trailers));
+    forward.closed(status, RpcProgress.PROCESSED, trailers);
+    verify(mock).closed(same(status), same(RpcProgress.PROCESSED), same(trailers));
   }
 
   @Test
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
index 60405e22791..b148bd6aeef 100644
--- a/core/src/test/java/io/grpc/internal/ForwardingManagedChannelTest.java
+++ b/core/src/test/java/io/grpc/internal/ForwardingManagedChannelTest.java
@@ -28,6 +28,7 @@
 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;
diff --git a/core/src/test/java/io/grpc/internal/ForwardingNameResolverTest.java b/core/src/test/java/io/grpc/internal/ForwardingNameResolverTest.java
index f8f9ed2cfbe..5da172626bb 100644
--- a/core/src/test/java/io/grpc/internal/ForwardingNameResolverTest.java
+++ b/core/src/test/java/io/grpc/internal/ForwardingNameResolverTest.java
@@ -81,7 +81,6 @@ public void start_observer() {
     NameResolver.Listener2 listener = new NameResolver.Listener2() {
       @Override
       public void onResult(ResolutionResult result) {
-
       }
 
       @Override
diff --git a/core/src/test/java/io/grpc/internal/ForwardingReadableBufferTest.java b/core/src/test/java/io/grpc/internal/ForwardingReadableBufferTest.java
index b778f25e5de..696fb35e379 100644
--- a/core/src/test/java/io/grpc/internal/ForwardingReadableBufferTest.java
+++ b/core/src/test/java/io/grpc/internal/ForwardingReadableBufferTest.java
@@ -25,7 +25,6 @@
 import java.io.IOException;
 import java.io.OutputStream;
 import java.lang.reflect.Method;
-import java.nio.ByteBuffer;
 import java.util.Collections;
 import org.junit.Before;
 import org.junit.Rule;
@@ -36,13 +35,10 @@
 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();
+  @Rule public final MockitoRule mocks = MockitoJUnit.rule();
 
   @Mock private ReadableBuffer delegate;
   private ForwardingReadableBuffer buffer;
@@ -55,10 +51,7 @@ public void setUp() {
   @Test
   public void allMethodsForwarded() throws Exception {
     ForwardingTestUtil.testMethodsForwarded(
-        ReadableBuffer.class,
-        delegate,
-        buffer,
-        Collections.<Method>emptyList());
+        ReadableBuffer.class, delegate, buffer, Collections.<Method>emptyList());
   }
 
   @Test
@@ -97,14 +90,6 @@ public void readBytes() {
     verify(delegate).readBytes(dest, 1, 2);
   }
 
-  @Test
-  public void readBytes_overload1() {
-    ByteBuffer dest = mock(ByteBuffer.class);
-    buffer.readBytes(dest);
-
-    verify(delegate).readBytes(dest);
-  }
-
   @Test
   public void readBytes_overload2() throws IOException {
     OutputStream dest = mock(OutputStream.class);
diff --git a/core/src/test/java/io/grpc/internal/GrpcUtilTest.java b/core/src/test/java/io/grpc/internal/GrpcUtilTest.java
index 7a3808de6e3..c243790028c 100644
--- a/core/src/test/java/io/grpc/internal/GrpcUtilTest.java
+++ b/core/src/test/java/io/grpc/internal/GrpcUtilTest.java
@@ -16,36 +16,52 @@
 
 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 {
 
-  @SuppressWarnings("deprecation") // https://github.com/grpc/grpc-java/issues/7467
-  @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() {
@@ -82,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"));
@@ -146,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("-._~!$&'()*+,;=@:[]"));
+  }
 
-    GrpcUtil.checkAuthority(null);
+  @Test
+  public void urlAuthorityEscape_allLettersAndNumbers() {
+    assertEquals(
+        "abcdefghijklmnopqrstuvwxyz0123456789",
+        GrpcUtil.AuthorityEscaper.encodeAuthority("abcdefghijklmnopqrstuvwxyz0123456789"));
+  }
+
+  @Test
+  public void urlAuthorityEscape_unicodeAreNotEncoded() {
+    assertEquals(
+        "ö®", GrpcUtil.AuthorityEscaper.encodeAuthority("ö®"));
+  }
+
+  @Test
+  public void checkAuthority_failsOnNull() {
+    assertThrows(NullPointerException.class, () -> GrpcUtil.checkAuthority(null));
   }
 
   @Test
@@ -175,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
@@ -244,14 +286,78 @@ public void getTransportFromPickResult_errorPickResult_failFast() {
 
     assertNotNull(transport);
 
-    ClientStream stream = transport
-        .newStream(TestMethodDescriptors.voidMethod(), new Metadata(), CallOptions.DEFAULT);
+    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;
@@ -260,8 +366,9 @@ public void getTransportFromPickResult_dropPickResult_waitForReady() {
 
     assertNotNull(transport);
 
-    ClientStream stream = transport
-        .newStream(TestMethodDescriptors.voidMethod(), new Metadata(), CallOptions.DEFAULT);
+    ClientStream stream = transport.newStream(
+        TestMethodDescriptors.voidMethod(), new Metadata(), CallOptions.DEFAULT,
+        tracers);
     ClientStreamListener listener = mock(ClientStreamListener.class);
     stream.start(listener);
 
@@ -276,8 +383,9 @@ public void getTransportFromPickResult_dropPickResult_failFast() {
 
     assertNotNull(transport);
 
-    ClientStream stream = transport
-        .newStream(TestMethodDescriptors.voidMethod(), new Metadata(), CallOptions.DEFAULT);
+    ClientStream stream = transport.newStream(
+        TestMethodDescriptors.voidMethod(), new Metadata(), CallOptions.DEFAULT,
+        tracers);
     ClientStreamListener listener = mock(ClientStreamListener.class);
     stream.start(listener);
 
diff --git a/core/src/test/java/io/grpc/internal/Http2ClientStreamTransportStateTest.java b/core/src/test/java/io/grpc/internal/Http2ClientStreamTransportStateTest.java
index d49e41a4f4a..66df062a3e0 100644
--- a/core/src/test/java/io/grpc/internal/Http2ClientStreamTransportStateTest.java
+++ b/core/src/test/java/io/grpc/internal/Http2ClientStreamTransportStateTest.java
@@ -16,9 +16,9 @@
 
 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.ArgumentMatchers.any;
@@ -27,6 +27,7 @@
 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;
@@ -300,6 +301,24 @@ public void transportTrailersReceived_missingStatusUsesHttpStatus() {
     assertTrue(statusCaptor.getValue().getDescription().contains("401"));
   }
 
+  @Test
+  public void transportTrailersReceived_missingContentTypeUsesHttpStatus() {
+    BaseTransportState state = new BaseTransportState(transportTracer);
+    state.setListener(mockListener);
+    Metadata trailers = new Metadata();
+    trailers.put(testStatusMashaller, "431");
+
+    state.transportTrailersReceived(trailers);
+
+    verify(mockListener, never()).headersRead(any(Metadata.class));
+    verify(mockListener).closed(statusCaptor.capture(), same(PROCESSED), same(trailers));
+    assertEquals(Code.INTERNAL, statusCaptor.getValue().getCode());
+    assertTrue(statusCaptor.getValue().getDescription().contains("HTTP status code 431"));
+    assertTrue(
+        statusCaptor.getValue().getDescription().contains(
+            "missing content-type in response headers"));
+  }
+
   @Test
   public void transportTrailersReceived_missingHttpStatus() {
     BaseTransportState state = new BaseTransportState(transportTracer);
@@ -347,9 +366,22 @@ public void transportTrailersReceived_missingStatusAfterHeadersIgnoresHttpStatus
     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 {
+    private int onReadyThreshold;
+
+    public BaseTransportState(TransportTracer transportTracer, CallOptions options) {
+      super(DEFAULT_MAX_MESSAGE_SIZE, StatsTraceContext.NOOP, transportTracer, options);
+    }
+
     public BaseTransportState(TransportTracer transportTracer) {
-      super(DEFAULT_MAX_MESSAGE_SIZE, StatsTraceContext.NOOP, transportTracer);
+      this(transportTracer, CallOptions.DEFAULT);
     }
 
     @Override
@@ -367,5 +399,11 @@ public void bytesRead(int processedBytes) {}
     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 0359dbef95b..4236c091d9c 100644
--- a/core/src/test/java/io/grpc/internal/InternalSubchannelTest.java
+++ b/core/src/test/java/io/grpc/internal/InternalSubchannelTest.java
@@ -27,11 +27,15 @@
 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.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;
@@ -44,8 +48,14 @@
 import io.grpc.ConnectivityStateInfo;
 import io.grpc.EquivalentAddressGroup;
 import io.grpc.InternalChannelz;
+import io.grpc.InternalEquivalentAddressGroup;
 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;
@@ -54,6 +64,7 @@
 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;
@@ -63,9 +74,9 @@
 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.InOrder;
 import org.mockito.Mock;
 import org.mockito.junit.MockitoJUnit;
 import org.mockito.junit.MockitoRule;
@@ -77,11 +88,11 @@
 public class InternalSubchannelTest {
   @Rule
   public final MockitoRule mocks = MockitoJUnit.rule();
-  @SuppressWarnings("deprecation") // https://github.com/grpc/grpc-java/issues/7467
-  @Rule
-  public final ExpectedException thrown = ExpectedException.none();
 
   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);
@@ -109,6 +120,10 @@ public void uncaughtException(Thread t, Throwable e) {
   @Mock private BackoffPolicy.Provider mockBackoffPolicyProvider;
   @Mock private ClientTransportFactory mockTransportFactory;
 
+  @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() {
@@ -219,7 +234,8 @@ public void constructor_eagListWithNull_throws() {
 
     // Fail this one. Because there is only one address to try, enter TRANSIENT_FAILURE.
     assertNoCallbackInvoke();
-    transports.poll().listener.transportShutdown(Status.UNAVAILABLE);
+    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
@@ -250,7 +266,8 @@ public void constructor_eagListWithNull_throws() {
     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);
+    transports.poll().listener.transportShutdown(Status.RESOURCE_EXHAUSTED,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
     assertEquals(TRANSIENT_FAILURE, internalSubchannel.getState());
     assertExactCallbackInvokes("onStateChange:" + RESOURCE_EXHAUSTED_STATE);
     // Second back-off interval
@@ -288,7 +305,8 @@ public void constructor_eagListWithNull_throws() {
 
     // Close the READY transport, will enter IDLE state.
     assertNoCallbackInvoke();
-    transports.poll().listener.transportShutdown(Status.UNAVAILABLE);
+    transports.poll().listener.transportShutdown(Status.UNAVAILABLE,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
     assertEquals(IDLE, internalSubchannel.getState());
     assertExactCallbackInvokes("onStateChange:IDLE");
 
@@ -308,10 +326,59 @@ public void constructor_eagListWithNull_throws() {
     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);
+    createInternalSubchannel(false,
+        new EquivalentAddressGroup(Arrays.asList(addr1, addr2)));
     assertEquals(IDLE, internalSubchannel.getState());
     // Invocation counters
     int transportsAddr1 = 0;
@@ -333,7 +400,8 @@ public void constructor_eagListWithNull_throws() {
             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();
@@ -349,7 +417,8 @@ public void constructor_eagListWithNull_throws() {
     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(TRANSIENT_FAILURE, internalSubchannel.getState());
     assertExactCallbackInvokes("onStateChange:" + UNAVAILABLE_STATE);
@@ -380,7 +449,8 @@ public void constructor_eagListWithNull_throws() {
             eq(createClientTransportOptions()),
             isA(TransportLogger.class));
     // Fail this one too
-    transports.poll().listener.transportShutdown(Status.UNAVAILABLE);
+    transports.poll().listener.transportShutdown(Status.UNAVAILABLE,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
     assertEquals(CONNECTING, internalSubchannel.getState());
 
     // Forth attempt will start immediately. Keep back-off policy.
@@ -394,7 +464,8 @@ public void constructor_eagListWithNull_throws() {
             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(TRANSIENT_FAILURE, internalSubchannel.getState());
@@ -431,7 +502,8 @@ public void constructor_eagListWithNull_throws() {
         ((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(IDLE, internalSubchannel.getState());
 
@@ -447,7 +519,8 @@ public void constructor_eagListWithNull_throws() {
             eq(createClientTransportOptions()),
             isA(TransportLogger.class));
     // Fail the transport
-    transports.poll().listener.transportShutdown(Status.UNAVAILABLE);
+    transports.poll().listener.transportShutdown(Status.UNAVAILABLE,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
     assertEquals(CONNECTING, internalSubchannel.getState());
 
     // Second attempt will start immediately. Still no new back-off policy.
@@ -459,7 +532,8 @@ public void constructor_eagListWithNull_throws() {
             isA(TransportLogger.class));
     // Fail this one too
     assertEquals(CONNECTING, internalSubchannel.getState());
-    transports.poll().listener.transportShutdown(Status.UNAVAILABLE);
+    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(TRANSIENT_FAILURE, internalSubchannel.getState());
@@ -495,8 +569,9 @@ public void constructor_eagListWithNull_throws() {
   public void updateAddresses_emptyEagList_throws() {
     SocketAddress addr = new FakeSocketAddress();
     createInternalSubchannel(addr);
-    thrown.expect(IllegalArgumentException.class);
-    internalSubchannel.updateAddresses(Arrays.<EquivalentAddressGroup>asList());
+    List<EquivalentAddressGroup> newAddressGroups = Collections.emptyList();
+    assertThrows(IllegalArgumentException.class,
+        () -> internalSubchannel.updateAddresses(newAddressGroups));
   }
 
   @Test
@@ -504,8 +579,7 @@ public void updateAddresses_eagListWithNull_throws() {
     SocketAddress addr = new FakeSocketAddress();
     createInternalSubchannel(addr);
     List<EquivalentAddressGroup> eags = Arrays.asList((EquivalentAddressGroup) null);
-    thrown.expect(NullPointerException.class);
-    internalSubchannel.updateAddresses(eags);
+    assertThrows(NullPointerException.class, () -> internalSubchannel.updateAddresses(eags));
   }
 
   @Test public void updateAddresses_intersecting_ready() {
@@ -523,7 +597,8 @@ public void updateAddresses_eagListWithNull_throws() {
             eq(addr1),
             eq(createClientTransportOptions()),
             isA(TransportLogger.class));
-    transports.poll().listener.transportShutdown(Status.UNAVAILABLE);
+    transports.poll().listener.transportShutdown(Status.UNAVAILABLE,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
     assertEquals(CONNECTING, internalSubchannel.getState());
 
     // Second address connects
@@ -545,7 +620,8 @@ public void updateAddresses_eagListWithNull_throws() {
     verify(transports.peek().transport, never()).shutdownNow(any(Status.class));
 
     // And new addresses chosen when re-connecting
-    transports.poll().listener.transportShutdown(Status.UNAVAILABLE);
+    transports.poll().listener.transportShutdown(Status.UNAVAILABLE,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
     assertExactCallbackInvokes("onStateChange:IDLE");
 
     assertNull(internalSubchannel.obtainActiveTransport());
@@ -555,13 +631,15 @@ public void updateAddresses_eagListWithNull_throws() {
             eq(addr2),
             eq(createClientTransportOptions()),
             isA(TransportLogger.class));
-    transports.poll().listener.transportShutdown(Status.UNAVAILABLE);
+    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);
+    transports.poll().listener.transportShutdown(Status.UNAVAILABLE,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
     verifyNoMoreInteractions(mockTransportFactory);
 
     fakeClock.forwardNanos(10); // Drain retry, but don't care about result
@@ -582,7 +660,8 @@ public void updateAddresses_eagListWithNull_throws() {
             eq(addr1),
             eq(createClientTransportOptions()),
             isA(TransportLogger.class));
-    transports.poll().listener.transportShutdown(Status.UNAVAILABLE);
+    transports.poll().listener.transportShutdown(Status.UNAVAILABLE,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
     assertEquals(CONNECTING, internalSubchannel.getState());
 
     // Second address connecting
@@ -605,7 +684,8 @@ public void updateAddresses_eagListWithNull_throws() {
     // And new addresses chosen when re-connecting
     transports.peek().listener.transportReady();
     assertExactCallbackInvokes("onStateChange:READY");
-    transports.poll().listener.transportShutdown(Status.UNAVAILABLE);
+    transports.poll().listener.transportShutdown(Status.UNAVAILABLE,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
     assertExactCallbackInvokes("onStateChange:IDLE");
 
     assertNull(internalSubchannel.obtainActiveTransport());
@@ -615,13 +695,15 @@ public void updateAddresses_eagListWithNull_throws() {
             eq(addr2),
             eq(createClientTransportOptions()),
             isA(TransportLogger.class));
-    transports.poll().listener.transportShutdown(Status.UNAVAILABLE);
+    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);
+    transports.poll().listener.transportShutdown(Status.UNAVAILABLE,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
     verifyNoMoreInteractions(mockTransportFactory);
 
     fakeClock.forwardNanos(10); // Drain retry, but don't care about result
@@ -660,7 +742,8 @@ public void updateAddresses_eagListWithNull_throws() {
 
     // And no other addresses attempted
     assertEquals(0, fakeClock.numPendingTasks());
-    transports.poll().listener.transportShutdown(Status.UNAVAILABLE);
+    transports.poll().listener.transportShutdown(Status.UNAVAILABLE,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
     assertExactCallbackInvokes("onStateChange:" + UNAVAILABLE_STATE);
     assertEquals(TRANSIENT_FAILURE, internalSubchannel.getState());
     verifyNoMoreInteractions(mockTransportFactory);
@@ -684,7 +767,8 @@ public void updateAddresses_eagListWithNull_throws() {
             eq(addr1),
             eq(createClientTransportOptions()),
             isA(TransportLogger.class));
-    transports.poll().listener.transportShutdown(Status.UNAVAILABLE);
+    transports.poll().listener.transportShutdown(Status.UNAVAILABLE,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
     assertEquals(CONNECTING, internalSubchannel.getState());
 
     // Second address connects
@@ -708,7 +792,8 @@ public void updateAddresses_eagListWithNull_throws() {
     verify(transports.peek().transport).shutdown(any(Status.class));
 
     // And new addresses chosen when re-connecting
-    transports.poll().listener.transportShutdown(Status.UNAVAILABLE);
+    transports.poll().listener.transportShutdown(Status.UNAVAILABLE,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
     assertNoCallbackInvoke();
     assertEquals(IDLE, internalSubchannel.getState());
 
@@ -719,13 +804,15 @@ public void updateAddresses_eagListWithNull_throws() {
             eq(addr3),
             eq(createClientTransportOptions()),
             isA(TransportLogger.class));
-    transports.poll().listener.transportShutdown(Status.UNAVAILABLE);
+    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);
+    transports.poll().listener.transportShutdown(Status.UNAVAILABLE,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
     verifyNoMoreInteractions(mockTransportFactory);
 
     fakeClock.forwardNanos(10); // Drain retry, but don't care about result
@@ -747,7 +834,8 @@ public void updateAddresses_eagListWithNull_throws() {
             eq(addr1),
             eq(createClientTransportOptions()),
             isA(TransportLogger.class));
-    transports.poll().listener.transportShutdown(Status.UNAVAILABLE);
+    transports.poll().listener.transportShutdown(Status.UNAVAILABLE,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
     assertEquals(CONNECTING, internalSubchannel.getState());
 
     // Second address connecting
@@ -777,13 +865,15 @@ public void updateAddresses_eagListWithNull_throws() {
             eq(addr3),
             eq(createClientTransportOptions()),
             isA(TransportLogger.class));
-    transports.poll().listener.transportShutdown(Status.UNAVAILABLE);
+    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);
+    transports.poll().listener.transportShutdown(Status.UNAVAILABLE,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
     verifyNoMoreInteractions(mockTransportFactory);
 
     fakeClock.forwardNanos(10); // Drain retry, but don't care about result
@@ -867,7 +957,8 @@ public void connectIsLazy() {
             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
@@ -883,7 +974,8 @@ public void connectIsLazy() {
     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 ...
@@ -913,7 +1005,8 @@ public void shutdownWhenReady() throws Exception {
     internalSubchannel.shutdown(SHUTDOWN_REASON);
     verify(transportInfo.transport).shutdown(same(SHUTDOWN_REASON));
     assertExactCallbackInvokes("onStateChange:SHUTDOWN");
-    transportInfo.listener.transportShutdown(SHUTDOWN_REASON);
+    transportInfo.listener.transportShutdown(SHUTDOWN_REASON,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
 
     transportInfo.listener.transportTerminated();
     assertExactCallbackInvokes("onTerminated");
@@ -936,7 +1029,8 @@ public void shutdownBeforeTransportCreated() throws Exception {
 
     // 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
@@ -963,7 +1057,7 @@ 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(SHUTDOWN, internalSubchannel.getState());
     assertNoCallbackInvoke();
@@ -992,7 +1086,8 @@ public void shutdownBeforeTransportReady() throws Exception {
 
     // The transport should've been shut down even though it's not the active transport yet.
     verify(transportInfo.transport).shutdown(same(SHUTDOWN_REASON));
-    transportInfo.listener.transportShutdown(Status.UNAVAILABLE);
+    transportInfo.listener.transportShutdown(Status.UNAVAILABLE,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
     assertNoCallbackInvoke();
     transportInfo.listener.transportTerminated();
     assertExactCallbackInvokes("onTerminated");
@@ -1008,7 +1103,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();
@@ -1065,7 +1160,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());
@@ -1098,7 +1193,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");
@@ -1125,12 +1220,12 @@ 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());
@@ -1157,7 +1252,8 @@ public void resetConnectBackoff() throws Exception {
             eq(addr),
             eq(createClientTransportOptions()),
             isA(TransportLogger.class));
-    transports.poll().listener.transportShutdown(Status.UNAVAILABLE);
+    transports.poll().listener.transportShutdown(Status.UNAVAILABLE,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
     assertExactCallbackInvokes("onStateChange:" + UNAVAILABLE_STATE);
 
     // Save the reconnectTask
@@ -1193,7 +1289,8 @@ public void resetConnectBackoff() throws Exception {
 
     // Fail the reconnect attempt to verify that a fresh reconnect policy is generated after
     // invoking resetConnectBackoff()
-    transports.poll().listener.transportShutdown(Status.UNAVAILABLE);
+    transports.poll().listener.transportShutdown(Status.UNAVAILABLE,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
     assertExactCallbackInvokes("onStateChange:" + UNAVAILABLE_STATE);
     verify(mockBackoffPolicyProvider, times(2)).get();
     fakeClock.forwardNanos(10);
@@ -1221,7 +1318,8 @@ public void channelzMembership() throws Exception {
     MockClientTransportInfo t0 = transports.poll();
     t0.listener.transportReady();
     assertTrue(channelz.containsClientSocket(t0.transport.getLogId()));
-    t0.listener.transportShutdown(Status.RESOURCE_EXHAUSTED);
+    t0.listener.transportShutdown(Status.RESOURCE_EXHAUSTED,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
     t0.listener.transportTerminated();
     assertFalse(channelz.containsClientSocket(t0.transport.getLogId()));
   }
@@ -1338,6 +1436,32 @@ public void channelzStatContainsTransport() throws Exception {
     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()
@@ -1350,17 +1474,201 @@ private void createInternalSubchannel(SocketAddress ... 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");
-    internalSubchannel = new InternalSubchannel(addressGroups, AUTHORITY, USER_AGENT,
+    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(), syncContext, mockInternalSubchannelCallback,
         channelz, CallTracer.getDefaultFactory().create(),
         subchannelTracer,
         logId,
-        new ChannelLoggerImpl(subchannelTracer, fakeClock.getTimeProvider()));
+        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(InternalEquivalentAddressGroup.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(InternalEquivalentAddressGroup.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();
+  }
+
+  @Test
+  public void subchannelStateChanges_backendServiceFallsBackToResolutionResultAttr() {
+    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
+    );
+
+    internalSubchannel.obtainActiveTransport();
+    MockClientTransportInfo transportInfo = transports.poll();
+    assertNotNull(transportInfo);
+    transportInfo.listener.transportReady();
+    fakeClock.runDueTasks();
+
+    verify(mockMetricRecorder).addLongCounter(
+        eqMetricInstrumentName("grpc.subchannel.connection_attempts_succeeded"),
+        eq(1L),
+        eq(Arrays.asList(AUTHORITY)),
+        eq(Arrays.asList(BACKEND_SERVICE, LOCALITY))
+    );
   }
 
   private void assertNoCallbackInvoke() {
@@ -1373,5 +1681,13 @@ private void assertExactCallbackInvokes(String ... expectedInvokes) {
     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/JsonParserTest.java b/core/src/test/java/io/grpc/internal/JsonParserTest.java
index 1e74c753d4d..a0dd81c20ce 100644
--- a/core/src/test/java/io/grpc/internal/JsonParserTest.java
+++ b/core/src/test/java/io/grpc/internal/JsonParserTest.java
@@ -17,15 +17,14 @@
 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.Rule;
 import org.junit.Test;
-import org.junit.rules.ExpectedException;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 
@@ -35,10 +34,6 @@
 @RunWith(JUnit4.class)
 public class JsonParserTest {
 
-  @SuppressWarnings("deprecation") // https://github.com/grpc/grpc-java/issues/7467
-  @Rule
-  public final ExpectedException thrown = ExpectedException.none();
-
   @Test
   public void emptyObject() throws IOException {
     assertEquals(new LinkedHashMap<String, Object>(), JsonParser.parse("{}"));
@@ -75,45 +70,33 @@ public void nullValue() throws IOException {
   }
 
   @Test
-  public void nanFails() throws IOException {
-    thrown.expect(MalformedJsonException.class);
-
-    JsonParser.parse("NaN");
+  public void nanFails() {
+    assertThrows(MalformedJsonException.class, () -> JsonParser.parse("NaN"));
   }
 
   @Test
-  public void objectEarlyEnd() throws IOException {
-    thrown.expect(MalformedJsonException.class);
-
-    JsonParser.parse("{foo:}");
+  public void objectEarlyEnd() {
+    assertThrows(MalformedJsonException.class, () -> JsonParser.parse("{foo:}"));
   }
 
   @Test
-  public void earlyEndArray() throws IOException {
-    thrown.expect(EOFException.class);
-
-    JsonParser.parse("[1, 2, ");
+  public void earlyEndArray() {
+    assertThrows(EOFException.class, () -> JsonParser.parse("[1, 2, "));
   }
 
   @Test
-  public void arrayMissingElement() throws IOException {
-    thrown.expect(MalformedJsonException.class);
-
-    JsonParser.parse("[1, 2, ]");
+  public void arrayMissingElement() {
+    assertThrows(MalformedJsonException.class, () -> JsonParser.parse("[1, 2, ]"));
   }
 
   @Test
-  public void objectMissingElement() throws IOException {
-    thrown.expect(MalformedJsonException.class);
-
-    JsonParser.parse("{1: ");
+  public void objectMissingElement() {
+    assertThrows(MalformedJsonException.class, () -> JsonParser.parse("{1: "));
   }
 
   @Test
-  public void objectNoName() throws IOException {
-    thrown.expect(MalformedJsonException.class);
-
-    JsonParser.parse("{: 1");
+  public void objectNoName() {
+    assertThrows(MalformedJsonException.class, () -> JsonParser.parse("{: 1"));
   }
 
   @Test
@@ -123,4 +106,9 @@ public void objectStringName() throws IOException {
 
     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/netty/src/test/java/io/grpc/netty/KeepAliveEnforcerTest.java b/core/src/test/java/io/grpc/internal/KeepAliveEnforcerTest.java
similarity index 97%
rename from netty/src/test/java/io/grpc/netty/KeepAliveEnforcerTest.java
rename to core/src/test/java/io/grpc/internal/KeepAliveEnforcerTest.java
index 33c40390826..c58ed6ea160 100644
--- a/netty/src/test/java/io/grpc/netty/KeepAliveEnforcerTest.java
+++ b/core/src/test/java/io/grpc/internal/KeepAliveEnforcerTest.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.grpc.netty;
+package io.grpc.internal;
 
 import static com.google.common.truth.Truth.assertThat;
 
@@ -32,12 +32,12 @@ public class KeepAliveEnforcerTest {
 
   @Test(expected = IllegalArgumentException.class)
   public void negativeTime() {
-    new KeepAliveEnforcer(true, -1, TimeUnit.NANOSECONDS);
+    KeepAliveEnforcer unused = new KeepAliveEnforcer(true, -1, TimeUnit.NANOSECONDS);
   }
 
   @Test(expected = NullPointerException.class)
   public void nullTimeUnit() {
-    new KeepAliveEnforcer(true, 1, null);
+    KeepAliveEnforcer unused = new KeepAliveEnforcer(true, 1, null);
   }
 
   @Test
diff --git a/core/src/test/java/io/grpc/internal/KeepAliveManagerTest.java b/core/src/test/java/io/grpc/internal/KeepAliveManagerTest.java
index 88002d13558..81e3d1b2638 100644
--- a/core/src/test/java/io/grpc/internal/KeepAliveManagerTest.java
+++ b/core/src/test/java/io/grpc/internal/KeepAliveManagerTest.java
@@ -19,6 +19,7 @@
 import static com.google.common.truth.Truth.assertThat;
 import static org.junit.Assert.assertEquals;
 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;
@@ -104,13 +105,15 @@ public void keepAlivePingDelayedByIncomingData() {
 
   @Test
   public void clientKeepAlivePinger_pingTimeout() {
-    ConnectionClientTransport transport = mock(ConnectionClientTransport.class);
-    keepAlivePinger = new ClientKeepAlivePinger(transport);
+    ClientKeepAlivePinger.TransportWithDisconnectReason transport =
+        mock(ClientKeepAlivePinger.TransportWithDisconnectReason.class);
+    ClientKeepAlivePinger pinger = new ClientKeepAlivePinger(transport);
 
-    keepAlivePinger.onPingTimeout();
+    pinger.onPingTimeout();
 
     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();
     assertThat(status.getCode()).isEqualTo(Status.Code.UNAVAILABLE);
     assertThat(status.getDescription()).isEqualTo(
@@ -119,18 +122,20 @@ public void clientKeepAlivePinger_pingTimeout() {
 
   @Test
   public void clientKeepAlivePinger_pingFailure() {
-    ConnectionClientTransport transport = mock(ConnectionClientTransport.class);
-    keepAlivePinger = new ClientKeepAlivePinger(transport);
-    keepAlivePinger.ping();
+    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();
 
-    pingCallback.onFailure(new Throwable());
+    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();
     assertThat(status.getCode()).isEqualTo(Status.Code.UNAVAILABLE);
     assertThat(status.getDescription()).isEqualTo(
diff --git a/core/src/test/java/io/grpc/internal/ManagedChannelImplBuilderTest.java b/core/src/test/java/io/grpc/internal/ManagedChannelImplBuilderTest.java
index bc5b7cde651..b0939239477 100644
--- a/core/src/test/java/io/grpc/internal/ManagedChannelImplBuilderTest.java
+++ b/core/src/test/java/io/grpc/internal/ManagedChannelImplBuilderTest.java
@@ -22,8 +22,11 @@
 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;
@@ -35,9 +38,18 @@
 import io.grpc.ClientInterceptor;
 import io.grpc.CompressorRegistry;
 import io.grpc.DecompressorRegistry;
+import io.grpc.FlagResetRule;
+import io.grpc.InternalConfigurator;
+import io.grpc.InternalConfiguratorRegistry;
+import io.grpc.InternalFeatureFlags;
+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;
@@ -47,24 +59,27 @@
 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.rules.ExpectedException;
 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.Mock;
 import org.mockito.junit.MockitoJUnit;
 import org.mockito.junit.MockitoRule;
 
 /** Unit tests for {@link ManagedChannelImplBuilder}. */
-@RunWith(JUnit4.class)
+@RunWith(Parameterized.class)
 public class ManagedChannelImplBuilderTest {
   private static final int DUMMY_PORT = 42;
   private static final String DUMMY_TARGET = "fake-target";
@@ -78,11 +93,25 @@ public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
           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();
-  @SuppressWarnings("deprecation") // https://github.com/grpc/grpc-java/issues/7467
-  @Rule public final ExpectedException thrown = ExpectedException.none();
   @Rule public final GrpcCleanupRule grpcCleanupRule = new GrpcCleanupRule();
+  @Rule public final FlagResetRule flagResetRule = new FlagResetRule();
 
   @Mock private ClientTransportFactory mockClientTransportFactory;
   @Mock private ClientTransportFactoryBuilder mockClientTransportFactoryBuilder;
@@ -90,10 +119,19 @@ public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
   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(
+        InternalFeatureFlags::setRfc3986UrisEnabled, enableRfc3986UrisParam);
+
     builder = new ManagedChannelImplBuilder(
         DUMMY_TARGET,
         new UnsupportedClientTransportFactoryBuilder(),
@@ -145,59 +183,64 @@ public void executor_default() {
   @Test
   public void executor_normal() {
     Executor executor = mock(Executor.class);
-    assertEquals(builder, builder.executor(executor));
-    assertEquals(executor, builder.executorPool.getObject());
+    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));
-    assertEquals(builder, builder.executor(null));
-    assertEquals(defaultValue, builder.executorPool);
+    assertSame(builder, builder.executor(null));
+    assertSame(defaultValue, builder.executorPool);
   }
 
   @Test
   public void directExecutor() {
-    assertEquals(builder, builder.directExecutor());
+    assertSame(builder, builder.directExecutor());
     assertEquals(MoreExecutors.directExecutor(), builder.executorPool.getObject());
   }
 
   @Test
   public void offloadExecutor_normal() {
     Executor executor = mock(Executor.class);
-    assertEquals(builder, builder.offloadExecutor(executor));
-    assertEquals(executor, builder.offloadExecutorPool.getObject());
+    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));
-    assertEquals(builder, builder.offloadExecutor(null));
-    assertEquals(defaultValue, builder.offloadExecutorPool);
+    assertSame(builder, builder.offloadExecutor(null));
+    assertSame(defaultValue, builder.offloadExecutorPool);
   }
 
   @Test
-  public void nameResolverFactory_default() {
-    assertNotNull(builder.nameResolverFactory);
+  public void nameResolverRegistry_default() {
+    assertNotNull(builder.nameResolverRegistry);
   }
 
   @Test
   @SuppressWarnings("deprecation")
   public void nameResolverFactory_normal() {
     NameResolver.Factory nameResolverFactory = mock(NameResolver.Factory.class);
-    assertEquals(builder, builder.nameResolverFactory(nameResolverFactory));
-    assertEquals(nameResolverFactory, builder.nameResolverFactory);
+    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() {
-    NameResolver.Factory defaultValue = builder.nameResolverFactory;
-    builder.nameResolverFactory(mock(NameResolver.Factory.class));
-    assertEquals(builder, builder.nameResolverFactory(null));
-    assertEquals(defaultValue, builder.nameResolverFactory);
+    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)
@@ -213,7 +256,7 @@ public void defaultLoadBalancingPolicy_default() {
 
   @Test
   public void defaultLoadBalancingPolicy_normal() {
-    assertEquals(builder, builder.defaultLoadBalancingPolicy("magic_balancer"));
+    assertSame(builder, builder.defaultLoadBalancingPolicy("magic_balancer"));
     assertEquals("magic_balancer", builder.defaultLbPolicy);
   }
 
@@ -232,12 +275,6 @@ public void fullStreamDecompression_default() {
     assertFalse(builder.fullStreamDecompression);
   }
 
-  @Test
-  public void fullStreamDecompression_enabled() {
-    assertEquals(builder, builder.enableFullStreamDecompression());
-    assertTrue(builder.fullStreamDecompression);
-  }
-
   @Test
   public void decompressorRegistry_default() {
     assertNotNull(builder.decompressorRegistry);
@@ -247,14 +284,14 @@ public void decompressorRegistry_default() {
   public void decompressorRegistry_normal() {
     DecompressorRegistry decompressorRegistry = DecompressorRegistry.emptyInstance();
     assertNotEquals(decompressorRegistry, builder.decompressorRegistry);
-    assertEquals(builder, builder.decompressorRegistry(decompressorRegistry));
+    assertSame(builder, builder.decompressorRegistry(decompressorRegistry));
     assertEquals(decompressorRegistry, builder.decompressorRegistry);
   }
 
   @Test
   public void decompressorRegistry_null() {
     DecompressorRegistry defaultValue = builder.decompressorRegistry;
-    assertEquals(builder, builder.decompressorRegistry(DecompressorRegistry.emptyInstance()));
+    assertSame(builder, builder.decompressorRegistry(DecompressorRegistry.emptyInstance()));
     assertNotEquals(defaultValue, builder.decompressorRegistry);
     builder.decompressorRegistry(null);
     assertEquals(defaultValue, builder.decompressorRegistry);
@@ -269,8 +306,8 @@ public void compressorRegistry_default() {
   public void compressorRegistry_normal() {
     CompressorRegistry compressorRegistry = CompressorRegistry.newEmptyInstance();
     assertNotEquals(compressorRegistry, builder.compressorRegistry);
-    assertEquals(builder, builder.compressorRegistry(compressorRegistry));
-    assertEquals(compressorRegistry, builder.compressorRegistry);
+    assertSame(builder, builder.compressorRegistry(compressorRegistry));
+    assertSame(compressorRegistry, builder.compressorRegistry);
   }
 
   @Test
@@ -278,8 +315,8 @@ public void compressorRegistry_null() {
     CompressorRegistry defaultValue = builder.compressorRegistry;
     builder.compressorRegistry(CompressorRegistry.newEmptyInstance());
     assertNotEquals(defaultValue, builder.compressorRegistry);
-    assertEquals(builder, builder.compressorRegistry(null));
-    assertEquals(defaultValue, builder.compressorRegistry);
+    assertSame(builder, builder.compressorRegistry(null));
+    assertSame(defaultValue, builder.compressorRegistry);
   }
 
   @Test
@@ -290,13 +327,13 @@ public void userAgent_default() {
   @Test
   public void userAgent_normal() {
     String userAgent = "user-agent/1";
-    assertEquals(builder, builder.userAgent(userAgent));
-    assertEquals(userAgent, builder.userAgent);
+    assertSame(builder, builder.userAgent(userAgent));
+    assertSame(userAgent, builder.userAgent);
   }
 
   @Test
   public void userAgent_null() {
-    assertEquals(builder, builder.userAgent(null));
+    assertSame(builder, builder.userAgent(null));
     assertNull(builder.userAgent);
 
     builder.userAgent("user-agent/1");
@@ -310,6 +347,8 @@ public void authorityIsReadable_default() {
         .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));
@@ -324,6 +363,8 @@ public void authorityIsReadable_overrideAuthority() {
         .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))
@@ -332,6 +373,44 @@ mockClientTransportFactoryBuilder, new FixedPortProvider(DUMMY_PORT))
     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);
@@ -340,8 +419,8 @@ public void overrideAuthority_default() {
   @Test
   public void overrideAuthority_normal() {
     String overrideAuthority = "best-authority";
-    assertEquals(builder, builder.overrideAuthority(overrideAuthority));
-    assertEquals(overrideAuthority, builder.authorityOverride);
+    assertSame(builder, builder.overrideAuthority(overrideAuthority));
+    assertSame(overrideAuthority, builder.authorityOverride);
   }
 
   @Test(expected = NullPointerException.class)
@@ -351,7 +430,7 @@ public void overrideAuthority_null() {
 
   @Test(expected = IllegalArgumentException.class)
   public void overrideAuthority_invalid() {
-    builder.overrideAuthority("not_allowed");
+    builder.overrideAuthority("user@not_allowed");
   }
 
   @Test
@@ -361,10 +440,9 @@ public void checkAuthority_validAuthorityAllowed() {
 
   @Test
   public void checkAuthority_invalidAuthorityFailed() {
-    thrown.expect(IllegalArgumentException.class);
-    thrown.expectMessage("Invalid authority");
-
-    builder.checkAuthority(DUMMY_AUTHORITY_INVALID);
+    IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
+        () -> builder.checkAuthority(DUMMY_AUTHORITY_INVALID));
+    assertThat(e).hasMessageThat().isEqualTo("Invalid authority: [ : : 1]");
   }
 
   @Test
@@ -387,27 +465,30 @@ public void enableCheckAuthority_validAuthorityAllowed() {
 
   @Test
   public void disableCheckAuthority_invalidAuthorityFailed() {
-    thrown.expect(IllegalArgumentException.class);
-    thrown.expectMessage("Invalid authority");
-
     builder.disableCheckAuthority().enableCheckAuthority();
-    builder.checkAuthority(DUMMY_AUTHORITY_INVALID);
+    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);
-    assertEquals("/0:0:0:0:0:0:0:0%0:10005", address.toString());
     String target = ManagedChannelImplBuilder.makeTargetStringForDirectAddress(address);
     URI uri = new URI(target);
-    assertEquals("directaddress:////0:0:0:0:0:0:0:0%250:10005", 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();
+    List<ClientInterceptor> effectiveInterceptors = builder.getEffectiveInterceptors("unused:///");
     assertEquals(3, effectiveInterceptors.size());
     assertThat(effectiveInterceptors.get(0).getClass().getName())
         .isEqualTo("io.grpc.census.CensusTracingModule$TracingClientInterceptor");
@@ -420,7 +501,7 @@ public void getEffectiveInterceptors_default() {
   public void getEffectiveInterceptors_disableStats() {
     builder.intercept(DUMMY_USER_INTERCEPTOR);
     builder.setStatsEnabled(false);
-    List<ClientInterceptor> effectiveInterceptors = builder.getEffectiveInterceptors();
+    List<ClientInterceptor> effectiveInterceptors = builder.getEffectiveInterceptors("unused:///");
     assertEquals(2, effectiveInterceptors.size());
     assertThat(effectiveInterceptors.get(0).getClass().getName())
         .isEqualTo("io.grpc.census.CensusTracingModule$TracingClientInterceptor");
@@ -431,7 +512,7 @@ public void getEffectiveInterceptors_disableStats() {
   public void getEffectiveInterceptors_disableTracing() {
     builder.intercept(DUMMY_USER_INTERCEPTOR);
     builder.setTracingEnabled(false);
-    List<ClientInterceptor> effectiveInterceptors = builder.getEffectiveInterceptors();
+    List<ClientInterceptor> effectiveInterceptors = builder.getEffectiveInterceptors("unused:///");
     assertEquals(2, effectiveInterceptors.size());
     assertThat(effectiveInterceptors.get(0).getClass().getName())
         .isEqualTo("io.grpc.census.CensusStatsModule$StatsClientInterceptor");
@@ -443,10 +524,112 @@ public void getEffectiveInterceptors_disableBoth() {
     builder.intercept(DUMMY_USER_INTERCEPTOR);
     builder.setStatsEnabled(false);
     builder.setTracingEnabled(false);
-    List<ClientInterceptor> effectiveInterceptors = builder.getEffectiveInterceptors();
+    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,
@@ -508,14 +691,12 @@ public void perRpcBufferLimit() {
 
   @Test
   public void retryBufferSizeInvalidArg() {
-    thrown.expect(IllegalArgumentException.class);
-    builder.retryBufferSize(0L);
+    assertThrows(IllegalArgumentException.class, () -> builder.retryBufferSize(0L));
   }
 
   @Test
   public void perRpcBufferLimitInvalidArg() {
-    thrown.expect(IllegalArgumentException.class);
-    builder.perRpcBufferLimit(0L);
+    assertThrows(IllegalArgumentException.class, () -> builder.perRpcBufferLimit(0L));
   }
 
   @Test
@@ -538,8 +719,7 @@ public void defaultServiceConfig_nullKey() {
     Map<String, Object> config = new HashMap<>();
     config.put(null, "val");
 
-    thrown.expect(IllegalArgumentException.class);
-    builder.defaultServiceConfig(config);
+    assertThrows(IllegalArgumentException.class, () -> builder.defaultServiceConfig(config));
   }
 
   @Test
@@ -549,8 +729,7 @@ public void defaultServiceConfig_intKey() {
     Map<String, Object> config = new HashMap<>();
     config.put("key", subConfig);
 
-    thrown.expect(IllegalArgumentException.class);
-    builder.defaultServiceConfig(config);
+    assertThrows(IllegalArgumentException.class, () -> builder.defaultServiceConfig(config));
   }
 
   @Test
@@ -558,8 +737,7 @@ public void defaultServiceConfig_intValue() {
     Map<String, Object> config = new HashMap<>();
     config.put("key", 3);
 
-    thrown.expect(IllegalArgumentException.class);
-    builder.defaultServiceConfig(config);
+    assertThrows(IllegalArgumentException.class, () -> builder.defaultServiceConfig(config));
   }
 
   @Test
@@ -591,4 +769,35 @@ public void disableNameResolverServiceConfig() {
     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 481db99b11d..792f4daca4e 100644
--- a/core/src/test/java/io/grpc/internal/ManagedChannelImplGetNameResolverTest.java
+++ b/core/src/test/java/io/grpc/internal/ManagedChannelImplGetNameResolverTest.java
@@ -17,39 +17,42 @@
 package io.grpc.internal;
 
 import static com.google.common.truth.Truth.assertThat;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
+import static io.grpc.internal.UriWrapper.wrap;
 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.ProxyDetector;
-import io.grpc.SynchronizationContext;
-import java.lang.Thread.UncaughtExceptionHandler;
+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(
- * String, String,NameResolver.Factory, NameResolver.Args)}. */
+/** Unit tests for ManagedChannelImplBuilder#getNameResolverProvider(). */
 @RunWith(JUnit4.class)
 public class ManagedChannelImplGetNameResolverTest {
-  private static final NameResolver.Args NAMERESOLVER_ARGS = NameResolver.Args.newBuilder()
-      .setDefaultPort(447)
-      .setProxyDetector(mock(ProxyDetector.class))
-      .setSynchronizationContext(new SynchronizationContext(mock(UncaughtExceptionHandler.class)))
-      .setServiceConfigParser(mock(ServiceConfigParser.class))
-      .setChannelLogger(mock(ChannelLogger.class))
-      .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",
@@ -62,17 +65,6 @@ public void validAuthorityTarget() throws Exception {
         new URI("defaultscheme", "", "/foo.googleapis.com:8080", null));
   }
 
-  @Test
-  public void validAuthorityTarget_overrideAuthority() throws Exception {
-    String target = "foo.googleapis.com:8080";
-    String overrideAuthority = "override.authority";
-    URI expectedUri = new URI("defaultscheme", "", "/foo.googleapis.com:8080", null);
-    NameResolver.Factory nameResolverFactory = new FakeNameResolverFactory(expectedUri.getScheme());
-    NameResolver nameResolver = ManagedChannelImpl.getNameResolver(
-        target, overrideAuthority, nameResolverFactory, NAMERESOLVER_ARGS);
-    assertThat(nameResolver.getServiceAuthority()).isEqualTo(overrideAuthority);
-  }
-
   @Test
   public void validUriTarget() throws Exception {
     testValidTarget("scheme:///foo.googleapis.com:8080", "scheme:///foo.googleapis.com:8080",
@@ -97,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");
@@ -115,52 +114,65 @@ public void validTargetStartingWithSlash() throws Exception {
   }
 
   @Test
-  public void validTargetNoResovler() {
-    NameResolver.Factory nameResolverFactory = new NameResolver.Factory() {
-      @Override
-      public NameResolver newNameResolver(URI targetUri, NameResolver.Args args) {
-        return null;
-      }
-
-      @Override
-      public String getDefaultScheme() {
-        return "defaultscheme";
-      }
-    };
+  public void validTargetNoProvider() {
+    NameResolverRegistry nameResolverRegistry = new NameResolverRegistry();
     try {
-      ManagedChannelImpl.getNameResolver(
-          "foo.googleapis.com:8080", null, nameResolverFactory, NAMERESOLVER_ARGS);
+      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) {
-    NameResolver.Factory nameResolverFactory = new FakeNameResolverFactory(expectedUri.getScheme());
-    FakeNameResolver nameResolver = (FakeNameResolver) ManagedChannelImpl.getNameResolver(
-        target, null, nameResolverFactory, NAMERESOLVER_ARGS);
-    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) {
-    NameResolver.Factory nameResolverFactory = new FakeNameResolverFactory("dns");
+    NameResolverRegistry nameResolverRegistry = getTestRegistry("dns");
 
     try {
-      FakeNameResolver nameResolver = (FakeNameResolver) ManagedChannelImpl.getNameResolver(
-          target, null, nameResolverFactory, NAMERESOLVER_ARGS);
-      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;
     }
 
@@ -176,6 +188,16 @@ public NameResolver newNameResolver(URI targetUri, NameResolver.Args args) {
     public String getDefaultScheme() {
       return expectedScheme;
     }
+
+    @Override
+    protected boolean isAvailable() {
+      return true;
+    }
+
+    @Override
+    protected int priority() {
+      return 5;
+    }
   }
 
   private static class FakeNameResolver extends NameResolver {
@@ -193,4 +215,6 @@ private static class FakeNameResolver extends NameResolver {
 
     @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 a2a2925c4f3..97e92be7fdd 100644
--- a/core/src/test/java/io/grpc/internal/ManagedChannelImplIdlenessTest.java
+++ b/core/src/test/java/io/grpc/internal/ManagedChannelImplIdlenessTest.java
@@ -19,6 +19,7 @@
 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.assertNull;
@@ -26,7 +27,9 @@
 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;
@@ -59,11 +62,14 @@
 import io.grpc.MethodDescriptor.MethodType;
 import io.grpc.NameResolver;
 import io.grpc.NameResolver.ResolutionResult;
+import io.grpc.NameResolverProvider;
 import io.grpc.Status;
+import io.grpc.StatusOr;
 import io.grpc.StringMarshaller;
 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;
@@ -152,15 +158,23 @@ public String getPolicyName() {
   @Before
   @SuppressWarnings("deprecation") // For NameResolver.Listener
   public void setUp() {
+    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(NameResolver.Args.class)))
         .thenReturn(mockNameResolver);
+    when(mockNameResolverFactory.getDefaultScheme())
+        .thenReturn("mockscheme");
     when(mockTransportFactory.getScheduledExecutorService())
         .thenReturn(timer.getScheduledExecutorService());
+    when(mockTransportFactory.getSupportedSocketAddressTypes())
+        .thenReturn(Collections.singleton(InetSocketAddress.class));
 
-    ManagedChannelImplBuilder builder = new ManagedChannelImplBuilder("fake://target",
+    String target = "mockscheme:///target";
+    URI targetUri = URI.create(target);
+    ManagedChannelImplBuilder builder = new ManagedChannelImplBuilder(target,
         new UnsupportedClientTransportFactoryBuilder(), null);
 
     builder
@@ -169,8 +183,11 @@ public void setUp() {
         .idleTimeout(IDLE_TIMEOUT_SECONDS, TimeUnit.SECONDS)
         .userAgent(USER_AGENT);
     builder.executorPool = executorPool;
+    NameResolverProvider nameResolverProvider =
+        builder.nameResolverRegistry.getProviderForScheme(targetUri.getScheme());
     channel = new ManagedChannelImpl(
-        builder, mockTransportFactory, new FakeBackoffPolicyProvider(),
+        builder, mockTransportFactory, wrap(targetUri), nameResolverProvider,
+        new FakeBackoffPolicyProvider(),
         oobExecutorPool, timer.getStopwatchSupplier(),
         Collections.<ClientInterceptor>emptyList(),
         TimeProvider.SYSTEM_TIME_PROVIDER);
@@ -218,7 +235,7 @@ public void newCallExitsIdleness() throws Exception {
 
     ArgumentCaptor<ResolvedAddresses> resolvedAddressCaptor =
         ArgumentCaptor.forClass(ResolvedAddresses.class);
-    verify(mockLoadBalancer).handleResolvedAddresses(resolvedAddressCaptor.capture());
+    verify(mockLoadBalancer).acceptResolvedAddresses(resolvedAddressCaptor.capture());
     assertThat(resolvedAddressCaptor.getValue().getAddresses())
         .containsExactlyElementsIn(servers);
   }
@@ -284,6 +301,35 @@ public void delayedTransportHoldsOffIdleness() throws Exception {
     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 = servers.get(1);
@@ -293,7 +339,7 @@ public void realTransportsHoldsOffIdleness() throws Exception {
     call.start(mockCallListener, new Metadata());
 
     // Verify that we have exited the idle mode
-    ArgumentCaptor<Helper> helperCaptor = ArgumentCaptor.forClass(null);
+    ArgumentCaptor<Helper> helperCaptor = ArgumentCaptor.forClass(Helper.class);
     verify(mockLoadBalancerProvider).newLoadBalancer(helperCaptor.capture());
     deliverResolutionResult();
     Helper helper = helperCaptor.getValue();
@@ -332,11 +378,55 @@ public void realTransportsHoldsOffIdleness() throws Exception {
     verify(mockLoadBalancer).shutdown();
   }
 
+  @Test
+  public void enterIdleWhileRealTransportInProgress() {
+    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());
+
+    // 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();
+
+    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();
+
+    // 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(null);
+    ArgumentCaptor<Helper> helperCaptor = ArgumentCaptor.forClass(Helper.class);
     verify(mockLoadBalancerProvider).newLoadBalancer(helperCaptor.capture());
     deliverResolutionResult();
     Helper helper = helperCaptor.getValue();
@@ -360,7 +450,7 @@ public void updateSubchannelAddresses_newAddressConnects() {
   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(null);
+    ArgumentCaptor<Helper> helperCaptor = ArgumentCaptor.forClass(Helper.class);
     verify(mockLoadBalancerProvider).newLoadBalancer(helperCaptor.capture());
     deliverResolutionResult();
     Helper helper = helperCaptor.getValue();
@@ -385,7 +475,7 @@ public void oobTransportDoesNotAffectIdleness() {
     call.start(mockCallListener, new Metadata());
 
     // Verify that we have exited the idle mode
-    ArgumentCaptor<Helper> helperCaptor = ArgumentCaptor.forClass(null);
+    ArgumentCaptor<Helper> helperCaptor = ArgumentCaptor.forClass(Helper.class);
     verify(mockLoadBalancerProvider).newLoadBalancer(helperCaptor.capture());
     Helper helper = helperCaptor.getValue();
     deliverResolutionResult();
@@ -402,7 +492,7 @@ public void oobTransportDoesNotAffectIdleness() {
     assertFalse(channel.inUseStateAggregator.isInUse());
 
     // Now make an RPC on an OOB channel
-    ManagedChannel oob = helper.createOobChannel(servers.get(0), "oobauthority");
+    ManagedChannel oob = helper.createOobChannel(servers, "oobauthority");
     verify(mockTransportFactory, never())
         .newClientTransport(
             any(SocketAddress.class),
@@ -434,17 +524,17 @@ public void oobTransportDoesNotAffectIdleness() {
   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(null);
+    ArgumentCaptor<Helper> helperCaptor = ArgumentCaptor.forClass(Helper.class);
     verify(mockLoadBalancerProvider).newLoadBalancer(helperCaptor.capture());
     deliverResolutionResult();
     Helper helper = helperCaptor.getValue();
-    ManagedChannel oobChannel = helper.createOobChannel(servers.get(0), "localhost");
+    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.get(1));
+    helper.updateOobChannelAddresses(oobChannel, servers.subList(1,2));
 
     oobChannel.newCall(method, CallOptions.DEFAULT).start(mockCallListener, new Metadata());
     MockClientTransportInfo t1 = newTransports.poll();
@@ -458,11 +548,11 @@ public void updateOobChannelAddresses_newAddressConnects() {
   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(null);
+    ArgumentCaptor<Helper> helperCaptor = ArgumentCaptor.forClass(Helper.class);
     verify(mockLoadBalancerProvider).newLoadBalancer(helperCaptor.capture());
     Helper helper = helperCaptor.getValue();
     deliverResolutionResult();
-    ManagedChannel oobChannel = helper.createOobChannel(servers.get(0), "localhost");
+    ManagedChannel oobChannel = helper.createOobChannel(servers.subList(0,1), "localhost");
 
     oobChannel.newCall(method, CallOptions.DEFAULT).start(mockCallListener, new Metadata());
     MockClientTransportInfo t0 = newTransports.poll();
@@ -470,7 +560,8 @@ public void updateOobChannelAddresses_existingAddressDoesNotConnect() {
 
     List<SocketAddress> changedList = new ArrayList<>(servers.get(0).getAddresses());
     changedList.add(new FakeSocketAddress("aDifferentServer"));
-    helper.updateOobChannelAddresses(oobChannel, new EquivalentAddressGroup(changedList));
+    helper.updateOobChannelAddresses(oobChannel, Collections.singletonList(
+        new EquivalentAddressGroup(changedList)));
 
     oobChannel.newCall(method, CallOptions.DEFAULT).start(mockCallListener, new Metadata());
     assertNull(newTransports.poll());
@@ -526,7 +617,7 @@ private void deliverResolutionResult() {
     // the NameResolver.
     ResolutionResult resolutionResult =
         ResolutionResult.newBuilder()
-            .setAddresses(servers)
+            .setAddressesOrError(StatusOr.fromValue(servers))
             .setAttributes(Attributes.EMPTY)
             .build();
     nameResolverListenerCaptor.getValue().onResult(resolutionResult);
diff --git a/core/src/test/java/io/grpc/internal/ManagedChannelImplTest.java b/core/src/test/java/io/grpc/internal/ManagedChannelImplTest.java
index 875f363ac83..ae224af27e1 100644
--- a/core/src/test/java/io/grpc/internal/ManagedChannelImplTest.java
+++ b/core/src/test/java/io/grpc/internal/ManagedChannelImplTest.java
@@ -19,12 +19,16 @@
 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;
@@ -70,6 +74,8 @@
 import io.grpc.ClientInterceptor;
 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;
@@ -80,6 +86,7 @@
 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;
@@ -93,13 +100,17 @@
 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.NameResolver.ConfigOrError;
 import io.grpc.NameResolver.ResolutionResult;
+import io.grpc.NameResolverProvider;
 import io.grpc.NameResolverRegistry;
 import io.grpc.ProxiedSocketAddress;
 import io.grpc.ProxyDetector;
@@ -107,20 +118,23 @@
 import io.grpc.ServerMethodDefinition;
 import io.grpc.Status;
 import io.grpc.Status.Code;
+import io.grpc.StatusOr;
 import io.grpc.StringMarshaller;
+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.ManagedChannelImpl.ScParser;
 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;
@@ -137,6 +151,7 @@
 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;
@@ -148,6 +163,7 @@
 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;
@@ -159,7 +175,7 @@
 /** Unit tests for {@link ManagedChannelImpl}. */
 @RunWith(JUnit4.class)
 // TODO(creamsoup) remove backward compatible check when fully migrated
-@SuppressWarnings("deprecation")
+@SuppressWarnings({"deprecation"})
 public class ManagedChannelImplTest {
   private static final int DEFAULT_PORT = 447;
 
@@ -182,6 +198,17 @@ public class ManagedChannelImplTest {
           .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() {
@@ -203,17 +230,12 @@ public String toString() {
   private final FakeClock timer = new FakeClock();
   private final FakeClock executor = new FakeClock();
   private final FakeClock balancerRpcExecutor = 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(
-              ManagedChannelImpl.DelayedNameResolverRefresh.class.getName());
-        }
-      };
 
   private final InternalChannelz channelz = new InternalChannelz();
 
+  private final MetricInstrumentRegistry metricInstrumentRegistry =
+      MetricInstrumentRegistry.getDefaultRegistry();
+
   @Rule public final MockitoRule mocks = MockitoJUnit.rule();
 
   private ManagedChannelImpl channel;
@@ -222,6 +244,8 @@ public boolean shouldAccept(Runnable command) {
   private ArgumentCaptor<Status> statusCaptor;
   @Captor
   private ArgumentCaptor<CallOptions> callOptionsCaptor;
+  @Captor
+  private ArgumentCaptor<ClientStreamTracer[]> tracersCaptor;
   @Mock
   private LoadBalancer mockLoadBalancer;
   @Mock
@@ -262,10 +286,6 @@ public String getPolicyName() {
   @Mock
   private ClientCall.Listener<Integer> mockCallListener3;
   @Mock
-  private ClientCall.Listener<Integer> mockCallListener4;
-  @Mock
-  private ClientCall.Listener<Integer> mockCallListener5;
-  @Mock
   private ObjectPool<Executor> executorPool;
   @Mock
   private ObjectPool<Executor> balancerRpcExecutorPool;
@@ -284,15 +304,25 @@ public String getPolicyName() {
       ArgumentCaptor.forClass(ClientStreamListener.class);
 
   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, new FakeBackoffPolicyProvider(),
+        channelBuilder, mockTransportFactory, wrap(expectedUri), nameResolverProvider,
+        new FakeBackoffPolicyProvider(),
         balancerRpcExecutorPool, timer.getStopwatchSupplier(), Arrays.asList(interceptors),
         timer.getTimeProvider());
 
     if (requestConnection) {
-      int numExpectedTasks = 0;
+      int numExpectedTasks = nameResolutionExpectedToFail ? 1 : 0;
 
       // Force-exit the initial idle-mode
       channel.syncContext.execute(new Runnable() {
@@ -305,13 +335,9 @@ public void run() {
         numExpectedTasks += 1;
       }
 
-      if (getNameResolverRefresh() != null) {
-        numExpectedTasks += 1;
-      }
-
       assertEquals(numExpectedTasks, timer.numPendingTasks());
 
-      ArgumentCaptor<Helper> helperCaptor = ArgumentCaptor.forClass(null);
+      ArgumentCaptor<Helper> helperCaptor = ArgumentCaptor.forClass(Helper.class);
       verify(mockLoadBalancerProvider).newLoadBalancer(helperCaptor.capture());
       helper = helperCaptor.getValue();
     }
@@ -319,7 +345,8 @@ public void run() {
 
   @Before
   public void setUp() throws Exception {
-    when(mockLoadBalancer.canHandleEmptyAddressListFromNameResolution()).thenCallRealMethod();
+    when(mockLoadBalancer.acceptResolvedAddresses(isA(ResolvedAddresses.class))).thenReturn(
+        Status.OK);
     LoadBalancerRegistry.getDefaultRegistry().register(mockLoadBalancerProvider);
     expectedUri = new URI(TARGET);
     transports = TestUtils.captureTransports(mockTransportFactory);
@@ -331,6 +358,7 @@ public void setUp() throws Exception {
 
     channelBuilder = new ManagedChannelImplBuilder(TARGET,
         new UnsupportedClientTransportFactoryBuilder(), new FixedPortProvider(DEFAULT_PORT));
+    channelBuilder.disableRetry();
     configureBuilder(channelBuilder);
   }
 
@@ -397,7 +425,8 @@ public void createSubchannel_resolverOverrideAuthority() {
     Subchannel subchannel =
         createSubchannelSafely(helper, addressGroup, Attributes.EMPTY, subchannelStateListener);
     requestConnectionSafely(helper, subchannel);
-    ArgumentCaptor<ClientTransportOptions> transportOptionCaptor = ArgumentCaptor.forClass(null);
+    ArgumentCaptor<ClientTransportOptions> transportOptionCaptor =
+        ArgumentCaptor.forClass(ClientTransportOptions.class);
     verify(mockTransportFactory)
         .newClientTransport(
             any(SocketAddress.class), transportOptionCaptor.capture(), any(ChannelLogger.class));
@@ -422,7 +451,8 @@ public void createSubchannel_channelBuilderOverrideAuthority() {
     final Subchannel subchannel =
         createSubchannelSafely(helper, addressGroup, Attributes.EMPTY, subchannelStateListener);
     requestConnectionSafely(helper, subchannel);
-    ArgumentCaptor<ClientTransportOptions> transportOptionCaptor = ArgumentCaptor.forClass(null);
+    ArgumentCaptor<ClientTransportOptions> transportOptionCaptor =
+        ArgumentCaptor.forClass(ClientTransportOptions.class);
     verify(mockTransportFactory)
         .newClientTransport(
             any(SocketAddress.class), transportOptionCaptor.capture(), any(ChannelLogger.class));
@@ -472,8 +502,11 @@ public void startCallBeforeNameResolution() throws Exception {
         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, new FakeBackoffPolicyProvider(),
+        channelBuilder, mockTransportFactory, wrap(expectedUri), nameResolverFactory,
+        new FakeBackoffPolicyProvider(),
         balancerRpcExecutorPool, timer.getStopwatchSupplier(),
         Collections.<ClientInterceptor>emptyList(), timer.getTimeProvider());
     Map<String, Object> rawServiceConfig =
@@ -489,7 +522,7 @@ channelBuilder, mockTransportFactory, new FakeBackoffPolicyProvider(),
     ClientCall<String, Integer> call = channel.newCall(method, CallOptions.DEFAULT);
     call.start(mockCallListener, headers);
 
-    ArgumentCaptor<Helper> helperCaptor = ArgumentCaptor.forClass(null);
+    ArgumentCaptor<Helper> helperCaptor = ArgumentCaptor.forClass(Helper.class);
     verify(mockLoadBalancerProvider).newLoadBalancer(helperCaptor.capture());
     helper = helperCaptor.getValue();
     // Make the transport available
@@ -505,7 +538,9 @@ channelBuilder, mockTransportFactory, new FakeBackoffPolicyProvider(),
     MockClientTransportInfo transportInfo = transports.poll();
     ConnectionClientTransport mockTransport = transportInfo.transport;
     ManagedClientTransport.Listener transportListener = transportInfo.listener;
-    when(mockTransport.newStream(same(method), same(headers), any(CallOptions.class)))
+    when(mockTransport.newStream(
+            same(method), same(headers), any(CallOptions.class),
+            ArgumentMatchers.<ClientStreamTracer[]>any()))
         .thenReturn(mockStream);
     transportListener.transportReady();
     when(mockPicker.pickSubchannel(any(PickSubchannelArgs.class)))
@@ -513,8 +548,10 @@ channelBuilder, mockTransportFactory, new FakeBackoffPolicyProvider(),
     updateBalancingStateSafely(helper, READY, mockPicker);
     executor.runDueTasks();
 
-    ArgumentCaptor<CallOptions> callOptionsCaptor = ArgumentCaptor.forClass(null);
-    verify(mockTransport).newStream(same(method), same(headers), callOptionsCaptor.capture());
+    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());
 
@@ -530,8 +567,11 @@ public void newCallWithConfigSelector() {
         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, new FakeBackoffPolicyProvider(),
+        channelBuilder, mockTransportFactory, wrap(expectedUri), nameResolverFactory,
+        new FakeBackoffPolicyProvider(),
         balancerRpcExecutorPool, timer.getStopwatchSupplier(),
         Collections.<ClientInterceptor>emptyList(), timer.getTimeProvider());
     nameResolverFactory.nextConfigOrError.set(
@@ -567,7 +607,7 @@ public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
     ClientCall<String, Integer> call = channel.newCall(method, CallOptions.DEFAULT);
     call.start(mockCallListener, headers);
 
-    ArgumentCaptor<Helper> helperCaptor = ArgumentCaptor.forClass(null);
+    ArgumentCaptor<Helper> helperCaptor = ArgumentCaptor.forClass(Helper.class);
     verify(mockLoadBalancerProvider).newLoadBalancer(helperCaptor.capture());
     helper = helperCaptor.getValue();
     // Make the transport available
@@ -580,7 +620,9 @@ public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
     MockClientTransportInfo transportInfo = transports.poll();
     ConnectionClientTransport mockTransport = transportInfo.transport;
     ManagedClientTransport.Listener transportListener = transportInfo.listener;
-    when(mockTransport.newStream(same(method), same(headers), any(CallOptions.class)))
+    when(mockTransport.newStream(
+            same(method), same(headers), any(CallOptions.class),
+            ArgumentMatchers.<ClientStreamTracer[]>any()))
         .thenReturn(mockStream);
     transportListener.transportReady();
     when(mockPicker.pickSubchannel(any(PickSubchannelArgs.class)))
@@ -588,8 +630,10 @@ public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
     updateBalancingStateSafely(helper, READY, mockPicker);
     executor.runDueTasks();
 
-    ArgumentCaptor<CallOptions> callOptionsCaptor = ArgumentCaptor.forClass(null);
-    verify(mockTransport).newStream(same(method), same(headers), callOptionsCaptor.capture());
+    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());
 
@@ -599,6 +643,74 @@ public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
         TimeUnit.SECONDS.toNanos(ManagedChannelImpl.SUBCHANNEL_SHUTDOWN_DELAY_SECONDS));
   }
 
+  @Test
+  public void pickSubchannelAddOptionalLabel_callsTracer() {
+    channelBuilder.directExecutor();
+    createChannel();
+
+    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());
+
+    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(
@@ -683,7 +795,8 @@ public void channelzMembership_subchannel() throws Exception {
     transportInfo.listener.transportReady();
 
     // terminate transport
-    transportInfo.listener.transportShutdown(Status.CANCELLED);
+    transportInfo.listener.transportShutdown(Status.CANCELLED,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
     transportInfo.listener.transportTerminated();
     assertFalse(channelz.containsClientSocket(transportInfo.transport.getLogId()));
 
@@ -701,45 +814,6 @@ public void channelzMembership_subchannel() throws Exception {
     assertNotNull(channelz.getRootChannel(channel.getLogId().getId()));
   }
 
-  @Test
-  public void channelzMembership_oob() throws Exception {
-    createChannel();
-    OobChannel oob = (OobChannel) helper.createOobChannel(addressGroup, AUTHORITY);
-    // oob channels are not root channels
-    assertNull(channelz.getRootChannel(oob.getLogId().getId()));
-    assertTrue(channelz.containsSubchannel(oob.getLogId()));
-    assertThat(getStats(channel).subchannels).containsExactly(oob);
-    assertTrue(channelz.containsSubchannel(oob.getLogId()));
-
-    AbstractSubchannel subchannel = (AbstractSubchannel) oob.getSubchannel();
-    assertTrue(
-        channelz.containsSubchannel(subchannel.getInstrumentedInternalSubchannel().getLogId()));
-    assertThat(getStats(oob).subchannels)
-        .containsExactly(subchannel.getInstrumentedInternalSubchannel());
-    assertTrue(
-        channelz.containsSubchannel(subchannel.getInstrumentedInternalSubchannel().getLogId()));
-
-    oob.getSubchannel().requestConnection();
-    MockClientTransportInfo transportInfo = transports.poll();
-    assertNotNull(transportInfo);
-    assertTrue(channelz.containsClientSocket(transportInfo.transport.getLogId()));
-
-    // terminate transport
-    transportInfo.listener.transportShutdown(Status.INTERNAL);
-    transportInfo.listener.transportTerminated();
-    assertFalse(channelz.containsClientSocket(transportInfo.transport.getLogId()));
-
-    // terminate oobchannel
-    oob.shutdown();
-    assertFalse(channelz.containsSubchannel(oob.getLogId()));
-    assertThat(getStats(channel).subchannels).isEmpty();
-    assertFalse(
-        channelz.containsSubchannel(subchannel.getInstrumentedInternalSubchannel().getLogId()));
-
-    // channel still appears
-    assertNotNull(channelz.getRootChannel(channel.getLogId().getId()));
-  }
-
   @Test
   public void callsAndShutdown() {
     subtestCallsAndShutdown(false, false);
@@ -779,16 +853,20 @@ private void subtestCallsAndShutdown(boolean shutdownNow, boolean shutdownNowAft
     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)))
+    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)))
+    when(mockTransport.newStream(
+            same(method), same(headers2), same(CallOptions.DEFAULT),
+            ArgumentMatchers.<ClientStreamTracer[]>any()))
         .thenReturn(mockStream2);
     transportListener.transportReady();
     when(mockPicker.pickSubchannel(
-        new PickSubchannelArgsImpl(method, headers, CallOptions.DEFAULT))).thenReturn(
+        eqPickSubchannelArgs(method, headers, CallOptions.DEFAULT))).thenReturn(
         PickResult.withNoResult());
     when(mockPicker.pickSubchannel(
-        new PickSubchannelArgsImpl(method, headers2, CallOptions.DEFAULT))).thenReturn(
+        eqPickSubchannelArgs(method, headers2, CallOptions.DEFAULT))).thenReturn(
         PickResult.withSubchannel(subchannel));
     updateBalancingStateSafely(helper, READY, mockPicker);
 
@@ -799,14 +877,19 @@ private void subtestCallsAndShutdown(boolean shutdownNow, boolean shutdownNowAft
             any(SocketAddress.class), any(ClientTransportOptions.class), any(ChannelLogger.class));
     call.start(mockCallListener, headers);
 
-    verify(mockTransport, never())
-        .newStream(same(method), same(headers), same(CallOptions.DEFAULT));
+    verify(mockTransport, never()).newStream(
+        same(method), same(headers), same(CallOptions.DEFAULT),
+        ArgumentMatchers.<ClientStreamTracer[]>any());
 
     // 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));
-    verify(mockTransport).newStream(same(method), same(headers2), same(CallOptions.DEFAULT));
+    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
@@ -847,11 +930,13 @@ private void subtestCallsAndShutdown(boolean shutdownNow, boolean shutdownNowAft
       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(new PickSubchannelArgsImpl(method, headers, CallOptions.DEFAULT)))
+      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));
+      verify(mockTransport).newStream(
+          same(method), same(headers), same(CallOptions.DEFAULT),
+          ArgumentMatchers.<ClientStreamTracer[]>any());
       verify(mockStream).start(any(ClientStreamListener.class));
     }
 
@@ -875,7 +960,8 @@ private void subtestCallsAndShutdown(boolean shutdownNow, boolean shutdownNowAft
     }
 
     // Killing the remaining real transport will terminate the channel
-    transportListener.transportShutdown(Status.UNAVAILABLE);
+    transportListener.transportShutdown(Status.UNAVAILABLE,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
     assertFalse(channel.isTerminated());
     verify(executorPool, never()).returnObject(any());
     transportListener.transportTerminated();
@@ -903,7 +989,7 @@ public void noMoreCallbackAfterLoadBalancerShutdown() {
 
     FakeNameResolverFactory.FakeNameResolver resolver = nameResolverFactory.resolvers.get(0);
     verify(mockLoadBalancerProvider).newLoadBalancer(any(Helper.class));
-    verify(mockLoadBalancer).handleResolvedAddresses(resolvedAddressCaptor.capture());
+    verify(mockLoadBalancer).acceptResolvedAddresses(resolvedAddressCaptor.capture());
     assertThat(resolvedAddressCaptor.getValue().getAddresses()).containsExactly(addressGroup);
 
     SubchannelStateListener stateListener1 = mock(SubchannelStateListener.class);
@@ -945,7 +1031,8 @@ public void noMoreCallbackAfterLoadBalancerShutdown() {
 
     // Since subchannels are shutdown, SubchannelStateListeners will only get SHUTDOWN regardless of
     // the transport states.
-    transportInfo1.listener.transportShutdown(Status.UNAVAILABLE);
+    transportInfo1.listener.transportShutdown(Status.UNAVAILABLE,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
     transportInfo2.listener.transportReady();
     verify(stateListener1).onSubchannelState(ConnectivityStateInfo.forNonError(SHUTDOWN));
     verify(stateListener2).onSubchannelState(ConnectivityStateInfo.forNonError(SHUTDOWN));
@@ -957,6 +1044,131 @@ public void noMoreCallbackAfterLoadBalancerShutdown() {
     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 {
     final AtomicLong atomic = new AtomicLong();
@@ -1000,7 +1212,9 @@ public void callOptionsExecutor() {
     MockClientTransportInfo transportInfo = transports.poll();
     ConnectionClientTransport mockTransport = transportInfo.transport;
     ManagedClientTransport.Listener transportListener = transportInfo.listener;
-    when(mockTransport.newStream(same(method), same(headers), any(CallOptions.class)))
+    when(mockTransport.newStream(
+            same(method), same(headers), any(CallOptions.class),
+            ArgumentMatchers.<ClientStreamTracer[]>any()))
         .thenReturn(mockStream);
     transportListener.transportReady();
     when(mockPicker.pickSubchannel(any(PickSubchannelArgs.class)))
@@ -1010,20 +1224,22 @@ public void callOptionsExecutor() {
 
     // 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));
+    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));
 
 
-    transportListener.transportShutdown(Status.UNAVAILABLE);
+    transportListener.transportShutdown(Status.UNAVAILABLE,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
     transportListener.transportTerminated();
 
     // Clean up as much as possible to allow the channel to terminate.
@@ -1033,206 +1249,113 @@ public void callOptionsExecutor() {
   }
 
   @Test
-  public void nameResolutionFailed() {
-    Status error = Status.UNAVAILABLE.withCause(new Throwable("fake name resolution error"));
+  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)))
-            .setError(error)
             .build();
     channelBuilder.nameResolverFactory(nameResolverFactory);
-    // Name resolution is started as soon as channel is created.
     createChannel();
-    FakeNameResolverFactory.FakeNameResolver resolver = nameResolverFactory.resolvers.get(0);
-    verify(mockLoadBalancer).handleNameResolutionError(same(error));
-    assertEquals(1, timer.numPendingTasks(NAME_RESOLVER_REFRESH_TASK_FILTER));
-
-    timer.forwardNanos(RECONNECT_BACKOFF_INTERVAL_NANOS - 1);
-    assertEquals(0, resolver.refreshCalled);
-
-    timer.forwardNanos(1);
-    assertEquals(1, resolver.refreshCalled);
-    verify(mockLoadBalancer, times(2)).handleNameResolutionError(same(error));
-
-    // Verify an additional name resolution failure does not schedule another timer
-    resolver.refresh();
-    verify(mockLoadBalancer, times(3)).handleNameResolutionError(same(error));
-    assertEquals(1, timer.numPendingTasks(NAME_RESOLVER_REFRESH_TASK_FILTER));
 
-    // Allow the next refresh attempt to succeed
-    resolver.error = null;
+    verify(mockLoadBalancerProvider).newLoadBalancer(any(Helper.class));
+    doThrow(ex).when(mockLoadBalancer).acceptResolvedAddresses(any(ResolvedAddresses.class));
 
-    // For the second attempt, the backoff should occur at RECONNECT_BACKOFF_INTERVAL_NANOS * 2
-    timer.forwardNanos(RECONNECT_BACKOFF_INTERVAL_NANOS * 2 - 1);
-    assertEquals(2, resolver.refreshCalled);
-    timer.forwardNanos(1);
-    assertEquals(3, resolver.refreshCalled);
-    assertEquals(0, timer.numPendingTasks());
+    // NameResolver returns addresses.
+    nameResolverFactory.allResolved();
 
-    // Verify that the successful resolution reset the backoff policy
-    resolver.listener.onError(error);
-    timer.forwardNanos(RECONNECT_BACKOFF_INTERVAL_NANOS - 1);
-    assertEquals(3, resolver.refreshCalled);
-    timer.forwardNanos(1);
-    assertEquals(4, resolver.refreshCalled);
-    assertEquals(0, timer.numPendingTasks());
+    // Exception thrown from balancer is caught by ChannelExecutor, making channel enter panic mode.
+    verifyPanicMode(ex);
   }
 
   @Test
-  public void nameResolutionFailed_delayedTransportShutdownCancelsBackoff() {
-    Status error = Status.UNAVAILABLE.withCause(new Throwable("fake name resolution error"));
-
-    FakeNameResolverFactory nameResolverFactory =
-        new FakeNameResolverFactory.Builder(expectedUri).setError(error).build();
-    channelBuilder.nameResolverFactory(nameResolverFactory);
-    // Name resolution is started as soon as channel is created.
+  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();
-    verify(mockLoadBalancer).handleNameResolutionError(same(error));
-
-    FakeClock.ScheduledTask nameResolverBackoff = getNameResolverRefresh();
-    assertNotNull(nameResolverBackoff);
-    assertFalse(nameResolverBackoff.isCancelled());
 
-    // Add a pending call to the delayed transport
-    ClientCall<String, Integer> call = channel.newCall(method, CallOptions.DEFAULT);
-    Metadata headers = new Metadata();
-    call.start(mockCallListener, headers);
+    CallOptions callOptions = CallOptions.DEFAULT.withStreamTracerFactory(factory);
+    ClientCall<String, Integer> call = channel.newCall(method, callOptions);
+    call.start(mockCallListener, new Metadata());
 
-    // The pending call on the delayed transport stops the name resolver backoff from cancelling
-    channel.shutdown();
-    assertFalse(nameResolverBackoff.isCancelled());
+    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));
 
-    // Notify that a subchannel is ready, which drains the delayed transport
-    SubchannelPicker picker = mock(SubchannelPicker.class);
-    Status status = Status.UNAVAILABLE.withDescription("for test");
-    when(picker.pickSubchannel(any(PickSubchannelArgs.class)))
-        .thenReturn(PickResult.withDrop(status));
-    updateBalancingStateSafely(helper, READY, picker);
-    executor.runDueTasks();
-    verify(mockCallListener).onClose(same(status), any(Metadata.class));
+    updateBalancingStateSafely(helper, READY, mockPicker);
+    assertEquals(3, executor.runDueTasks());
 
-    assertTrue(nameResolverBackoff.isCancelled());
+    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 nameResolverReturnsEmptySubLists_becomeErrorByDefault() throws Exception {
-    String errorDescription = "NameResolver returned no usable address";
-
-    // Pass a FakeNameResolverFactory with an empty list and LB config
+  public void nameResolvedAfterChannelShutdown() {
+    // Delay the success of name resolution until allResolved() is called.
     FakeNameResolverFactory nameResolverFactory =
-        new FakeNameResolverFactory.Builder(expectedUri).build();
-    Map<String, Object> rawServiceConfig =
-        parseConfig("{\"loadBalancingConfig\": [ {\"mock_lb\": { \"setting1\": \"high\" } } ] }");
-    ManagedChannelServiceConfig parsedServiceConfig =
-        createManagedChannelServiceConfig(rawServiceConfig, null);
-    nameResolverFactory.nextConfigOrError.set(ConfigOrError.fromConfig(parsedServiceConfig));
+        new FakeNameResolverFactory.Builder(expectedUri).setResolvedAtStart(false).build();
     channelBuilder.nameResolverFactory(nameResolverFactory);
     createChannel();
 
-    // LoadBalancer received the error
-    verify(mockLoadBalancerProvider).newLoadBalancer(any(Helper.class));
-    verify(mockLoadBalancer).handleNameResolutionError(statusCaptor.capture());
-    Status status = statusCaptor.getValue();
-    assertSame(Status.Code.UNAVAILABLE, status.getCode());
-    assertThat(status.getDescription()).startsWith(errorDescription);
+    channel.shutdown();
 
-    // A resolution retry has been scheduled
-    assertEquals(1, timer.numPendingTasks(NAME_RESOLVER_REFRESH_TASK_FILTER));
+    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 nameResolverReturnsEmptySubLists_optionallyAllowed() throws Exception {
-    when(mockLoadBalancer.canHandleEmptyAddressListFromNameResolution()).thenReturn(true);
+  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";
+        }
+      };
+    InOrder inOrder = inOrder(mockLoadBalancer, subchannelStateListener);
 
-    // Pass a FakeNameResolverFactory with an empty list and LB config
-    FakeNameResolverFactory nameResolverFactory =
-        new FakeNameResolverFactory.Builder(expectedUri).build();
-    String rawLbConfig = "{ \"setting1\": \"high\" }";
-    Object parsedLbConfig = new Object();
-    Map<String, Object> rawServiceConfig =
-        parseConfig("{\"loadBalancingConfig\": [ {\"mock_lb\": " + rawLbConfig + " } ] }");
-    ManagedChannelServiceConfig parsedServiceConfig =
-        createManagedChannelServiceConfig(
-            rawServiceConfig,
-            new PolicySelection(
-                mockLoadBalancerProvider,
-                parsedLbConfig));
-    nameResolverFactory.nextConfigOrError.set(ConfigOrError.fromConfig(parsedServiceConfig));
-    channelBuilder.nameResolverFactory(nameResolverFactory);
-    createChannel();
-
-    // LoadBalancer received the empty list and the LB config
-    verify(mockLoadBalancerProvider).newLoadBalancer(any(Helper.class));
-    ArgumentCaptor<ResolvedAddresses> resultCaptor =
-        ArgumentCaptor.forClass(ResolvedAddresses.class);
-    verify(mockLoadBalancer).handleResolvedAddresses(resultCaptor.capture());
-    assertThat(resultCaptor.getValue().getAddresses()).isEmpty();
-    assertThat(resultCaptor.getValue().getLoadBalancingPolicyConfig()).isEqualTo(parsedLbConfig);
-
-    // A no resolution retry
-    assertEquals(0, timer.numPendingTasks(NAME_RESOLVER_REFRESH_TASK_FILTER));
-  }
-
-  @Test
-  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();
-
-    verify(mockLoadBalancerProvider).newLoadBalancer(any(Helper.class));
-    doThrow(ex).when(mockLoadBalancer).handleResolvedAddresses(any(ResolvedAddresses.class));
-
-    // NameResolver returns addresses.
-    nameResolverFactory.allResolved();
-
-    // Exception thrown from balancer is caught by ChannelExecutor, making channel enter panic mode.
-    verifyPanicMode(ex);
-  }
-
-  @Test
-  public void nameResolvedAfterChannelShutdown() {
-    // Delay the success of name resolution until allResolved() is called.
-    FakeNameResolverFactory nameResolverFactory =
-        new FakeNameResolverFactory.Builder(expectedUri).setResolvedAtStart(false).build();
-    channelBuilder.nameResolverFactory(nameResolverFactory);
-    createChannel();
-
-    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";
-        }
-      };
-    InOrder inOrder = inOrder(mockLoadBalancer, subchannelStateListener);
-
-    List<SocketAddress> resolvedAddrs = Arrays.asList(badAddress, goodAddress);
+    List<SocketAddress> resolvedAddrs = Arrays.asList(badAddress, goodAddress);
     FakeNameResolverFactory nameResolverFactory =
         new FakeNameResolverFactory.Builder(expectedUri)
             .setServers(Collections.singletonList(new EquivalentAddressGroup(resolvedAddrs)))
@@ -1248,7 +1371,7 @@ public void firstResolvedServerFailedToConnect() throws Exception {
 
     // Simulate name resolution results
     EquivalentAddressGroup addressGroup = new EquivalentAddressGroup(resolvedAddrs);
-    inOrder.verify(mockLoadBalancer).handleResolvedAddresses(resolvedAddressCaptor.capture());
+    inOrder.verify(mockLoadBalancer).acceptResolvedAddresses(resolvedAddressCaptor.capture());
     assertThat(resolvedAddressCaptor.getValue().getAddresses()).containsExactly(addressGroup);
     Subchannel subchannel =
         createSubchannelSafely(helper, addressGroup, Attributes.EMPTY, subchannelStateListener);
@@ -1268,7 +1391,8 @@ public void firstResolvedServerFailedToConnect() throws Exception {
 
     MockClientTransportInfo badTransportInfo = transports.poll();
     // Which failed to connect
-    badTransportInfo.listener.transportShutdown(Status.UNAVAILABLE);
+    badTransportInfo.listener.transportShutdown(Status.UNAVAILABLE,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
     inOrder.verifyNoMoreInteractions();
 
     // The channel then try the second address (goodAddress)
@@ -1277,7 +1401,8 @@ public void firstResolvedServerFailedToConnect() throws Exception {
             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)))
+            any(MethodDescriptor.class), any(Metadata.class), any(CallOptions.class),
+            ArgumentMatchers.<ClientStreamTracer[]>any()))
         .thenReturn(mock(ClientStream.class));
 
     goodTransportInfo.listener.transportReady();
@@ -1289,11 +1414,13 @@ public void firstResolvedServerFailedToConnect() throws Exception {
     // Delayed transport uses the app executor to create real streams.
     executor.runDueTasks();
 
-    verify(goodTransportInfo.transport).newStream(same(method), same(headers),
-        same(CallOptions.DEFAULT));
+    verify(goodTransportInfo.transport).newStream(
+        same(method), same(headers), same(CallOptions.DEFAULT),
+        ArgumentMatchers.<ClientStreamTracer[]>any());
     // The bad transport was never used.
-    verify(badTransportInfo.transport, times(0)).newStream(any(MethodDescriptor.class),
-        any(Metadata.class), any(CallOptions.class));
+    verify(badTransportInfo.transport, times(0)).newStream(
+        any(MethodDescriptor.class), any(Metadata.class), any(CallOptions.class),
+        ArgumentMatchers.<ClientStreamTracer[]>any());
   }
 
   @Test
@@ -1395,7 +1522,7 @@ public void allServersFailedToConnect() throws Exception {
 
     // Simulate name resolution results
     EquivalentAddressGroup addressGroup = new EquivalentAddressGroup(resolvedAddrs);
-    inOrder.verify(mockLoadBalancer).handleResolvedAddresses(resolvedAddressCaptor.capture());
+    inOrder.verify(mockLoadBalancer).acceptResolvedAddresses(resolvedAddressCaptor.capture());
     assertThat(resolvedAddressCaptor.getValue().getAddresses()).containsExactly(addressGroup);
 
     Subchannel subchannel =
@@ -1415,7 +1542,8 @@ public void allServersFailedToConnect() throws Exception {
         .newClientTransport(
             same(addr2), any(ClientTransportOptions.class), any(ChannelLogger.class));
     MockClientTransportInfo transportInfo1 = transports.poll();
-    transportInfo1.listener.transportShutdown(Status.UNAVAILABLE);
+    transportInfo1.listener.transportShutdown(Status.UNAVAILABLE,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
 
     // Connecting to server2, which will fail too
     verify(mockTransportFactory)
@@ -1423,7 +1551,8 @@ public void allServersFailedToConnect() throws Exception {
             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);
+    transportInfo2.listener.transportShutdown(server2Error,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
 
     // ... which makes the subchannel enter TRANSIENT_FAILURE. The last error Status is propagated
     // to LoadBalancer.
@@ -1443,10 +1572,12 @@ public void allServersFailedToConnect() throws Exception {
     // ... 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));
-    verify(transportInfo2.transport, times(0))
-        .newStream(any(MethodDescriptor.class), any(Metadata.class), any(CallOptions.class));
+    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
@@ -1531,9 +1662,11 @@ public void run() {
     verify(transportInfo2.transport).shutdown(same(ManagedChannelImpl.SHUTDOWN_STATUS));
 
     // Cleanup
-    transportInfo1.listener.transportShutdown(Status.UNAVAILABLE);
+    transportInfo1.listener.transportShutdown(Status.UNAVAILABLE,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
     transportInfo1.listener.transportTerminated();
-    transportInfo2.listener.transportShutdown(Status.UNAVAILABLE);
+    transportInfo2.listener.transportShutdown(Status.UNAVAILABLE,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
     transportInfo2.listener.transportTerminated();
     timer.forwardTime(ManagedChannelImpl.SUBCHANNEL_SHUTDOWN_DELAY_SECONDS, TimeUnit.SECONDS);
   }
@@ -1573,8 +1706,10 @@ public void subchannelsWhenChannelShutdownNow() {
     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.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());
@@ -1601,6 +1736,19 @@ public void subchannelsNoConnectionShutdown() {
             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();
@@ -1609,7 +1757,7 @@ public void subchannelsNoConnectionShutdownNow() {
     channel.shutdownNow();
 
     verify(mockLoadBalancer).shutdown();
-    // Channel's shutdownNow() will call shutdownNow() on all subchannels and oobchannels.
+    // 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())
@@ -1617,109 +1765,6 @@ public void subchannelsNoConnectionShutdownNow() {
             any(SocketAddress.class), any(ClientTransportOptions.class), any(ChannelLogger.class));
   }
 
-  @Test
-  public void oobchannels() {
-    createChannel();
-
-    ManagedChannel oob1 = helper.createOobChannel(addressGroup, "oob1authority");
-    ManagedChannel oob2 = helper.createOobChannel(addressGroup, "oob2authority");
-    verify(balancerRpcExecutorPool, 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(
-            eq(socketAddress),
-            eq(new ClientTransportOptions().setAuthority("oob1authority").setUserAgent(USER_AGENT)),
-            isA(ChannelLogger.class));
-    MockClientTransportInfo transportInfo = transports.poll();
-    assertNotNull(transportInfo);
-
-    assertEquals(0, balancerRpcExecutor.numPendingTasks());
-    transportInfo.listener.transportReady();
-    assertEquals(1, balancerRpcExecutor.runDueTasks());
-    verify(transportInfo.transport).newStream(same(method), same(headers),
-        same(CallOptions.DEFAULT));
-
-    // 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(
-        eq(socketAddress),
-        eq(new ClientTransportOptions().setAuthority("oob1authority").setUserAgent(USER_AGENT)),
-        isA(ChannelLogger.class));
-    transportInfo = transports.poll();
-    assertNotNull(transportInfo);
-
-    // This transport fails
-    Status transportError = Status.UNAVAILABLE.withDescription("Connection refused");
-    assertEquals(0, balancerRpcExecutor.numPendingTasks());
-    transportInfo.listener.transportShutdown(transportError);
-    assertTrue(balancerRpcExecutor.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();
-    oob2.shutdownNow();
-    assertTrue(oob1.isShutdown());
-    assertTrue(oob2.isShutdown());
-    assertTrue(oob2.isTerminated());
-    verify(balancerRpcExecutorPool).returnObject(balancerRpcExecutor.getScheduledExecutorService());
-
-    // New RPCs will be rejected.
-    assertEquals(0, balancerRpcExecutor.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(balancerRpcExecutor.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, balancerRpcExecutor.numPendingTasks());
-    oob1.shutdownNow();
-    assertTrue(balancerRpcExecutor.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(balancerRpcExecutorPool).returnObject(balancerRpcExecutor.getScheduledExecutorService());
-    transportInfo.listener.transportTerminated();
-    assertTrue(oob1.isTerminated());
-    assertTrue(channel.isTerminated());
-    verify(balancerRpcExecutorPool, times(2))
-        .returnObject(balancerRpcExecutor.getScheduledExecutorService());
-  }
-
   @Test
   public void oobChannelHasNoChannelCallCredentials() {
     Metadata.Key<String> metadataKey =
@@ -1729,6 +1774,7 @@ public void oobChannelHasNoChannelCallCredentials() {
         TARGET, InsecureChannelCredentials.create(),
         new FakeCallCredentials(metadataKey, channelCredValue),
         new UnsupportedClientTransportFactoryBuilder(), new FixedPortProvider(DEFAULT_PORT));
+    channelBuilder.disableRetry();
     configureBuilder(channelBuilder);
     createChannel();
 
@@ -1750,12 +1796,15 @@ public void oobChannelHasNoChannelCallCredentials() {
     ClientCall<String, Integer> call = channel.newCall(method, callOptions);
     call.start(mockCallListener, headers);
 
-    verify(transportInfo.transport).newStream(same(method), same(headers), same(callOptions));
+    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(addressGroup, "oobauthority");
+    ManagedChannel oob = helper.createOobChannel(
+        Collections.singletonList(addressGroup), "oobauthority");
 
     headers = new Metadata();
     call = oob.newCall(method, callOptions);
@@ -1766,16 +1815,19 @@ public void oobChannelHasNoChannelCallCredentials() {
     transportInfo.listener.transportReady();
     balancerRpcExecutor.runDueTasks();
 
-    verify(transportInfo.transport).newStream(same(method), same(headers), same(callOptions));
+    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("oobauthority")).build())
+            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);
@@ -1798,7 +1850,9 @@ public void oobChannelHasNoChannelCallCredentials() {
     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));
+    verify(transportInfo.transport).newStream(
+        same(method), same(headers), any(CallOptions.class),
+        ArgumentMatchers.<ClientStreamTracer[]>any());
     assertThat(headers.getAll(metadataKey)).containsExactly(callCredValue);
     oob.shutdownNow();
   }
@@ -1821,6 +1875,7 @@ public SwapChannelCredentialsResult answer(InvocationOnMock invocation) {
         TARGET, InsecureChannelCredentials.create(),
         new FakeCallCredentials(metadataKey, channelCredValue),
         new UnsupportedClientTransportFactoryBuilder(), new FixedPortProvider(DEFAULT_PORT));
+    channelBuilder.disableRetry();
     configureBuilder(channelBuilder);
     createChannel();
 
@@ -1841,7 +1896,9 @@ public SwapChannelCredentialsResult answer(InvocationOnMock invocation) {
     ClientCall<String, Integer> call = channel.newCall(method, callOptions);
     call.start(mockCallListener, headers);
 
-    verify(transportInfo.transport).newStream(same(method), same(headers), same(callOptions));
+    verify(transportInfo.transport).newStream(
+        same(method), same(headers), same(callOptions),
+        ArgumentMatchers.<ClientStreamTracer[]>any());
     assertThat(headers.getAll(metadataKey))
         .containsExactly(channelCredValue, callCredValue).inOrder();
 
@@ -1856,6 +1913,7 @@ public SwapChannelCredentialsResult answer(InvocationOnMock invocation) {
             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);
@@ -1877,76 +1935,14 @@ public SwapChannelCredentialsResult answer(InvocationOnMock invocation) {
     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));
+    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 oobChannelsWhenChannelShutdownNow() {
-    createChannel();
-    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());
-
-    assertThat(transports).hasSize(2);
-    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();
-    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), any(ClientTransportOptions.class), any(ChannelLogger.class));
-  }
-
-  @Test
-  public void oobChannelsNoConnectionShutdownNow() {
-    createChannel();
-    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), any(ClientTransportOptions.class), any(ChannelLogger.class));
-  }
-
   @Test
   public void subchannelChannel_normalUsage() {
     createChannel();
@@ -1972,7 +1968,9 @@ public void subchannelChannel_normalUsage() {
 
     ClientCall<String, Integer> call = sChannel.newCall(method, callOptions);
     call.start(mockCallListener, headers);
-    verify(mockTransport).newStream(same(method), same(headers), callOptionsCaptor.capture());
+    verify(mockTransport).newStream(
+        same(method), same(headers), callOptionsCaptor.capture(),
+        ArgumentMatchers.<ClientStreamTracer[]>any());
 
     CallOptions capturedCallOption = callOptionsCaptor.getValue();
     assertThat(capturedCallOption.getDeadline()).isSameInstanceAs(callOptions.getDeadline());
@@ -2000,7 +1998,8 @@ public void subchannelChannel_failWhenNotReady() {
     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));
+        any(MethodDescriptor.class), any(Metadata.class), any(CallOptions.class),
+        ArgumentMatchers.<ClientStreamTracer[]>any());
 
     verifyNoInteractions(mockCallListener);
     assertEquals(1, balancerRpcExecutor.runDueTasks());
@@ -2032,7 +2031,8 @@ public void subchannelChannel_failWaitForReady() {
         sChannel.newCall(method, CallOptions.DEFAULT.withWaitForReady());
     call.start(mockCallListener, headers);
     verify(mockTransport, never()).newStream(
-        any(MethodDescriptor.class), any(Metadata.class), any(CallOptions.class));
+        any(MethodDescriptor.class), any(Metadata.class), any(CallOptions.class),
+        ArgumentMatchers.<ClientStreamTracer[]>any());
 
     verifyNoInteractions(mockCallListener);
     assertEquals(1, balancerRpcExecutor.runDueTasks());
@@ -2077,101 +2077,15 @@ public void lbHelper_getNameResolverArgs() {
     assertThat(args.getSynchronizationContext())
         .isSameInstanceAs(helper.getSynchronizationContext());
     assertThat(args.getServiceConfigParser()).isNotNull();
+    assertThat(args.getMetricRecorder()).isNotNull();
   }
 
   @Test
-  public void lbHelper_getNameResolverRegistry() {
+  public void lbHelper_getNonDefaultNameResolverRegistry() {
     createChannel();
 
     assertThat(helper.getNameResolverRegistry())
-        .isSameInstanceAs(NameResolverRegistry.getDefaultRegistry());
-  }
-
-  @Test
-  public void refreshNameResolution_whenSubchannelConnectionFailed_notIdle() {
-    subtestNameResolutionRefreshWhenConnectionFailed(false, false);
-  }
-
-  @Test
-  public void refreshNameResolution_whenOobChannelConnectionFailed_notIdle() {
-    subtestNameResolutionRefreshWhenConnectionFailed(true, false);
-  }
-
-  @Test
-  public void notRefreshNameResolution_whenSubchannelConnectionFailed_idle() {
-    subtestNameResolutionRefreshWhenConnectionFailed(false, true);
-  }
-
-  @Test
-  public void notRefreshNameResolution_whenOobChannelConnectionFailed_idle() {
-    subtestNameResolutionRefreshWhenConnectionFailed(true, true);
-  }
-
-  private void subtestNameResolutionRefreshWhenConnectionFailed(
-      boolean isOobChannel, boolean isIdle) {
-    FakeNameResolverFactory nameResolverFactory =
-        new FakeNameResolverFactory.Builder(expectedUri)
-            .setServers(Collections.singletonList(new EquivalentAddressGroup(socketAddress)))
-            .build();
-    channelBuilder.nameResolverFactory(nameResolverFactory);
-    createChannel();
-    if (isOobChannel) {
-      OobChannel oobChannel = (OobChannel) helper.createOobChannel(addressGroup, "oobAuthority");
-      oobChannel.getSubchannel().requestConnection();
-    } else {
-      Subchannel subchannel =
-          createSubchannelSafely(helper, addressGroup, Attributes.EMPTY, subchannelStateListener);
-      requestConnectionSafely(helper, subchannel);
-    }
-
-    MockClientTransportInfo transportInfo = transports.poll();
-    assertNotNull(transportInfo);
-
-    FakeNameResolverFactory.FakeNameResolver resolver = nameResolverFactory.resolvers.remove(0);
-
-    if (isIdle) {
-      channel.enterIdle();
-      // Entering idle mode will result in a new resolver
-      resolver = nameResolverFactory.resolvers.remove(0);
-    }
-
-    assertEquals(0, nameResolverFactory.resolvers.size());
-
-    int expectedRefreshCount = 0;
-
-    // Transport closed when connecting
-    assertEquals(expectedRefreshCount, resolver.refreshCalled);
-    transportInfo.listener.transportShutdown(Status.UNAVAILABLE);
-    // When channel enters idle, new resolver is created but not started.
-    if (!isIdle) {
-      expectedRefreshCount++;
-    }
-    assertEquals(expectedRefreshCount, resolver.refreshCalled);
-
-    timer.forwardNanos(RECONNECT_BACKOFF_INTERVAL_NANOS);
-    transportInfo = transports.poll();
-    assertNotNull(transportInfo);
-
-    transportInfo.listener.transportReady();
-
-    // Transport closed when ready
-    assertEquals(expectedRefreshCount, resolver.refreshCalled);
-    transportInfo.listener.transportShutdown(Status.UNAVAILABLE);
-    // When channel enters idle, new resolver is created but not started.
-    if (!isIdle) {
-      expectedRefreshCount++;
-    }
-    assertEquals(expectedRefreshCount, resolver.refreshCalled);
-  }
-
-  @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
+        .isNotSameInstanceAs(NameResolverRegistry.getDefaultRegistry());
   }
 
   /**
@@ -2223,7 +2137,8 @@ public ClientStream answer(InvocationOnMock in) throws Throwable {
           return mock(ClientStream.class);
         }
       }).when(transport).newStream(
-          any(MethodDescriptor.class), any(Metadata.class), any(CallOptions.class));
+          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));
@@ -2234,19 +2149,26 @@ public ClientStream answer(InvocationOnMock in) throws Throwable {
         .thenReturn(PickResult.withSubchannel(subchannel));
     updateBalancingStateSafely(helper, READY, mockPicker);
     executor.runDueTasks();
-    ArgumentCaptor<RequestInfo> infoCaptor = ArgumentCaptor.forClass(null);
-    ArgumentCaptor<CallCredentials.MetadataApplier> applierCaptor = ArgumentCaptor.forClass(null);
+    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(),
-        same(executor.getScheduledExecutorService()), applierCaptor.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));
+        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));
+    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());
@@ -2259,17 +2181,22 @@ public ClientStream answer(InvocationOnMock in) throws Throwable {
     call.start(mockCallListener, new Metadata());
 
     verify(creds, times(2)).applyRequestMetadata(infoCaptor.capture(),
-        same(executor.getScheduledExecutorService()), applierCaptor.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));
+        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));
+    verify(transport, times(2)).newStream(
+        same(method), any(Metadata.class), same(callOptions),
+        ArgumentMatchers.<ClientStreamTracer[]>any());
     assertEquals("testValue", testKey.get(newStreamContexts.poll()));
 
     assertNull(testKey.get());
@@ -2278,8 +2205,20 @@ public ClientStream answer(InvocationOnMock in) throws Throwable {
   @Test
   public void pickerReturnsStreamTracer_noDelay() {
     ClientStream mockStream = mock(ClientStream.class);
-    ClientStreamTracer.Factory factory1 = mock(ClientStreamTracer.Factory.class);
-    ClientStreamTracer.Factory factory2 = mock(ClientStreamTracer.Factory.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);
@@ -2288,7 +2227,8 @@ public void pickerReturnsStreamTracer_noDelay() {
     transportInfo.listener.transportReady();
     ClientTransport mockTransport = transportInfo.transport;
     when(mockTransport.newStream(
-            any(MethodDescriptor.class), any(Metadata.class), any(CallOptions.class)))
+            any(MethodDescriptor.class), any(Metadata.class), any(CallOptions.class),
+            ArgumentMatchers.<ClientStreamTracer[]>any()))
         .thenReturn(mockStream);
 
     when(mockPicker.pickSubchannel(any(PickSubchannelArgs.class))).thenReturn(
@@ -2300,20 +2240,29 @@ public void pickerReturnsStreamTracer_noDelay() {
     call.start(mockCallListener, new Metadata());
 
     verify(mockPicker).pickSubchannel(any(PickSubchannelArgs.class));
-    verify(mockTransport).newStream(same(method), any(Metadata.class), callOptionsCaptor.capture());
-    assertEquals(
-        Arrays.asList(factory1, factory2),
-        callOptionsCaptor.getValue().getStreamTracerFactories());
-    // The factories are safely not stubbed because we do not expect any usage of them.
-    verifyNoInteractions(factory1);
-    verifyNoInteractions(factory2);
+    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);
-    ClientStreamTracer.Factory factory1 = mock(ClientStreamTracer.Factory.class);
-    ClientStreamTracer.Factory factory2 = mock(ClientStreamTracer.Factory.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);
@@ -2327,7 +2276,8 @@ public void pickerReturnsStreamTracer_delayed() {
     transportInfo.listener.transportReady();
     ClientTransport mockTransport = transportInfo.transport;
     when(mockTransport.newStream(
-            any(MethodDescriptor.class), any(Metadata.class), any(CallOptions.class)))
+            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));
@@ -2336,13 +2286,10 @@ public void pickerReturnsStreamTracer_delayed() {
     assertEquals(1, executor.runDueTasks());
 
     verify(mockPicker).pickSubchannel(any(PickSubchannelArgs.class));
-    verify(mockTransport).newStream(same(method), any(Metadata.class), callOptionsCaptor.capture());
-    assertEquals(
-        Arrays.asList(factory1, factory2),
-        callOptionsCaptor.getValue().getStreamTracerFactories());
-    // The factories are safely not stubbed because we do not expect any usage of them.
-    verifyNoInteractions(factory1);
-    verifyNoInteractions(factory2);
+    verify(mockTransport).newStream(
+        same(method), any(Metadata.class), callOptionsCaptor.capture(),
+        tracersCaptor.capture());
+    assertThat(tracersCaptor.getValue()).isEqualTo(new ClientStreamTracer[] {tracer1, tracer2});
   }
 
   @Test
@@ -2350,7 +2297,7 @@ public void getState_loadBalancerSupportsChannelState() {
     channelBuilder.nameResolverFactory(
         new FakeNameResolverFactory.Builder(expectedUri).setResolvedAtStart(false).build());
     createChannel();
-    assertEquals(IDLE, channel.getState(false));
+    assertEquals(CONNECTING, channel.getState(false));
 
     updateBalancingStateSafely(helper, TRANSIENT_FAILURE, mockPicker);
     assertEquals(TRANSIENT_FAILURE, channel.getState(false));
@@ -2368,7 +2315,7 @@ public void getState_withRequestConnect() {
 
     // call getState() with requestConnection = true
     assertEquals(IDLE, channel.getState(true));
-    ArgumentCaptor<Helper> helperCaptor = ArgumentCaptor.forClass(null);
+    ArgumentCaptor<Helper> helperCaptor = ArgumentCaptor.forClass(Helper.class);
     verify(mockLoadBalancerProvider).newLoadBalancer(helperCaptor.capture());
     helper = helperCaptor.getValue();
 
@@ -2390,7 +2337,6 @@ public void getState_withRequestConnect_IdleWithLbRunning() {
 
     assertEquals(IDLE, channel.getState(true));
     verify(mockLoadBalancerProvider).newLoadBalancer(any(Helper.class));
-    verify(mockPicker).requestConnection();
     verify(mockLoadBalancer).requestConnection();
   }
 
@@ -2407,21 +2353,21 @@ public void run() {
     channelBuilder.nameResolverFactory(
         new FakeNameResolverFactory.Builder(expectedUri).setResolvedAtStart(false).build());
     createChannel();
-    assertEquals(IDLE, channel.getState(false));
+    assertEquals(CONNECTING, channel.getState(false));
 
-    channel.notifyWhenStateChanged(IDLE, onStateChanged);
+    channel.notifyWhenStateChanged(CONNECTING, onStateChanged);
     executor.runDueTasks();
     assertFalse(stateChanged.get());
 
-    // state change from IDLE to CONNECTING
-    updateBalancingStateSafely(helper, CONNECTING, mockPicker);
+    // state change from CONNECTING to IDLE
+    updateBalancingStateSafely(helper, IDLE, mockPicker);
     // onStateChanged callback should run
     executor.runDueTasks();
     assertTrue(stateChanged.get());
 
-    // clear and test form CONNECTING
+    // clear and test form IDLE
     stateChanged.set(false);
-    channel.notifyWhenStateChanged(IDLE, onStateChanged);
+    channel.notifyWhenStateChanged(CONNECTING, onStateChanged);
     // onStateChanged callback should run immediately
     executor.runDueTasks();
     assertTrue(stateChanged.get());
@@ -2440,8 +2386,8 @@ public void run() {
     channelBuilder.nameResolverFactory(
         new FakeNameResolverFactory.Builder(expectedUri).setResolvedAtStart(false).build());
     createChannel();
-    assertEquals(IDLE, channel.getState(false));
-    channel.notifyWhenStateChanged(IDLE, onStateChanged);
+    assertEquals(CONNECTING, channel.getState(false));
+    channel.notifyWhenStateChanged(CONNECTING, onStateChanged);
     executor.runDueTasks();
     assertFalse(stateChanged.get());
 
@@ -2464,9 +2410,6 @@ public void stateIsIdleOnIdleTimeout() {
     long idleTimeoutMillis = 2000L;
     channelBuilder.idleTimeout(idleTimeoutMillis, TimeUnit.MILLISECONDS);
     createChannel();
-    assertEquals(IDLE, channel.getState(false));
-
-    updateBalancingStateSafely(helper, CONNECTING, mockPicker);
     assertEquals(CONNECTING, channel.getState(false));
 
     timer.forwardNanos(TimeUnit.MILLISECONDS.toNanos(idleTimeoutMillis));
@@ -2612,6 +2555,40 @@ public void run() {
     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")
@@ -2631,7 +2608,7 @@ private void verifyPanicMode(Throwable cause) {
 
   private void verifyCallListenerClosed(
       ClientCall.Listener<Integer> listener, Status.Code code, Throwable cause) {
-    ArgumentCaptor<Status> captor = ArgumentCaptor.forClass(null);
+    ArgumentCaptor<Status> captor = ArgumentCaptor.forClass(Status.class);
     verify(listener).onClose(captor.capture(), any(Metadata.class));
     Status rpcStatus = captor.getValue();
     assertEquals(code, rpcStatus.getCode());
@@ -2655,11 +2632,11 @@ public void idleTimeoutAndReconnect() {
 
     // Updating on the old helper (whose balancer has been shutdown) does not change the channel
     // state.
-    updateBalancingStateSafely(helper, CONNECTING, mockPicker);
-    assertEquals(IDLE, channel.getState(false));
-
-    updateBalancingStateSafely(helper2, CONNECTING, mockPicker);
+    updateBalancingStateSafely(helper, IDLE, mockPicker);
     assertEquals(CONNECTING, channel.getState(false));
+
+    updateBalancingStateSafely(helper2, IDLE, mockPicker);
+    assertEquals(IDLE, channel.getState(false));
   }
 
   @Test
@@ -2673,7 +2650,7 @@ public void idleMode_resetsDelayedTransportPicker() {
             .setServers(Collections.singletonList(new EquivalentAddressGroup(socketAddress)))
             .build());
     createChannel();
-    assertEquals(IDLE, channel.getState(false));
+    assertEquals(CONNECTING, channel.getState(false));
 
     // This call will be buffered in delayedTransport
     ClientCall<String, Integer> call = channel.newCall(method, CallOptions.DEFAULT);
@@ -2709,7 +2686,9 @@ public void idleMode_resetsDelayedTransportPicker() {
     MockClientTransportInfo transportInfo = transports.poll();
     ConnectionClientTransport mockTransport = transportInfo.transport;
     ManagedClientTransport.Listener transportListener = transportInfo.listener;
-    when(mockTransport.newStream(same(method), any(Metadata.class), any(CallOptions.class)))
+    when(mockTransport.newStream(
+            same(method), any(Metadata.class), any(CallOptions.class),
+            ArgumentMatchers.<ClientStreamTracer[]>any()))
         .thenReturn(mockStream);
     transportListener.transportReady();
 
@@ -2720,7 +2699,9 @@ public void idleMode_resetsDelayedTransportPicker() {
     executor.runDueTasks();
 
     // Verify the buffered call was drained
-    verify(mockTransport).newStream(same(method), any(Metadata.class), any(CallOptions.class));
+    verify(mockTransport).newStream(
+        same(method), any(Metadata.class), any(CallOptions.class),
+        ArgumentMatchers.<ClientStreamTracer[]>any());
     verify(mockStream).start(any(ClientStreamListener.class));
   }
 
@@ -2764,7 +2745,7 @@ public void enterIdle_exitsIdleIfDelayedStreamPending() {
     // enterIdle() will shut down the name resolver and lb policy used to get a pick for the delayed
     // call
     channel.enterIdle();
-    assertEquals(IDLE, channel.getState(false));
+    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);
@@ -2779,7 +2760,9 @@ public void enterIdle_exitsIdleIfDelayedStreamPending() {
     MockClientTransportInfo transportInfo = transports.poll();
     ConnectionClientTransport mockTransport = transportInfo.transport;
     ManagedClientTransport.Listener transportListener = transportInfo.listener;
-    when(mockTransport.newStream(same(method), any(Metadata.class), any(CallOptions.class)))
+    when(mockTransport.newStream(
+            same(method), any(Metadata.class), any(CallOptions.class),
+            ArgumentMatchers.<ClientStreamTracer[]>any()))
         .thenReturn(mockStream);
     transportListener.transportReady();
     when(mockPicker.pickSubchannel(any(PickSubchannelArgs.class)))
@@ -2789,7 +2772,9 @@ public void enterIdle_exitsIdleIfDelayedStreamPending() {
 
     // Verify the original call was drained
     executor.runDueTasks();
-    verify(mockTransport).newStream(same(method), any(Metadata.class), any(CallOptions.class));
+    verify(mockTransport).newStream(
+        same(method), any(Metadata.class), any(CallOptions.class),
+        ArgumentMatchers.<ClientStreamTracer[]>any());
     verify(mockStream).start(any(ClientStreamListener.class));
   }
 
@@ -2811,7 +2796,9 @@ public void updateBalancingStateDoesUpdatePicker() {
     MockClientTransportInfo transportInfo = transports.poll();
     ConnectionClientTransport mockTransport = transportInfo.transport;
     ManagedClientTransport.Listener transportListener = transportInfo.listener;
-    when(mockTransport.newStream(same(method), any(Metadata.class), any(CallOptions.class)))
+    when(mockTransport.newStream(
+            same(method), any(Metadata.class), any(CallOptions.class),
+            ArgumentMatchers.<ClientStreamTracer[]>any()))
         .thenReturn(mockStream);
     transportListener.transportReady();
 
@@ -2820,8 +2807,9 @@ public void updateBalancingStateDoesUpdatePicker() {
     updateBalancingStateSafely(helper, READY, mockPicker);
 
     executor.runDueTasks();
-    verify(mockTransport, never())
-        .newStream(any(MethodDescriptor.class), any(Metadata.class), any(CallOptions.class));
+    verify(mockTransport, never()).newStream(
+        any(MethodDescriptor.class), any(Metadata.class), any(CallOptions.class),
+        ArgumentMatchers.<ClientStreamTracer[]>any());
     verify(mockStream, never()).start(any(ClientStreamListener.class));
 
 
@@ -2830,7 +2818,9 @@ public void updateBalancingStateDoesUpdatePicker() {
     updateBalancingStateSafely(helper, READY, mockPicker);
 
     executor.runDueTasks();
-    verify(mockTransport).newStream(same(method), any(Metadata.class), any(CallOptions.class));
+    verify(mockTransport).newStream(
+        same(method), any(Metadata.class), any(CallOptions.class),
+        ArgumentMatchers.<ClientStreamTracer[]>any());
     verify(mockStream).start(any(ClientStreamListener.class));
   }
 
@@ -2849,7 +2839,9 @@ public void updateBalancingState_withWrappedSubchannel() {
     MockClientTransportInfo transportInfo = transports.poll();
     ConnectionClientTransport mockTransport = transportInfo.transport;
     ManagedClientTransport.Listener transportListener = transportInfo.listener;
-    when(mockTransport.newStream(same(method), any(Metadata.class), any(CallOptions.class)))
+    when(mockTransport.newStream(
+            same(method), any(Metadata.class), any(CallOptions.class),
+            ArgumentMatchers.<ClientStreamTracer[]>any()))
         .thenReturn(mockStream);
     transportListener.transportReady();
 
@@ -2864,7 +2856,9 @@ protected Subchannel delegate() {
     updateBalancingStateSafely(helper, READY, mockPicker);
 
     executor.runDueTasks();
-    verify(mockTransport).newStream(same(method), any(Metadata.class), any(CallOptions.class));
+    verify(mockTransport).newStream(
+        same(method), any(Metadata.class), any(CallOptions.class),
+        ArgumentMatchers.<ClientStreamTracer[]>any());
     verify(mockStream).start(any(ClientStreamListener.class));
   }
 
@@ -2873,14 +2867,14 @@ public void updateBalancingStateWithShutdownShouldBeIgnored() {
     channelBuilder.nameResolverFactory(
         new FakeNameResolverFactory.Builder(expectedUri).setResolvedAtStart(false).build());
     createChannel();
-    assertEquals(IDLE, channel.getState(false));
+    assertEquals(CONNECTING, channel.getState(false));
 
     Runnable onStateChanged = mock(Runnable.class);
-    channel.notifyWhenStateChanged(IDLE, onStateChanged);
+    channel.notifyWhenStateChanged(CONNECTING, onStateChanged);
 
     updateBalancingStateSafely(helper, SHUTDOWN, mockPicker);
 
-    assertEquals(IDLE, channel.getState(false));
+    assertEquals(CONNECTING, channel.getState(false));
     executor.runDueTasks();
     verify(onStateChanged, never()).run();
   }
@@ -2898,52 +2892,6 @@ public void balancerRefreshNameResolution() {
     assertEquals(initialRefreshCount + 1, resolver.refreshCalled);
   }
 
-  @Test
-  public void resetConnectBackoff() {
-    // Start with a name resolution failure to trigger backoff attempts
-    Status error = Status.UNAVAILABLE.withCause(new Throwable("fake name resolution error"));
-    FakeNameResolverFactory nameResolverFactory =
-        new FakeNameResolverFactory.Builder(expectedUri).setError(error).build();
-    channelBuilder.nameResolverFactory(nameResolverFactory);
-    // Name resolution is started as soon as channel is created.
-    createChannel();
-    FakeNameResolverFactory.FakeNameResolver resolver = nameResolverFactory.resolvers.get(0);
-    verify(mockLoadBalancer).handleNameResolutionError(same(error));
-
-    FakeClock.ScheduledTask nameResolverBackoff = getNameResolverRefresh();
-    assertNotNull("There should be a name resolver backoff task", nameResolverBackoff);
-    assertEquals(0, resolver.refreshCalled);
-
-    // Verify resetConnectBackoff() calls refresh and cancels the scheduled backoff
-    channel.resetConnectBackoff();
-    assertEquals(1, resolver.refreshCalled);
-    assertTrue(nameResolverBackoff.isCancelled());
-
-    // Simulate a race between cancel and the task scheduler. Should be a no-op.
-    nameResolverBackoff.command.run();
-    assertEquals(1, resolver.refreshCalled);
-
-    // Verify that the reconnect policy was recreated and the backoff multiplier reset to 1
-    timer.forwardNanos(RECONNECT_BACKOFF_INTERVAL_NANOS);
-    assertEquals(2, resolver.refreshCalled);
-  }
-
-  @Test
-  public void resetConnectBackoff_noOpWithoutPendingResolverBackoff() {
-    FakeNameResolverFactory nameResolverFactory =
-        new FakeNameResolverFactory.Builder(expectedUri)
-            .setServers(Collections.singletonList(new EquivalentAddressGroup(socketAddress)))
-            .build();
-    channelBuilder.nameResolverFactory(nameResolverFactory);
-    createChannel();
-    FakeNameResolverFactory.FakeNameResolver nameResolver = nameResolverFactory.resolvers.get(0);
-    assertEquals(0, nameResolver.refreshCalled);
-
-    channel.resetConnectBackoff();
-
-    assertEquals(0, nameResolver.refreshCalled);
-  }
-
   @Test
   public void resetConnectBackoff_noOpWhenChannelShutdown() {
     FakeNameResolverFactory nameResolverFactory =
@@ -3026,7 +2974,7 @@ public void channelTracing_nameResolvingErrorEvent() throws Exception {
     FakeNameResolverFactory nameResolverFactory =
         new FakeNameResolverFactory.Builder(expectedUri).setError(error).build();
     channelBuilder.nameResolverFactory(nameResolverFactory);
-    createChannel();
+    createChannel(true);
 
     assertThat(getStats(channel).channelTrace.events).contains(new ChannelTrace.Event.Builder()
         .setDescription("Failed to resolve name: " + error)
@@ -3091,6 +3039,56 @@ public void channelTracing_nameResolvedEvent_zeorAndNonzeroBackends() throws Exc
     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);
@@ -3150,6 +3148,69 @@ public void channelTracing_serviceConfigChange() throws Exception {
             .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);
@@ -3179,56 +3240,14 @@ public void channelTracing_subchannelStateChangeEvent() throws Exception {
         .build());
   }
 
-  @Test
-  public void channelTracing_oobChannelStateChangeEvent() throws Exception {
-    channelBuilder.maxTraceEvents(10);
-    createChannel();
-    OobChannel oobChannel = (OobChannel) helper.createOobChannel(addressGroup, "authority");
-    timer.forwardNanos(1234);
-    oobChannel.handleSubchannelStateChange(
-        ConnectivityStateInfo.forNonError(ConnectivityState.CONNECTING));
-    assertThat(getStats(oobChannel).channelTrace.events).contains(new ChannelTrace.Event.Builder()
-        .setDescription("Entering CONNECTING state")
-        .setSeverity(ChannelTrace.Event.Severity.CT_INFO)
-        .setTimestampNanos(timer.getTicker().read())
-        .build());
-  }
-
-  @Test
-  public void channelTracing_oobChannelCreationEvents() throws Exception {
-    channelBuilder.maxTraceEvents(10);
-    createChannel();
-    timer.forwardNanos(1234);
-    OobChannel oobChannel = (OobChannel) helper.createOobChannel(addressGroup, "authority");
-    assertThat(getStats(channel).channelTrace.events).contains(new ChannelTrace.Event.Builder()
-        .setDescription("Child OobChannel created")
-        .setSeverity(ChannelTrace.Event.Severity.CT_INFO)
-        .setTimestampNanos(timer.getTicker().read())
-        .setChannelRef(oobChannel)
-        .build());
-    assertThat(getStats(oobChannel).channelTrace.events).contains(new ChannelTrace.Event.Builder()
-        .setDescription("OobChannel for [[test-addr]/{}] created")
-        .setSeverity(ChannelTrace.Event.Severity.CT_INFO)
-        .setTimestampNanos(timer.getTicker().read())
-        .build());
-    assertThat(getStats(oobChannel.getInternalSubchannel()).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 channelsAndSubchannels_instrumented_state() throws Exception {
     createChannel();
 
-    ArgumentCaptor<Helper> helperCaptor = ArgumentCaptor.forClass(null);
+    ArgumentCaptor<Helper> helperCaptor = ArgumentCaptor.forClass(Helper.class);
     verify(mockLoadBalancerProvider).newLoadBalancer(helperCaptor.capture());
     helper = helperCaptor.getValue();
 
-    assertEquals(IDLE, getStats(channel).state);
-    updateBalancingStateSafely(helper, CONNECTING, mockPicker);
     assertEquals(CONNECTING, getStats(channel).state);
 
     AbstractSubchannel subchannel =
@@ -3294,7 +3313,8 @@ private void channelsAndSubchannels_instrumented0(boolean success) throws Except
     transportInfo.listener.transportReady();
     ClientTransport mockTransport = transportInfo.transport;
     when(mockTransport.newStream(
-            any(MethodDescriptor.class), any(Metadata.class), any(CallOptions.class)))
+            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));
@@ -3312,130 +3332,27 @@ private void channelsAndSubchannels_instrumented0(boolean success) throws Except
     // closing stream listener affects subchannel stats immediately
     assertEquals(0, getStats(subchannel).callsSucceeded);
     assertEquals(0, getStats(subchannel).callsFailed);
-    streamListener.closed(success ? Status.OK : Status.UNKNOWN, new Metadata());
+    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 channelsAndSubchannels_oob_instrumented_success() throws Exception {
-    channelsAndSubchannels_oob_instrumented0(true);
-  }
-
-  @Test
-  public void channelsAndSubchannels_oob_instrumented_fail() throws Exception {
-    channelsAndSubchannels_oob_instrumented0(false);
-  }
-
-  private void channelsAndSubchannels_oob_instrumented0(boolean success) throws Exception {
-    // set up
-    ClientStream mockStream = mock(ClientStream.class);
-    createChannel();
-
-    OobChannel oobChannel = (OobChannel) helper.createOobChannel(addressGroup, "oobauthority");
-    AbstractSubchannel oobSubchannel = (AbstractSubchannel) oobChannel.getSubchannel();
-    FakeClock callExecutor = new FakeClock();
-    CallOptions options =
-        CallOptions.DEFAULT.withExecutor(callExecutor.getScheduledExecutorService());
-    ClientCall<String, Integer> call = oobChannel.newCall(method, options);
-    Metadata headers = new Metadata();
-
-    // Channel stat bumped when ClientCall.start() called
-    assertEquals(0, getStats(oobChannel).callsStarted);
-    call.start(mockCallListener, headers);
-    assertEquals(1, getStats(oobChannel).callsStarted);
-
-    MockClientTransportInfo transportInfo = transports.poll();
-    ConnectionClientTransport mockTransport = transportInfo.transport;
-    ManagedClientTransport.Listener transportListener = transportInfo.listener;
-    when(mockTransport.newStream(same(method), same(headers), any(CallOptions.class)))
-        .thenReturn(mockStream);
-
-    // subchannel stat bumped when call gets assigned to it
-    assertEquals(0, getStats(oobSubchannel).callsStarted);
-    transportListener.transportReady();
-    callExecutor.runDueTasks();
-    verify(mockStream).start(streamListenerCaptor.capture());
-    assertEquals(1, getStats(oobSubchannel).callsStarted);
-
-    ClientStreamListener streamListener = streamListenerCaptor.getValue();
-    call.halfClose();
-
-    // closing stream listener affects subchannel stats immediately
-    assertEquals(0, getStats(oobSubchannel).callsSucceeded);
-    assertEquals(0, getStats(oobSubchannel).callsFailed);
-    streamListener.closed(success ? Status.OK : Status.UNKNOWN, new Metadata());
-    if (success) {
-      assertEquals(1, getStats(oobSubchannel).callsSucceeded);
-      assertEquals(0, getStats(oobSubchannel).callsFailed);
-    } else {
-      assertEquals(0, getStats(oobSubchannel).callsSucceeded);
-      assertEquals(1, getStats(oobSubchannel).callsFailed);
-    }
-
-    // channel stats bumped when the ClientCall.Listener is notified
-    assertEquals(0, getStats(oobChannel).callsSucceeded);
-    assertEquals(0, getStats(oobChannel).callsFailed);
-    callExecutor.runDueTasks();
-    if (success) {
-      assertEquals(1, getStats(oobChannel).callsSucceeded);
-      assertEquals(0, getStats(oobChannel).callsFailed);
-    } else {
-      assertEquals(0, getStats(oobChannel).callsSucceeded);
-      assertEquals(1, getStats(oobChannel).callsFailed);
-    }
-    // oob channel is separate from the original channel
-    assertEquals(0, getStats(channel).callsSucceeded);
-    assertEquals(0, getStats(channel).callsFailed);
-  }
-
-  @Test
-  public void channelsAndSubchannels_oob_instrumented_name() throws Exception {
-    createChannel();
-
-    String authority = "oobauthority";
-    OobChannel oobChannel = (OobChannel) helper.createOobChannel(addressGroup, authority);
-    assertEquals(authority, getStats(oobChannel).target);
-  }
-
-  @Test
-  public void channelsAndSubchannels_oob_instrumented_state() throws Exception {
-    createChannel();
-
-    OobChannel oobChannel = (OobChannel) helper.createOobChannel(addressGroup, "oobauthority");
-    assertEquals(IDLE, getStats(oobChannel).state);
-
-    oobChannel.getSubchannel().requestConnection();
-    assertEquals(CONNECTING, getStats(oobChannel).state);
-
-    MockClientTransportInfo transportInfo = transports.poll();
-    ManagedClientTransport.Listener transportListener = transportInfo.listener;
-
-    transportListener.transportReady();
-    assertEquals(READY, getStats(oobChannel).state);
+    }
 
-    // oobchannel state is separate from the ManagedChannel
-    assertEquals(IDLE, getStats(channel).state);
-    channel.shutdownNow();
-    assertEquals(SHUTDOWN, getStats(channel).state);
-    assertEquals(SHUTDOWN, getStats(oobChannel).state);
+    // 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
@@ -3520,10 +3437,9 @@ public double nextDouble() {
     ArgumentCaptor<Helper> helperCaptor = ArgumentCaptor.forClass(Helper.class);
     verify(mockLoadBalancerProvider).newLoadBalancer(helperCaptor.capture());
     helper = helperCaptor.getValue();
-    verify(mockLoadBalancer).handleResolvedAddresses(
-        ResolvedAddresses.newBuilder()
-            .setAddresses(nameResolverFactory.servers)
-            .build());
+    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 =
@@ -3535,7 +3451,9 @@ public double nextDouble() {
     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)))
+    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);
@@ -3546,10 +3464,11 @@ public double nextDouble() {
     assertThat(timer.getPendingTasks()).isEmpty();
 
     // trigger retry
-    streamListenerCaptor.getValue().closed(Status.UNAVAILABLE, new Metadata());
+    streamListenerCaptor.getValue().closed(
+        Status.UNAVAILABLE, PROCESSED, new Metadata());
 
     // in backoff
-    timer.forwardTime(5, TimeUnit.SECONDS);
+    timer.forwardTime(6, TimeUnit.SECONDS);
     assertThat(timer.getPendingTasks()).hasSize(1);
     verify(mockStream2, never()).start(any(ClientStreamListener.class));
 
@@ -3568,7 +3487,7 @@ public double nextDouble() {
     assertEquals("Channel shutdown invoked", statusCaptor.getValue().getDescription());
 
     // backoff ends
-    timer.forwardTime(5, TimeUnit.SECONDS);
+    timer.forwardTime(6, TimeUnit.SECONDS);
     assertThat(timer.getPendingTasks()).isEmpty();
     verify(mockStream2).start(streamListenerCaptor.capture());
     verify(mockLoadBalancer, never()).shutdown();
@@ -3576,11 +3495,13 @@ public double nextDouble() {
         "channel.isTerminated() is expected to be false but was true",
         channel.isTerminated());
 
-    streamListenerCaptor.getValue().closed(Status.INTERNAL, new Metadata());
+    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);
+    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",
@@ -3622,10 +3543,9 @@ public void hedgingScheduledThenChannelShutdown_hedgeShouldStillHappen_newCallSh
     ArgumentCaptor<Helper> helperCaptor = ArgumentCaptor.forClass(Helper.class);
     verify(mockLoadBalancerProvider).newLoadBalancer(helperCaptor.capture());
     helper = helperCaptor.getValue();
-    verify(mockLoadBalancer).handleResolvedAddresses(
-        ResolvedAddresses.newBuilder()
-            .setAddresses(nameResolverFactory.servers)
-            .build());
+    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 =
@@ -3637,7 +3557,9 @@ public void hedgingScheduledThenChannelShutdown_hedgeShouldStillHappen_newCallSh
     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)))
+    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);
@@ -3650,7 +3572,8 @@ public void hedgingScheduledThenChannelShutdown_hedgeShouldStillHappen_newCallSh
     timer.forwardTime(5, TimeUnit.SECONDS);
     assertThat(timer.numPendingTasks()).isEqualTo(1);
     // first hedge fails
-    streamListenerCaptor.getValue().closed(Status.UNAVAILABLE, new Metadata());
+    streamListenerCaptor.getValue().closed(
+        Status.UNAVAILABLE, PROCESSED, new Metadata());
     verify(mockStream2, never()).start(any(ClientStreamListener.class));
 
     // shutdown during backoff period
@@ -3676,13 +3599,15 @@ public void hedgingScheduledThenChannelShutdown_hedgeShouldStillHappen_newCallSh
         "channel.isTerminated() is expected to be false but was true",
         channel.isTerminated());
 
-    streamListenerCaptor.getValue().closed(Status.INTERNAL, new Metadata());
+    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);
+    transportInfo.listener.transportShutdown(Status.INTERNAL,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
     transportInfo.listener.transportTerminated();
     assertTrue(
         "channel.isTerminated() is expected to be true but was false",
@@ -3742,6 +3667,8 @@ public ClientTransportFactory buildClientTransportFactory() {
           }
         },
         null);
+    when(mockTransportFactory.getSupportedSocketAddressTypes()).thenReturn(Collections.singleton(
+        InetSocketAddress.class));
     customBuilder.executorPool = executorPool;
     customBuilder.channelz = channelz;
     ManagedChannel mychannel = customBuilder.nameResolverFactory(factory).build();
@@ -3791,59 +3718,118 @@ public ClientTransportFactory buildClientTransportFactory() {
     mychannel.shutdownNow();
   }
 
-  @Deprecated
   @Test
-  public void nameResolver_forwardingStartOldApi() {
-    final AtomicReference<NameResolver.Listener2> listenerCapture = new AtomicReference<>();
-    final NameResolver noopResolver = new NameResolver() {
-        @Override
-        public String getServiceAuthority() {
-          return "fake-authority";
-        }
+  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;
 
-        @Override
-        public void start(Listener2 listener) {
-          listenerCapture.set(listener);
-        }
+      FakeNameResolver(Args args) {
+        this.syncContext = args.getSynchronizationContext();
+      }
 
-        @Override
-        public void shutdown() {}
-      };
+      @Override
+      public String getServiceAuthority() {
+        return "also fake";
+      }
 
-    // This forwarding resolver is still on the old start() API.  Despite that, the delegate
-    // resolver which is on the new API should get the new Listener2.
-    final NameResolver oldApiForwardingResolver = new NameResolver() {
-        @Override
-        public String getServiceAuthority() {
-          return noopResolver.getServiceAuthority();
-        }
+      @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 start(Listener listener) {
-          noopResolver.start(listener);
-        }
+      @Override
+      public void shutdown() {}
+    }
 
-        @Override
-        public void shutdown() {
-          noopResolver.shutdown();
-        }
-      };
+    final class FakeNameResolverFactory2 extends NameResolver.Factory {
+      FakeNameResolver resolver;
+      ManagedChannelImpl managedChannel;
+      SynchronizationContext syncContext;
 
-    NameResolver.Factory oldApiResolverFactory = new NameResolver.Factory() {
-        @Override
-        public NameResolver newNameResolver(URI targetUri, NameResolver.Helper helper) {
-          return oldApiForwardingResolver;
-        }
+      @Nullable
+      @Override
+      public NameResolver newNameResolver(URI targetUri, NameResolver.Args args) {
+        syncContext = args.getSynchronizationContext();
+        return (resolver = new FakeNameResolver(args));
+      }
 
-        @Override
-        public String getDefaultScheme() {
-          return "fakescheme";
-        }
-      };
-    channelBuilder.nameResolverFactory(oldApiResolverFactory);
-    createChannel();
+      @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");
+    }
 
-    assertThat(listenerCapture.get()).isNotNull();
+    mychannel.shutdownNow();
   }
 
   @Test
@@ -3877,16 +3863,21 @@ public NameResolver newNameResolver(URI targetUri, NameResolver.Args args) {
 
         @Override
         public String getDefaultScheme() {
-          return "fakescheme";
+          return "fake";
         }
       };
-    channelBuilder.nameResolverFactory(factory).proxyDetector(neverProxy);
+    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()
@@ -3951,13 +3942,37 @@ public void nameResolverHelper_badConfigFails() {
     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("pick_first");
+        new AutoConfiguredLoadBalancerFactory(registry, MOCK_POLICY_NAME);
 
     ScParser parser = new ScParser(
         retryEnabled,
@@ -4000,7 +4015,7 @@ public void disableServiceConfigLookUp_noDefaultConfig() throws Exception {
 
       ArgumentCaptor<ResolvedAddresses> resultCaptor =
           ArgumentCaptor.forClass(ResolvedAddresses.class);
-      verify(mockLoadBalancer).handleResolvedAddresses(resultCaptor.capture());
+      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));
@@ -4038,10 +4053,44 @@ public void disableServiceConfigLookUp_withDefaultConfig() throws Exception {
 
       ArgumentCaptor<ResolvedAddresses> resultCaptor =
           ArgumentCaptor.forClass(ResolvedAddresses.class);
-      verify(mockLoadBalancer).handleResolvedAddresses(resultCaptor.capture());
+      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);
     }
@@ -4068,7 +4117,7 @@ public void enableServiceConfigLookUp_noDefaultConfig() throws Exception {
       createChannel();
       ArgumentCaptor<ResolvedAddresses> resultCaptor =
           ArgumentCaptor.forClass(ResolvedAddresses.class);
-      verify(mockLoadBalancer).handleResolvedAddresses(resultCaptor.capture());
+      verify(mockLoadBalancer).acceptResolvedAddresses(resultCaptor.capture());
       assertThat(resultCaptor.getValue().getAddresses()).containsExactly(addressGroup);
       verify(mockLoadBalancer, never()).handleNameResolutionError(any(Status.class));
 
@@ -4084,7 +4133,7 @@ public void enableServiceConfigLookUp_noDefaultConfig() throws Exception {
       nameResolverFactory.allResolved();
 
       resultCaptor = ArgumentCaptor.forClass(ResolvedAddresses.class);
-      verify(mockLoadBalancer, times(2)).handleResolvedAddresses(resultCaptor.capture());
+      verify(mockLoadBalancer, times(2)).acceptResolvedAddresses(resultCaptor.capture());
       assertThat(resultCaptor.getValue().getAddresses()).containsExactly(addressGroup);
       verify(mockLoadBalancer, never()).handleNameResolutionError(any(Status.class));
     } finally {
@@ -4118,7 +4167,7 @@ public void enableServiceConfigLookUp_withDefaultConfig() throws Exception {
       createChannel();
       ArgumentCaptor<ResolvedAddresses> resultCaptor =
           ArgumentCaptor.forClass(ResolvedAddresses.class);
-      verify(mockLoadBalancer).handleResolvedAddresses(resultCaptor.capture());
+      verify(mockLoadBalancer).acceptResolvedAddresses(resultCaptor.capture());
       assertThat(resultCaptor.getValue().getAddresses()).containsExactly(addressGroup);
       verify(mockLoadBalancer, never()).handleNameResolutionError(any(Status.class));
     } finally {
@@ -4146,9 +4195,42 @@ public void enableServiceConfigLookUp_resolverReturnsNoConfig_withDefaultConfig(
       createChannel();
       ArgumentCaptor<ResolvedAddresses> resultCaptor =
           ArgumentCaptor.forClass(ResolvedAddresses.class);
-      verify(mockLoadBalancer).handleResolvedAddresses(resultCaptor.capture());
+      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);
     }
@@ -4172,7 +4254,7 @@ public void enableServiceConfigLookUp_resolverReturnsNoConfig_noDefaultConfig()
       createChannel();
       ArgumentCaptor<ResolvedAddresses> resultCaptor =
           ArgumentCaptor.forClass(ResolvedAddresses.class);
-      verify(mockLoadBalancer).handleResolvedAddresses(resultCaptor.capture());
+      verify(mockLoadBalancer).acceptResolvedAddresses(resultCaptor.capture());
       assertThat(resultCaptor.getValue().getAddresses()).containsExactly(addressGroup);
       verify(mockLoadBalancer, never()).handleNameResolutionError(any(Status.class));
     } finally {
@@ -4225,7 +4307,7 @@ public void notUseDefaultImmediatelyIfEnableLookUp() throws Exception {
     int size = getStats(channel).channelTrace.events.size();
     assertThat(getStats(channel).channelTrace.events.get(size - 1))
         .isNotEqualTo(new ChannelTrace.Event.Builder()
-            .setDescription("Using default service config")
+            .setDescription("timer.forwardNanos(1234);")
             .setSeverity(ChannelTrace.Event.Severity.CT_INFO)
             .setTimestampNanos(timer.getTicker().read())
             .build());
@@ -4252,7 +4334,7 @@ public void healthCheckingConfigPropagated() throws Exception {
 
       ArgumentCaptor<ResolvedAddresses> resultCaptor =
           ArgumentCaptor.forClass(ResolvedAddresses.class);
-      verify(mockLoadBalancer).handleResolvedAddresses(resultCaptor.capture());
+      verify(mockLoadBalancer).acceptResolvedAddresses(resultCaptor.capture());
       assertThat(resultCaptor.getValue().getAttributes()
           .get(LoadBalancer.ATTR_HEALTH_CHECKING_CONFIG))
           .containsExactly("serviceName", "service1");
@@ -4283,6 +4365,122 @@ public void createResolvingOobChannel() throws Exception {
     }
   }
 
+  @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() {
@@ -4297,7 +4495,7 @@ public long nextBackoffNanos() {
     }
   }
 
-  private static final class FakeNameResolverFactory extends NameResolver.Factory {
+  private static final class FakeNameResolverFactory extends NameResolverProvider {
     final List<URI> expectedUris;
     final List<EquivalentAddressGroup> servers;
     final boolean resolvedAtStart;
@@ -4324,7 +4522,7 @@ public NameResolver newNameResolver(final URI targetUri, NameResolver.Args args)
       }
       assertEquals(DEFAULT_PORT, args.getDefaultPort());
       FakeNameResolverFactory.FakeNameResolver resolver =
-          new FakeNameResolverFactory.FakeNameResolver(targetUri, error);
+          new FakeNameResolverFactory.FakeNameResolver(targetUri, error, args);
       resolvers.add(resolver);
       return resolver;
     }
@@ -4334,6 +4532,16 @@ public String getDefaultScheme() {
       return "fake";
     }
 
+    @Override
+    public int priority() {
+      return 9;
+    }
+
+    @Override
+    public boolean isAvailable() {
+      return true;
+    }
+
     void allResolved() {
       for (FakeNameResolverFactory.FakeNameResolver resolver : resolvers) {
         resolver.resolved();
@@ -4342,14 +4550,16 @@ void allResolved() {
 
     final class FakeNameResolver extends NameResolver {
       final URI targetUri;
+      final SynchronizationContext syncContext;
       Listener2 listener;
       boolean shutdown;
       int refreshCalled;
       Status error;
 
-      FakeNameResolver(URI targetUri, Status error) {
+      FakeNameResolver(URI targetUri, Status error, Args args) {
         this.targetUri = targetUri;
         this.error = error;
+        syncContext = args.getSynchronizationContext();
       }
 
       @Override public String getServiceAuthority() {
@@ -4370,7 +4580,10 @@ final class FakeNameResolver extends NameResolver {
 
       void resolved() {
         if (error != null) {
-          listener.onError(error);
+          syncContext.execute(() ->
+              listener.onResult2(
+                  ResolutionResult.newBuilder()
+                      .setAddressesOrError(StatusOr.fromStatus(error)).build()));
           return;
         }
         ResolutionResult.Builder builder =
@@ -4381,7 +4594,7 @@ void resolved() {
         if (configOrError != null) {
           builder.setServiceConfig(configOrError);
         }
-        listener.onResult(builder.build());
+        syncContext.execute(() -> listener.onResult(builder.build()));
       }
 
       @Override public void shutdown() {
@@ -4434,10 +4647,6 @@ private static ChannelStats getStats(
     return instrumented.getStats().get();
   }
 
-  private FakeClock.ScheduledTask getNameResolverRefresh() {
-    return Iterables.getOnlyElement(timer.getPendingTasks(NAME_RESOLVER_REFRESH_TASK_FILTER), null);
-  }
-
   // Helper methods to call methods from SynchronizationContext
   private static Subchannel createSubchannelSafely(
       final Helper helper, final EquivalentAddressGroup addressGroup, final Attributes attrs,
diff --git a/core/src/test/java/io/grpc/internal/ManagedChannelOrphanWrapperTest.java b/core/src/test/java/io/grpc/internal/ManagedChannelOrphanWrapperTest.java
index 5ae97c69211..45fb3881722 100644
--- a/core/src/test/java/io/grpc/internal/ManagedChannelOrphanWrapperTest.java
+++ b/core/src/test/java/io/grpc/internal/ManagedChannelOrphanWrapperTest.java
@@ -101,6 +101,45 @@ public boolean isDone() {
     }
   }
 
+  @Test
+  public void shutdown_withDelegateStillReferenced_doesNotLogWarning() {
+    ManagedChannel mc = new TestManagedChannel();
+    final ReferenceQueue<ManagedChannelOrphanWrapper> refqueue = new ReferenceQueue<>();
+    ConcurrentMap<ManagedChannelReference, ManagedChannelReference> refs =
+        new ConcurrentHashMap<>();
+    
+    ManagedChannelOrphanWrapper wrapper = new ManagedChannelOrphanWrapper(mc, refqueue, refs);
+    WeakReference<ManagedChannelOrphanWrapper> wrapperWeakRef = new WeakReference<>(wrapper);
+
+    final List<LogRecord> records = new ArrayList<>();
+    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 {
+      wrapper.shutdown(); 
+      wrapper = null; 
+      
+      // Wait for the WRAPPER itself to be garbage collected
+      GcFinalization.awaitClear(wrapperWeakRef);
+      ManagedChannelReference.cleanQueue(refqueue);
+
+      synchronized (records) {
+        assertEquals("Warning was logged even though shutdownNow() was called!", 0, records.size());
+      }
+    } finally {
+      orphanLogger.setFilter(oldFilter);
+    }
+  }
+
   @Test
   public void refCycleIsGCed() {
     ReferenceQueue<ManagedChannelOrphanWrapper> refqueue =
diff --git a/core/src/test/java/io/grpc/internal/ManagedChannelServiceConfigTest.java b/core/src/test/java/io/grpc/internal/ManagedChannelServiceConfigTest.java
index 45071504331..fefc37e4fdc 100644
--- a/core/src/test/java/io/grpc/internal/ManagedChannelServiceConfigTest.java
+++ b/core/src/test/java/io/grpc/internal/ManagedChannelServiceConfigTest.java
@@ -20,31 +20,28 @@
 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.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 ManagedChannelServiceConfigTest {
 
-  @SuppressWarnings("deprecation") // https://github.com/grpc/grpc-java/issues/7467
-  @Rule
-  public final ExpectedException thrown = ExpectedException.none();
-
   @Test
   public void managedChannelServiceConfig_shouldParseHealthCheckingConfig() throws Exception {
     Map<String, ?> rawServiceConfig =
@@ -77,10 +74,9 @@ public void createManagedChannelServiceConfig_failsOnDuplicateMethod() {
     Map<String, ?> methodConfig = ImmutableMap.of("name", ImmutableList.of(name1, name2));
     Map<String, ?> serviceConfig = ImmutableMap.of("methodConfig", ImmutableList.of(methodConfig));
 
-    thrown.expect(IllegalArgumentException.class);
-    thrown.expectMessage("Duplicate method");
-
-    ManagedChannelServiceConfig.fromServiceConfig(serviceConfig, true, 3, 4, null);
+    IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
+        () -> ManagedChannelServiceConfig.fromServiceConfig(serviceConfig, true, 3, 4, null));
+    assertThat(e).hasMessageThat().isEqualTo("Duplicate method name service/method");
   }
 
   @Test
@@ -90,10 +86,9 @@ public void createManagedChannelServiceConfig_failsOnDuplicateService() {
     Map<String, ?> methodConfig = ImmutableMap.of("name", ImmutableList.of(name1, name2));
     Map<String, ?> serviceConfig = ImmutableMap.of("methodConfig", ImmutableList.of(methodConfig));
 
-    thrown.expect(IllegalArgumentException.class);
-    thrown.expectMessage("Duplicate service");
-
-    ManagedChannelServiceConfig.fromServiceConfig(serviceConfig, true, 3, 4, null);
+    IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
+        () -> ManagedChannelServiceConfig.fromServiceConfig(serviceConfig, true, 3, 4, null));
+    assertThat(e).hasMessageThat().isEqualTo("Duplicate service service");
   }
 
   @Test
@@ -105,10 +100,9 @@ public void createManagedChannelServiceConfig_failsOnDuplicateServiceMultipleCon
     Map<String, ?> serviceConfig =
         ImmutableMap.of("methodConfig", ImmutableList.of(methodConfig1, methodConfig2));
 
-    thrown.expect(IllegalArgumentException.class);
-    thrown.expectMessage("Duplicate service");
-
-    ManagedChannelServiceConfig.fromServiceConfig(serviceConfig, true, 3, 4, null);
+    IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
+        () -> ManagedChannelServiceConfig.fromServiceConfig(serviceConfig, true, 3, 4, null));
+    assertThat(e).hasMessageThat().isEqualTo("Duplicate service service");
   }
 
   @Test
@@ -117,10 +111,9 @@ public void createManagedChannelServiceConfig_failsOnMethodNameWithEmptyServiceN
     Map<String, ?> methodConfig = ImmutableMap.of("name", ImmutableList.of(name));
     Map<String, ?> serviceConfig = ImmutableMap.of("methodConfig", ImmutableList.of(methodConfig));
 
-    thrown.expect(IllegalArgumentException.class);
-    thrown.expectMessage("missing service name for method method1");
-
-    ManagedChannelServiceConfig.fromServiceConfig(serviceConfig, true, 3, 4, null);
+    IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
+        () -> ManagedChannelServiceConfig.fromServiceConfig(serviceConfig, true, 3, 4, null));
+    assertThat(e).hasMessageThat().isEqualTo("missing service name for method method1");
   }
 
   @Test
@@ -129,10 +122,9 @@ public void createManagedChannelServiceConfig_failsOnMethodNameWithoutServiceNam
     Map<String, ?> methodConfig = ImmutableMap.of("name", ImmutableList.of(name));
     Map<String, ?> serviceConfig = ImmutableMap.of("methodConfig", ImmutableList.of(methodConfig));
 
-    thrown.expect(IllegalArgumentException.class);
-    thrown.expectMessage("missing service name for method method1");
-
-    ManagedChannelServiceConfig.fromServiceConfig(serviceConfig, true, 3, 4, null);
+    IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
+        () -> ManagedChannelServiceConfig.fromServiceConfig(serviceConfig, true, 3, 4, null));
+    assertThat(e).hasMessageThat().isEqualTo("missing service name for method method1");
   }
 
   @Test
@@ -141,10 +133,9 @@ public void createManagedChannelServiceConfig_failsOnMissingServiceName() {
     Map<String, ?> methodConfig = ImmutableMap.of("name", ImmutableList.of(name));
     Map<String, ?> serviceConfig = ImmutableMap.of("methodConfig", ImmutableList.of(methodConfig));
 
-    thrown.expect(IllegalArgumentException.class);
-    thrown.expectMessage("missing service");
-
-    ManagedChannelServiceConfig.fromServiceConfig(serviceConfig, true, 3, 4, null);
+    IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
+        () -> ManagedChannelServiceConfig.fromServiceConfig(serviceConfig, true, 3, 4, null));
+    assertThat(e).hasMessageThat().isEqualTo("missing service name for method method");
   }
 
   @Test
@@ -155,13 +146,14 @@ public void managedChannelServiceConfig_parseMethodConfig() {
         "name", ImmutableList.of(name1, name2),
         "timeout", "1.234s",
         "retryPolicy",
-        ImmutableMap.of(
-            "maxAttempts", 3.0D,
-            "initialBackoff", "1s",
-            "maxBackoff", "10s",
-            "backoffMultiplier", 1.5D,
-            "retryableStatusCodes", ImmutableList.of("UNAVAILABLE")
-        ));
+        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");
@@ -187,6 +179,8 @@ public void managedChannelServiceConfig_parseMethodConfig() {
     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));
@@ -205,13 +199,92 @@ public void getDefaultConfigSelectorFromConfig() {
     InternalConfigSelector configSelector = serviceConfig.getDefaultConfigSelector();
     MethodDescriptor<?, ?> method = methodForName("service1", "method1");
     Result result = configSelector.selectConfig(
-        new PickSubchannelArgsImpl(method, new Metadata(), CallOptions.DEFAULT));
+        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)
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 c1907e51703..54758bc096f 100644
--- a/core/src/test/java/io/grpc/internal/MessageDeframerTest.java
+++ b/core/src/test/java/io/grpc/internal/MessageDeframerTest.java
@@ -20,6 +20,7 @@
 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.junit.Assume.assumeTrue;
 import static org.mockito.ArgumentMatchers.anyInt;
@@ -31,7 +32,6 @@
 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 io.grpc.Codec;
@@ -46,16 +46,16 @@
 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.Before;
-import org.junit.Rule;
 import org.junit.Test;
 import org.junit.experimental.runners.Enclosed;
-import org.junit.rules.ExpectedException;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 import org.junit.runners.Parameterized;
@@ -132,7 +132,7 @@ public void simplePayload() {
       assertEquals(Bytes.asList(new byte[]{3, 14}), bytes(producer.getValue().next()));
       verify(listener, atLeastOnce()).bytesRead(anyInt());
       verifyNoMoreInteractions(listener);
-      checkStats(tracer, transportTracer.getStats(), fakeClock, 2, 2);
+      checkStats(tracer, transportTracer.getStats(), fakeClock, useGzipInflatingBuffer, 2, 2);
     }
 
     @Test
@@ -147,7 +147,7 @@ public void smallCombinedPayloads() {
       verify(listener, atLeastOnce()).bytesRead(anyInt());
       assertEquals(Bytes.asList(new byte[]{14, 15}), bytes(streams.get(1).next()));
       verifyNoMoreInteractions(listener);
-      checkStats(tracer, transportTracer.getStats(), fakeClock, 1, 1, 2, 2);
+      checkStats(tracer, transportTracer.getStats(), fakeClock, useGzipInflatingBuffer, 1, 1, 2, 2);
     }
 
     @Test
@@ -161,7 +161,7 @@ public void endOfStreamWithPayloadShouldNotifyEndOfStream() {
       verify(listener).deframerClosed(false);
       verify(listener, atLeastOnce()).bytesRead(anyInt());
       verifyNoMoreInteractions(listener);
-      checkStats(tracer, transportTracer.getStats(), fakeClock, 1, 1);
+      checkStats(tracer, transportTracer.getStats(), fakeClock,  useGzipInflatingBuffer, 1, 1);
     }
 
     @Test
@@ -176,7 +176,7 @@ public void endOfStreamShouldNotifyEndOfStream() {
       }
       verify(listener).deframerClosed(false);
       verifyNoMoreInteractions(listener);
-      checkStats(tracer, transportTracer.getStats(), fakeClock);
+      checkStats(tracer, transportTracer.getStats(), fakeClock, false);
     }
 
     @Test
@@ -188,7 +188,7 @@ public void endOfStreamWithPartialMessageShouldNotifyDeframerClosedWithPartialMe
       verify(listener, atLeastOnce()).bytesRead(anyInt());
       verify(listener).deframerClosed(true);
       verifyNoMoreInteractions(listener);
-      checkStats(tracer, transportTracer.getStats(), fakeClock);
+      checkStats(tracer, transportTracer.getStats(), fakeClock, false);
     }
 
     @Test
@@ -205,7 +205,7 @@ public void endOfStreamWithInvalidGzipBlockShouldNotifyDeframerClosedWithPartial
       deframer.closeWhenComplete();
       verify(listener).deframerClosed(true);
       verifyNoMoreInteractions(listener);
-      checkStats(tracer, transportTracer.getStats(), fakeClock);
+      checkStats(tracer, transportTracer.getStats(), fakeClock, false);
     }
 
     @Test
@@ -227,10 +227,11 @@ public void payloadSplitBetweenBuffers() {
             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, 7, 7);
+        checkStats(tracer, transportTracer.getStats(), fakeClock, false, 7, 7);
       }
     }
 
@@ -247,7 +248,7 @@ public void frameHeaderSplitBetweenBuffers() {
       assertEquals(Bytes.asList(new byte[]{3}), bytes(producer.getValue().next()));
       verify(listener, atLeastOnce()).bytesRead(anyInt());
       verifyNoMoreInteractions(listener);
-      checkStats(tracer, transportTracer.getStats(), fakeClock, 1, 1);
+      checkStats(tracer, transportTracer.getStats(), fakeClock, useGzipInflatingBuffer, 1, 1);
     }
 
     @Test
@@ -258,7 +259,7 @@ public void emptyPayload() {
       assertEquals(Bytes.asList(), bytes(producer.getValue().next()));
       verify(listener, atLeastOnce()).bytesRead(anyInt());
       verifyNoMoreInteractions(listener);
-      checkStats(tracer, transportTracer.getStats(), fakeClock, 0, 0);
+      checkStats(tracer, transportTracer.getStats(), fakeClock, useGzipInflatingBuffer, 0, 0);
     }
 
     @Test
@@ -272,9 +273,10 @@ public void largerFrameSize() {
       verify(listener, atLeastOnce()).bytesRead(anyInt());
       verifyNoMoreInteractions(listener);
       if (useGzipInflatingBuffer) {
-        checkStats(tracer, transportTracer.getStats(), fakeClock, 8 /* compressed size */, 1000);
+        checkStats(tracer, transportTracer.getStats(), fakeClock,true,
+            8 /* compressed size */, 1000);
       } else {
-        checkStats(tracer, transportTracer.getStats(), fakeClock, 1000, 1000);
+        checkStats(tracer, transportTracer.getStats(), fakeClock, false, 1000, 1000);
       }
     }
 
@@ -291,7 +293,7 @@ public void endOfStreamCallbackShouldWaitForMessageDelivery() {
       verify(listener).deframerClosed(false);
       verify(listener, atLeastOnce()).bytesRead(anyInt());
       verifyNoMoreInteractions(listener);
-      checkStats(tracer, transportTracer.getStats(), fakeClock, 1, 1);
+      checkStats(tracer, transportTracer.getStats(), fakeClock, useGzipInflatingBuffer, 1, 1);
     }
 
     @Test
@@ -307,6 +309,7 @@ public void compressed() {
       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);
     }
 
@@ -337,16 +340,13 @@ public Void answer(InvocationOnMock invocation) throws Throwable {
 
   @RunWith(JUnit4.class)
   public static class SizeEnforcingInputStreamTests {
-    @SuppressWarnings("deprecation") // https://github.com/grpc/grpc-java/issues/7467
-    @Rule
-    public final ExpectedException thrown = ExpectedException.none();
 
     private TestBaseStreamTracer tracer = new TestBaseStreamTracer();
     private StatsTraceContext statsTraceCtx = new StatsTraceContext(new StreamTracer[]{tracer});
 
     @Test
     public void sizeEnforcingInputStream_readByteBelowLimit() throws IOException {
-      ByteArrayInputStream in = new ByteArrayInputStream("foo".getBytes(Charsets.UTF_8));
+      ByteArrayInputStream in = new ByteArrayInputStream("foo".getBytes(StandardCharsets.UTF_8));
       SizeEnforcingInputStream stream =
               new MessageDeframer.SizeEnforcingInputStream(in, 4, statsTraceCtx);
 
@@ -359,7 +359,7 @@ public void sizeEnforcingInputStream_readByteBelowLimit() throws IOException {
 
     @Test
     public void sizeEnforcingInputStream_readByteAtLimit() throws IOException {
-      ByteArrayInputStream in = new ByteArrayInputStream("foo".getBytes(Charsets.UTF_8));
+      ByteArrayInputStream in = new ByteArrayInputStream("foo".getBytes(StandardCharsets.UTF_8));
       SizeEnforcingInputStream stream =
               new MessageDeframer.SizeEnforcingInputStream(in, 3, statsTraceCtx);
 
@@ -372,16 +372,17 @@ public void sizeEnforcingInputStream_readByteAtLimit() throws IOException {
 
     @Test
     public void sizeEnforcingInputStream_readByteAboveLimit() throws IOException {
-      ByteArrayInputStream in = new ByteArrayInputStream("foo".getBytes(Charsets.UTF_8));
+      ByteArrayInputStream in = new ByteArrayInputStream("foo".getBytes(StandardCharsets.UTF_8));
       SizeEnforcingInputStream stream =
               new MessageDeframer.SizeEnforcingInputStream(in, 2, statsTraceCtx);
 
       try {
-        thrown.expect(StatusRuntimeException.class);
-        thrown.expectMessage("RESOURCE_EXHAUSTED: Compressed gRPC message exceeds");
-
-        while (stream.read() != -1) {
-        }
+        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();
       }
@@ -389,7 +390,7 @@ public void sizeEnforcingInputStream_readByteAboveLimit() throws IOException {
 
     @Test
     public void sizeEnforcingInputStream_readBelowLimit() throws IOException {
-      ByteArrayInputStream in = new ByteArrayInputStream("foo".getBytes(Charsets.UTF_8));
+      ByteArrayInputStream in = new ByteArrayInputStream("foo".getBytes(StandardCharsets.UTF_8));
       SizeEnforcingInputStream stream =
               new MessageDeframer.SizeEnforcingInputStream(in, 4, statsTraceCtx);
       byte[] buf = new byte[10];
@@ -403,7 +404,7 @@ public void sizeEnforcingInputStream_readBelowLimit() throws IOException {
 
     @Test
     public void sizeEnforcingInputStream_readAtLimit() throws IOException {
-      ByteArrayInputStream in = new ByteArrayInputStream("foo".getBytes(Charsets.UTF_8));
+      ByteArrayInputStream in = new ByteArrayInputStream("foo".getBytes(StandardCharsets.UTF_8));
       SizeEnforcingInputStream stream =
               new MessageDeframer.SizeEnforcingInputStream(in, 3, statsTraceCtx);
       byte[] buf = new byte[10];
@@ -417,16 +418,16 @@ public void sizeEnforcingInputStream_readAtLimit() throws IOException {
 
     @Test
     public void sizeEnforcingInputStream_readAboveLimit() throws IOException {
-      ByteArrayInputStream in = new ByteArrayInputStream("foo".getBytes(Charsets.UTF_8));
+      ByteArrayInputStream in = new ByteArrayInputStream("foo".getBytes(StandardCharsets.UTF_8));
       SizeEnforcingInputStream stream =
               new MessageDeframer.SizeEnforcingInputStream(in, 2, statsTraceCtx);
       byte[] buf = new byte[10];
 
       try {
-        thrown.expect(StatusRuntimeException.class);
-        thrown.expectMessage("RESOURCE_EXHAUSTED: Compressed gRPC message exceeds");
-
-        stream.read(buf, 0, buf.length);
+        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();
       }
@@ -434,7 +435,7 @@ public void sizeEnforcingInputStream_readAboveLimit() throws IOException {
 
     @Test
     public void sizeEnforcingInputStream_skipBelowLimit() throws IOException {
-      ByteArrayInputStream in = new ByteArrayInputStream("foo".getBytes(Charsets.UTF_8));
+      ByteArrayInputStream in = new ByteArrayInputStream("foo".getBytes(StandardCharsets.UTF_8));
       SizeEnforcingInputStream stream =
               new MessageDeframer.SizeEnforcingInputStream(in, 4, statsTraceCtx);
 
@@ -448,7 +449,7 @@ public void sizeEnforcingInputStream_skipBelowLimit() throws IOException {
 
     @Test
     public void sizeEnforcingInputStream_skipAtLimit() throws IOException {
-      ByteArrayInputStream in = new ByteArrayInputStream("foo".getBytes(Charsets.UTF_8));
+      ByteArrayInputStream in = new ByteArrayInputStream("foo".getBytes(StandardCharsets.UTF_8));
       SizeEnforcingInputStream stream =
               new MessageDeframer.SizeEnforcingInputStream(in, 3, statsTraceCtx);
 
@@ -461,15 +462,14 @@ public void sizeEnforcingInputStream_skipAtLimit() throws IOException {
 
     @Test
     public void sizeEnforcingInputStream_skipAboveLimit() throws IOException {
-      ByteArrayInputStream in = new ByteArrayInputStream("foo".getBytes(Charsets.UTF_8));
+      ByteArrayInputStream in = new ByteArrayInputStream("foo".getBytes(StandardCharsets.UTF_8));
       SizeEnforcingInputStream stream =
               new MessageDeframer.SizeEnforcingInputStream(in, 2, statsTraceCtx);
 
       try {
-        thrown.expect(StatusRuntimeException.class);
-        thrown.expectMessage("RESOURCE_EXHAUSTED: Compressed gRPC message exceeds");
-
-        stream.skip(4);
+        StatusRuntimeException e = assertThrows(StatusRuntimeException.class, () -> stream.skip(4));
+        assertThat(e).hasMessageThat()
+            .isEqualTo("RESOURCE_EXHAUSTED: Decompressed gRPC message exceeds maximum size 2");
       } finally {
         stream.close();
       }
@@ -477,7 +477,7 @@ public void sizeEnforcingInputStream_skipAboveLimit() throws IOException {
 
     @Test
     public void sizeEnforcingInputStream_markReset() throws IOException {
-      ByteArrayInputStream in = new ByteArrayInputStream("foo".getBytes(Charsets.UTF_8));
+      ByteArrayInputStream in = new ByteArrayInputStream("foo".getBytes(StandardCharsets.UTF_8));
       SizeEnforcingInputStream stream =
               new MessageDeframer.SizeEnforcingInputStream(in, 3, statsTraceCtx);
       // stream currently looks like: |foo
@@ -494,12 +494,15 @@ public void sizeEnforcingInputStream_markReset() throws IOException {
   }
 
   /**
+   * 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, long... sizes) {
+      TestBaseStreamTracer tracer, TransportStats transportStats, FakeClock clock,
+      boolean compressed, long... sizes) {
     assertEquals(0, sizes.length % 2);
     int count = sizes.length / 2;
     long expectedWireSize = 0;
@@ -507,7 +510,8 @@ private static void checkStats(
     for (int i = 0; i < count; i++) {
       assertEquals("inboundMessage(" + i + ")", tracer.nextInboundEvent());
       assertEquals(
-          String.format("inboundMessageRead(%d, %d, -1)", i, sizes[i * 2]),
+          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];
diff --git a/core/src/test/java/io/grpc/internal/MessageFramerTest.java b/core/src/test/java/io/grpc/internal/MessageFramerTest.java
index 91698acced7..07f717cb81d 100644
--- a/core/src/test/java/io/grpc/internal/MessageFramerTest.java
+++ b/core/src/test/java/io/grpc/internal/MessageFramerTest.java
@@ -34,6 +34,7 @@
 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;
@@ -372,6 +373,8 @@ private static void writeKnownLength(MessageFramer framer, byte[] bytes) {
   }
 
   /**
+   * Verify stats were published through the tracer.
+   *
    * @param sizes in the format {wire0, uncompressed0, wire1, uncompressed1, ...}
    */
   private void checkStats(long... sizes) {
@@ -382,7 +385,8 @@ private void checkStats(long... sizes) {
     for (int i = 0; i < count; i++) {
       assertEquals("outboundMessage(" + i + ")", tracer.nextOutboundEvent());
       assertEquals(
-          String.format("outboundMessageSent(%d, %d, %d)", i, sizes[i * 2], sizes[i * 2 + 1]),
+          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];
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/NoopClientStreamTest.java b/core/src/test/java/io/grpc/internal/NoopClientStreamTest.java
new file mode 100644
index 00000000000..d68642dad85
--- /dev/null
+++ b/core/src/test/java/io/grpc/internal/NoopClientStreamTest.java
@@ -0,0 +1,44 @@
+/*
+ * 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.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
+import java.io.InputStream;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Unit tests for {@link NoopClientStream}.
+ */
+@RunWith(JUnit4.class)
+public class NoopClientStreamTest {
+
+  @Test
+  public void writeMessageShouldCloseInputStream() throws Exception {
+    // NoopClientStream.writeMessage() is called when a stream is cancelled or failed
+    // before the real transport stream is established (e.g. via DelayedStream draining
+    // buffered messages to NoopClientStream on cancellation, or FailingClientStream
+    // which extends NoopClientStream). The InputStream must be closed to avoid leaking
+    // resources such as ref-counted ByteBufs.
+    InputStream message = mock(InputStream.class);
+    NoopClientStream.INSTANCE.writeMessage(message);
+    verify(message).close();
+  }
+}
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..eb7b40257c0
--- /dev/null
+++ b/core/src/test/java/io/grpc/internal/PickFirstLeafLoadBalancerTest.java
@@ -0,0 +1,3137 @@
+/*
+ * 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.InternalEquivalentAddressGroup.ATTR_WEIGHT;
+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.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Queue;
+import java.util.Random;
+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 boolean originalWeightedShuffling;
+
+  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));
+
+    originalWeightedShuffling = PickFirstLeafLoadBalancer.weightedShuffling;
+
+    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);
+    }
+    PickFirstLeafLoadBalancer.weightedShuffling = originalWeightedShuffling;
+
+    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_oppositeWeightedShuffling() {
+    PickFirstLeafLoadBalancer.weightedShuffling = !PickFirstLeafLoadBalancer.weightedShuffling;
+    pickAfterResolved_shuffle();
+  }
+
+  @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 pickAfterResolved_shuffleImplicitUniform_oppositeWeightedShuffling() {
+    PickFirstLeafLoadBalancer.weightedShuffling = !PickFirstLeafLoadBalancer.weightedShuffling;
+    pickAfterResolved_shuffleImplicitUniform();
+  }
+
+  @Test
+  public void pickAfterResolved_shuffleImplicitUniform() {
+    EquivalentAddressGroup eag1 = new EquivalentAddressGroup(new FakeSocketAddress("server1"));
+    EquivalentAddressGroup eag2 = new EquivalentAddressGroup(new FakeSocketAddress("server2"));
+    EquivalentAddressGroup eag3 = new EquivalentAddressGroup(new FakeSocketAddress("server3"));
+
+    int[] counts = countAddressSelections(99, Arrays.asList(eag1, eag2, eag3));
+    assertThat(counts[0]).isWithin(7).of(33);
+    assertThat(counts[1]).isWithin(7).of(33);
+    assertThat(counts[2]).isWithin(7).of(33);
+  }
+
+  @Test
+  public void pickAfterResolved_shuffleExplicitUniform_oppositeWeightedShuffling() {
+    PickFirstLeafLoadBalancer.weightedShuffling = !PickFirstLeafLoadBalancer.weightedShuffling;
+    pickAfterResolved_shuffleExplicitUniform();
+  }
+
+  @Test
+  public void pickAfterResolved_shuffleExplicitUniform() {
+    EquivalentAddressGroup eag1 = new EquivalentAddressGroup(
+        new FakeSocketAddress("server1"), Attributes.newBuilder().set(ATTR_WEIGHT, 111L).build());
+    EquivalentAddressGroup eag2 = new EquivalentAddressGroup(
+        new FakeSocketAddress("server2"), Attributes.newBuilder().set(ATTR_WEIGHT, 111L).build());
+    EquivalentAddressGroup eag3 = new EquivalentAddressGroup(
+        new FakeSocketAddress("server3"), Attributes.newBuilder().set(ATTR_WEIGHT, 111L).build());
+
+    int[] counts = countAddressSelections(99, Arrays.asList(eag1, eag2, eag3));
+    assertThat(counts[0]).isWithin(7).of(33);
+    assertThat(counts[1]).isWithin(7).of(33);
+    assertThat(counts[2]).isWithin(7).of(33);
+  }
+
+  @Test
+  public void pickAfterResolved_shuffleWeighted_noWeightedShuffling() {
+    PickFirstLeafLoadBalancer.weightedShuffling = false;
+    EquivalentAddressGroup eag1 = new EquivalentAddressGroup(
+        new FakeSocketAddress("server1"), Attributes.newBuilder().set(ATTR_WEIGHT, 12L).build());
+    EquivalentAddressGroup eag2 = new EquivalentAddressGroup(
+        new FakeSocketAddress("server2"), Attributes.newBuilder().set(ATTR_WEIGHT, 3L).build());
+    EquivalentAddressGroup eag3 = new EquivalentAddressGroup(
+        new FakeSocketAddress("server3"), Attributes.newBuilder().set(ATTR_WEIGHT, 1L).build());
+
+    int[] counts = countAddressSelections(100, Arrays.asList(eag1, eag2, eag3));
+    assertThat(counts[0]).isWithin(7).of(33);
+    assertThat(counts[1]).isWithin(7).of(33);
+    assertThat(counts[2]).isWithin(7).of(33);
+  }
+
+  @Test
+  public void pickAfterResolved_shuffleWeighted_weightedShuffling() {
+    PickFirstLeafLoadBalancer.weightedShuffling = true;
+    EquivalentAddressGroup eag1 = new EquivalentAddressGroup(
+        new FakeSocketAddress("server1"), Attributes.newBuilder().set(ATTR_WEIGHT, 12L).build());
+    EquivalentAddressGroup eag2 = new EquivalentAddressGroup(
+        new FakeSocketAddress("server2"), Attributes.newBuilder().set(ATTR_WEIGHT, 3L).build());
+    EquivalentAddressGroup eag3 = new EquivalentAddressGroup(
+        new FakeSocketAddress("server3"), Attributes.newBuilder().set(ATTR_WEIGHT, 1L).build());
+
+    int[] counts = countAddressSelections(100, Arrays.asList(eag1, eag2, eag3));
+    assertThat(counts[0]).isWithin(7).of(75); // 100*12/16
+    assertThat(counts[1]).isWithin(7).of(19); // 100*3/16
+    assertThat(counts[2]).isWithin(7).of(6); // 100*1/16
+  }
+
+  /** Returns int[index_of_eag] array with number of times each eag was selected. */
+  private int[] countAddressSelections(int trials, List<EquivalentAddressGroup> eags) {
+    int[] counts = new int[eags.size()];
+    Random random = new Random(1);
+    for (int i = 0; i < trials; i++) {
+      RecordingHelper helper = new RecordingHelper();
+      LoadBalancer lb = new PickFirstLeafLoadBalancer(helper);
+      assertThat(lb.acceptResolvedAddresses(ResolvedAddresses.newBuilder()
+            .setAddresses(eags)
+            .setAttributes(affinity)
+            .setLoadBalancingPolicyConfig(
+                new PickFirstLeafLoadBalancerConfig(true, random.nextLong()))
+            .build()))
+          .isSameInstanceAs(Status.OK);
+      helper.subchannels.remove().listener.onSubchannelState(
+          ConnectivityStateInfo.forNonError(READY));
+
+      assertThat(helper.state).isEqualTo(READY);
+      Subchannel subchannel = helper.picker.pickSubchannel(mockArgs).getSubchannel();
+      counts[eags.indexOf(subchannel.getAddresses())]++;
+
+      lb.shutdown();
+    }
+    return counts;
+  }
+
+  @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());
+
+    if (serializeRetries) {
+      inOrder.verify(mockSubchannel3, never()).start(stateListenerCaptor.capture());
+      forwardTimeByBackoffDelay();
+    }
+
+    // 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 BaseHelper extends LoadBalancer.Helper {
+    @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
+    }
+  }
+
+  private class MockHelperImpl extends BaseHelper {
+    private final List<Subchannel> subchannels;
+
+    public MockHelperImpl(List<? extends Subchannel> subchannels) {
+      this.subchannels = new ArrayList<Subchannel>(subchannels);
+    }
+
+    @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());
+    }
+  }
+
+  class RecordingHelper extends BaseHelper {
+    ConnectivityState state;
+    SubchannelPicker picker;
+    final Queue<FakeSubchannel> subchannels = new ArrayDeque<>();
+
+    @Override
+    public void updateBalancingState(ConnectivityState newState, SubchannelPicker newPicker) {
+      this.state = newState;
+      this.picker = newPicker;
+    }
+
+    @Override
+    public Subchannel createSubchannel(CreateSubchannelArgs args) {
+      FakeSubchannel subchannel = new FakeSubchannel(args.getAddresses(), args.getAttributes());
+      subchannels.add(subchannel);
+      return subchannel;
+    }
+  }
+}
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
index 1c3e0cb1a1b..1e130423a45 100644
--- a/core/src/test/java/io/grpc/internal/PickFirstLoadBalancerTest.java
+++ b/core/src/test/java/io/grpc/internal/PickFirstLoadBalancerTest.java
@@ -21,7 +21,10 @@
 import static io.grpc.ConnectivityState.IDLE;
 import static io.grpc.ConnectivityState.READY;
 import static io.grpc.ConnectivityState.TRANSIENT_FAILURE;
+import static io.grpc.InternalEquivalentAddressGroup.ATTR_WEIGHT;
 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;
@@ -47,10 +50,18 @@
 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.PickFirstLoadBalancer.PickFirstLoadBalancerConfig;
 import java.net.SocketAddress;
+import java.util.ArrayDeque;
+import java.util.Arrays;
+import java.util.Collections;
 import java.util.List;
+import java.util.Queue;
+import java.util.Random;
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Rule;
@@ -87,6 +98,8 @@ public void uncaughtException(Thread t, Throwable e) {
   @Captor
   private ArgumentCaptor<SubchannelPicker> pickerCaptor;
   @Captor
+  private ArgumentCaptor<ConnectivityState> connectivityStateCaptor;
+  @Captor
   private ArgumentCaptor<CreateSubchannelArgs> createArgsCaptor;
   @Captor
   private ArgumentCaptor<SubchannelStateListener> stateListenerCaptor;
@@ -97,8 +110,12 @@ public void uncaughtException(Thread t, Throwable e) {
   @Mock // This LoadBalancer doesn't use any of the arg fields, as verified in tearDown().
   private PickSubchannelArgs mockArgs;
 
+  private boolean originalWeightedShuffling;
+
   @Before
   public void setUp() {
+    originalWeightedShuffling = PickFirstLeafLoadBalancer.weightedShuffling;
+
     for (int i = 0; i < 3; i++) {
       SocketAddress addr = new FakeSocketAddress("server" + i);
       servers.add(new EquivalentAddressGroup(addr));
@@ -114,12 +131,13 @@ public void setUp() {
 
   @After
   public void tearDown() throws Exception {
+    PickFirstLeafLoadBalancer.weightedShuffling = originalWeightedShuffling;
     verifyNoMoreInteractions(mockArgs);
   }
 
   @Test
   public void pickAfterResolved() throws Exception {
-    loadBalancer.handleResolvedAddresses(
+    loadBalancer.acceptResolvedAddresses(
         ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(affinity).build());
 
     verify(mockHelper).createSubchannel(createArgsCaptor.capture());
@@ -135,9 +153,155 @@ public void pickAfterResolved() throws Exception {
     verifyNoMoreInteractions(mockHelper);
   }
 
+  @Test
+  public void pickAfterResolved_shuffle_oppositeWeightedShuffling() throws Exception {
+    PickFirstLeafLoadBalancer.weightedShuffling = !PickFirstLeafLoadBalancer.weightedShuffling;
+    pickAfterResolved_shuffle();
+  }
+
+  @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 pickAfterResolved_shuffleImplicitUniform_oppositeWeightedShuffling() {
+    PickFirstLeafLoadBalancer.weightedShuffling = !PickFirstLeafLoadBalancer.weightedShuffling;
+    pickAfterResolved_shuffleImplicitUniform();
+  }
+
+  @Test
+  public void pickAfterResolved_shuffleImplicitUniform() {
+    EquivalentAddressGroup eag1 = new EquivalentAddressGroup(new FakeSocketAddress("server1"));
+    EquivalentAddressGroup eag2 = new EquivalentAddressGroup(new FakeSocketAddress("server2"));
+    EquivalentAddressGroup eag3 = new EquivalentAddressGroup(new FakeSocketAddress("server3"));
+
+    int[] counts = countAddressSelections(99, Arrays.asList(eag1, eag2, eag3));
+    assertThat(counts[0]).isWithin(7).of(33);
+    assertThat(counts[1]).isWithin(7).of(33);
+    assertThat(counts[2]).isWithin(7).of(33);
+  }
+
+  @Test
+  public void pickAfterResolved_shuffleExplicitUniform_oppositeWeightedShuffling() {
+    PickFirstLeafLoadBalancer.weightedShuffling = !PickFirstLeafLoadBalancer.weightedShuffling;
+    pickAfterResolved_shuffleExplicitUniform();
+  }
+
+  @Test
+  public void pickAfterResolved_shuffleExplicitUniform() {
+    EquivalentAddressGroup eag1 = new EquivalentAddressGroup(
+        new FakeSocketAddress("server1"), Attributes.newBuilder().set(ATTR_WEIGHT, 111L).build());
+    EquivalentAddressGroup eag2 = new EquivalentAddressGroup(
+        new FakeSocketAddress("server2"), Attributes.newBuilder().set(ATTR_WEIGHT, 111L).build());
+    EquivalentAddressGroup eag3 = new EquivalentAddressGroup(
+        new FakeSocketAddress("server3"), Attributes.newBuilder().set(ATTR_WEIGHT, 111L).build());
+
+    int[] counts = countAddressSelections(99, Arrays.asList(eag1, eag2, eag3));
+    assertThat(counts[0]).isWithin(7).of(33);
+    assertThat(counts[1]).isWithin(7).of(33);
+    assertThat(counts[2]).isWithin(7).of(33);
+  }
+
+  @Test
+  public void pickAfterResolved_shuffleWeighted_noWeightedShuffling() {
+    PickFirstLeafLoadBalancer.weightedShuffling = false;
+    EquivalentAddressGroup eag1 = new EquivalentAddressGroup(
+        new FakeSocketAddress("server1"), Attributes.newBuilder().set(ATTR_WEIGHT, 12L).build());
+    EquivalentAddressGroup eag2 = new EquivalentAddressGroup(
+        new FakeSocketAddress("server2"), Attributes.newBuilder().set(ATTR_WEIGHT, 3L).build());
+    EquivalentAddressGroup eag3 = new EquivalentAddressGroup(
+        new FakeSocketAddress("server3"), Attributes.newBuilder().set(ATTR_WEIGHT, 1L).build());
+
+    int[] counts = countAddressSelections(100, Arrays.asList(eag1, eag2, eag3));
+    assertThat(counts[0]).isWithin(7).of(33);
+    assertThat(counts[1]).isWithin(7).of(33);
+    assertThat(counts[2]).isWithin(7).of(33);
+  }
+
+  @Test
+  public void pickAfterResolved_shuffleWeighted_weightedShuffling() {
+    PickFirstLeafLoadBalancer.weightedShuffling = true;
+    EquivalentAddressGroup eag1 = new EquivalentAddressGroup(
+        new FakeSocketAddress("server1"), Attributes.newBuilder().set(ATTR_WEIGHT, 12L).build());
+    EquivalentAddressGroup eag2 = new EquivalentAddressGroup(
+        new FakeSocketAddress("server2"), Attributes.newBuilder().set(ATTR_WEIGHT, 3L).build());
+    EquivalentAddressGroup eag3 = new EquivalentAddressGroup(
+        new FakeSocketAddress("server3"), Attributes.newBuilder().set(ATTR_WEIGHT, 1L).build());
+
+    int[] counts = countAddressSelections(100, Arrays.asList(eag1, eag2, eag3));
+    assertThat(counts[0]).isWithin(7).of(75); // 100*12/16
+    assertThat(counts[1]).isWithin(7).of(19); // 100*3/16
+    assertThat(counts[2]).isWithin(7).of(6); // 100*1/16
+  }
+
+  /** Returns int[index_of_eag] array with number of times each eag was selected. */
+  private int[] countAddressSelections(int trials, List<EquivalentAddressGroup> eags) {
+    int[] counts = new int[eags.size()];
+    Random random = new Random(1);
+    for (int i = 0; i < trials; i++) {
+      RecordingHelper helper = new RecordingHelper();
+      PickFirstLoadBalancer lb = new PickFirstLoadBalancer(helper);
+      assertThat(lb.acceptResolvedAddresses(ResolvedAddresses.newBuilder()
+            .setAddresses(eags)
+            .setAttributes(affinity)
+            .setLoadBalancingPolicyConfig(
+                new PickFirstLoadBalancerConfig(true, random.nextLong()))
+            .build()))
+          .isSameInstanceAs(Status.OK);
+      helper.subchannels.remove().listener.onSubchannelState(
+          ConnectivityStateInfo.forNonError(READY));
+
+      assertThat(helper.state).isEqualTo(READY);
+      Subchannel subchannel = helper.picker.pickSubchannel(mockArgs).getSubchannel();
+      counts[eags.indexOf(subchannel.getAllAddresses().get(0))]++;
+
+      lb.shutdown();
+    }
+    return counts;
+  }
+
   @Test
   public void requestConnectionPicker() throws Exception {
-    loadBalancer.handleResolvedAddresses(
+    loadBalancer.acceptResolvedAddresses(
         ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(affinity).build());
 
     InOrder inOrder = inOrder(mockHelper, mockSubchannel);
@@ -160,13 +324,45 @@ public void requestConnectionPicker() throws Exception {
     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.handleResolvedAddresses(
+    loadBalancer.acceptResolvedAddresses(
         ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(affinity).build());
     verify(mockSubchannel).start(any(SubchannelStateListener.class));
     verify(mockSubchannel).requestConnection();
-    loadBalancer.handleResolvedAddresses(
+    loadBalancer.acceptResolvedAddresses(
         ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(affinity).build());
     verify(mockSubchannel).updateAddresses(eq(servers));
     verifyNoMoreInteractions(mockSubchannel);
@@ -189,7 +385,7 @@ public void pickAfterResolvedAndChanged() throws Exception {
 
     InOrder inOrder = inOrder(mockHelper, mockSubchannel);
 
-    loadBalancer.handleResolvedAddresses(
+    loadBalancer.acceptResolvedAddresses(
         ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(affinity).build());
     inOrder.verify(mockHelper).createSubchannel(createArgsCaptor.capture());
     verify(mockSubchannel).start(any(SubchannelStateListener.class));
@@ -197,9 +393,9 @@ public void pickAfterResolvedAndChanged() throws Exception {
     assertThat(args.getAddresses()).isEqualTo(servers);
     inOrder.verify(mockHelper).updateBalancingState(eq(CONNECTING), pickerCaptor.capture());
     verify(mockSubchannel).requestConnection();
-    assertEquals(mockSubchannel, pickerCaptor.getValue().pickSubchannel(mockArgs).getSubchannel());
+    assertThat(pickerCaptor.getValue().pickSubchannel(mockArgs).hasResult()).isFalse();
 
-    loadBalancer.handleResolvedAddresses(
+    loadBalancer.acceptResolvedAddresses(
         ResolvedAddresses.newBuilder().setAddresses(newServers).setAttributes(affinity).build());
     inOrder.verify(mockSubchannel).updateAddresses(eq(newServers));
 
@@ -211,7 +407,7 @@ public void pickAfterResolvedAndChanged() throws Exception {
   public void pickAfterStateChangeAfterResolution() throws Exception {
     InOrder inOrder = inOrder(mockHelper);
 
-    loadBalancer.handleResolvedAddresses(
+    loadBalancer.acceptResolvedAddresses(
         ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(affinity).build());
     inOrder.verify(mockHelper).createSubchannel(createArgsCaptor.capture());
     CreateSubchannelArgs args = createArgsCaptor.getValue();
@@ -219,27 +415,66 @@ public void pickAfterStateChangeAfterResolution() throws Exception {
     verify(mockSubchannel).start(stateListenerCaptor.capture());
     SubchannelStateListener stateListener = stateListenerCaptor.getValue();
     verify(mockHelper).updateBalancingState(eq(CONNECTING), pickerCaptor.capture());
-    Subchannel subchannel = pickerCaptor.getValue().pickSubchannel(mockArgs).getSubchannel();
+    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(IDLE));
-    inOrder.verify(mockHelper).updateBalancingState(eq(IDLE), pickerCaptor.capture());
-    assertEquals(Status.OK, pickerCaptor.getValue().pickSubchannel(mockArgs).getStatus());
-
     stateListener.onSubchannelState(ConnectivityStateInfo.forNonError(READY));
     inOrder.verify(mockHelper).updateBalancingState(eq(READY), pickerCaptor.capture());
-    assertEquals(subchannel, pickerCaptor.getValue().pickSubchannel(mockArgs).getSubchannel());
+    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");
@@ -252,6 +487,21 @@ public void nameResolutionError() throws Exception {
     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);
@@ -261,7 +511,7 @@ public void nameResolutionSuccessAfterError() throws Exception {
         .updateBalancingState(any(ConnectivityState.class), any(SubchannelPicker.class));
     verify(mockSubchannel, never()).requestConnection();
 
-    loadBalancer.handleResolvedAddresses(
+    loadBalancer.acceptResolvedAddresses(
         ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(affinity).build());
     inOrder.verify(mockHelper).createSubchannel(createArgsCaptor.capture());
     CreateSubchannelArgs args = createArgsCaptor.getValue();
@@ -270,8 +520,7 @@ public void nameResolutionSuccessAfterError() throws Exception {
     inOrder.verify(mockHelper).updateBalancingState(eq(CONNECTING), pickerCaptor.capture());
     verify(mockSubchannel).requestConnection();
 
-    assertEquals(mockSubchannel, pickerCaptor.getValue().pickSubchannel(mockArgs)
-        .getSubchannel());
+    assertThat(pickerCaptor.getValue().pickSubchannel(mockArgs).hasResult()).isFalse();
 
     assertEquals(pickerCaptor.getValue().pickSubchannel(mockArgs),
         pickerCaptor.getValue().pickSubchannel(mockArgs));
@@ -282,7 +531,7 @@ public void nameResolutionSuccessAfterError() throws Exception {
   @Test
   public void nameResolutionErrorWithStateChanges() throws Exception {
     InOrder inOrder = inOrder(mockHelper);
-    loadBalancer.handleResolvedAddresses(
+    loadBalancer.acceptResolvedAddresses(
         ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(affinity).build());
     inOrder.verify(mockHelper).createSubchannel(createArgsCaptor.capture());
     verify(mockSubchannel).start(stateListenerCaptor.capture());
@@ -294,6 +543,7 @@ public void nameResolutionErrorWithStateChanges() throws Exception {
     SubchannelStateListener stateListener = stateListenerCaptor.getValue();
 
     stateListener.onSubchannelState(ConnectivityStateInfo.forTransientFailure(Status.UNAVAILABLE));
+    inOrder.verify(mockHelper).refreshNameResolution();
     inOrder.verify(mockHelper).updateBalancingState(
         eq(TRANSIENT_FAILURE), any(SubchannelPicker.class));
 
@@ -321,7 +571,7 @@ public void requestConnection() {
     loadBalancer.requestConnection();
 
     verify(mockSubchannel, never()).requestConnection();
-    loadBalancer.handleResolvedAddresses(
+    loadBalancer.acceptResolvedAddresses(
         ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(affinity).build());
     verify(mockSubchannel).requestConnection();
 
@@ -351,4 +601,96 @@ public String toString() {
       return "FakeSocketAddress-" + name;
     }
   }
+
+  private static class FakeSubchannel extends Subchannel {
+    private final Attributes attributes;
+    private List<EquivalentAddressGroup> eags;
+    private SubchannelStateListener listener;
+
+    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 = listener;
+    }
+
+    @Override
+    public void updateAddresses(List<EquivalentAddressGroup> addrs) {
+      this.eags = Collections.unmodifiableList(addrs);
+    }
+
+    @Override
+    public void shutdown() {
+      listener.onSubchannelState(ConnectivityStateInfo.forNonError(ConnectivityState.SHUTDOWN));
+    }
+
+    @Override
+    public void requestConnection() {
+    }
+
+    @Override
+    public String toString() {
+      return "FakeSubchannel@" + hashCode() + "(" + eags + ")";
+    }
+  }
+
+  private class BaseHelper extends Helper {
+    @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 void refreshNameResolution() {
+      // noop
+    }
+  }
+
+  class RecordingHelper extends BaseHelper {
+    ConnectivityState state;
+    SubchannelPicker picker;
+    final Queue<FakeSubchannel> subchannels = new ArrayDeque<>();
+
+    @Override
+    public void updateBalancingState(ConnectivityState newState, SubchannelPicker newPicker) {
+      this.state = newState;
+      this.picker = newPicker;
+    }
+
+    @Override
+    public Subchannel createSubchannel(CreateSubchannelArgs args) {
+      FakeSubchannel subchannel = new FakeSubchannel(args.getAddresses(), args.getAttributes());
+      subchannels.add(subchannel);
+      return subchannel;
+    }
+  }
+
 }
diff --git a/core/src/test/java/io/grpc/internal/ProxyDetectorImplTest.java b/core/src/test/java/io/grpc/internal/ProxyDetectorImplTest.java
index 682cc5abec9..771050f119d 100644
--- a/core/src/test/java/io/grpc/internal/ProxyDetectorImplTest.java
+++ b/core/src/test/java/io/grpc/internal/ProxyDetectorImplTest.java
@@ -73,7 +73,7 @@ public ProxySelector get() {
         return proxySelector;
       }
     };
-    proxyDetector = new ProxyDetectorImpl(proxySelectorSupplier, authenticator, null);
+    proxyDetector = new ProxyDetectorImpl(proxySelectorSupplier, authenticator);
     unresolvedProxy = InetSocketAddress.createUnresolved("10.0.0.1", proxyPort);
     proxySocketAddress = HttpConnectProxiedSocketAddress.newBuilder()
         .setTargetAddress(destination)
@@ -82,45 +82,6 @@ public ProxySelector get() {
         .build();
   }
 
-  @Test
-  public void override_hostPort() throws Exception {
-    final String overrideHost = "10.99.99.99";
-    final int overridePort = 1234;
-    final String overrideHostWithPort = overrideHost + ":" + overridePort;
-    ProxyDetectorImpl proxyDetector = new ProxyDetectorImpl(
-        proxySelectorSupplier,
-        authenticator,
-        overrideHostWithPort);
-    ProxiedSocketAddress detected = proxyDetector.proxyFor(destination);
-    assertNotNull(detected);
-    assertEquals(
-        HttpConnectProxiedSocketAddress.newBuilder()
-            .setTargetAddress(destination)
-            .setProxyAddress(
-                new InetSocketAddress(InetAddress.getByName(overrideHost), overridePort))
-            .build(),
-        detected);
-  }
-
-  @Test
-  public void override_hostOnly() throws Exception {
-    final String overrideHostWithoutPort = "10.99.99.99";
-    final int defaultPort = 80;
-    ProxyDetectorImpl proxyDetector = new ProxyDetectorImpl(
-        proxySelectorSupplier,
-        authenticator,
-        overrideHostWithoutPort);
-    ProxiedSocketAddress detected = proxyDetector.proxyFor(destination);
-    assertNotNull(detected);
-    assertEquals(
-        HttpConnectProxiedSocketAddress.newBuilder()
-            .setTargetAddress(destination)
-            .setProxyAddress(
-                new InetSocketAddress(InetAddress.getByName(overrideHostWithoutPort), defaultPort))
-            .build(),
-        detected);
-  }
-
   @Test
   public void returnNullWhenNoProxy() throws Exception {
     when(proxySelector.select(any(URI.class)))
@@ -201,7 +162,7 @@ public void authRequired() throws Exception {
             anyString(),
             anyString(),
             AdditionalMatchers.or(anyString(), ArgumentMatchers.<String>any())))
-      .thenReturn(auth);
+        .thenReturn(auth);
     when(proxySelector.select(any(URI.class))).thenReturn(ImmutableList.of(proxy));
 
     ProxiedSocketAddress detected = proxyDetector.proxyFor(destination);
@@ -227,8 +188,7 @@ public ProxySelector get() {
             return null;
           }
         },
-        authenticator,
-        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 e469b807d51..00000000000
--- a/core/src/test/java/io/grpc/internal/ReadableBufferTestBase.java
+++ /dev/null
@@ -1,130 +0,0 @@
-/*
- * 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 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.Buffer;
-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);
-    ((Buffer) 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);
-    ((Buffer) 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 d5c4fa77fd8..5b0fb02c611 100644
--- a/core/src/test/java/io/grpc/internal/ReadableBuffersArrayTest.java
+++ b/core/src/test/java/io/grpc/internal/ReadableBuffersArrayTest.java
@@ -16,8 +16,8 @@
 
 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;
diff --git a/core/src/test/java/io/grpc/internal/ReadableBuffersByteBufferTest.java b/core/src/test/java/io/grpc/internal/ReadableBuffersByteBufferTest.java
index a040182c259..67e7aaf9132 100644
--- a/core/src/test/java/io/grpc/internal/ReadableBuffersByteBufferTest.java
+++ b/core/src/test/java/io/grpc/internal/ReadableBuffersByteBufferTest.java
@@ -16,7 +16,7 @@
 
 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
index ea9daeed6a3..b9135b49503 100644
--- a/core/src/test/java/io/grpc/internal/ReadableBuffersTest.java
+++ b/core/src/test/java/io/grpc/internal/ReadableBuffersTest.java
@@ -16,15 +16,23 @@
 
 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.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;
@@ -128,4 +136,107 @@ public void bufferInputStream_close_closesBuffer() throws Exception {
     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/RetriableStreamTest.java b/core/src/test/java/io/grpc/internal/RetriableStreamTest.java
index 88812b17902..afbdaa395b0 100644
--- a/core/src/test/java/io/grpc/internal/RetriableStreamTest.java
+++ b/core/src/test/java/io/grpc/internal/RetriableStreamTest.java
@@ -18,6 +18,7 @@
 
 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;
@@ -42,6 +43,7 @@
 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;
@@ -53,17 +55,22 @@
 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;
@@ -119,6 +126,7 @@ public double nextDouble() {
           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(
@@ -139,6 +147,17 @@ public double nextDouble() {
   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,
@@ -156,43 +175,58 @@ private final class RecordedRetriableStream extends RetriableStream<String> {
     }
 
     @Override
+    @SuppressWarnings("DirectInvocationOnMock")
     void postCommit() {
       retriableStreamRecorder.postCommit();
     }
 
     @Override
-    ClientStream newSubstream(ClientStreamTracer.Factory tracerFactory, Metadata metadata) {
+    @SuppressWarnings("DirectInvocationOnMock")
+    ClientStream newSubstream(
+        Metadata metadata,
+        ClientStreamTracer.Factory tracerFactory,
+        int previousAttempts,
+        boolean isTransparentRetry,
+        boolean isHedgedStream) {
       bufferSizeTracer =
-          tracerFactory.newClientStreamTracer(STREAM_INFO, new Metadata());
+          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 final RetriableStream<String> retriableStream =
+  private RetriableStream<String> retriableStream =
       newThrottledRetriableStream(null /* throttle */);
-  private final RetriableStream<String> hedgingStream =
+  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,
-        MoreExecutors.directExecutor(), fakeClock.getScheduledExecutorService(), RETRY_POLICY,
-        null, throttle);
+        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,
-        MoreExecutors.directExecutor(), fakeClock.getScheduledExecutorService(),
+        executor, fakeClock.getScheduledExecutorService(),
         null, HEDGING_POLICY, throttle);
   }
 
@@ -252,6 +286,7 @@ public Void answer(InvocationOnMock in) {
     ArgumentCaptor<ClientStreamListener> sublistenerCaptor1 =
         ArgumentCaptor.forClass(ClientStreamListener.class);
     inOrder.verify(mockStream1).start(sublistenerCaptor1.capture());
+    inOrder.verify(mockStream1).isReady();
     inOrder.verifyNoMoreInteractions();
 
     retriableStream.sendMessage("msg1");
@@ -262,28 +297,33 @@ public Void answer(InvocationOnMock in) {
     retriableStream.sendMessage("msg3");
     retriableStream.request(456);
 
-    inOrder.verify(mockStream1, times(2)).writeMessage(any(InputStream.class));
+    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), new Metadata());
+    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((long) (INITIAL_BACKOFF_IN_SECONDS * FAKE_RANDOM) - 1L, TimeUnit.SECONDS);
+    fakeClock.forwardTime(calculateBackoffWithRetries(0) - 1L, TimeUnit.SECONDS);
     inOrder.verifyNoMoreInteractions();
     assertEquals(1, fakeClock.numPendingTasks());
     fakeClock.forwardTime(1L, TimeUnit.SECONDS);
     assertEquals(0, fakeClock.numPendingTasks());
-    inOrder.verify(retriableStreamRecorder).newSubstream(1);
     inOrder.verify(mockStream2).setAuthority(AUTHORITY);
     inOrder.verify(mockStream2).setCompressor(COMPRESSOR);
     inOrder.verify(mockStream2).setDecompressorRegistry(DECOMPRESSOR_REGISTRY);
@@ -297,12 +337,20 @@ public Void answer(InvocationOnMock in) {
     ArgumentCaptor<ClientStreamListener> sublistenerCaptor2 =
         ArgumentCaptor.forClass(ClientStreamListener.class);
     inOrder.verify(mockStream2).start(sublistenerCaptor2.capture());
-    inOrder.verify(mockStream2, times(2)).writeMessage(any(InputStream.class));
+    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, times(2)).writeMessage(any(InputStream.class));
+    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
@@ -311,11 +359,16 @@ public Void answer(InvocationOnMock in) {
 
     // mockStream1 is closed so it is not in the drainedSubstreams
     verifyNoMoreInteractions(mockStream1);
-    inOrder.verify(mockStream2, times(2)).writeMessage(any(InputStream.class));
+    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), new Metadata());
+    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
@@ -323,14 +376,11 @@ public Void answer(InvocationOnMock in) {
     retriableStream.sendMessage("msg2 during backoff2");
     retriableStream.sendMessage("msg3 during backoff2");
 
-    fakeClock.forwardTime(
-        (long) (INITIAL_BACKOFF_IN_SECONDS * BACKOFF_MULTIPLIER * FAKE_RANDOM) - 1L,
-        TimeUnit.SECONDS);
+    fakeClock.forwardTime(calculateBackoffWithRetries(1) - 1L, TimeUnit.SECONDS);
     inOrder.verifyNoMoreInteractions();
     assertEquals(1, fakeClock.numPendingTasks());
     fakeClock.forwardTime(1L, TimeUnit.SECONDS);
     assertEquals(0, fakeClock.numPendingTasks());
-    inOrder.verify(retriableStreamRecorder).newSubstream(2);
     inOrder.verify(mockStream3).setAuthority(AUTHORITY);
     inOrder.verify(mockStream3).setCompressor(COMPRESSOR);
     inOrder.verify(mockStream3).setDecompressorRegistry(DECOMPRESSOR_REGISTRY);
@@ -344,12 +394,20 @@ public Void answer(InvocationOnMock in) {
     ArgumentCaptor<ClientStreamListener> sublistenerCaptor3 =
         ArgumentCaptor.forClass(ClientStreamListener.class);
     inOrder.verify(mockStream3).start(sublistenerCaptor3.capture());
-    inOrder.verify(mockStream3, times(2)).writeMessage(any(InputStream.class));
+    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, times(7)).writeMessage(any(InputStream.class));
+    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();
@@ -359,10 +417,11 @@ public Void answer(InvocationOnMock in) {
 
     // no more retry
     sublistenerCaptor3.getValue().closed(
-        Status.fromCode(NON_RETRIABLE_STATUS_CODE), new Metadata());
+        Status.fromCode(NON_RETRIABLE_STATUS_CODE), PROCESSED, new Metadata());
 
     inOrder.verify(retriableStreamRecorder).postCommit();
-    inOrder.verify(masterListener).closed(any(Status.class), any(Metadata.class));
+    inOrder.verify(masterListener).closed(
+        any(Status.class), any(RpcProgress.class), any(Metadata.class));
     inOrder.verifyNoMoreInteractions();
 
     insight = new InsightBuilder();
@@ -407,9 +466,10 @@ public void retry_headersRead_cancel() {
     // retry
     ClientStream mockStream2 = mock(ClientStream.class);
     doReturn(mockStream2).when(retriableStreamRecorder).newSubstream(1);
-    sublistenerCaptor1.getValue().closed(Status.fromCode(RETRIABLE_STATUS_CODE_1), new Metadata());
+    sublistenerCaptor1.getValue().closed(
+        Status.fromCode(RETRIABLE_STATUS_CODE_1), PROCESSED, new Metadata());
     assertEquals(1, fakeClock.numPendingTasks());
-    fakeClock.forwardTime((long) (INITIAL_BACKOFF_IN_SECONDS * FAKE_RANDOM), TimeUnit.SECONDS);
+    fakeClock.forwardTime(calculateBackoffWithRetries(0), TimeUnit.SECONDS);
 
     ArgumentCaptor<ClientStreamListener> sublistenerCaptor2 =
         ArgumentCaptor.forClass(ClientStreamListener.class);
@@ -445,9 +505,9 @@ public void headersRead_closed() {
 
     Status status = Status.fromCode(RETRIABLE_STATUS_CODE_1);
     Metadata metadata = new Metadata();
-    sublistenerCaptor1.getValue().closed(status, metadata);
+    sublistenerCaptor1.getValue().closed(status, PROCESSED, metadata);
 
-    verify(masterListener).closed(status, metadata);
+    verify(masterListener).closed(status, PROCESSED, metadata);
     inOrder.verify(retriableStreamRecorder, never()).postCommit();
   }
 
@@ -466,8 +526,9 @@ public void retry_headersRead_closed() {
     // retry
     ClientStream mockStream2 = mock(ClientStream.class);
     doReturn(mockStream2).when(retriableStreamRecorder).newSubstream(1);
-    sublistenerCaptor1.getValue().closed(Status.fromCode(RETRIABLE_STATUS_CODE_1), new Metadata());
-    fakeClock.forwardTime((long) (INITIAL_BACKOFF_IN_SECONDS * FAKE_RANDOM), TimeUnit.SECONDS);
+    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);
@@ -482,9 +543,9 @@ public void retry_headersRead_closed() {
     // closed even with retriable status
     Status status = Status.fromCode(RETRIABLE_STATUS_CODE_1);
     Metadata metadata = new Metadata();
-    sublistenerCaptor2.getValue().closed(status, metadata);
+    sublistenerCaptor2.getValue().closed(status, PROCESSED, metadata);
 
-    verify(masterListener).closed(status, metadata);
+    verify(masterListener).closed(status, PROCESSED, metadata);
     inOrder.verify(retriableStreamRecorder, never()).postCommit();
   }
 
@@ -512,7 +573,7 @@ public void cancel_closed() {
     // closed even with retriable status
     Status status = Status.fromCode(RETRIABLE_STATUS_CODE_1);
     Metadata metadata = new Metadata();
-    sublistenerCaptor1.getValue().closed(status, metadata);
+    sublistenerCaptor1.getValue().closed(status, PROCESSED, metadata);
     inOrder.verify(retriableStreamRecorder, never()).postCommit();
   }
 
@@ -531,8 +592,9 @@ public void retry_cancel_closed() {
     // retry
     ClientStream mockStream2 = mock(ClientStream.class);
     doReturn(mockStream2).when(retriableStreamRecorder).newSubstream(1);
-    sublistenerCaptor1.getValue().closed(Status.fromCode(RETRIABLE_STATUS_CODE_1), new Metadata());
-    fakeClock.forwardTime((long) (INITIAL_BACKOFF_IN_SECONDS * FAKE_RANDOM), TimeUnit.SECONDS);
+    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);
@@ -551,10 +613,48 @@ public void retry_cancel_closed() {
     // closed
     Status status = Status.fromCode(NON_RETRIABLE_STATUS_CODE);
     Metadata metadata = new Metadata();
-    sublistenerCaptor2.getValue().closed(status, 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);
@@ -570,10 +670,10 @@ public void unretriableClosed_cancel() {
     // closed
     Status status = Status.fromCode(NON_RETRIABLE_STATUS_CODE);
     Metadata metadata = new Metadata();
-    sublistenerCaptor1.getValue().closed(status, metadata);
+    sublistenerCaptor1.getValue().closed(status, PROCESSED, metadata);
 
     inOrder.verify(retriableStreamRecorder).postCommit();
-    verify(masterListener).closed(status, metadata);
+    verify(masterListener).closed(status, PROCESSED, metadata);
 
     // cancel
     retriableStream.cancel(Status.CANCELLED);
@@ -595,8 +695,9 @@ public void retry_unretriableClosed_cancel() {
     // retry
     ClientStream mockStream2 = mock(ClientStream.class);
     doReturn(mockStream2).when(retriableStreamRecorder).newSubstream(1);
-    sublistenerCaptor1.getValue().closed(Status.fromCode(RETRIABLE_STATUS_CODE_1), new Metadata());
-    fakeClock.forwardTime((long) (INITIAL_BACKOFF_IN_SECONDS * FAKE_RANDOM), TimeUnit.SECONDS);
+    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);
@@ -606,14 +707,15 @@ public void retry_unretriableClosed_cancel() {
     // closed
     Status status = Status.fromCode(NON_RETRIABLE_STATUS_CODE);
     Metadata metadata = new Metadata();
-    sublistenerCaptor2.getValue().closed(status, metadata);
+    sublistenerCaptor2.getValue().closed(status, PROCESSED, metadata);
 
     inOrder.verify(retriableStreamRecorder).postCommit();
-    verify(masterListener).closed(status, metadata);
+    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
@@ -626,11 +728,13 @@ public void retry_cancelWhileBackoff() {
     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), new Metadata());
+    sublistenerCaptor1.getValue().closed(
+        Status.fromCode(RETRIABLE_STATUS_CODE_1), PROCESSED, new Metadata());
 
     // cancel while backoff
     assertEquals(1, fakeClock.numPendingTasks());
@@ -640,11 +744,12 @@ public void retry_cancelWhileBackoff() {
 
     verifyNoMoreInteractions(mockStream1);
     verifyNoMoreInteractions(mockStream2);
+    verify(masterListener, times(1)).closed(any(), any(), any());
   }
 
   @Test
   public void operationsWhileDraining() {
-    ArgumentCaptor<ClientStreamListener> sublistenerCaptor1 =
+    final ArgumentCaptor<ClientStreamListener> sublistenerCaptor1 =
         ArgumentCaptor.forClass(ClientStreamListener.class);
     final AtomicReference<ClientStreamListener> sublistenerCaptor2 =
         new AtomicReference<>();
@@ -657,10 +762,16 @@ public void operationsWhileDraining() {
                   @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 =
@@ -676,7 +787,7 @@ public void start(ClientStreamListener listener) {
                   @Override
                   public void request(int numMessages) {
                     retriableStream.sendMessage("substream2 request " + numMessages);
-
+                    sublistenerCaptor2.get().onReady();
                     if (numMessages == 3) {
                       sublistenerCaptor2.get().headersRead(new Metadata());
                     }
@@ -687,9 +798,14 @@ public void request(int numMessages) {
                       retriableStream.cancel(cancelStatus);
                     }
                   }
+
+                  @Override
+                  public boolean isReady() {
+                    return true;
+                  }
                 }));
 
-    InOrder inOrder = inOrder(retriableStreamRecorder, mockStream1, mockStream2);
+    InOrder inOrder = inOrder(retriableStreamRecorder, mockStream1, mockStream2, masterListener);
 
     doReturn(mockStream1).when(retriableStreamRecorder).newSubstream(0);
     retriableStream.start(masterListener);
@@ -704,16 +820,18 @@ public void request(int numMessages) {
     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), new Metadata());
+    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((long) (INITIAL_BACKOFF_IN_SECONDS * FAKE_RANDOM), TimeUnit.SECONDS);
+    fakeClock.forwardTime(calculateBackoffWithRetries(0), TimeUnit.SECONDS);
 
     inOrder.verify(mockStream2).start(sublistenerCaptor2.get());
     inOrder.verify(mockStream2).request(3);
@@ -730,13 +848,104 @@ public void request(int numMessages) {
     // msg "substream2 request 2"
     inOrder.verify(mockStream2, times(2)).writeMessage(any(InputStream.class));
     inOrder.verify(mockStream2).request(100);
-
-    verify(mockStream2).cancel(cancelStatus);
+    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 =
@@ -821,14 +1030,15 @@ public boolean isReady() {
     // 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), new Metadata());
+    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((long) (INITIAL_BACKOFF_IN_SECONDS * FAKE_RANDOM), TimeUnit.SECONDS);
+    fakeClock.forwardTime(calculateBackoffWithRetries(0), TimeUnit.SECONDS);
 
     verify(mockStream2).start(any(ClientStreamListener.class));
     readiness.add(retriableStream.isReady()); // expected true
@@ -854,6 +1064,78 @@ public void messageAvailable() {
     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);
@@ -865,7 +1147,8 @@ public void closedWhileDraining() {
                   @Override
                   public void start(ClientStreamListener listener) {
                     // closed while draning
-                    listener.closed(Status.fromCode(RETRIABLE_STATUS_CODE_1), new Metadata());
+                    listener.closed(
+                        Status.fromCode(RETRIABLE_STATUS_CODE_1), PROCESSED, new Metadata());
                   }
                 }));
     final ClientStream mockStream3 = mock(ClientStream.class);
@@ -884,15 +1167,15 @@ public void start(ClientStreamListener listener) {
     ClientStreamListener listener1 = sublistenerCaptor1.getValue();
 
     // retry
-    listener1.closed(Status.fromCode(RETRIABLE_STATUS_CODE_1), new Metadata());
+    listener1.closed(
+        Status.fromCode(RETRIABLE_STATUS_CODE_1), PROCESSED, new Metadata());
     assertEquals(1, fakeClock.numPendingTasks());
-    fakeClock.forwardTime((long) (INITIAL_BACKOFF_IN_SECONDS * FAKE_RANDOM), TimeUnit.SECONDS);
+    fakeClock.forwardTime(calculateBackoffWithRetries(0), TimeUnit.SECONDS);
     assertEquals(1, fakeClock.numPendingTasks());
 
     // send requests during backoff
     retriableStream.request(3);
-    fakeClock.forwardTime(
-        (long) (INITIAL_BACKOFF_IN_SECONDS * BACKOFF_MULTIPLIER * FAKE_RANDOM), TimeUnit.SECONDS);
+    fakeClock.forwardTime(calculateBackoffWithRetries(1), TimeUnit.SECONDS);
 
     retriableStream.request(1);
     verify(mockStream1, never()).request(anyInt());
@@ -901,6 +1184,47 @@ public void start(ClientStreamListener listener) {
     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() {
@@ -931,26 +1255,26 @@ public void perRpcBufferLimitExceededDuringBackoff() {
     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), new Metadata());
+    sublistenerCaptor1.getValue().closed(
+        Status.fromCode(RETRIABLE_STATUS_CODE_1), PROCESSED, new Metadata());
 
-    // bufferSizeTracer.outboundWireSize() quits immediately while backoff b/c substream1 is closed
     assertEquals(1, fakeClock.numPendingTasks());
     bufferSizeTracer.outboundWireSize(2);
     verify(retriableStreamRecorder, never()).postCommit();
 
-    fakeClock.forwardTime((long) (INITIAL_BACKOFF_IN_SECONDS * FAKE_RANDOM), TimeUnit.SECONDS);
+    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, never()).postCommit();
-    bufferSizeTracer.outboundWireSize(2);
     verify(retriableStreamRecorder).postCommit();
 
     verifyNoMoreInteractions(mockStream1);
@@ -1009,13 +1333,15 @@ public void expBackoff_maxBackoff_maxRetryAttempts() {
     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), new Metadata());
+    sublistenerCaptor1.getValue().closed(
+        Status.fromCode(RETRIABLE_STATUS_CODE_1), PROCESSED, new Metadata());
     assertEquals(1, fakeClock.numPendingTasks());
-    fakeClock.forwardTime((long) (INITIAL_BACKOFF_IN_SECONDS * FAKE_RANDOM) - 1L, TimeUnit.SECONDS);
+    fakeClock.forwardTime(calculateBackoffWithRetries(0) - 1L, TimeUnit.SECONDS);
     assertEquals(1, fakeClock.numPendingTasks());
     fakeClock.forwardTime(1L, TimeUnit.SECONDS);
     assertEquals(0, fakeClock.numPendingTasks());
@@ -1023,14 +1349,14 @@ public void expBackoff_maxBackoff_maxRetryAttempts() {
     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), new Metadata());
+    sublistenerCaptor2.getValue().closed(
+        Status.fromCode(RETRIABLE_STATUS_CODE_2), PROCESSED, new Metadata());
     assertEquals(1, fakeClock.numPendingTasks());
-    fakeClock.forwardTime(
-        (long) (INITIAL_BACKOFF_IN_SECONDS * BACKOFF_MULTIPLIER * FAKE_RANDOM) - 1L,
-        TimeUnit.SECONDS);
+    fakeClock.forwardTime(calculateBackoffWithRetries(1) - 1L, TimeUnit.SECONDS);
     assertEquals(1, fakeClock.numPendingTasks());
     fakeClock.forwardTime(1L, TimeUnit.SECONDS);
     assertEquals(0, fakeClock.numPendingTasks());
@@ -1038,15 +1364,14 @@ public void expBackoff_maxBackoff_maxRetryAttempts() {
     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), new Metadata());
+    sublistenerCaptor3.getValue().closed(
+        Status.fromCode(RETRIABLE_STATUS_CODE_1), PROCESSED, new Metadata());
     assertEquals(1, fakeClock.numPendingTasks());
-    fakeClock.forwardTime(
-        (long) (INITIAL_BACKOFF_IN_SECONDS * BACKOFF_MULTIPLIER * BACKOFF_MULTIPLIER * FAKE_RANDOM)
-            - 1L,
-        TimeUnit.SECONDS);
+    fakeClock.forwardTime(calculateBackoffWithRetries(2) - 1L, TimeUnit.SECONDS);
     assertEquals(1, fakeClock.numPendingTasks());
     fakeClock.forwardTime(1L, TimeUnit.SECONDS);
     assertEquals(0, fakeClock.numPendingTasks());
@@ -1054,12 +1379,14 @@ public void expBackoff_maxBackoff_maxRetryAttempts() {
     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), new Metadata());
+    sublistenerCaptor4.getValue().closed(
+        Status.fromCode(RETRIABLE_STATUS_CODE_2), PROCESSED, new Metadata());
     assertEquals(1, fakeClock.numPendingTasks());
-    fakeClock.forwardTime((long) (MAX_BACKOFF_IN_SECONDS * FAKE_RANDOM) - 1L, TimeUnit.SECONDS);
+    fakeClock.forwardTime(calculateMaxBackoff() - 1L, TimeUnit.SECONDS);
     assertEquals(1, fakeClock.numPendingTasks());
     fakeClock.forwardTime(1L, TimeUnit.SECONDS);
     assertEquals(0, fakeClock.numPendingTasks());
@@ -1067,12 +1394,14 @@ public void expBackoff_maxBackoff_maxRetryAttempts() {
     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), new Metadata());
+    sublistenerCaptor5.getValue().closed(
+        Status.fromCode(RETRIABLE_STATUS_CODE_2), PROCESSED, new Metadata());
     assertEquals(1, fakeClock.numPendingTasks());
-    fakeClock.forwardTime((long) (MAX_BACKOFF_IN_SECONDS * FAKE_RANDOM) - 1L, TimeUnit.SECONDS);
+    fakeClock.forwardTime(calculateMaxBackoff() - 1L, TimeUnit.SECONDS);
     assertEquals(1, fakeClock.numPendingTasks());
     fakeClock.forwardTime(1L, TimeUnit.SECONDS);
     assertEquals(0, fakeClock.numPendingTasks());
@@ -1080,11 +1409,13 @@ public void expBackoff_maxBackoff_maxRetryAttempts() {
     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), new Metadata());
+    sublistenerCaptor6.getValue().closed(
+        Status.fromCode(RETRIABLE_STATUS_CODE_1), PROCESSED, new Metadata());
     verify(retriableStreamRecorder).postCommit();
     inOrder.verifyNoMoreInteractions();
   }
@@ -1109,6 +1440,7 @@ public void pushback() {
     ArgumentCaptor<ClientStreamListener> sublistenerCaptor1 =
         ArgumentCaptor.forClass(ClientStreamListener.class);
     inOrder.verify(mockStream1).start(sublistenerCaptor1.capture());
+    inOrder.verify(mockStream1).isReady();
     inOrder.verifyNoMoreInteractions();
 
 
@@ -1116,7 +1448,8 @@ public void pushback() {
     int pushbackInMillis = 123;
     Metadata headers = new Metadata();
     headers.put(RetriableStream.GRPC_RETRY_PUSHBACK_MS, "" + pushbackInMillis);
-    sublistenerCaptor1.getValue().closed(Status.fromCode(RETRIABLE_STATUS_CODE_1), headers);
+    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());
@@ -1126,13 +1459,15 @@ public void pushback() {
     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), headers);
+    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());
@@ -1142,12 +1477,14 @@ public void pushback() {
     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), new Metadata());
+    sublistenerCaptor3.getValue().closed(
+        Status.fromCode(RETRIABLE_STATUS_CODE_1), PROCESSED, new Metadata());
     assertEquals(1, fakeClock.numPendingTasks());
-    fakeClock.forwardTime((long) (INITIAL_BACKOFF_IN_SECONDS * FAKE_RANDOM) - 1L, TimeUnit.SECONDS);
+    fakeClock.forwardTime(calculateBackoffWithRetries(0) - 1L, TimeUnit.SECONDS);
     assertEquals(1, fakeClock.numPendingTasks());
     fakeClock.forwardTime(1L, TimeUnit.SECONDS);
     assertEquals(0, fakeClock.numPendingTasks());
@@ -1155,14 +1492,14 @@ public void pushback() {
     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), new Metadata());
+    sublistenerCaptor4.getValue().closed(
+        Status.fromCode(RETRIABLE_STATUS_CODE_2), PROCESSED, new Metadata());
     assertEquals(1, fakeClock.numPendingTasks());
-    fakeClock.forwardTime(
-        (long) (INITIAL_BACKOFF_IN_SECONDS * BACKOFF_MULTIPLIER * FAKE_RANDOM) - 1L,
-        TimeUnit.SECONDS);
+    fakeClock.forwardTime(calculateBackoffWithRetries(1) - 1L, TimeUnit.SECONDS);
     assertEquals(1, fakeClock.numPendingTasks());
     fakeClock.forwardTime(1L, TimeUnit.SECONDS);
     assertEquals(0, fakeClock.numPendingTasks());
@@ -1170,15 +1507,14 @@ public void pushback() {
     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), new Metadata());
+    sublistenerCaptor5.getValue().closed(
+        Status.fromCode(RETRIABLE_STATUS_CODE_2), PROCESSED, new Metadata());
     assertEquals(1, fakeClock.numPendingTasks());
-    fakeClock.forwardTime(
-        (long) (INITIAL_BACKOFF_IN_SECONDS * BACKOFF_MULTIPLIER * BACKOFF_MULTIPLIER * FAKE_RANDOM)
-            - 1L,
-        TimeUnit.SECONDS);
+    fakeClock.forwardTime(calculateBackoffWithRetries(2) - 1L, TimeUnit.SECONDS);
     assertEquals(1, fakeClock.numPendingTasks());
     fakeClock.forwardTime(1L, TimeUnit.SECONDS);
     assertEquals(0, fakeClock.numPendingTasks());
@@ -1186,6 +1522,7 @@ public void pushback() {
     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
@@ -1193,7 +1530,8 @@ public void pushback() {
     headers = new Metadata();
     headers.put(RetriableStream.GRPC_RETRY_PUSHBACK_MS, "" + pushbackInMillis);
     verify(retriableStreamRecorder, never()).postCommit();
-    sublistenerCaptor6.getValue().closed(Status.fromCode(RETRIABLE_STATUS_CODE_1), headers);
+    sublistenerCaptor6.getValue().closed(
+        Status.fromCode(RETRIABLE_STATUS_CODE_1), PROCESSED, headers);
     verify(retriableStreamRecorder).postCommit();
     inOrder.verifyNoMoreInteractions();
   }
@@ -1214,7 +1552,8 @@ public void pushback_noRetry() {
     // pushback no retry
     Metadata headers = new Metadata();
     headers.put(RetriableStream.GRPC_RETRY_PUSHBACK_MS, "");
-    sublistenerCaptor1.getValue().closed(Status.fromCode(RETRIABLE_STATUS_CODE_1), headers);
+    sublistenerCaptor1.getValue().closed(
+        Status.fromCode(RETRIABLE_STATUS_CODE_1), PROCESSED, headers);
 
     verify(retriableStreamRecorder, never()).newSubstream(1);
     verify(retriableStreamRecorder).postCommit();
@@ -1269,7 +1608,8 @@ public void throttledStream_FailWithRetriableStatusCode_WithoutPushback() {
     // 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), new Metadata());
+    sublistenerCaptor.getValue().closed(
+        Status.fromCode(RETRIABLE_STATUS_CODE_1), PROCESSED, new Metadata());
     verify(retriableStreamRecorder).postCommit();
     assertFalse(throttle.isAboveThreshold()); // count = 2
   }
@@ -1289,7 +1629,8 @@ public void throttledStream_FailWithNonRetriableStatusCode_WithoutPushback() {
     // 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), new Metadata());
+    sublistenerCaptor.getValue().closed(
+        Status.fromCode(NON_RETRIABLE_STATUS_CODE), PROCESSED, new Metadata());
     verify(retriableStreamRecorder).postCommit();
     assertTrue(throttle.isAboveThreshold()); // count = 3
 
@@ -1314,7 +1655,8 @@ public void throttledStream_FailWithRetriableStatusCode_WithRetriablePushback()
     int pushbackInMillis = 123;
     Metadata headers = new Metadata();
     headers.put(RetriableStream.GRPC_RETRY_PUSHBACK_MS, "" + pushbackInMillis);
-    sublistenerCaptor.getValue().closed(Status.fromCode(RETRIABLE_STATUS_CODE_1), headers);
+    sublistenerCaptor.getValue().closed(
+        Status.fromCode(RETRIABLE_STATUS_CODE_1), PROCESSED, headers);
     verify(retriableStreamRecorder).postCommit();
     assertFalse(throttle.isAboveThreshold()); // count = 2
   }
@@ -1337,7 +1679,8 @@ public void throttledStream_FailWithNonRetriableStatusCode_WithRetriablePushback
     int pushbackInMillis = 123;
     Metadata headers = new Metadata();
     headers.put(RetriableStream.GRPC_RETRY_PUSHBACK_MS, "" + pushbackInMillis);
-    sublistenerCaptor.getValue().closed(Status.fromCode(NON_RETRIABLE_STATUS_CODE), headers);
+    sublistenerCaptor.getValue().closed(
+        Status.fromCode(NON_RETRIABLE_STATUS_CODE), PROCESSED, headers);
     verify(retriableStreamRecorder, never()).postCommit();
     assertTrue(throttle.isAboveThreshold()); // count = 3
 
@@ -1365,7 +1708,8 @@ public void throttledStream_FailWithRetriableStatusCode_WithNonRetriablePushback
 
     Metadata headers = new Metadata();
     headers.put(RetriableStream.GRPC_RETRY_PUSHBACK_MS, "");
-    sublistenerCaptor.getValue().closed(Status.fromCode(RETRIABLE_STATUS_CODE_1), headers);
+    sublistenerCaptor.getValue().closed(
+        Status.fromCode(RETRIABLE_STATUS_CODE_1), PROCESSED, headers);
     verify(retriableStreamRecorder).postCommit();
     assertFalse(throttle.isAboveThreshold()); // count = 2
   }
@@ -1387,7 +1731,8 @@ public void throttledStream_FailWithNonRetriableStatusCode_WithNonRetriablePushb
 
     Metadata headers = new Metadata();
     headers.put(RetriableStream.GRPC_RETRY_PUSHBACK_MS, "");
-    sublistenerCaptor.getValue().closed(Status.fromCode(NON_RETRIABLE_STATUS_CODE), headers);
+    sublistenerCaptor.getValue().closed(
+        Status.fromCode(NON_RETRIABLE_STATUS_CODE), PROCESSED, headers);
     verify(retriableStreamRecorder).postCommit();
     assertFalse(throttle.isAboveThreshold()); // count = 2
   }
@@ -1419,7 +1764,7 @@ public void throttleStream_Succeed() {
   }
 
   @Test
-  public void transparentRetry() {
+  public void transparentRetry_onlyOnceOnRefused() {
     ClientStream mockStream1 = mock(ClientStream.class);
     ClientStream mockStream2 = mock(ClientStream.class);
     ClientStream mockStream3 = mock(ClientStream.class);
@@ -1435,6 +1780,7 @@ public void transparentRetry() {
     ArgumentCaptor<ClientStreamListener> sublistenerCaptor1 =
         ArgumentCaptor.forClass(ClientStreamListener.class);
     inOrder.verify(mockStream1).start(sublistenerCaptor1.capture());
+    inOrder.verify(mockStream1).isReady();
     inOrder.verifyNoMoreInteractions();
 
     // transparent retry
@@ -1446,6 +1792,7 @@ public void transparentRetry() {
     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());
@@ -1456,14 +1803,81 @@ public void transparentRetry() {
         .closed(Status.fromCode(RETRIABLE_STATUS_CODE_1), REFUSED, new Metadata());
 
     assertEquals(1, fakeClock.numPendingTasks());
-    fakeClock.forwardTime((long) (INITIAL_BACKOFF_IN_SECONDS * FAKE_RANDOM), TimeUnit.SECONDS);
+    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
@@ -1483,6 +1897,7 @@ public void normalRetry_thenNoTransparentRetry_butNormalRetry() {
     ArgumentCaptor<ClientStreamListener> sublistenerCaptor1 =
         ArgumentCaptor.forClass(ClientStreamListener.class);
     inOrder.verify(mockStream1).start(sublistenerCaptor1.capture());
+    inOrder.verify(mockStream1).isReady();
     inOrder.verifyNoMoreInteractions();
 
     // normal retry
@@ -1491,11 +1906,12 @@ public void normalRetry_thenNoTransparentRetry_butNormalRetry() {
         .closed(Status.fromCode(RETRIABLE_STATUS_CODE_1), PROCESSED, new Metadata());
 
     assertEquals(1, fakeClock.numPendingTasks());
-    fakeClock.forwardTime((long) (INITIAL_BACKOFF_IN_SECONDS * FAKE_RANDOM), TimeUnit.SECONDS);
+    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());
@@ -1506,12 +1922,12 @@ public void normalRetry_thenNoTransparentRetry_butNormalRetry() {
         .closed(Status.fromCode(RETRIABLE_STATUS_CODE_1), REFUSED, new Metadata());
 
     assertEquals(1, fakeClock.numPendingTasks());
-    fakeClock.forwardTime(
-        (long) (INITIAL_BACKOFF_IN_SECONDS * BACKOFF_MULTIPLIER * FAKE_RANDOM), TimeUnit.SECONDS);
+    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();
   }
@@ -1533,6 +1949,7 @@ public void normalRetry_thenNoTransparentRetry_andNoMoreRetry() {
     ArgumentCaptor<ClientStreamListener> sublistenerCaptor1 =
         ArgumentCaptor.forClass(ClientStreamListener.class);
     inOrder.verify(mockStream1).start(sublistenerCaptor1.capture());
+    inOrder.verify(mockStream1).isReady();
     inOrder.verifyNoMoreInteractions();
 
     // normal retry
@@ -1541,11 +1958,12 @@ public void normalRetry_thenNoTransparentRetry_andNoMoreRetry() {
         .closed(Status.fromCode(RETRIABLE_STATUS_CODE_1), PROCESSED, new Metadata());
 
     assertEquals(1, fakeClock.numPendingTasks());
-    fakeClock.forwardTime((long) (INITIAL_BACKOFF_IN_SECONDS * FAKE_RANDOM), TimeUnit.SECONDS);
+    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());
@@ -1559,7 +1977,7 @@ public void normalRetry_thenNoTransparentRetry_andNoMoreRetry() {
   }
 
   @Test
-  public void noRetry_transparentRetry_earlyCommit() {
+  public void noRetry_transparentRetry_noEarlyCommit() {
     ClientStream mockStream1 = mock(ClientStream.class);
     ClientStream mockStream2 = mock(ClientStream.class);
     InOrder inOrder = inOrder(retriableStreamRecorder, mockStream1, mockStream2);
@@ -1576,6 +1994,7 @@ method, new Metadata(), channelBufferUsed, PER_RPC_BUFFER_LIMIT, CHANNEL_BUFFER_
     ArgumentCaptor<ClientStreamListener> sublistenerCaptor1 =
         ArgumentCaptor.forClass(ClientStreamListener.class);
     inOrder.verify(mockStream1).start(sublistenerCaptor1.capture());
+    inOrder.verify(mockStream1).isReady();
     inOrder.verifyNoMoreInteractions();
 
     // transparent retry
@@ -1586,8 +2005,9 @@ method, new Metadata(), channelBufferUsed, PER_RPC_BUFFER_LIMIT, CHANNEL_BUFFER_
     inOrder.verify(retriableStreamRecorder).newSubstream(0);
     ArgumentCaptor<ClientStreamListener> sublistenerCaptor2 =
         ArgumentCaptor.forClass(ClientStreamListener.class);
-    inOrder.verify(retriableStreamRecorder).postCommit();
+    verify(retriableStreamRecorder, never()).postCommit();
     inOrder.verify(mockStream2).start(sublistenerCaptor2.capture());
+    inOrder.verify(mockStream2).isReady();
     inOrder.verifyNoMoreInteractions();
     assertEquals(0, fakeClock.numPendingTasks());
   }
@@ -1606,6 +2026,7 @@ public void droppedShouldNeverRetry() {
     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);
@@ -1613,7 +2034,7 @@ public void droppedShouldNeverRetry() {
 
     verifyNoMoreInteractions(mockStream1, mockStream2);
     verify(retriableStreamRecorder).postCommit();
-    verify(masterListener).closed(same(status), any(Metadata.class));
+    verify(masterListener).closed(same(status), any(RpcProgress.class), any(Metadata.class));
   }
 
 
@@ -1677,6 +2098,7 @@ public Void answer(InvocationOnMock in) {
     ArgumentCaptor<ClientStreamListener> sublistenerCaptor1 =
         ArgumentCaptor.forClass(ClientStreamListener.class);
     inOrder.verify(mockStream1).start(sublistenerCaptor1.capture());
+    inOrder.verify(mockStream1).isReady();
     inOrder.verifyNoMoreInteractions();
 
     hedgingStream.sendMessage("msg1");
@@ -1687,10 +2109,14 @@ public Void answer(InvocationOnMock in) {
     hedgingStream.sendMessage("msg3");
     hedgingStream.request(456);
 
-    inOrder.verify(mockStream1, times(2)).writeMessage(any(InputStream.class));
+    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();
 
@@ -1713,11 +2139,17 @@ public Void answer(InvocationOnMock in) {
     ArgumentCaptor<ClientStreamListener> sublistenerCaptor2 =
         ArgumentCaptor.forClass(ClientStreamListener.class);
     inOrder.verify(mockStream2).start(sublistenerCaptor2.capture());
-    inOrder.verify(mockStream2, times(2)).writeMessage(any(InputStream.class));
+    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
@@ -1725,9 +2157,13 @@ public Void answer(InvocationOnMock in) {
     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();
 
 
@@ -1749,28 +2185,44 @@ public Void answer(InvocationOnMock in) {
     ArgumentCaptor<ClientStreamListener> sublistenerCaptor3 =
         ArgumentCaptor.forClass(ClientStreamListener.class);
     inOrder.verify(mockStream3).start(sublistenerCaptor3.capture());
-    inOrder.verify(mockStream3, times(2)).writeMessage(any(InputStream.class));
+    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, times(2)).writeMessage(any(InputStream.class));
+    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(), new Metadata());
+    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);
@@ -1790,12 +2242,22 @@ public Void answer(InvocationOnMock in) {
     ArgumentCaptor<ClientStreamListener> sublistenerCaptor4 =
         ArgumentCaptor.forClass(ClientStreamListener.class);
     inOrder.verify(mockStream4).start(sublistenerCaptor4.capture());
-    inOrder.verify(mockStream4, times(2)).writeMessage(any(InputStream.class));
+    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);
-    inOrder.verify(mockStream4, times(4)).writeMessage(any(InputStream.class));
+    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();
@@ -1806,7 +2268,7 @@ public Void answer(InvocationOnMock in) {
 
     // commit
     sublistenerCaptor2.getValue().closed(
-        Status.fromCode(FATAL_STATUS_CODE), new Metadata());
+        Status.fromCode(FATAL_STATUS_CODE), PROCESSED, new Metadata());
 
     ArgumentCaptor<Status> statusCaptor = ArgumentCaptor.forClass(Status.class);
     inOrder.verify(mockStream1).cancel(statusCaptor.capture());
@@ -1816,13 +2278,19 @@ public Void answer(InvocationOnMock in) {
     assertEquals(Status.CANCELLED.getCode(), statusCaptor.getValue().getCode());
     assertEquals(CANCELLED_BECAUSE_COMMITTED, statusCaptor.getValue().getDescription());
     inOrder.verify(retriableStreamRecorder).postCommit();
-    inOrder.verify(masterListener).closed(any(Status.class), any(Metadata.class));
+    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], committed=[remote_addr=2.2.2.2:81]]");
+        "[closed=[UNAVAILABLE, INTERNAL, CANCELLED, CANCELLED], "
+            + "committed=[remote_addr=2.2.2.2:81]]");
   }
 
   @Test
@@ -1845,6 +2313,7 @@ public void hedging_maxAttempts() {
     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);
@@ -1852,6 +2321,7 @@ public void hedging_maxAttempts() {
     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);
@@ -1859,6 +2329,7 @@ public void hedging_maxAttempts() {
     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);
@@ -1866,16 +2337,19 @@ public void hedging_maxAttempts() {
     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(), new Metadata());
+    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);
@@ -1883,21 +2357,27 @@ public void hedging_maxAttempts() {
     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(), new Metadata());
-    sublistenerCaptor4.getValue().closed(NON_FATAL_STATUS_CODE_2.toStatus(), new Metadata());
-    sublistenerCaptor5.getValue().closed(NON_FATAL_STATUS_CODE_2.toStatus(), new Metadata());
+    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(), new Metadata());
+    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();
@@ -1923,6 +2403,7 @@ public void hedging_receiveHeaders() {
     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);
@@ -1930,6 +2411,7 @@ public void hedging_receiveHeaders() {
     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);
@@ -1937,6 +2419,7 @@ public void hedging_receiveHeaders() {
     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
@@ -1974,6 +2457,7 @@ public void hedging_pushback_negative() {
     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);
@@ -1981,6 +2465,7 @@ public void hedging_pushback_negative() {
     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);
@@ -1988,12 +2473,14 @@ public void hedging_pushback_negative() {
     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), headers);
+    sublistenerCaptor2.getValue().closed(
+        Status.fromCode(NON_FATAL_STATUS_CODE_1), PROCESSED, headers);
     assertEquals(0, fakeClock.numPendingTasks());
 
     fakeClock.forwardTime(HEDGING_DELAY_IN_SECONDS, TimeUnit.SECONDS);
@@ -2001,6 +2488,119 @@ public void hedging_pushback_negative() {
     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);
@@ -2018,6 +2618,7 @@ public void hedging_pushback_positive() {
     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);
@@ -2025,46 +2626,52 @@ public void hedging_pushback_positive() {
     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), headers);
+    sublistenerCaptor1.getValue().closed(
+        Status.fromCode(NON_FATAL_STATUS_CODE_1), PROCESSED, headers);
 
     fakeClock.forwardTime(HEDGING_DELAY_IN_SECONDS, TimeUnit.SECONDS);
-    inOrder.verifyNoMoreInteractions();
+    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), headers);
+    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, 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();
-    inOrder.verify(masterListener).closed(fatal, metadata);
+    sublistenerCaptor3.getValue().closed(Status.CANCELLED, PROCESSED, metadata);
+    inOrder.verify(masterListener).closed(fatal, PROCESSED, metadata);
     inOrder.verifyNoMoreInteractions();
   }
 
@@ -2082,6 +2689,7 @@ public void hedging_cancelled() {
     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);
@@ -2089,6 +2697,8 @@ public void hedging_cancelled() {
     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");
@@ -2103,6 +2713,10 @@ public void hedging_cancelled() {
     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();
   }
 
@@ -2117,6 +2731,7 @@ public void hedging_perRpcBufferLimitExceeded() {
     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);
@@ -2125,6 +2740,8 @@ public void hedging_perRpcBufferLimitExceeded() {
     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);
@@ -2141,6 +2758,7 @@ public void hedging_perRpcBufferLimitExceeded() {
     verify(retriableStreamRecorder).postCommit();
 
     verifyNoMoreInteractions(mockStream1);
+    verify(mockStream2).isReady();
     verifyNoMoreInteractions(mockStream2);
   }
 
@@ -2155,6 +2773,7 @@ public void hedging_channelBufferLimitExceeded() {
     ArgumentCaptor<ClientStreamListener> sublistenerCaptor1 =
         ArgumentCaptor.forClass(ClientStreamListener.class);
     verify(mockStream1).start(sublistenerCaptor1.capture());
+    verify(mockStream1).isReady();
 
     ClientStreamTracer bufferSizeTracer1 = bufferSizeTracer;
     bufferSizeTracer1.outboundWireSize(100);
@@ -2163,6 +2782,8 @@ public void hedging_channelBufferLimitExceeded() {
     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);
@@ -2220,8 +2841,7 @@ public void hedging_transparentRetry() {
     // no more transparent retry
     Status status = Status.fromCode(FATAL_STATUS_CODE);
     Metadata metadata = new Metadata();
-    sublistenerCaptor3.getValue()
-        .closed(status, REFUSED, metadata);
+    sublistenerCaptor3.getValue().closed(status, REFUSED, metadata);
 
     ArgumentCaptor<Status> statusCaptor = ArgumentCaptor.forClass(Status.class);
     verify(mockStream1).cancel(statusCaptor.capture());
@@ -2231,7 +2851,9 @@ public void hedging_transparentRetry() {
     assertEquals(Status.CANCELLED.getCode(), statusCaptor.getValue().getCode());
     assertEquals(CANCELLED_BECAUSE_COMMITTED, statusCaptor.getValue().getDescription());
     verify(retriableStreamRecorder).postCommit();
-    verify(masterListener).closed(status, metadata);
+    sublistenerCaptor1.getValue().closed(Status.CANCELLED, PROCESSED, metadata);
+    sublistenerCaptor4.getValue().closed(Status.CANCELLED, PROCESSED, metadata);
+    verify(masterListener).closed(status, REFUSED, metadata);
   }
 
   @Test
@@ -2258,7 +2880,7 @@ public void hedging_transparentRetryNotAllowed() {
     verify(mockStream3).start(sublistenerCaptor3.capture());
 
     sublistenerCaptor2.getValue()
-        .closed(Status.fromCode(NON_FATAL_STATUS_CODE_1), new Metadata());
+        .closed(Status.fromCode(NON_FATAL_STATUS_CODE_1), PROCESSED, new Metadata());
 
     // no more transparent retry
     Status status = Status.fromCode(FATAL_STATUS_CODE);
@@ -2271,7 +2893,10 @@ public void hedging_transparentRetryNotAllowed() {
     assertEquals(Status.CANCELLED.getCode(), statusCaptor.getValue().getCode());
     assertEquals(CANCELLED_BECAUSE_COMMITTED, statusCaptor.getValue().getDescription());
     verify(retriableStreamRecorder).postCommit();
-    verify(masterListener).closed(status, metadata);
+    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
@@ -2293,7 +2918,8 @@ public void hedging_throttledByOtherCall() {
     fakeClock.forwardTime(HEDGING_DELAY_IN_SECONDS, TimeUnit.SECONDS);
     verify(mockStream2).start(any(ClientStreamListener.class));
 
-    sublistenerCaptor1.getValue().closed(Status.fromCode(NON_FATAL_STATUS_CODE_1), new Metadata());
+    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
@@ -2325,12 +2951,14 @@ public void hedging_throttledByHedgingStreams() {
         ArgumentCaptor.forClass(ClientStreamListener.class);
     verify(mockStream2).start(sublistenerCaptor2.capture());
 
-    sublistenerCaptor1.getValue().closed(Status.fromCode(NON_FATAL_STATUS_CODE_1), new Metadata());
+    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), new Metadata());
+    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(Metadata.class));
+    verify(masterListener).closed(any(Status.class), any(RpcProgress.class), any(Metadata.class));
     verifyNoInteractions(mockStream3);
     assertEquals(0, fakeClock.numPendingTasks());
   }
@@ -2346,4 +2974,22 @@ private interface RetriableStreamRecorder {
 
     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
index 5ff96df539b..51d196c20bf 100644
--- a/core/src/test/java/io/grpc/internal/RetryPolicyTest.java
+++ b/core/src/test/java/io/grpc/internal/RetryPolicyTest.java
@@ -78,6 +78,7 @@ public void getRetryPolicies() throws Exception {
               TimeUnit.MILLISECONDS.toNanos(2100),
               TimeUnit.MILLISECONDS.toNanos(2200),
               parseDouble("3"),
+              null,
               ImmutableSet.of(Code.UNAVAILABLE, Code.RESOURCE_EXHAUSTED)));
 
       method = builder.setFullMethodName("SimpleService1/Foo1").build();
@@ -87,6 +88,7 @@ public void getRetryPolicies() throws Exception {
               TimeUnit.MILLISECONDS.toNanos(100),
               TimeUnit.MILLISECONDS.toNanos(1000),
               parseDouble("2"),
+              null,
               ImmutableSet.of(Code.UNAVAILABLE)));
 
       method = builder.setFullMethodName("SimpleService2/not_exist").build();
@@ -99,6 +101,7 @@ public void getRetryPolicies() throws Exception {
               TimeUnit.MILLISECONDS.toNanos(100),
               TimeUnit.MILLISECONDS.toNanos(1000),
               parseDouble("2"),
+              null,
               ImmutableSet.of(Code.UNAVAILABLE)));
     } finally {
       if (reader != null) {
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/SerializingExecutorTest.java b/core/src/test/java/io/grpc/internal/SerializingExecutorTest.java
index 55f40819299..a1a8146b7bb 100644
--- a/core/src/test/java/io/grpc/internal/SerializingExecutorTest.java
+++ b/core/src/test/java/io/grpc/internal/SerializingExecutorTest.java
@@ -209,6 +209,38 @@ public void run() {
     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;
 
diff --git a/core/src/test/java/io/grpc/internal/ServerCallImplTest.java b/core/src/test/java/io/grpc/internal/ServerCallImplTest.java
index 5130bc05aa7..7394c83eab2 100644
--- a/core/src/test/java/io/grpc/internal/ServerCallImplTest.java
+++ b/core/src/test/java/io/grpc/internal/ServerCallImplTest.java
@@ -16,9 +16,14 @@
 
 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.ArgumentMatchers.any;
@@ -31,6 +36,7 @@
 import static org.mockito.Mockito.when;
 
 import com.google.common.io.CharStreams;
+import io.grpc.Attributes;
 import io.grpc.CompressorRegistry;
 import io.grpc.Context;
 import io.grpc.DecompressorRegistry;
@@ -39,10 +45,10 @@
 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.SingleMessageProducer;
 import io.perfmark.PerfMark;
 import java.io.ByteArrayInputStream;
 import java.io.InputStream;
@@ -50,17 +56,17 @@
 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.Mock;
-import org.mockito.MockitoAnnotations;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
 
 @RunWith(JUnit4.class)
 public class ServerCallImplTest {
-  @SuppressWarnings("deprecation") // https://github.com/grpc/grpc-java/issues/7467
-  @Rule public final ExpectedException thrown = ExpectedException.none();
+  @Rule public final MockitoRule mocks = MockitoJUnit.rule();
+
   @Mock private ServerStream stream;
   @Mock private ServerCall.Listener<Long> callListener;
 
@@ -88,7 +94,6 @@ public class ServerCallImplTest {
 
   @Before
   public void setUp() {
-    MockitoAnnotations.initMocks(this);
     context = Context.ROOT.withCancellation();
     call = new ServerCallImpl<>(stream, UNARY_METHOD, requestHeaders, context,
         DecompressorRegistry.getDefaultInstance(), CompressorRegistry.getDefaultInstance(),
@@ -141,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
@@ -175,7 +196,6 @@ public void sendMessage() {
     call.sendMessage(1234L);
 
     verify(stream).writeMessage(isA(InputStream.class));
-    verify(stream).flush();
   }
 
   @Test
@@ -183,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
@@ -204,7 +222,7 @@ public void sendMessage_closesOnFailure() {
 
     call.sendMessage(1234L);
 
-    verify(stream).close(isA(Status.class), isA(Metadata.class));
+    verify(stream).cancel(isA(Status.class));
   }
 
   @Test
@@ -322,6 +340,8 @@ public void isReady() {
     when(stream.isReady()).thenReturn(true);
 
     assertTrue(call.isReady());
+    call.close(Status.OK, new Metadata());
+    assertFalse(call.isReady());
   }
 
   @Test
@@ -338,6 +358,23 @@ public void getNullAuthority() {
     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);
@@ -378,6 +415,9 @@ public void streamListener_closedOk() {
     verify(callListener).onComplete();
     assertTrue(context.isCancelled());
     assertNull(context.cancellationCause());
+    // The call considers cancellation to be an exceptional situation so it should
+    // not be cancelled with an OK status.
+    assertFalse(call.isCancelled());
   }
 
   @Test
@@ -389,7 +429,7 @@ public void streamListener_closedCancelled() {
 
     verify(callListener).onCancel();
     assertTrue(context.isCancelled());
-    assertNull(context.cancellationCause());
+    assertNotNull(context.cancellationCause());
   }
 
   @Test
@@ -447,9 +487,10 @@ public void streamListener_unexpectedRuntimeException() {
 
     InputStream inputStream = UNARY_METHOD.streamRequest(1234L);
 
-    thrown.expect(RuntimeException.class);
-    thrown.expectMessage("unexpected exception");
-    streamListener.messagesAvailable(new SingleMessageProducer(inputStream));
+    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
index ad8cf41598a..c2cb281a19e 100644
--- a/core/src/test/java/io/grpc/internal/ServerImplBuilderTest.java
+++ b/core/src/test/java/io/grpc/internal/ServerImplBuilderTest.java
@@ -19,10 +19,23 @@
 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.MetricRecorder;
+import io.grpc.MetricSink;
+import io.grpc.NoopMetricSink;
+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;
@@ -38,6 +51,22 @@ public ServerStreamTracer newServerStreamTracer(String fullMethodName, Metadata
           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;
 
@@ -47,7 +76,8 @@ public void setUp() throws Exception {
         new ClientTransportServersBuilder() {
           @Override
           public InternalServer buildClientTransportServers(
-              List<? extends ServerStreamTracer.Factory> streamTracerFactories) {
+              List<? extends ServerStreamTracer.Factory> streamTracerFactories,
+              MetricRecorder metricRecorder) {
             throw new UnsupportedOperationException();
           }
         });
@@ -101,4 +131,83 @@ public void getTracerFactories_disableBoth() {
     List<? extends ServerStreamTracer.Factory> factories = builder.getTracerFactories();
     assertThat(factories).containsExactly(DUMMY_USER_TRACER);
   }
+
+  @Test
+  public void addMetricSink_addsToSinks() {
+    MetricSink noopMetricSink = new NoopMetricSink();
+    builder.addMetricSink(noopMetricSink);
+    assertThat(builder.metricSinks).containsExactly(noopMetricSink);
+  }
+
+  @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, metricRecorder) -> {
+                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, metricRecorder) -> {
+                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, metricRecorder) -> {
+                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 5b5f5384d30..91969dd6910 100644
--- a/core/src/test/java/io/grpc/internal/ServerImplTest.java
+++ b/core/src/test/java/io/grpc/internal/ServerImplTest.java
@@ -26,6 +26,7 @@
 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.AdditionalAnswers.delegatesTo;
@@ -52,6 +53,7 @@
 import io.grpc.Channel;
 import io.grpc.Compressor;
 import io.grpc.Context;
+import io.grpc.Deadline;
 import io.grpc.Grpc;
 import io.grpc.HandlerRegistry;
 import io.grpc.IntegerMarshaller;
@@ -63,8 +65,10 @@
 import io.grpc.InternalServerInterceptors;
 import io.grpc.Metadata;
 import io.grpc.MethodDescriptor;
+import io.grpc.MetricRecorder;
 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;
@@ -73,10 +77,11 @@
 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.ServerImplBuilder.ClientTransportServersBuilder;
-import io.grpc.internal.testing.SingleMessageProducer;
+import io.grpc.internal.SingleMessageProducer;
 import io.grpc.internal.testing.TestServerStreamTracer;
 import io.grpc.util.MutableHandlerRegistry;
 import io.perfmark.PerfMark;
@@ -102,7 +107,6 @@
 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;
@@ -110,7 +114,8 @@
 import org.mockito.Captor;
 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)
@@ -124,11 +129,15 @@ public class ServerImplTest {
           .setRequestMarshaller(STRING_MARSHALLER)
           .setResponseMarshaller(INTEGER_MARSHALLER)
           .build();
+  private static final MethodDescriptor<String, Integer> GENERATED_METHOD =
+      METHOD.toBuilder()
+          .setSampledToLocalTracing(true)
+          .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 FakeClock.TaskFilter CONTEXT_CLOSER_TASK_FITLER =
+  private static final FakeClock.TaskFilter CONTEXT_CLOSER_TASK_FILTER =
       new FakeClock.TaskFilter() {
         @Override
         public boolean shouldAccept(Runnable runnable) {
@@ -137,8 +146,61 @@ public boolean shouldAccept(Runnable runnable) {
       };
   private static final String AUTHORITY = "some_authority";
 
-  @SuppressWarnings("deprecation") // https://github.com/grpc/grpc-java/issues/7467
-  @Rule public final ExpectedException thrown = ExpectedException.none();
+  private static final class MethodNameCapturingTracer extends ServerStreamTracer
+      implements StatsTraceContext.ServerCallMethodListener {
+    @Nullable private ServerCallInfo<?, ?> serverCallInfo;
+    @Nullable private String recordedMethodName;
+    @Nullable private String resolvedMethodName;
+    private boolean streamClosed;
+
+    @Override
+    public synchronized void serverCallMethodResolved(MethodDescriptor<?, ?> method) {
+      resolvedMethodName =
+          recordMethodName(method.isSampledToLocalTracing(), method.getFullMethodName());
+    }
+
+    @Override
+    public synchronized void streamClosed(Status status) {
+      streamClosed = true;
+      if (serverCallInfo != null) {
+        recordedMethodName =
+            recordMethodName(
+                serverCallInfo.getMethodDescriptor().isSampledToLocalTracing(),
+                serverCallInfo.getMethodDescriptor().getFullMethodName());
+      } else if (resolvedMethodName != null) {
+        recordedMethodName = resolvedMethodName;
+      } else {
+        recordedMethodName = "other";
+      }
+    }
+
+    @Override
+    public synchronized void serverCallStarted(ServerCallInfo<?, ?> callInfo) {
+      serverCallInfo = callInfo;
+      if (streamClosed) {
+        recordedMethodName =
+            recordMethodName(
+                callInfo.getMethodDescriptor().isSampledToLocalTracing(),
+                callInfo.getMethodDescriptor().getFullMethodName());
+      }
+    }
+
+    @Nullable
+    synchronized ServerCallInfo<?, ?> getServerCallInfo() {
+      return serverCallInfo;
+    }
+
+    @Nullable
+    synchronized String getRecordedMethodName() {
+      return recordedMethodName;
+    }
+
+    private static String recordMethodName(boolean generatedMethod, String fullMethodName) {
+      return generatedMethod ? fullMethodName : "other";
+    }
+  }
+
+  @Rule public final MockitoRule mocks = MockitoJUnit.rule();
 
   @BeforeClass
   public static void beforeStartUp() {
@@ -199,12 +261,12 @@ public List<ServerServiceDefinition> getServices() {
   /** 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) {
+              List<? extends ServerStreamTracer.Factory> streamTracerFactories,
+              MetricRecorder metricRecorder) {
             throw new UnsupportedOperationException();
           }
         });
@@ -458,6 +520,293 @@ public void methodNotFound() throws Exception {
     assertEquals(Status.Code.UNIMPLEMENTED, statusCaptor.getValue().getCode());
   }
 
+  @Test
+  public void primaryRegistryGeneratedMethod_streamClosedBeforeStart_preservesMethodName()
+      throws Exception {
+    MethodNameCapturingTracer methodNameTracer = new MethodNameCapturingTracer();
+    streamTracerFactories =
+        Collections.singletonList(
+            new ServerStreamTracer.Factory() {
+              @Override
+              public ServerStreamTracer newServerStreamTracer(
+                  String fullMethodName, Metadata headers) {
+                return methodNameTracer;
+              }
+            });
+    builder.addService(
+        ServerServiceDefinition.builder(new ServiceDescriptor("Waiter", GENERATED_METHOD))
+            .addMethod(
+                GENERATED_METHOD,
+                new ServerCallHandler<String, Integer>() {
+                  @Override
+                  public ServerCall.Listener<String> startCall(
+                      ServerCall<String, Integer> call, Metadata headers) {
+                    return callListener;
+                  }
+                })
+            .build());
+
+    createAndStartServer();
+    ServerTransportListener transportListener
+        = transportServer.registerNewServerTransport(new SimpleServerTransport());
+    transportListener.transportReady(Attributes.EMPTY);
+    Metadata requestHeaders = new Metadata();
+    StatsTraceContext statsTraceCtx =
+        StatsTraceContext.newServerContext(
+            streamTracerFactories, GENERATED_METHOD.getFullMethodName(), requestHeaders);
+    when(stream.getAttributes()).thenReturn(Attributes.EMPTY);
+    when(stream.statsTraceContext()).thenReturn(statsTraceCtx);
+
+    transportListener.streamCreated(stream, GENERATED_METHOD.getFullMethodName(), requestHeaders);
+    verify(stream).setListener(isA(ServerStreamListener.class));
+    verify(stream, atLeast(1)).statsTraceContext();
+
+    statsTraceCtx.streamClosed(Status.CANCELLED);
+    assertNull(methodNameTracer.getServerCallInfo());
+    assertEquals(
+        GENERATED_METHOD.getFullMethodName(),
+        methodNameTracer.getRecordedMethodName());
+
+    assertEquals(1, executor.runDueTasks());
+
+    assertNotNull(methodNameTracer.getServerCallInfo());
+    assertSame(GENERATED_METHOD, methodNameTracer.getServerCallInfo().getMethodDescriptor());
+    assertEquals(
+        GENERATED_METHOD.getFullMethodName(),
+        methodNameTracer.getRecordedMethodName());
+    verify(fallbackRegistry, never()).lookupMethod(anyString(), any());
+  }
+
+  @Test
+  public void primaryRegistryNonGeneratedMethod_streamClosedBeforeStart_recordsOther()
+      throws Exception {
+    MethodNameCapturingTracer methodNameTracer = new MethodNameCapturingTracer();
+    streamTracerFactories =
+        Collections.singletonList(
+            new ServerStreamTracer.Factory() {
+              @Override
+              public ServerStreamTracer newServerStreamTracer(
+                  String fullMethodName, Metadata headers) {
+                return methodNameTracer;
+              }
+            });
+    builder.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) {
+                    return callListener;
+                  }
+                })
+            .build());
+
+    createAndStartServer();
+    ServerTransportListener transportListener
+        = transportServer.registerNewServerTransport(new SimpleServerTransport());
+    transportListener.transportReady(Attributes.EMPTY);
+    Metadata requestHeaders = new Metadata();
+    StatsTraceContext statsTraceCtx =
+        StatsTraceContext.newServerContext(
+            streamTracerFactories, METHOD.getFullMethodName(), requestHeaders);
+    when(stream.getAttributes()).thenReturn(Attributes.EMPTY);
+    when(stream.statsTraceContext()).thenReturn(statsTraceCtx);
+
+    transportListener.streamCreated(stream, METHOD.getFullMethodName(), requestHeaders);
+    verify(stream).setListener(isA(ServerStreamListener.class));
+    verify(stream, atLeast(1)).statsTraceContext();
+
+    statsTraceCtx.streamClosed(Status.CANCELLED);
+    assertNull(methodNameTracer.getServerCallInfo());
+    assertEquals("other", methodNameTracer.getRecordedMethodName());
+
+    assertEquals(1, executor.runDueTasks());
+
+    assertNotNull(methodNameTracer.getServerCallInfo());
+    assertSame(METHOD, methodNameTracer.getServerCallInfo().getMethodDescriptor());
+    assertEquals("other", methodNameTracer.getRecordedMethodName());
+    verify(fallbackRegistry, never()).lookupMethod(anyString(), any());
+  }
+
+  @Test
+  public void fallbackRegistryGeneratedMethod_streamClosedBeforeStart_resolvesOnAsyncLookup()
+      throws Exception {
+    MethodNameCapturingTracer methodNameTracer = new MethodNameCapturingTracer();
+    streamTracerFactories =
+        Collections.singletonList(
+            new ServerStreamTracer.Factory() {
+              @Override
+              public ServerStreamTracer newServerStreamTracer(
+                  String fullMethodName, Metadata headers) {
+                return methodNameTracer;
+              }
+            });
+    mutableFallbackRegistry.addService(
+        ServerServiceDefinition.builder(new ServiceDescriptor("Waiter", GENERATED_METHOD))
+            .addMethod(
+                GENERATED_METHOD,
+                new ServerCallHandler<String, Integer>() {
+                  @Override
+                  public ServerCall.Listener<String> startCall(
+                      ServerCall<String, Integer> call, Metadata headers) {
+                    return callListener;
+                  }
+                })
+            .build());
+
+    createAndStartServer();
+    ServerTransportListener transportListener
+        = transportServer.registerNewServerTransport(new SimpleServerTransport());
+    transportListener.transportReady(Attributes.EMPTY);
+    Metadata requestHeaders = new Metadata();
+    StatsTraceContext statsTraceCtx =
+        StatsTraceContext.newServerContext(
+            streamTracerFactories, GENERATED_METHOD.getFullMethodName(), requestHeaders);
+    when(stream.getAttributes()).thenReturn(Attributes.EMPTY);
+    when(stream.statsTraceContext()).thenReturn(statsTraceCtx);
+
+    transportListener.streamCreated(stream, GENERATED_METHOD.getFullMethodName(), requestHeaders);
+    verify(stream).setListener(isA(ServerStreamListener.class));
+    verify(stream, atLeast(1)).statsTraceContext();
+
+    statsTraceCtx.streamClosed(Status.CANCELLED);
+    assertNull(methodNameTracer.getServerCallInfo());
+    assertEquals("other", methodNameTracer.getRecordedMethodName());
+    verify(fallbackRegistry, never()).lookupMethod(anyString(), any());
+
+    assertEquals(1, executor.runDueTasks());
+
+    assertNotNull(methodNameTracer.getServerCallInfo());
+    assertSame(GENERATED_METHOD, methodNameTracer.getServerCallInfo().getMethodDescriptor());
+    assertEquals(
+        GENERATED_METHOD.getFullMethodName(),
+        methodNameTracer.getRecordedMethodName());
+    verify(fallbackRegistry).lookupMethod(GENERATED_METHOD.getFullMethodName(), AUTHORITY);
+  }
+
+
+  @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";
@@ -557,7 +906,7 @@ public ServerCall.Listener<String> startCall(
     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(firstResponse);
@@ -808,7 +1157,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) {
         }
@@ -848,7 +1197,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) {
@@ -962,7 +1311,7 @@ private void checkContext() {
     assertTrue(onHalfCloseCalled.get());
 
     streamListener.closed(Status.CANCELLED);
-    assertEquals(1, executor.numPendingTasks(CONTEXT_CLOSER_TASK_FITLER));
+    assertEquals(1, executor.numPendingTasks(CONTEXT_CLOSER_TASK_FILTER));
     assertEquals(2, executor.runDueTasks());
     assertTrue(onCancelCalled.get());
 
@@ -1024,11 +1373,21 @@ public ServerCall.Listener<String> startCall(
   @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, 0L);
+    testStreamClose_setup(callReference, context, contextCancelled, 1L);
 
     // This assert that stream.setListener(jumpListener) is called before stream.cancel(), which
     // prevents extremely short deadlines causing NPEs.
@@ -1056,10 +1415,11 @@ public void testStreamClose_clientCancelTriggersImmediateCancellation() throws E
     assertFalse(callReference.get().isCancelled());
     assertFalse(context.get().isCancelled());
     streamListener.closed(Status.CANCELLED);
-    assertEquals(1, executor.numPendingTasks(CONTEXT_CLOSER_TASK_FITLER));
+    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());
   }
 
@@ -1073,7 +1433,9 @@ public void testStreamClose_clientOkTriggersDelayedCancellation() throws Excepti
         context, contextCancelled, null);
 
     // For close status OK:
-    // isCancelled is expected to be true after all pending work is done
+    // 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);
@@ -1081,8 +1443,9 @@ public void testStreamClose_clientOkTriggersDelayedCancellation() throws Excepti
     assertFalse(context.get().isCancelled());
 
     assertEquals(1, executor.runDueTasks());
-    assertTrue(callReference.get().isCancelled());
+    assertFalse(callReference.get().isCancelled());
     assertTrue(context.get().isCancelled());
+    assertThat(context.get().cancellationCause()).isNull();
     assertTrue(contextCancelled.get());
   }
 
@@ -1100,9 +1463,10 @@ public void testStreamClose_deadlineExceededTriggersImmediateCancellation() thro
     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());
   }
 
@@ -1131,9 +1495,8 @@ public List<InetSocketAddress> getListenSocketAddresses() {
   public void getPortBeforeStartedFails() {
     transportServer = new SimpleServer();
     createServer();
-    thrown.expect(IllegalStateException.class);
-    thrown.expectMessage("started");
-    server.getPort();
+    IllegalStateException e = assertThrows(IllegalStateException.class, () -> server.getPort());
+    assertThat(e).hasMessageThat().isEqualTo("Not started");
   }
 
   @Test
@@ -1142,9 +1505,8 @@ public void getPortAfterTerminationFails() throws Exception {
     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
@@ -1169,7 +1531,7 @@ public void handlerRegistryPriorities() throws Exception {
     assertEquals(1, executor.runDueTasks());
     verify(callHandler).startCall(ArgumentMatchers.<ServerCall<String, Integer>>any(),
         ArgumentMatchers.<Metadata>any());
-    // This call will be handled by the fallbackRegistry because it's not registred in the internal
+    // 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());
@@ -1513,4 +1875,24 @@ public ListenableFuture<SocketStats> getStats() {
 
   /** 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
index 16c6f3bf302..0daee676b82 100644
--- a/core/src/test/java/io/grpc/internal/ServiceConfigErrorHandlingTest.java
+++ b/core/src/test/java/io/grpc/internal/ServiceConfigErrorHandlingTest.java
@@ -19,6 +19,7 @@
 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;
@@ -45,9 +46,11 @@
 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;
@@ -98,7 +101,7 @@ public String toString() {
         @Override
         public boolean shouldAccept(Runnable command) {
           return command.toString().contains(
-              ManagedChannelImpl.DelayedNameResolverRefresh.class.getName());
+              RetryingNameResolver.DelayedNameResolverRefresh.class.getName());
         }
       };
 
@@ -158,10 +161,16 @@ public ConfigOrError parseLoadBalancingPolicyConfig(
   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(),
@@ -186,13 +195,13 @@ public void run() {
     }
 
     assertEquals(numExpectedTasks, timer.numPendingTasks());
-    ArgumentCaptor<Helper> helperCaptor = ArgumentCaptor.forClass(null);
+    ArgumentCaptor<Helper> helperCaptor = ArgumentCaptor.forClass(Helper.class);
     verify(mockLoadBalancerProvider).newLoadBalancer(helperCaptor.capture());
   }
 
   @Before
   public void setUp() throws Exception {
-    when(mockLoadBalancer.canHandleEmptyAddressListFromNameResolution()).thenCallRealMethod();
+    mockLoadBalancer.setAddressAcceptanceStatus(Status.OK);
     LoadBalancerRegistry.getDefaultRegistry().register(mockLoadBalancerProvider);
     expectedUri = new URI(TARGET);
     when(mockTransportFactory.getScheduledExecutorService())
@@ -236,7 +245,7 @@ public void cleanUp() {
   public void emptyAddresses_validConfig_firstResolution_lbNeedsAddress() throws Exception {
     FakeNameResolverFactory nameResolverFactory =
         new FakeNameResolverFactory.Builder(expectedUri)
-            .setServers(Collections.<EquivalentAddressGroup>emptyList())
+            .setServers(Collections.emptyList())
             .build();
     channelBuilder.nameResolverFactory(nameResolverFactory);
 
@@ -268,41 +277,35 @@ public void emptyAddresses_validConfig_2ndResolution_lbNeedsAddress() throws Exc
 
     ArgumentCaptor<ResolvedAddresses> resultCaptor =
         ArgumentCaptor.forClass(ResolvedAddresses.class);
-    verify(mockLoadBalancer).handleResolvedAddresses(resultCaptor.capture());
+    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.IDLE);
+    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
-    ArgumentCaptor<Status> statusCaptor = ArgumentCaptor.forClass(Status.class);
-    verify(mockLoadBalancer, never()).handleResolvedAddresses(any(ResolvedAddresses.class));
-    verify(mockLoadBalancer).handleNameResolutionError(statusCaptor.capture());
-    assertThat(statusCaptor.getValue().getCode()).isEqualTo(Status.Code.UNAVAILABLE);
-    assertThat(statusCaptor.getValue().getDescription())
-        .contains("NameResolver returned no usable address.");
-    assertThat(channel.getState(true)).isEqualTo(ConnectivityState.TRANSIENT_FAILURE);
-    assertWithMessage("Empty address should schedule NameResolver retry")
-        .that(getNameResolverRefresh())
-        .isNotNull();
+    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.<EquivalentAddressGroup>emptyList())
+            .setServers(Collections.emptyList())
             .build();
     channelBuilder.nameResolverFactory(nameResolverFactory);
-    when(mockLoadBalancer.canHandleEmptyAddressListFromNameResolution()).thenReturn(true);
 
     Map<String, Object> rawServiceConfig =
         parseJson("{\"loadBalancingConfig\": [{\"mock_lb\": {\"check\": \"val\"}}]}");
@@ -312,11 +315,11 @@ public void emptyAddresses_validConfig_lbDoesNotNeedAddress() throws Exception {
 
     ArgumentCaptor<ResolvedAddresses> resultCaptor =
         ArgumentCaptor.forClass(ResolvedAddresses.class);
-    verify(mockLoadBalancer).handleResolvedAddresses(resultCaptor.capture());
+    verify(mockLoadBalancer).acceptResolvedAddresses(resultCaptor.capture());
 
     ResolvedAddresses resolvedAddresses = resultCaptor.getValue();
     assertThat(resolvedAddresses.getAddresses()).isEmpty();
-    assertThat(resolvedAddresses.getLoadBalancingPolicyConfig()).isEqualTo("val");;
+    assertThat(resolvedAddresses.getLoadBalancingPolicyConfig()).isEqualTo("val");
 
     verify(mockLoadBalancer, never()).handleNameResolutionError(any(Status.class));
     assertThat(channel.getState(false)).isNotEqualTo(ConnectivityState.TRANSIENT_FAILURE);
@@ -338,7 +341,7 @@ public void validConfig_lbDoesNotNeedAddress() throws Exception {
 
     ArgumentCaptor<ResolvedAddresses> resultCaptor =
         ArgumentCaptor.forClass(ResolvedAddresses.class);
-    verify(mockLoadBalancer).handleResolvedAddresses(resultCaptor.capture());
+    verify(mockLoadBalancer).acceptResolvedAddresses(resultCaptor.capture());
     ResolvedAddresses resolvedAddresses = resultCaptor.getValue();
     assertThat(resolvedAddresses.getAddresses()).containsExactly(addressGroup);
     assertThat(resolvedAddresses.getLoadBalancingPolicyConfig()).isEqualTo("foo");
@@ -360,7 +363,7 @@ public void noConfig_noDefaultConfig() {
 
     ArgumentCaptor<ResolvedAddresses> resultCaptor =
         ArgumentCaptor.forClass(ResolvedAddresses.class);
-    verify(mockLoadBalancer).handleResolvedAddresses(resultCaptor.capture());
+    verify(mockLoadBalancer).acceptResolvedAddresses(resultCaptor.capture());
     ResolvedAddresses resolvedAddresses = resultCaptor.getValue();
     assertThat(resolvedAddresses.getAddresses()).containsExactly(addressGroup);
     assertThat(resolvedAddresses.getLoadBalancingPolicyConfig()).isNull();
@@ -386,7 +389,7 @@ public void noConfig_usingDefaultConfig() throws Exception {
 
     ArgumentCaptor<ResolvedAddresses> resultCaptor =
         ArgumentCaptor.forClass(ResolvedAddresses.class);
-    verify(mockLoadBalancer).handleResolvedAddresses(resultCaptor.capture());
+    verify(mockLoadBalancer).acceptResolvedAddresses(resultCaptor.capture());
     ResolvedAddresses resolvedAddresses = resultCaptor.getValue();
     assertThat(resolvedAddresses.getAddresses()).containsExactly(addressGroup);
     assertThat(resolvedAddresses.getLoadBalancingPolicyConfig()).isEqualTo("foo");
@@ -431,7 +434,7 @@ public void invalidConfig_withDefaultConfig() throws Exception {
 
     ArgumentCaptor<ResolvedAddresses> resultCaptor =
         ArgumentCaptor.forClass(ResolvedAddresses.class);
-    verify(mockLoadBalancer).handleResolvedAddresses(resultCaptor.capture());
+    verify(mockLoadBalancer).acceptResolvedAddresses(resultCaptor.capture());
 
     ResolvedAddresses resolvedAddresses = resultCaptor.getValue();
     assertThat(resolvedAddresses.getAddresses()).containsExactly(addressGroup);
@@ -462,7 +465,7 @@ public void invalidConfig_2ndResolution() throws Exception {
 
     ArgumentCaptor<ResolvedAddresses> resultCaptor =
         ArgumentCaptor.forClass(ResolvedAddresses.class);
-    verify(mockLoadBalancer).handleResolvedAddresses(resultCaptor.capture());
+    verify(mockLoadBalancer).acceptResolvedAddresses(resultCaptor.capture());
     ResolvedAddresses resolvedAddresses = resultCaptor.getValue();
     assertThat(resolvedAddresses.getAddresses()).containsExactly(addressGroup);
     assertThat(resolvedAddresses.getLoadBalancingPolicyConfig()).isEqualTo("1st raw config");
@@ -477,13 +480,13 @@ public void invalidConfig_2ndResolution() throws Exception {
     nextLbPolicyConfigError.set(Status.UNKNOWN);
     nameResolverFactory.allResolved();
 
-    verify(mockLoadBalancer).handleResolvedAddresses(resultCaptor.capture());
+    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.IDLE);
+    assertThat(channel.getState(false)).isEqualTo(ConnectivityState.CONNECTING);
   }
 
   @Test
@@ -510,7 +513,7 @@ public void validConfig_thenNoConfig_withDefaultConfig() throws Exception {
 
     ArgumentCaptor<ResolvedAddresses> resultCaptor =
         ArgumentCaptor.forClass(ResolvedAddresses.class);
-    verify(mockLoadBalancer).handleResolvedAddresses(resultCaptor.capture());
+    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.
@@ -522,7 +525,7 @@ public void validConfig_thenNoConfig_withDefaultConfig() throws Exception {
     nameResolverFactory.nextRawServiceConfig.set(null);
     nameResolverFactory.allResolved();
 
-    verify(mockLoadBalancer, times(2)).handleResolvedAddresses(resultCaptor.capture());
+    verify(mockLoadBalancer, times(2)).acceptResolvedAddresses(resultCaptor.capture());
     ResolvedAddresses newResolvedAddress = resultCaptor.getValue();
     assertThat(newResolvedAddress.getLoadBalancingPolicyConfig()).isEqualTo("mate");
     assertThat(newResolvedAddress.getAttributes().get(InternalConfigSelector.KEY))
@@ -587,8 +590,6 @@ final class FakeNameResolver extends NameResolver {
 
       final ServiceConfigParser serviceConfigParser;
       Listener2 listener;
-      boolean shutdown;
-      int refreshCalled;
 
       FakeNameResolver(ServiceConfigParser serviceConfigParser) {
         this.serviceConfigParser = serviceConfigParser;
@@ -606,7 +607,6 @@ final class FakeNameResolver extends NameResolver {
       }
 
       @Override public void refresh() {
-        refreshCalled++;
         resolved();
       }
 
@@ -623,7 +623,6 @@ void resolved() {
       }
 
       @Override public void shutdown() {
-        shutdown = true;
       }
 
       @Override
@@ -653,11 +652,14 @@ FakeNameResolverFactory build() {
   }
 
   private FakeClock.ScheduledTask getNameResolverRefresh() {
-    return Iterables.getOnlyElement(timer.getPendingTasks(NAME_RESOLVER_REFRESH_TASK_FILTER), null);
+    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;
 
@@ -665,6 +667,15 @@ 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,
diff --git a/core/src/test/java/io/grpc/internal/SharedResourceHolderTest.java b/core/src/test/java/io/grpc/internal/SharedResourceHolderTest.java
index 531632ca79c..692b22a0a68 100644
--- a/core/src/test/java/io/grpc/internal/SharedResourceHolderTest.java
+++ b/core/src/test/java/io/grpc/internal/SharedResourceHolderTest.java
@@ -30,7 +30,9 @@
 
 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;
@@ -98,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);
 
@@ -201,6 +203,46 @@ public void close(ResourceInstance instance) {
     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
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/TransportFrameUtilTest.java b/core/src/test/java/io/grpc/internal/TransportFrameUtilTest.java
index 3de0a207ddf..8b4bc170d52 100644
--- a/core/src/test/java/io/grpc/internal/TransportFrameUtilTest.java
+++ b/core/src/test/java/io/grpc/internal/TransportFrameUtilTest.java
@@ -16,10 +16,10 @@
 
 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;
@@ -46,16 +46,16 @@ 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 String parseBytes(byte[] serialized) {
-      return new String(serialized, 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);
+        }
+      };
 
   private static final Metadata.Key<String> PLAIN_STRING =
       Metadata.Key.of("plainstring", ASCII_STRING_MARSHALLER);
diff --git a/core/src/test/java/io/grpc/util/ForwardingClientStreamTracerTest.java b/core/src/test/java/io/grpc/util/ForwardingClientStreamTracerTest.java
deleted file mode 100644
index fcb19b69eb8..00000000000
--- a/core/src/test/java/io/grpc/util/ForwardingClientStreamTracerTest.java
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
- * 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());
-  }
-
-  private final class TestClientStreamTracer extends ForwardingClientStreamTracer {
-    @Override
-    protected ClientStreamTracer delegate() {
-      return mockDelegate;
-    }
-  }
-}
diff --git a/core/src/test/java/io/grpc/util/GracefulSwitchLoadBalancerTest.java b/core/src/test/java/io/grpc/util/GracefulSwitchLoadBalancerTest.java
deleted file mode 100644
index 2131cd725b6..00000000000
--- a/core/src/test/java/io/grpc/util/GracefulSwitchLoadBalancerTest.java
+++ /dev/null
@@ -1,545 +0,0 @@
-/*
- * 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.READY;
-import static io.grpc.ConnectivityState.TRANSIENT_FAILURE;
-import static io.grpc.util.GracefulSwitchLoadBalancer.BUFFER_PICKER;
-import static org.mockito.ArgumentMatchers.eq;
-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 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.Status;
-import java.net.SocketAddress;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-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;
-
-/**
- * Tests for {@link GracefulSwitchLoadBalancer}.
- */
-@RunWith(JUnit4.class)
-public class GracefulSwitchLoadBalancerTest {
-  @SuppressWarnings("deprecation") // https://github.com/grpc/grpc-java/issues/7467
-  @Rule
-  public final ExpectedException thrown = ExpectedException.none();
-
-  private final LoadBalancerRegistry lbRegistry = new LoadBalancerRegistry();
-  // maps policy name to lb provide
-  private final Map<String, LoadBalancerProvider> lbProviders = new HashMap<>();
-  // maps policy name to lb
-  private final Map<String, 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 String[] lbPolicies = {"lb_policy_0", "lb_policy_1", "lb_policy_2", "lb_policy_3"};
-
-  @Before
-  public void setUp() {
-    for (String lbPolicy : lbPolicies) {
-      LoadBalancerProvider lbProvider = new FakeLoadBalancerProvider(lbPolicy);
-      lbProviders.put(lbPolicy, lbProvider);
-      lbRegistry.register(lbProvider);
-    }
-  }
-
-  @Test
-  public void canHandleEmptyAddressListFromNameResolutionForwardedToLatestPolicy() {
-    gracefulSwitchLb.switchTo(lbProviders.get(lbPolicies[0]));
-    LoadBalancer lb0 = balancers.get(lbPolicies[0]);
-    Helper helper0 = helpers.get(lb0);
-    SubchannelPicker picker = mock(SubchannelPicker.class);
-    helper0.updateBalancingState(READY, picker);
-
-    assertThat(gracefulSwitchLb.canHandleEmptyAddressListFromNameResolution()).isFalse();
-    doReturn(true).when(lb0).canHandleEmptyAddressListFromNameResolution();
-    assertThat(gracefulSwitchLb.canHandleEmptyAddressListFromNameResolution()).isTrue();
-
-    gracefulSwitchLb.switchTo(lbProviders.get(lbPolicies[1]));
-    LoadBalancer lb1 = balancers.get(lbPolicies[1]);
-
-    assertThat(gracefulSwitchLb.canHandleEmptyAddressListFromNameResolution()).isFalse();
-
-    doReturn(true).when(lb1).canHandleEmptyAddressListFromNameResolution();
-    assertThat(gracefulSwitchLb.canHandleEmptyAddressListFromNameResolution()).isTrue();
-
-    gracefulSwitchLb.switchTo(lbProviders.get(lbPolicies[2]));
-    LoadBalancer lb2 = balancers.get(lbPolicies[2]);
-
-    assertThat(gracefulSwitchLb.canHandleEmptyAddressListFromNameResolution()).isFalse();
-
-    doReturn(true).when(lb2).canHandleEmptyAddressListFromNameResolution();
-    assertThat(gracefulSwitchLb.canHandleEmptyAddressListFromNameResolution()).isTrue();
-  }
-
-  @Test
-  public void handleResolvedAddressesAndNameResolutionErrorForwardedToLatestPolicy() {
-    gracefulSwitchLb.switchTo(lbProviders.get(lbPolicies[0]));
-    LoadBalancer lb0 = balancers.get(lbPolicies[0]);
-    Helper helper0 = helpers.get(lb0);
-    SubchannelPicker picker = mock(SubchannelPicker.class);
-    helper0.updateBalancingState(READY, picker);
-
-    ResolvedAddresses addresses = newFakeAddresses();
-    gracefulSwitchLb.handleResolvedAddresses(addresses);
-    verify(lb0).handleResolvedAddresses(addresses);
-    gracefulSwitchLb.handleNameResolutionError(Status.DATA_LOSS);
-    verify(lb0).handleNameResolutionError(Status.DATA_LOSS);
-
-    gracefulSwitchLb.switchTo(lbProviders.get(lbPolicies[1]));
-    LoadBalancer lb1 = balancers.get(lbPolicies[1]);
-    addresses = newFakeAddresses();
-    gracefulSwitchLb.handleResolvedAddresses(addresses);
-    verify(lb0, never()).handleResolvedAddresses(addresses);
-    verify(lb1).handleResolvedAddresses(addresses);
-    gracefulSwitchLb.handleNameResolutionError(Status.ALREADY_EXISTS);
-    verify(lb0, never()).handleNameResolutionError(Status.ALREADY_EXISTS);
-    verify(lb1).handleNameResolutionError(Status.ALREADY_EXISTS);
-
-    gracefulSwitchLb.switchTo(lbProviders.get(lbPolicies[2]));
-    verify(lb1).shutdown();
-    LoadBalancer lb2 = balancers.get(lbPolicies[2]);
-    addresses = newFakeAddresses();
-    gracefulSwitchLb.handleResolvedAddresses(addresses);
-    verify(lb0, never()).handleResolvedAddresses(addresses);
-    verify(lb1, never()).handleResolvedAddresses(addresses);
-    verify(lb2).handleResolvedAddresses(addresses);
-    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() {
-    gracefulSwitchLb.switchTo(lbProviders.get(lbPolicies[0]));
-    LoadBalancer lb0 = balancers.get(lbPolicies[0]);
-    Helper helper0 = helpers.get(lb0);
-    SubchannelPicker picker = mock(SubchannelPicker.class);
-    helper0.updateBalancingState(READY, picker);
-
-    gracefulSwitchLb.switchTo(lbProviders.get(lbPolicies[1]));
-    LoadBalancer lb1 = balancers.get(lbPolicies[1]);
-    verify(lb1, never()).shutdown();
-
-    gracefulSwitchLb.switchTo(lbProviders.get(lbPolicies[2]));
-    verify(lb1).shutdown();
-    LoadBalancer lb2 = balancers.get(lbPolicies[2]);
-    verify(lb0, never()).shutdown();
-    helpers.get(lb2).updateBalancingState(READY, mock(SubchannelPicker.class));
-    verify(lb0).shutdown();
-
-    gracefulSwitchLb.switchTo(lbProviders.get(lbPolicies[3]));
-    LoadBalancer lb3 = balancers.get(lbPolicies[3]);
-    verify(lb2, never()).shutdown();
-    verify(lb3, never()).shutdown();
-
-    gracefulSwitchLb.shutdown();
-    verify(lb2).shutdown();
-    verify(lb3).shutdown();
-
-    verifyNoMoreInteractions(lb0, lb1, lb2, lb3);
-  }
-
-  @Test
-  public void requestConnectionForwardedToLatestPolicies() {
-    gracefulSwitchLb.switchTo(lbProviders.get(lbPolicies[0]));
-    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();
-
-    gracefulSwitchLb.switchTo(lbProviders.get(lbPolicies[1]));
-    LoadBalancer lb1 = balancers.get(lbPolicies[1]);
-    gracefulSwitchLb.requestConnection();
-    verify(lb1).requestConnection();
-
-    gracefulSwitchLb.switchTo(lbProviders.get(lbPolicies[2]));
-    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();
-
-    gracefulSwitchLb.switchTo(lbProviders.get(lbPolicies[3]));
-    LoadBalancer lb3 = balancers.get(lbPolicies[3]);
-    gracefulSwitchLb.requestConnection();
-    verify(lb3).requestConnection();
-
-    verifyNoMoreInteractions(lb0, lb1, lb2, lb3);
-  }
-
-  @Test
-  public void createSubchannelForwarded() {
-    gracefulSwitchLb.switchTo(lbProviders.get(lbPolicies[0]));
-    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);
-
-    gracefulSwitchLb.switchTo(lbProviders.get(lbPolicies[1]));
-    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);
-
-    verifyNoMoreInteractions(lb0, lb1);
-  }
-
-  @Test
-  public void updateBalancingStateIsGraceful() {
-    gracefulSwitchLb.switchTo(lbProviders.get(lbPolicies[0]));
-    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);
-
-    gracefulSwitchLb.switchTo(lbProviders.get(lbPolicies[1]));
-    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);
-
-    gracefulSwitchLb.switchTo(lbProviders.get(lbPolicies[2]));
-    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 READY
-    SubchannelPicker picker2 = mock(SubchannelPicker.class);
-    helper2.updateBalancingState(READY, picker2);
-    verify(lb0).shutdown();
-    verify(mockHelper).updateBalancingState(READY, picker2);
-
-    gracefulSwitchLb.switchTo(lbProviders.get(lbPolicies[3]));
-    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 READY
-    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);
-
-    verifyNoMoreInteractions(lb0, lb1, lb2, lb3);
-  }
-
-  @Test
-  public void switchWhileOldPolicyIsNotReady() {
-    gracefulSwitchLb.switchTo(lbProviders.get(lbPolicies[0]));
-    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();
-    gracefulSwitchLb.switchTo(lbProviders.get(lbPolicies[1]));
-    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();
-    gracefulSwitchLb.switchTo(lbProviders.get(lbPolicies[2]));
-    verify(lb1).shutdown();
-    LoadBalancer lb2 = balancers.get(lbPolicies[2]);
-
-    verifyNoMoreInteractions(lb0, lb1, lb2);
-  }
-
-  @Test
-  public void switchWhileOldPolicyGoesFromReadyToNotReady() {
-    gracefulSwitchLb.switchTo(lbProviders.get(lbPolicies[0]));
-    LoadBalancer lb0 = balancers.get(lbPolicies[0]);
-    Helper helper0 = helpers.get(lb0);
-    SubchannelPicker picker = mock(SubchannelPicker.class);
-    helper0.updateBalancingState(READY, picker);
-
-    gracefulSwitchLb.switchTo(lbProviders.get(lbPolicies[1]));
-    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);
-
-    verifyNoMoreInteractions(lb0, lb1);
-  }
-
-  @Test
-  public void switchWhileOldPolicyGoesFromReadyToNotReadyWhileNewPolicyStillIdle() {
-    gracefulSwitchLb.switchTo(lbProviders.get(lbPolicies[0]));
-    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);
-
-    gracefulSwitchLb.switchTo(lbProviders.get(lbPolicies[1]));
-    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);
-    inOrder.verify(mockHelper).updateBalancingState(CONNECTING, BUFFER_PICKER);
-    inOrder.verify(lb0).shutdown(); // shutdown after update
-
-    picker = mock(SubchannelPicker.class);
-    helper1.updateBalancingState(CONNECTING, picker);
-    inOrder.verify(mockHelper).updateBalancingState(CONNECTING, picker);
-
-    inOrder.verifyNoMoreInteractions();
-    verifyNoMoreInteractions(lb1);
-  }
-
-  @Test
-  public void newPolicyNameTheSameAsPendingPolicy_shouldHaveNoEffect() {
-    gracefulSwitchLb.switchTo(lbProviders.get(lbPolicies[0]));
-    LoadBalancer lb0 = balancers.get(lbPolicies[0]);
-    Helper helper0 = helpers.get(lb0);
-    SubchannelPicker picker = mock(SubchannelPicker.class);
-    helper0.updateBalancingState(READY, picker);
-
-    gracefulSwitchLb.switchTo(lbProviders.get(lbPolicies[1]));
-    LoadBalancer lb1 = balancers.get(lbPolicies[1]);
-
-    gracefulSwitchLb.switchTo(lbProviders.get(lbPolicies[1]));
-    assertThat(balancers.get(lbPolicies[1])).isSameInstanceAs(lb1);
-
-    verifyNoMoreInteractions(lb0, lb1);
-  }
-
-  @Test
-  public void newPolicyNameTheSameAsCurrentPolicy_shouldShutdownPendingLb() {
-    gracefulSwitchLb.switchTo(lbProviders.get(lbPolicies[0]));
-    LoadBalancer lb0 = balancers.get(lbPolicies[0]);
-
-    gracefulSwitchLb.switchTo(lbProviders.get(lbPolicies[0]));
-    assertThat(balancers.get(lbPolicies[0])).isSameInstanceAs(lb0);
-
-    Helper helper0 = helpers.get(lb0);
-    SubchannelPicker picker = mock(SubchannelPicker.class);
-    helper0.updateBalancingState(READY, picker);
-
-    gracefulSwitchLb.switchTo(lbProviders.get(lbPolicies[1]));
-    LoadBalancer lb1 = balancers.get(lbPolicies[1]);
-
-    gracefulSwitchLb.switchTo(lbProviders.get(lbPolicies[0]));
-    verify(lb1).shutdown();
-    assertThat(balancers.get(lbPolicies[0])).isSameInstanceAs(lb0);
-
-    verifyNoMoreInteractions(lb0, lb1);
-  }
-
-
-  @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);
-        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;
-      }
-    }
-
-    gracefulSwitchLb.switchTo(new LoadBalancerFactoryWithId(0));
-    assertThat(balancers).hasSize(1);
-    LoadBalancer lb0 = balancers.get(0);
-
-    gracefulSwitchLb.switchTo(new LoadBalancerFactoryWithId(0));
-    assertThat(balancers).hasSize(1);
-
-    gracefulSwitchLb.switchTo(new LoadBalancerFactoryWithId(1));
-    assertThat(balancers).hasSize(2);
-    LoadBalancer lb1 = balancers.get(1);
-    verify(lb0).shutdown();
-
-    verifyNoMoreInteractions(lb0, lb1);
-  }
-
-  @Test
-  public void transientFailureOnInitialResolutionError() {
-    gracefulSwitchLb.handleNameResolutionError(Status.DATA_LOSS);
-    ArgumentCaptor<SubchannelPicker> pickerCaptor = ArgumentCaptor.forClass(null);
-    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() {
-    gracefulSwitchLb.switchTo(lbProviders.get(lbPolicies[0]));
-    Subchannel subchannel = mock(Subchannel.class);
-    ConnectivityStateInfo connectivityStateInfo = ConnectivityStateInfo.forNonError(READY);
-    thrown.expect(UnsupportedOperationException.class);
-    gracefulSwitchLb.handleSubchannelState(subchannel, connectivityStateInfo);
-  }
-
-  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);
-      balancers.put(policyName, balancer);
-      helpers.put(balancer, helper);
-      return balancer;
-    }
-  }
-
-  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/core/src/test/java/io/grpc/util/RoundRobinLoadBalancerTest.java b/core/src/test/java/io/grpc/util/RoundRobinLoadBalancerTest.java
deleted file mode 100644
index e9f4ff9b439..00000000000
--- a/core/src/test/java/io/grpc/util/RoundRobinLoadBalancerTest.java
+++ /dev/null
@@ -1,493 +0,0 @@
-/*
- * 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 io.grpc.util.RoundRobinLoadBalancer.STATE_INFO;
-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.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.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.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.Status;
-import io.grpc.util.RoundRobinLoadBalancer.EmptyPicker;
-import io.grpc.util.RoundRobinLoadBalancer.ReadyPicker;
-import io.grpc.util.RoundRobinLoadBalancer.Ref;
-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 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 test for {@link RoundRobinLoadBalancer}. */
-@RunWith(JUnit4.class)
-public class RoundRobinLoadBalancerTest {
-  private static final Attributes.Key<String> MAJOR_KEY = Attributes.Key.create("major-key");
-
-  private RoundRobinLoadBalancer 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 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;
-  @Mock
-  private Helper mockHelper;
-
-  @Mock // This LoadBalancer doesn't use any of the arg fields, as verified in tearDown().
-  private PickSubchannelArgs mockArgs;
-
-  @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.add(eag);
-      Subchannel sc = mock(Subchannel.class);
-      subchannels.put(Arrays.asList(eag), sc);
-    }
-
-    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.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;
-          }
-        });
-
-    loadBalancer = new RoundRobinLoadBalancer(mockHelper);
-  }
-
-  @After
-  public void tearDown() throws Exception {
-    verifyNoMoreInteractions(mockArgs);
-  }
-
-  @Test
-  public void pickAfterResolved() throws Exception {
-    final Subchannel readySubchannel = subchannels.values().iterator().next();
-    loadBalancer.handleResolvedAddresses(
-        ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(affinity).build());
-    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);
-
-    verifyNoMoreInteractions(mockHelper);
-  }
-
-  @Test
-  public void pickAfterResolvedUpdatedHosts() throws Exception {
-    Subchannel removedSubchannel = mock(Subchannel.class);
-    Subchannel oldSubchannel = mock(Subchannel.class);
-    Subchannel newSubchannel = mock(Subchannel.class);
-
-    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());
-
-    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);
-
-    loadBalancer.handleResolvedAddresses(
-        ResolvedAddresses.newBuilder().setAddresses(currentServers).setAttributes(affinity)
-            .build());
-
-    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();
-
-    assertThat(loadBalancer.getSubchannels()).containsExactly(removedSubchannel,
-        oldSubchannel);
-
-    // This time with Attributes
-    List<EquivalentAddressGroup> latestServers = Lists.newArrayList(oldEag2, newEag);
-
-    loadBalancer.handleResolvedAddresses(
-        ResolvedAddresses.newBuilder().setAddresses(latestServers).setAttributes(affinity).build());
-
-    verify(newSubchannel, times(1)).requestConnection();
-    verify(oldSubchannel, times(1)).updateAddresses(Arrays.asList(oldEag2));
-    verify(removedSubchannel, times(1)).shutdown();
-
-    deliverSubchannelState(removedSubchannel, ConnectivityStateInfo.forNonError(SHUTDOWN));
-    deliverSubchannelState(newSubchannel, ConnectivityStateInfo.forNonError(READY));
-
-    assertThat(loadBalancer.getSubchannels()).containsExactly(oldSubchannel,
-        newSubchannel);
-
-    verify(mockHelper, times(3)).createSubchannel(any(CreateSubchannelArgs.class));
-    inOrder.verify(mockHelper, times(2)).updateBalancingState(eq(READY), pickerCaptor.capture());
-
-    picker = pickerCaptor.getValue();
-    assertThat(getList(picker)).containsExactly(oldSubchannel, newSubchannel);
-
-    // test going from non-empty to empty
-    loadBalancer.handleResolvedAddresses(
-        ResolvedAddresses.newBuilder()
-            .setAddresses(Collections.<EquivalentAddressGroup>emptyList())
-            .setAttributes(affinity)
-            .build());
-
-    inOrder.verify(mockHelper).updateBalancingState(eq(TRANSIENT_FAILURE), pickerCaptor.capture());
-    assertEquals(PickResult.withNoResult(), pickerCaptor.getValue().pickSubchannel(mockArgs));
-
-    verifyNoMoreInteractions(mockHelper);
-  }
-
-  @Test
-  public void pickAfterStateChange() throws Exception {
-    InOrder inOrder = inOrder(mockHelper);
-    loadBalancer.handleResolvedAddresses(
-        ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(Attributes.EMPTY)
-            .build());
-    Subchannel subchannel = loadBalancer.getSubchannels().iterator().next();
-    Ref<ConnectivityStateInfo> subchannelStateInfo = subchannel.getAttributes().get(
-        STATE_INFO);
-
-    inOrder.verify(mockHelper).updateBalancingState(eq(CONNECTING), isA(EmptyPicker.class));
-    assertThat(subchannelStateInfo.value).isEqualTo(ConnectivityStateInfo.forNonError(IDLE));
-
-    deliverSubchannelState(subchannel,
-        ConnectivityStateInfo.forNonError(READY));
-    inOrder.verify(mockHelper).updateBalancingState(eq(READY), pickerCaptor.capture());
-    assertThat(pickerCaptor.getValue()).isInstanceOf(ReadyPicker.class);
-    assertThat(subchannelStateInfo.value).isEqualTo(
-        ConnectivityStateInfo.forNonError(READY));
-
-    Status error = Status.UNKNOWN.withDescription("¯\\_(ツ)_//¯");
-    deliverSubchannelState(subchannel,
-        ConnectivityStateInfo.forTransientFailure(error));
-    assertThat(subchannelStateInfo.value.getState()).isEqualTo(TRANSIENT_FAILURE);
-    assertThat(subchannelStateInfo.value.getStatus()).isEqualTo(error);
-    inOrder.verify(mockHelper).updateBalancingState(eq(CONNECTING), pickerCaptor.capture());
-    assertThat(pickerCaptor.getValue()).isInstanceOf(EmptyPicker.class);
-
-    deliverSubchannelState(subchannel,
-        ConnectivityStateInfo.forNonError(IDLE));
-    assertThat(subchannelStateInfo.value.getState()).isEqualTo(TRANSIENT_FAILURE);
-    assertThat(subchannelStateInfo.value.getStatus()).isEqualTo(error);
-
-    verify(subchannel, times(2)).requestConnection();
-    verify(mockHelper, times(3)).createSubchannel(any(CreateSubchannelArgs.class));
-    verifyNoMoreInteractions(mockHelper);
-  }
-
-  @Test
-  public void stayTransientFailureUntilReady() {
-    InOrder inOrder = inOrder(mockHelper);
-    loadBalancer.handleResolvedAddresses(
-        ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(Attributes.EMPTY)
-            .build());
-
-    inOrder.verify(mockHelper).updateBalancingState(eq(CONNECTING), isA(EmptyPicker.class));
-
-    // Simulate state transitions for each subchannel individually.
-    for (Subchannel sc : loadBalancer.getSubchannels()) {
-      Status error = Status.UNKNOWN.withDescription("connection broken");
-      deliverSubchannelState(
-          sc,
-          ConnectivityStateInfo.forTransientFailure(error));
-      deliverSubchannelState(
-          sc,
-          ConnectivityStateInfo.forNonError(IDLE));
-      deliverSubchannelState(
-          sc,
-          ConnectivityStateInfo.forNonError(CONNECTING));
-      Ref<ConnectivityStateInfo> scStateInfo = sc.getAttributes().get(
-          STATE_INFO);
-      assertThat(scStateInfo.value.getState()).isEqualTo(TRANSIENT_FAILURE);
-      assertThat(scStateInfo.value.getStatus()).isEqualTo(error);
-    }
-    inOrder.verify(mockHelper).updateBalancingState(eq(TRANSIENT_FAILURE), isA(EmptyPicker.class));
-    inOrder.verifyNoMoreInteractions();
-
-    Subchannel subchannel = loadBalancer.getSubchannels().iterator().next();
-    deliverSubchannelState(subchannel, ConnectivityStateInfo.forNonError(READY));
-    Ref<ConnectivityStateInfo> subchannelStateInfo = subchannel.getAttributes().get(
-        STATE_INFO);
-    assertThat(subchannelStateInfo.value).isEqualTo(ConnectivityStateInfo.forNonError(READY));
-    inOrder.verify(mockHelper).updateBalancingState(eq(READY), isA(ReadyPicker.class));
-
-    verify(mockHelper, times(3)).createSubchannel(any(CreateSubchannelArgs.class));
-    verifyNoMoreInteractions(mockHelper);
-  }
-
-  @Test
-  public void pickerRoundRobin() throws Exception {
-    Subchannel subchannel = mock(Subchannel.class);
-    Subchannel subchannel1 = mock(Subchannel.class);
-    Subchannel subchannel2 = mock(Subchannel.class);
-
-    ReadyPicker picker = new ReadyPicker(Collections.unmodifiableList(
-        Lists.newArrayList(subchannel, subchannel1, subchannel2)),
-        0 /* startIndex */);
-
-    assertThat(picker.getList()).containsExactly(subchannel, subchannel1, subchannel2);
-
-    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 pickerEmptyList() throws Exception {
-    SubchannelPicker picker = new EmptyPicker(Status.UNKNOWN);
-
-    assertEquals(null, picker.pickSubchannel(mockArgs).getSubchannel());
-    assertEquals(Status.UNKNOWN,
-        picker.pickSubchannel(mockArgs).getStatus());
-  }
-
-  @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 {
-    final Subchannel readySubchannel = subchannels.values().iterator().next();
-    loadBalancer.handleResolvedAddresses(
-        ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(affinity).build());
-    deliverSubchannelState(readySubchannel, ConnectivityStateInfo.forNonError(READY));
-    loadBalancer.handleNameResolutionError(Status.NOT_FOUND.withDescription("nameResolutionError"));
-
-    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());
-    verifyNoMoreInteractions(mockHelper);
-  }
-
-  @Test
-  public void subchannelStateIsolation() throws Exception {
-    Iterator<Subchannel> subchannelIterator = subchannels.values().iterator();
-    Subchannel sc1 = subchannelIterator.next();
-    Subchannel sc2 = subchannelIterator.next();
-    Subchannel sc3 = subchannelIterator.next();
-
-    loadBalancer.handleResolvedAddresses(
-        ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(Attributes.EMPTY)
-            .build());
-    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()).isInstanceOf(EmptyPicker.class);
-    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(expected = IllegalArgumentException.class)
-  public void readyPicker_emptyList() {
-    // ready picker list must be non-empty
-    new ReadyPicker(Collections.<Subchannel>emptyList(), 0);
-  }
-
-  @Test
-  public void internalPickerComparisons() {
-    EmptyPicker emptyOk1 = new EmptyPicker(Status.OK);
-    EmptyPicker emptyOk2 = new EmptyPicker(Status.OK.withDescription("different OK"));
-    EmptyPicker emptyErr = new EmptyPicker(Status.UNKNOWN.withDescription("¯\\_(ツ)_//¯"));
-
-    Iterator<Subchannel> subchannelIterator = subchannels.values().iterator();
-    Subchannel sc1 = subchannelIterator.next();
-    Subchannel sc2 = subchannelIterator.next();
-    ReadyPicker ready1 = new ReadyPicker(Arrays.asList(sc1, sc2), 0);
-    ReadyPicker ready2 = new ReadyPicker(Arrays.asList(sc1), 0);
-    ReadyPicker ready3 = new ReadyPicker(Arrays.asList(sc2, sc1), 1);
-    ReadyPicker ready4 = new ReadyPicker(Arrays.asList(sc1, sc2), 1);
-    ReadyPicker ready5 = new ReadyPicker(Arrays.asList(sc2, sc1), 0);
-
-    assertTrue(emptyOk1.isEquivalentTo(emptyOk2));
-    assertFalse(emptyOk1.isEquivalentTo(emptyErr));
-    assertFalse(ready1.isEquivalentTo(ready2));
-    assertTrue(ready1.isEquivalentTo(ready3));
-    assertTrue(ready3.isEquivalentTo(ready4));
-    assertTrue(ready4.isEquivalentTo(ready5));
-    assertFalse(emptyOk1.isEquivalentTo(ready1));
-    assertFalse(ready1.isEquivalentTo(emptyOk1));
-  }
-
-  private static List<Subchannel> getList(SubchannelPicker picker) {
-    return picker instanceof ReadyPicker ? ((ReadyPicker) picker).getList() :
-        Collections.<Subchannel>emptyList();
-  }
-
-  private void deliverSubchannelState(Subchannel subchannel, ConnectivityStateInfo newState) {
-    subchannelStateListeners.get(subchannel).onSubchannelState(newState);
-  }
-
-  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/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/testing/src/main/java/io/grpc/internal/testing/AbstractClientTransportFactoryTest.java b/core/src/testFixtures/java/io/grpc/internal/AbstractClientTransportFactoryTest.java
similarity index 95%
rename from testing/src/main/java/io/grpc/internal/testing/AbstractClientTransportFactoryTest.java
rename to core/src/testFixtures/java/io/grpc/internal/AbstractClientTransportFactoryTest.java
index b84ffbde4ff..8e6f00fbc65 100644
--- a/testing/src/main/java/io/grpc/internal/testing/AbstractClientTransportFactoryTest.java
+++ b/core/src/testFixtures/java/io/grpc/internal/AbstractClientTransportFactoryTest.java
@@ -14,10 +14,9 @@
  * limitations under the License.
  */
 
-package io.grpc.internal.testing;
+package io.grpc.internal;
 
 import io.grpc.ChannelLogger;
-import io.grpc.internal.ClientTransportFactory;
 import java.net.InetSocketAddress;
 import org.junit.Test;
 import org.junit.runner.RunWith;
diff --git a/core/src/test/java/io/grpc/internal/AbstractTransportTest.java b/core/src/testFixtures/java/io/grpc/internal/AbstractTransportTest.java
similarity index 80%
rename from core/src/test/java/io/grpc/internal/AbstractTransportTest.java
rename to core/src/testFixtures/java/io/grpc/internal/AbstractTransportTest.java
index e19db3e9638..5d07de32df9 100644
--- a/core/src/test/java/io/grpc/internal/AbstractTransportTest.java
+++ b/core/src/testFixtures/java/io/grpc/internal/AbstractTransportTest.java
@@ -16,14 +16,15 @@
 
 package io.grpc.internal;
 
-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.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;
@@ -38,6 +39,7 @@
 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;
@@ -48,7 +50,6 @@
 import io.grpc.CallOptions;
 import io.grpc.ChannelLogger;
 import io.grpc.ClientStreamTracer;
-import io.grpc.ClientStreamTracer.StreamInfo;
 import io.grpc.Grpc;
 import io.grpc.InternalChannelz.SocketStats;
 import io.grpc.InternalChannelz.TransportStats;
@@ -57,6 +58,7 @@
 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;
@@ -68,17 +70,13 @@
 import java.util.Arrays;
 import java.util.List;
 import java.util.concurrent.BlockingQueue;
-import java.util.concurrent.CountDownLatch;
 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;
@@ -94,7 +92,10 @@ public abstract class AbstractTransportTest {
    */
   public static final int TEST_FLOW_CONTROL_WINDOW = 65 * 1024;
 
-  private static final int TIMEOUT_MS = 5000;
+  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");
@@ -136,13 +137,6 @@ protected abstract InternalServer newServer(
    */
   protected abstract String testAuthority(InternalServer server);
 
-  /**
-   * Returns true (which is default) if the transport reports message sizes to StreamTracers.
-   */
-  protected boolean sizesReported() {
-    return true;
-  }
-
   protected final Attributes eagAttrs() {
     return EAG_ATTRS;
   }
@@ -163,16 +157,16 @@ public void log(ChannelLogLevel level, String messageFormat, Object... args) {}
    * tests in an indeterminate state.
    */
   protected InternalServer server;
-  private ServerTransport serverTransport;
-  private ManagedClientTransport client;
-  private MethodDescriptor<String, String> methodDescriptor =
+  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 CallOptions callOptions;
+  private final CallOptions callOptions = CallOptions.DEFAULT;
 
   private Metadata.Key<String> asciiKey = Metadata.Key.of(
       "ascii-key", Metadata.ASCII_STRING_MARSHALLER);
@@ -182,32 +176,22 @@ public void log(ChannelLogLevel level, String messageFormat, Object... args) {}
       "tracer-key", Metadata.ASCII_STRING_MARSHALLER);
   private final String tracerKeyValue = "tracer-key-value";
 
-  private ManagedClientTransport.Listener mockClientTransportListener
+  protected ManagedClientTransport.Listener mockClientTransportListener
       = mock(ManagedClientTransport.Listener.class);
-  private MockServerListener serverListener = new MockServerListener();
-  private ArgumentCaptor<Throwable> throwableCaptor = ArgumentCaptor.forClass(Throwable.class);
-  private final TestClientStreamTracer clientStreamTracer1 = new TestClientStreamTracer();
-  private final TestClientStreamTracer clientStreamTracer2 = new TestClientStreamTracer();
-  private final ClientStreamTracer.Factory clientStreamTracerFactory = mock(
-      ClientStreamTracer.Factory.class,
-      delegatesTo(new ClientStreamTracer.Factory() {
-          final ArrayDeque<TestClientStreamTracer> tracers =
-              new ArrayDeque<>(Arrays.asList(clientStreamTracer1, clientStreamTracer2));
-
-          @Override
-          public ClientStreamTracer newClientStreamTracer(StreamInfo info, Metadata metadata) {
-            metadata.put(tracerHeaderKey, tracerKeyValue);
-            TestClientStreamTracer tracer = tracers.poll();
-            if (tracer != null) {
-              return tracer;
-            }
-            return new TestClientStreamTracer();
-          }
-        }));
-
-  private final TestServerStreamTracer serverStreamTracer1 = new TestServerStreamTracer();
+  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
+  };
+  protected final ClientStreamTracer[] noopTracers = new ClientStreamTracer[] {
+    new ClientStreamTracer() {}
+  };
+
+  protected final TestServerStreamTracer serverStreamTracer1 = new TestServerStreamTracer();
   private final TestServerStreamTracer serverStreamTracer2 = new TestServerStreamTracer();
-  private final ServerStreamTracer.Factory serverStreamTracerFactory = mock(
+  protected final ServerStreamTracer.Factory serverStreamTracerFactory = mock(
       ServerStreamTracer.Factory.class,
       delegatesTo(new ServerStreamTracer.Factory() {
           final ArrayDeque<TestServerStreamTracer> tracers =
@@ -223,14 +207,10 @@ public ServerStreamTracer newServerStreamTracer(String fullMethodName, Metadata
           }
         }));
 
-  @SuppressWarnings("deprecation") // https://github.com/grpc/grpc-java/issues/7467
-  @Rule
-  public ExpectedException thrown = ExpectedException.none();
-
   @Before
   public void setUp() {
     server = newServer(Arrays.asList(serverStreamTracerFactory));
-    callOptions = CallOptions.DEFAULT.withStreamTracerFactory(clientStreamTracerFactory);
+    when(mockClientTransportListener.filterTransport(any())).thenAnswer(i -> i.getArguments()[0]);
   }
 
   @After
@@ -255,6 +235,13 @@ 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.
    */
@@ -276,7 +263,7 @@ protected long fakeCurrentTimeNanos() {
   //     (and maybe exceptions handled)
 
   /**
-   * Test for issue https://github.com/grpc/grpc-java/issues/1682
+   * Test for issue https://github.com/grpc/grpc-java/issues/1682 .
    */
   @Test
   public void frameAfterRstStreamShouldNotBreakClientChannel() throws Exception {
@@ -291,7 +278,8 @@ public void frameAfterRstStreamShouldNotBreakClientChannel() throws Exception {
     // 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);
+    ClientStream stream = client.newStream(
+        methodDescriptor, new Metadata(), callOptions, noopTracers);
     ClientStreamListenerBase clientStreamListener = new ClientStreamListenerBase();
     stream.start(clientStreamListener);
     StreamCreation serverStreamCreation
@@ -301,24 +289,25 @@ public void frameAfterRstStreamShouldNotBreakClientChannel() throws Exception {
     stream.flush();
     stream.cancel(Status.CANCELLED);
     stream.flush();
-    serverStreamCreation.stream.writeHeaders(new Metadata());
+    serverStreamCreation.stream.writeHeaders(new Metadata(), true);
     serverStreamCreation.stream.flush();
     serverStreamCreation.stream.writeMessage(methodDescriptor.streamResponse("bar"));
     serverStreamCreation.stream.flush();
 
     assertEquals(
-        Status.CANCELLED, clientStreamListener.status.get(TIMEOUT_MS, TimeUnit.MILLISECONDS));
-    assertNotNull(clientStreamListener.trailers.get(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+        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);
+    stream = client.newStream(
+        methodDescriptor, new Metadata(), callOptions, noopTracers);
     stream.start(mockClientStreamListener2);
     serverStreamCreation
         = serverTransportListener.takeStreamOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
-    serverStreamCreation.stream.writeHeaders(new Metadata());
+    serverStreamCreation.stream.writeHeaders(new Metadata(), true);
     serverStreamCreation.stream.flush();
 
     verify(mockClientStreamListener2, timeout(TIMEOUT_MS)).headersRead(any(Metadata.class));
@@ -337,7 +326,8 @@ public void serverNotListening() throws Exception {
     runIfNotNull(client.start(mockClientTransportListener));
     verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportTerminated();
     ArgumentCaptor<Status> statusCaptor = ArgumentCaptor.forClass(Status.class);
-    inOrder.verify(mockClientTransportListener).transportShutdown(statusCaptor.capture());
+    inOrder.verify(mockClientTransportListener).transportShutdown(statusCaptor.capture(),
+        any(DisconnectError.class));
     assertCodeEquals(Status.UNAVAILABLE, statusCaptor.getValue());
     inOrder.verify(mockClientTransportListener).transportTerminated();
     verify(mockClientTransportListener, never()).transportReady();
@@ -353,7 +343,8 @@ public void clientStartStop() throws Exception {
     Status shutdownReason = Status.UNAVAILABLE.withDescription("shutdown called");
     client.shutdown(shutdownReason);
     verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportTerminated();
-    inOrder.verify(mockClientTransportListener).transportShutdown(same(shutdownReason));
+    inOrder.verify(mockClientTransportListener).transportShutdown(same(shutdownReason),
+        any(DisconnectError.class));
     inOrder.verify(mockClientTransportListener).transportTerminated();
     verify(mockClientTransportListener, never()).transportInUse(anyBoolean());
   }
@@ -369,7 +360,8 @@ public void clientStartAndStopOnceConnected() throws Exception {
         = serverListener.takeListenerOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
     client.shutdown(Status.UNAVAILABLE);
     verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportTerminated();
-    inOrder.verify(mockClientTransportListener).transportShutdown(any(Status.class));
+    inOrder.verify(mockClientTransportListener).transportShutdown(any(Status.class),
+        any(DisconnectError.class));
     inOrder.verify(mockClientTransportListener).transportTerminated();
     assertTrue(serverTransportListener.waitForTermination(TIMEOUT_MS, TimeUnit.MILLISECONDS));
     server.shutdown();
@@ -401,8 +393,7 @@ public void serverAlreadyListening() throws Exception {
       port = ((InetSocketAddress) addr).getPort();
     }
     InternalServer server2 = newServer(port, Arrays.asList(serverStreamTracerFactory));
-    thrown.expect(IOException.class);
-    server2.start(new MockServerListener());
+    assertThrows(IOException.class, () -> server2.start(new MockServerListener()));
   }
 
   @Test
@@ -418,12 +409,13 @@ public void serverStartInterrupted() throws Exception {
     }
     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);
+      server.start(serverListener = new MockServerListener());
       success = true;
     } catch (Exception ex) {
       success = false;
@@ -449,7 +441,8 @@ public void openStreamPreventsTermination() throws Exception {
         = serverListener.takeListenerOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
     serverTransport = serverTransportListener.transport;
 
-    ClientStream clientStream = client.newStream(methodDescriptor, new Metadata(), callOptions);
+    ClientStream clientStream = client.newStream(
+        methodDescriptor, new Metadata(), callOptions, tracers);
     ClientStreamListenerBase clientStreamListener = new ClientStreamListenerBase();
     clientStream.start(clientStreamListener);
     verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportInUse(true);
@@ -464,7 +457,8 @@ public void openStreamPreventsTermination() throws Exception {
     serverTransport.shutdown();
     serverTransport = null;
 
-    verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportShutdown(any(Status.class));
+    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
@@ -476,9 +470,9 @@ public void openStreamPreventsTermination() throws Exception {
 
     // Try to "flush" out any listener notifications on client and server. This also ensures that
     // the stream still functions.
-    serverStream.writeHeaders(new Metadata());
+    serverStream.writeHeaders(new Metadata(), true);
     clientStream.halfClose();
-    assertNotNull(clientStreamListener.headers.get(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+    assertNotNull(clientStreamListener.awaitHeaders(TIMEOUT_MS, TimeUnit.MILLISECONDS));
     assertTrue(serverStreamListener.awaitHalfClosed(TIMEOUT_MS, TimeUnit.MILLISECONDS));
 
     verify(mockClientTransportListener, never()).transportTerminated();
@@ -501,7 +495,8 @@ public void shutdownNowKillsClientStream() throws Exception {
         = serverListener.takeListenerOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
     serverTransport = serverTransportListener.transport;
 
-    ClientStream clientStream = client.newStream(methodDescriptor, new Metadata(), callOptions);
+    ClientStream clientStream = client.newStream(
+        methodDescriptor, new Metadata(), callOptions, tracers);
     ClientStreamListenerBase clientStreamListener = new ClientStreamListenerBase();
     clientStream.start(clientStreamListener);
     verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportInUse(true);
@@ -513,15 +508,16 @@ public void shutdownNowKillsClientStream() throws Exception {
     client.shutdownNow(status);
     client = null;
 
-    verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportShutdown(any(Status.class));
+    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.status.get(TIMEOUT_MS, TimeUnit.MILLISECONDS));
-    assertNotNull(clientStreamListener.trailers.get(TIMEOUT_MS, TimeUnit.MILLISECONDS));
-    Status serverStatus = serverStreamListener.status.get(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    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());
@@ -539,7 +535,8 @@ public void shutdownNowKillsServerStream() throws Exception {
         = serverListener.takeListenerOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
     serverTransport = serverTransportListener.transport;
 
-    ClientStream clientStream = client.newStream(methodDescriptor, new Metadata(), callOptions);
+    ClientStream clientStream = client.newStream(
+        methodDescriptor, new Metadata(), callOptions, tracers);
     ClientStreamListenerBase clientStreamListener = new ClientStreamListenerBase();
     clientStream.start(clientStreamListener);
     verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportInUse(true);
@@ -551,15 +548,16 @@ public void shutdownNowKillsServerStream() throws Exception {
     serverTransport.shutdownNow(shutdownStatus);
     serverTransport = null;
 
-    verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportShutdown(any(Status.class));
+    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.status.get(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    Status clientStreamStatus = clientStreamListener.awaitClose(TIMEOUT_MS, TimeUnit.MILLISECONDS);
     assertFalse(clientStreamStatus.isOk());
-    assertNotNull(clientStreamListener.trailers.get(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+    assertNotNull(clientStreamListener.awaitTrailers(TIMEOUT_MS, TimeUnit.MILLISECONDS));
     assertTrue(clientStreamTracer1.await(TIMEOUT_MS, TimeUnit.MILLISECONDS));
     assertNull(clientStreamTracer1.getInboundTrailers());
     assertStatusEquals(clientStreamStatus, clientStreamTracer1.getStatus());
@@ -569,7 +567,7 @@ public void shutdownNowKillsServerStream() throws Exception {
     // 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.status.get(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+    assertNotNull(serverStreamListener.awaitClose(TIMEOUT_MS, TimeUnit.MILLISECONDS));
   }
 
   @Test
@@ -594,11 +592,13 @@ public void ping_duringShutdown() throws Exception {
     client = newClientTransport(server);
     startTransport(client, mockClientTransportListener);
     // Stream prevents termination
-    ClientStream stream = client.newStream(methodDescriptor, new Metadata(), callOptions);
+    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));
+    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());
@@ -626,34 +626,32 @@ public void ping_afterTermination() throws Exception {
       // 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());
+    verify(mockPingCallback, timeout(TIMEOUT_MS)).onFailure(statusCaptor.capture());
+    Status status = statusCaptor.getValue();
     assertSame(shutdownReason, status);
   }
 
   @Test
   public void newStream_duringShutdown() throws Exception {
-    InOrder inOrder = inOrder(clientStreamTracerFactory);
     server.start(serverListener);
     client = newClientTransport(server);
     startTransport(client, mockClientTransportListener);
     // Stream prevents termination
-    ClientStream stream = client.newStream(methodDescriptor, new Metadata(), callOptions);
-    inOrder.verify(clientStreamTracerFactory).newClientStreamTracer(
-        any(ClientStreamTracer.StreamInfo.class), any(Metadata.class));
+    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));
+    verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportShutdown(any(Status.class),
+        any(DisconnectError.class));
 
-    ClientStream stream2 = client.newStream(methodDescriptor, new Metadata(), callOptions);
-    inOrder.verify(clientStreamTracerFactory).newClientStreamTracer(
-        any(ClientStreamTracer.StreamInfo.class), any(Metadata.class));
+    ClientStream stream2 = client.newStream(
+        methodDescriptor, new Metadata(), callOptions, tracers);
     ClientStreamListenerBase clientStreamListener2 = new ClientStreamListenerBase();
     stream2.start(clientStreamListener2);
     Status clientStreamStatus2 =
-        clientStreamListener2.status.get(TIMEOUT_MS, TimeUnit.MILLISECONDS);
-    assertNotNull(clientStreamListener2.trailers.get(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+        clientStreamListener2.awaitClose(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    assertNotNull(clientStreamListener2.awaitTrailers(TIMEOUT_MS, TimeUnit.MILLISECONDS));
     assertCodeEquals(Status.UNAVAILABLE, clientStreamStatus2);
     assertNull(clientStreamTracer2.getInboundTrailers());
     assertSame(clientStreamStatus2, clientStreamTracer2.getStatus());
@@ -667,8 +665,8 @@ public void newStream_duringShutdown() throws Exception {
     StreamCreation serverStreamCreation
         = serverTransportListener.takeStreamOrFail(20 * TIMEOUT_MS, TimeUnit.MILLISECONDS);
     serverStreamCreation.stream.close(Status.OK, new Metadata());
-    assertCodeEquals(Status.OK, clientStreamListener.status.get(TIMEOUT_MS, TimeUnit.MILLISECONDS));
-    assertNotNull(clientStreamListener.trailers.get(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+    assertCodeEquals(Status.OK, clientStreamListener.awaitClose(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+    assertNotNull(clientStreamListener.awaitTrailers(TIMEOUT_MS, TimeUnit.MILLISECONDS));
   }
 
   @Test
@@ -683,15 +681,14 @@ public void newStream_afterTermination() throws Exception {
     client.shutdown(shutdownReason);
     verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportTerminated();
     Thread.sleep(100);
-    ClientStream stream = client.newStream(methodDescriptor, new Metadata(), callOptions);
+    ClientStream stream = client.newStream(
+        methodDescriptor, new Metadata(), callOptions, tracers);
     ClientStreamListenerBase clientStreamListener = new ClientStreamListenerBase();
     stream.start(clientStreamListener);
     assertEquals(
-        shutdownReason, clientStreamListener.status.get(TIMEOUT_MS, TimeUnit.MILLISECONDS));
-    assertNotNull(clientStreamListener.trailers.get(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+        shutdownReason, clientStreamListener.awaitClose(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+    assertNotNull(clientStreamListener.awaitTrailers(TIMEOUT_MS, TimeUnit.MILLISECONDS));
     verify(mockClientTransportListener, never()).transportInUse(anyBoolean());
-    verify(clientStreamTracerFactory).newClientStreamTracer(
-        any(ClientStreamTracer.StreamInfo.class), any(Metadata.class));
     assertNull(clientStreamTracer1.getInboundTrailers());
     assertSame(shutdownReason, clientStreamTracer1.getStatus());
     // Assert no interactions
@@ -708,7 +705,8 @@ public void transportInUse_balancerRpcsNotCounted() throws Exception {
     // 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));
+        callOptions.withOption(GrpcUtil.CALL_OPTIONS_RPC_OWNED_BY_BALANCER, Boolean.TRUE),
+        noopTracers);
     ClientStreamListenerBase clientStreamListener1 = new ClientStreamListenerBase();
     stream1.start(clientStreamListener1);
     MockServerTransportListener serverTransportListener
@@ -717,7 +715,8 @@ methodDescriptor, new Metadata(),
         = 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);
+    ClientStream stream2 = client.newStream(
+        methodDescriptor, new Metadata(), callOptions, noopTracers);
     ClientStreamListenerBase clientStreamListener2 = new ClientStreamListenerBase();
     stream2.start(clientStreamListener2);
     verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportInUse(true);
@@ -743,7 +742,8 @@ public void transportInUse_normalClose() throws Exception {
     server.start(serverListener);
     client = newClientTransport(server);
     startTransport(client, mockClientTransportListener);
-    ClientStream stream1 = client.newStream(methodDescriptor, new Metadata(), callOptions);
+    ClientStream stream1 = client.newStream(
+        methodDescriptor, new Metadata(), callOptions, noopTracers);
     ClientStreamListenerBase clientStreamListener1 = new ClientStreamListenerBase();
     stream1.start(clientStreamListener1);
     verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportInUse(true);
@@ -751,7 +751,8 @@ public void transportInUse_normalClose() throws Exception {
         = serverListener.takeListenerOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
     StreamCreation serverStreamCreation1
         = serverTransportListener.takeStreamOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
-    ClientStream stream2 = client.newStream(methodDescriptor, new Metadata(), callOptions);
+    ClientStream stream2 = client.newStream(
+        methodDescriptor, new Metadata(), callOptions, noopTracers);
     ClientStreamListenerBase clientStreamListener2 = new ClientStreamListenerBase();
     stream2.start(clientStreamListener2);
     StreamCreation serverStreamCreation2
@@ -773,11 +774,13 @@ public void transportInUse_clientCancel() throws Exception {
     server.start(serverListener);
     client = newClientTransport(server);
     startTransport(client, mockClientTransportListener);
-    ClientStream stream1 = client.newStream(methodDescriptor, new Metadata(), callOptions);
+    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);
+    ClientStream stream2 = client.newStream(
+        methodDescriptor, new Metadata(), callOptions, noopTracers);
     ClientStreamListenerBase clientStreamListener2 = new ClientStreamListenerBase();
     stream2.start(clientStreamListener2);
 
@@ -792,7 +795,17 @@ public void transportInUse_clientCancel() throws Exception {
 
   @Test
   public void basicStream() throws Exception {
-    InOrder clientInOrder = inOrder(clientStreamTracerFactory);
+    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);
@@ -816,14 +829,10 @@ public void basicStream() throws Exception {
     Metadata clientHeadersCopy = new Metadata();
 
     clientHeadersCopy.merge(clientHeaders);
-    ClientStream clientStream = client.newStream(methodDescriptor, clientHeaders, callOptions);
-    ArgumentCaptor<ClientStreamTracer.StreamInfo> streamInfoCaptor = ArgumentCaptor.forClass(null);
-    clientInOrder.verify(clientStreamTracerFactory).newClientStreamTracer(
-        streamInfoCaptor.capture(), same(clientHeaders));
-    ClientStreamTracer.StreamInfo streamInfo = streamInfoCaptor.getValue();
-    assertThat(streamInfo.getTransportAttrs()).isSameInstanceAs(
-        ((ConnectionClientTransport) client).getAttributes());
-    assertThat(streamInfo.getCallOptions()).isSameInstanceAs(callOptions);
+    ClientStream clientStream = client.newStream(
+        methodDescriptor, clientHeaders, callOptions, tracers);
+    assertThat(((TestHeaderClientStreamTracer) clientStreamTracer1).transportAttrs)
+        .isSameInstanceAs(((ConnectionClientTransport) client).getAttributes());
 
     ClientStreamListenerBase clientStreamListener = new ClientStreamListenerBase();
     clientStream.start(clientStreamListener);
@@ -863,25 +872,20 @@ public void basicStream() throws Exception {
     message.close();
     assertThat(clientStreamTracer1.nextOutboundEvent())
         .matches("outboundMessageSent\\(0, -?[0-9]+, -?[0-9]+\\)");
-    if (sizesReported()) {
+    if (isEnabledSupportTracingMessageSizes()) {
       assertThat(clientStreamTracer1.getOutboundWireSize()).isGreaterThan(0L);
       assertThat(clientStreamTracer1.getOutboundUncompressedSize()).isGreaterThan(0L);
-    } else {
-      assertThat(clientStreamTracer1.getOutboundWireSize()).isEqualTo(0L);
-      assertThat(clientStreamTracer1.getOutboundUncompressedSize()).isEqualTo(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 (sizesReported()) {
+    if (isEnabledSupportTracingMessageSizes()) {
       assertThat(serverStreamTracer1.getInboundWireSize()).isGreaterThan(0L);
       assertThat(serverStreamTracer1.getInboundUncompressedSize()).isGreaterThan(0L);
-    } else {
-      assertThat(serverStreamTracer1.getInboundWireSize()).isEqualTo(0L);
-      assertThat(serverStreamTracer1.getInboundUncompressedSize()).isEqualTo(0L);
     }
     assertThat(serverStreamTracer1.nextInboundEvent())
         .matches("inboundMessageRead\\(0, -?[0-9]+, -?[0-9]+\\)");
@@ -894,8 +898,8 @@ public void basicStream() throws Exception {
     serverHeaders.put(binaryKey, "dup,value");
     Metadata serverHeadersCopy = new Metadata();
     serverHeadersCopy.merge(serverHeaders);
-    serverStream.writeHeaders(serverHeaders);
-    Metadata headers = clientStreamListener.headers.get(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    serverStream.writeHeaders(serverHeaders, true);
+    Metadata headers = clientStreamListener.awaitHeaders(TIMEOUT_MS, TimeUnit.MILLISECONDS);
     assertNotNull(headers);
     assertAsciiMetadataValuesEqual(serverHeadersCopy.getAll(asciiKey), headers.getAll(asciiKey));
     assertEquals(
@@ -913,24 +917,18 @@ public void basicStream() throws Exception {
     assertNotNull("message expected", message);
     assertThat(serverStreamTracer1.nextOutboundEvent())
         .matches("outboundMessageSent\\(0, -?[0-9]+, -?[0-9]+\\)");
-    if (sizesReported()) {
+    if (isEnabledSupportTracingMessageSizes()) {
       assertThat(serverStreamTracer1.getOutboundWireSize()).isGreaterThan(0L);
       assertThat(serverStreamTracer1.getOutboundUncompressedSize()).isGreaterThan(0L);
-    } else {
-      assertThat(serverStreamTracer1.getOutboundWireSize()).isEqualTo(0L);
-      assertThat(serverStreamTracer1.getOutboundUncompressedSize()).isEqualTo(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 (sizesReported()) {
+    if (isEnabledSupportTracingMessageSizes()) {
       assertThat(clientStreamTracer1.getInboundWireSize()).isGreaterThan(0L);
       assertThat(clientStreamTracer1.getInboundUncompressedSize()).isGreaterThan(0L);
-    } else {
-      assertThat(clientStreamTracer1.getInboundWireSize()).isEqualTo(0L);
-      assertThat(clientStreamTracer1.getInboundUncompressedSize()).isEqualTo(0L);
     }
 
     message.close();
@@ -946,11 +944,11 @@ public void basicStream() throws Exception {
     serverStream.close(status, trailers);
     assertNull(serverStreamTracer1.nextInboundEvent());
     assertNull(serverStreamTracer1.nextOutboundEvent());
-    assertCodeEquals(Status.OK, serverStreamListener.status.get(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+    assertCodeEquals(Status.OK, serverStreamListener.awaitClose(TIMEOUT_MS, TimeUnit.MILLISECONDS));
     assertSame(status, serverStreamTracer1.getStatus());
-    Status clientStreamStatus = clientStreamListener.status.get(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    Status clientStreamStatus = clientStreamListener.awaitClose(TIMEOUT_MS, TimeUnit.MILLISECONDS);
     Metadata clientStreamTrailers =
-        clientStreamListener.trailers.get(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+        clientStreamListener.awaitTrailers(TIMEOUT_MS, TimeUnit.MILLISECONDS);
     assertSame(clientStreamTrailers, clientStreamTracer1.getInboundTrailers());
     assertSame(clientStreamStatus, clientStreamTracer1.getStatus());
     assertNull(clientStreamTracer1.nextInboundEvent());
@@ -974,7 +972,8 @@ public void authorityPropagation() throws Exception {
             = serverListener.takeListenerOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
 
     Metadata clientHeaders = new Metadata();
-    ClientStream clientStream = client.newStream(methodDescriptor, clientHeaders, callOptions);
+    ClientStream clientStream = client.newStream(
+        methodDescriptor, clientHeaders, callOptions, tracers);
     ClientStreamListenerBase clientStreamListener = new ClientStreamListenerBase();
     clientStream.start(clientStreamListener);
     StreamCreation serverStreamCreation
@@ -1005,7 +1004,8 @@ public void zeroMessageStream() throws Exception {
         = serverListener.takeListenerOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
     serverTransport = serverTransportListener.transport;
 
-    ClientStream clientStream = client.newStream(methodDescriptor, new Metadata(), callOptions);
+    ClientStream clientStream = client.newStream(
+        methodDescriptor, new Metadata(), callOptions, tracers);
     ClientStreamListenerBase clientStreamListener = new ClientStreamListenerBase();
     clientStream.start(clientStreamListener);
     StreamCreation serverStreamCreation
@@ -1016,15 +1016,15 @@ public void zeroMessageStream() throws Exception {
     clientStream.halfClose();
     assertTrue(serverStreamListener.awaitHalfClosed(TIMEOUT_MS, TimeUnit.MILLISECONDS));
 
-    serverStream.writeHeaders(new Metadata());
-    assertNotNull(clientStreamListener.headers.get(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.status.get(TIMEOUT_MS, TimeUnit.MILLISECONDS));
-    Status clientStreamStatus = clientStreamListener.status.get(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    assertCodeEquals(Status.OK, serverStreamListener.awaitClose(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+    Status clientStreamStatus = clientStreamListener.awaitClose(TIMEOUT_MS, TimeUnit.MILLISECONDS);
     Metadata clientStreamTrailers =
-        clientStreamListener.trailers.get(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+        clientStreamListener.awaitTrailers(TIMEOUT_MS, TimeUnit.MILLISECONDS);
     assertNotNull(clientStreamTrailers);
     assertEquals(status.getCode(), clientStreamStatus.getCode());
     assertEquals(status.getDescription(), clientStreamStatus.getDescription());
@@ -1044,7 +1044,8 @@ public void earlyServerClose_withServerHeaders() throws Exception {
         = serverListener.takeListenerOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
     serverTransport = serverTransportListener.transport;
 
-    ClientStream clientStream = client.newStream(methodDescriptor, new Metadata(), callOptions);
+    ClientStream clientStream = client.newStream(
+        methodDescriptor, new Metadata(), callOptions, tracers);
     ClientStreamListenerBase clientStreamListener = new ClientStreamListenerBase();
     clientStream.start(clientStreamListener);
     StreamCreation serverStreamCreation
@@ -1052,16 +1053,16 @@ public void earlyServerClose_withServerHeaders() throws Exception {
     ServerStream serverStream = serverStreamCreation.stream;
     ServerStreamListenerBase serverStreamListener = serverStreamCreation.listener;
 
-    serverStream.writeHeaders(new Metadata());
-    assertNotNull(clientStreamListener.headers.get(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+    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.status.get(TIMEOUT_MS, TimeUnit.MILLISECONDS));
-    Status clientStreamStatus = clientStreamListener.status.get(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    assertCodeEquals(Status.OK, serverStreamListener.awaitClose(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+    Status clientStreamStatus = clientStreamListener.awaitClose(TIMEOUT_MS, TimeUnit.MILLISECONDS);
     Metadata clientStreamTrailers =
-        clientStreamListener.trailers.get(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+        clientStreamListener.awaitTrailers(TIMEOUT_MS, TimeUnit.MILLISECONDS);
     assertNotNull(clientStreamTrailers);
     checkClientStatus(status, clientStreamStatus);
     assertTrue(clientStreamTracer1.getOutboundHeaders());
@@ -1080,7 +1081,8 @@ public void earlyServerClose_noServerHeaders() throws Exception {
         = serverListener.takeListenerOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
     serverTransport = serverTransportListener.transport;
 
-    ClientStream clientStream = client.newStream(methodDescriptor, new Metadata(), callOptions);
+    ClientStream clientStream = client.newStream(
+        methodDescriptor, new Metadata(), callOptions, tracers);
     ClientStreamListenerBase clientStreamListener = new ClientStreamListenerBase();
     clientStream.start(clientStreamListener);
     StreamCreation serverStreamCreation
@@ -1096,10 +1098,10 @@ public void earlyServerClose_noServerHeaders() throws Exception {
     trailers.put(asciiKey, "dupvalue");
     trailers.put(binaryKey, "äbinarytrailers");
     serverStream.close(status, trailers);
-    assertCodeEquals(Status.OK, serverStreamListener.status.get(TIMEOUT_MS, TimeUnit.MILLISECONDS));
-    Status clientStreamStatus = clientStreamListener.status.get(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    assertCodeEquals(Status.OK, serverStreamListener.awaitClose(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+    Status clientStreamStatus = clientStreamListener.awaitClose(TIMEOUT_MS, TimeUnit.MILLISECONDS);
     Metadata clientStreamTrailers =
-        clientStreamListener.trailers.get(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+        clientStreamListener.awaitTrailers(TIMEOUT_MS, TimeUnit.MILLISECONDS);
     checkClientStatus(status, clientStreamStatus);
     assertEquals(
         Lists.newArrayList(trailers.getAll(asciiKey)),
@@ -1122,7 +1124,8 @@ public void earlyServerClose_serverFailure() throws Exception {
         = serverListener.takeListenerOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
     serverTransport = serverTransportListener.transport;
 
-    ClientStream clientStream = client.newStream(methodDescriptor, new Metadata(), callOptions);
+    ClientStream clientStream = client.newStream(
+        methodDescriptor, new Metadata(), callOptions, tracers);
     ClientStreamListenerBase clientStreamListener = new ClientStreamListenerBase();
     clientStream.start(clientStreamListener);
     StreamCreation serverStreamCreation
@@ -1133,10 +1136,10 @@ public void earlyServerClose_serverFailure() throws Exception {
     Status strippedStatus = Status.INTERNAL.withDescription("I'm not listening");
     Status status = strippedStatus.withCause(new Exception());
     serverStream.close(status, new Metadata());
-    assertCodeEquals(Status.OK, serverStreamListener.status.get(TIMEOUT_MS, TimeUnit.MILLISECONDS));
-    Status clientStreamStatus = clientStreamListener.status.get(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    assertCodeEquals(Status.OK, serverStreamListener.awaitClose(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+    Status clientStreamStatus = clientStreamListener.awaitClose(TIMEOUT_MS, TimeUnit.MILLISECONDS);
     Metadata clientStreamTrailers =
-        clientStreamListener.trailers.get(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+        clientStreamListener.awaitTrailers(TIMEOUT_MS, TimeUnit.MILLISECONDS);
     assertNotNull(clientStreamTrailers);
     checkClientStatus(status, clientStreamStatus);
     assertTrue(clientStreamTracer1.getOutboundHeaders());
@@ -1149,20 +1152,15 @@ public void earlyServerClose_serverFailure() throws Exception {
   public void earlyServerClose_serverFailure_withClientCancelOnListenerClosed() throws Exception {
     server.start(serverListener);
     client = newClientTransport(server);
-    runIfNotNull(client.start(mockClientTransportListener));
+    startTransport(client, mockClientTransportListener);
     MockServerTransportListener serverTransportListener
         = serverListener.takeListenerOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
     serverTransport = serverTransportListener.transport;
 
     final ClientStream clientStream =
-        client.newStream(methodDescriptor, new Metadata(), callOptions);
+        client.newStream(
+        methodDescriptor, new Metadata(), callOptions, tracers);
     ClientStreamListenerBase clientStreamListener = new ClientStreamListenerBase() {
-      @Override
-      public void closed(Status status, Metadata trailers) {
-        super.closed(status, trailers);
-        // This simulates the blocking calls which can trigger clientStream.cancel().
-        clientStream.cancel(Status.CANCELLED.withCause(status.asRuntimeException()));
-      }
 
       @Override
       public void closed(
@@ -1181,10 +1179,10 @@ public void closed(
     Status strippedStatus = Status.INTERNAL.withDescription("I'm not listening");
     Status status = strippedStatus.withCause(new Exception());
     serverStream.close(status, new Metadata());
-    assertCodeEquals(Status.OK, serverStreamListener.status.get(TIMEOUT_MS, TimeUnit.MILLISECONDS));
-    Status clientStreamStatus = clientStreamListener.status.get(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    assertCodeEquals(Status.OK, serverStreamListener.awaitClose(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+    Status clientStreamStatus = clientStreamListener.awaitClose(TIMEOUT_MS, TimeUnit.MILLISECONDS);
     Metadata clientStreamTrailers =
-        clientStreamListener.trailers.get(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+        clientStreamListener.awaitTrailers(TIMEOUT_MS, TimeUnit.MILLISECONDS);
     assertNotNull(clientStreamTrailers);
     checkClientStatus(status, clientStreamStatus);
     assertTrue(clientStreamTracer1.getOutboundHeaders());
@@ -1202,7 +1200,8 @@ public void clientCancel() throws Exception {
         = serverListener.takeListenerOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
     serverTransport = serverTransportListener.transport;
 
-    ClientStream clientStream = client.newStream(methodDescriptor, new Metadata(), callOptions);
+    ClientStream clientStream = client.newStream(
+        methodDescriptor, new Metadata(), callOptions, tracers);
     ClientStreamListenerBase clientStreamListener = new ClientStreamListenerBase();
     clientStream.start(clientStreamListener);
     StreamCreation serverStreamCreation
@@ -1211,9 +1210,9 @@ public void clientCancel() throws Exception {
 
     Status status = Status.CANCELLED.withDescription("Nevermind").withCause(new Exception());
     clientStream.cancel(status);
-    assertEquals(status, clientStreamListener.status.get(TIMEOUT_MS, TimeUnit.MILLISECONDS));
-    assertNotNull(clientStreamListener.trailers.get(TIMEOUT_MS, TimeUnit.MILLISECONDS));
-    Status serverStatus = serverStreamListener.status.get(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    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());
@@ -1236,7 +1235,8 @@ public void clientCancelFromWithinMessageRead() throws Exception {
 
     final SettableFuture<Boolean> closedCalled = SettableFuture.create();
     final ClientStream clientStream =
-        client.newStream(methodDescriptor, new Metadata(), callOptions);
+        client.newStream(
+        methodDescriptor, new Metadata(), callOptions, tracers);
     final Status status = Status.CANCELLED.withDescription("nevermind");
     clientStream.start(new ClientStreamListener() {
       private boolean messageReceived = false;
@@ -1245,11 +1245,6 @@ public void clientCancelFromWithinMessageRead() throws Exception {
       public void headersRead(Metadata headers) {
       }
 
-      @Override
-      public void closed(Status status, Metadata trailers) {
-        closed(status, RpcProgress.PROCESSED, trailers);
-      }
-
       @Override
       public void closed(
           Status status, RpcProgress rpcProgress, Metadata trailers) {
@@ -1284,7 +1279,7 @@ public void onReady() {
     assertTrue(serverStreamListener.awaitOnReadyAndDrain(TIMEOUT_MS, TimeUnit.MILLISECONDS));
 
     assertTrue(serverStream.isReady());
-    serverStream.writeHeaders(new Metadata());
+    serverStream.writeHeaders(new Metadata(), true);
     serverStream.writeMessage(methodDescriptor.streamRequest("foo"));
     serverStream.flush();
 
@@ -1294,16 +1289,11 @@ public void onReady() {
     serverStream.close(Status.OK, new Metadata());
     assertTrue(clientStreamTracer1.getOutboundHeaders());
     assertTrue(clientStreamTracer1.getInboundHeaders());
-    if (sizesReported()) {
+    if (isEnabledSupportTracingMessageSizes()) {
       assertThat(clientStreamTracer1.getInboundWireSize()).isGreaterThan(0L);
       assertThat(clientStreamTracer1.getInboundUncompressedSize()).isGreaterThan(0L);
       assertThat(serverStreamTracer1.getOutboundWireSize()).isGreaterThan(0L);
       assertThat(serverStreamTracer1.getOutboundUncompressedSize()).isGreaterThan(0L);
-    } else {
-      assertThat(clientStreamTracer1.getInboundWireSize()).isEqualTo(0L);
-      assertThat(clientStreamTracer1.getInboundUncompressedSize()).isEqualTo(0L);
-      assertThat(serverStreamTracer1.getOutboundWireSize()).isEqualTo(0L);
-      assertThat(serverStreamTracer1.getOutboundUncompressedSize()).isEqualTo(0L);
     }
     assertNull(clientStreamTracer1.getInboundTrailers());
     assertSame(status, clientStreamTracer1.getStatus());
@@ -1322,7 +1312,8 @@ public void serverCancel() throws Exception {
         = serverListener.takeListenerOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
     serverTransport = serverTransportListener.transport;
 
-    ClientStream clientStream = client.newStream(methodDescriptor, new Metadata(), callOptions);
+    ClientStream clientStream = client.newStream(
+        methodDescriptor, new Metadata(), callOptions, tracers);
     ClientStreamListenerBase clientStreamListener = new ClientStreamListenerBase();
     clientStream.start(clientStreamListener);
     StreamCreation serverStreamCreation
@@ -1333,17 +1324,15 @@ public void serverCancel() throws Exception {
     Status status = Status.DEADLINE_EXCEEDED.withDescription("It was bound to happen")
         .withCause(new Exception());
     serverStream.cancel(status);
-    assertEquals(status, serverStreamListener.status.get(TIMEOUT_MS, TimeUnit.MILLISECONDS));
-    Status clientStreamStatus = clientStreamListener.status.get(TIMEOUT_MS, TimeUnit.MILLISECONDS);
-    assertNotNull(clientStreamListener.trailers.get(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+    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());
 
-    verify(clientStreamTracerFactory).newClientStreamTracer(
-        any(ClientStreamTracer.StreamInfo.class), any(Metadata.class));
     assertTrue(clientStreamTracer1.getOutboundHeaders());
     assertNull(clientStreamTracer1.getInboundTrailers());
     assertSame(clientStreamStatus, clientStreamTracer1.getStatus());
@@ -1364,7 +1353,8 @@ public void flowControlPushBack() throws Exception {
         serverListener.takeListenerOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
     serverTransport = serverTransportListener.transport;
 
-    ClientStream clientStream = client.newStream(methodDescriptor, new Metadata(), callOptions);
+    ClientStream clientStream =
+        client.newStream(methodDescriptor, new Metadata(), callOptions, tracers);
     ClientStreamListenerBase clientStreamListener = new ClientStreamListenerBase();
     clientStream.start(clientStreamListener);
     StreamCreation serverStreamCreation =
@@ -1373,17 +1363,9 @@ public void flowControlPushBack() throws Exception {
     ServerStream serverStream = serverStreamCreation.stream;
     ServerStreamListenerBase serverStreamListener = serverStreamCreation.listener;
 
-    serverStream.writeHeaders(new Metadata());
+    serverStream.writeHeaders(new Metadata(), true);
 
-    String largeMessage;
-    {
-      int size = 1 * 1024;
-      StringBuilder sb = new StringBuilder(size);
-      for (int i = 0; i < size; i++) {
-        sb.append('a');
-      }
-      largeMessage = sb.toString();
-    }
+    String largeMessage = newString(1024);
 
     serverStream.request(1);
     assertTrue(clientStreamListener.awaitOnReadyAndDrain(TIMEOUT_MS, TimeUnit.MILLISECONDS));
@@ -1475,7 +1457,7 @@ public void flowControlPushBack() throws Exception {
     clientStream.flush();
     clientStream.halfClose();
     doPingPong(serverListener);
-    assertFalse(serverStreamListener.awaitHalfClosed(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+    assertFalse(serverStreamListener.isHalfClosed());
 
     serverStream.request(1);
     serverReceived += verifyMessageCountAndClose(serverStreamListener.messageQueue, 1);
@@ -1487,18 +1469,72 @@ public void flowControlPushBack() throws Exception {
     Status status = Status.OK.withDescription("... quite a lengthy discussion");
     serverStream.close(status, new Metadata());
     doPingPong(serverListener);
-    try {
-      clientStreamListener.status.get(TIMEOUT_MS, TimeUnit.MILLISECONDS);
-      fail("Expected TimeoutException");
-    } catch (TimeoutException expectedException) {
-    }
+    assertFalse(clientStreamListener.isClosed());
 
     clientStream.request(1);
     clientReceived += verifyMessageCountAndClose(clientStreamListener.messageQueue, 1);
     assertEquals(serverSent + 6, clientReceived);
-    assertCodeEquals(Status.OK, serverStreamListener.status.get(TIMEOUT_MS, TimeUnit.MILLISECONDS));
-    Status clientStreamStatus = clientStreamListener.status.get(TIMEOUT_MS, TimeUnit.MILLISECONDS);
-    assertNotNull(clientStreamListener.trailers.get(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+    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());
   }
@@ -1515,6 +1551,36 @@ private int verifyMessageCountAndClose(BlockingQueue<InputStream> messageQueue,
     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);
@@ -1526,7 +1592,8 @@ public void interactionsAfterServerStreamCloseAreNoops() throws Exception {
 
     // boilerplate
     ClientStream clientStream =
-        client.newStream(methodDescriptor, new Metadata(), callOptions);
+        client.newStream(
+        methodDescriptor, new Metadata(), callOptions, tracers);
     ClientStreamListenerBase clientStreamListener = new ClientStreamListenerBase();
     clientStream.start(clientStreamListener);
     StreamCreation server
@@ -1535,11 +1602,11 @@ public void interactionsAfterServerStreamCloseAreNoops() throws Exception {
     // setup
     clientStream.request(1);
     server.stream.close(Status.INTERNAL, new Metadata());
-    assertNotNull(clientStreamListener.status.get(TIMEOUT_MS, TimeUnit.MILLISECONDS));
-    assertNotNull(clientStreamListener.trailers.get(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+    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());
+    server.stream.writeHeaders(new Metadata(), true);
     server.stream.writeMessage(methodDescriptor.streamResponse("response"));
     server.stream.close(Status.INTERNAL, new Metadata());
 
@@ -1558,7 +1625,8 @@ public void interactionsAfterClientStreamCancelAreNoops() throws Exception {
 
     // boilerplate
     ClientStream clientStream =
-        client.newStream(methodDescriptor, new Metadata(), callOptions);
+        client.newStream(
+        methodDescriptor, new Metadata(), callOptions, tracers);
     ClientStreamListener clientListener = mock(ClientStreamListener.class);
     clientStream.start(clientListener);
     StreamCreation server
@@ -1567,7 +1635,7 @@ public void interactionsAfterClientStreamCancelAreNoops() throws Exception {
     // setup
     server.stream.request(1);
     clientStream.cancel(Status.UNKNOWN);
-    assertNotNull(server.listener.status.get(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+    assertNotNull(server.listener.awaitClose(TIMEOUT_MS, TimeUnit.MILLISECONDS));
 
     // Ensure that for a cancelled ClientStream, interactions are noops
     clientStream.writeMessage(methodDescriptor.streamRequest("request"));
@@ -1605,7 +1673,8 @@ public void transportTracer_streamStarted() throws Exception {
       assertEquals(0, clientBefore.streamsStarted);
       assertEquals(0, clientBefore.lastRemoteStreamCreatedTimeNanos);
 
-      ClientStream clientStream = client.newStream(methodDescriptor, new Metadata(), callOptions);
+      ClientStream clientStream = client.newStream(
+          methodDescriptor, new Metadata(), callOptions, tracers);
       ClientStreamListenerBase clientStreamListener = new ClientStreamListenerBase();
       clientStream.start(clientStreamListener);
       StreamCreation serverStreamCreation = serverTransportListener
@@ -1635,7 +1704,8 @@ public void transportTracer_streamStarted() throws Exception {
       TransportStats clientBefore = getTransportStats(client);
       assertEquals(1, clientBefore.streamsStarted);
 
-      ClientStream clientStream = client.newStream(methodDescriptor, new Metadata(), callOptions);
+      ClientStream clientStream = client.newStream(
+          methodDescriptor, new Metadata(), callOptions, noopTracers);
       ClientStreamListenerBase clientStreamListener = new ClientStreamListenerBase();
       clientStream.start(clientStreamListener);
       StreamCreation serverStreamCreation = serverTransportListener
@@ -1665,7 +1735,8 @@ 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);
+    ClientStream clientStream = client.newStream(
+        methodDescriptor, new Metadata(), callOptions, tracers);
     ClientStreamListenerBase clientStreamListener = new ClientStreamListenerBase();
     clientStream.start(clientStreamListener);
     MockServerTransportListener serverTransportListener
@@ -1687,9 +1758,8 @@ public void transportTracer_server_streamEnded_ok() throws Exception {
     clientStream.halfClose();
     serverStream.close(Status.OK, new Metadata());
     // do not validate stats until close() has been called on client
-    assertNotNull(clientStreamListener.status.get(TIMEOUT_MS, TimeUnit.MILLISECONDS));
-    assertNotNull(clientStreamListener.trailers.get(TIMEOUT_MS, TimeUnit.MILLISECONDS));
-
+    assertNotNull(clientStreamListener.awaitClose(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+    assertNotNull(clientStreamListener.awaitTrailers(TIMEOUT_MS, TimeUnit.MILLISECONDS));
 
     TransportStats serverAfter = getTransportStats(serverTransportListener.transport);
     assertEquals(1, serverAfter.streamsSucceeded);
@@ -1704,7 +1774,8 @@ 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);
+    ClientStream clientStream = client.newStream(
+        methodDescriptor, new Metadata(), callOptions, tracers);
     ClientStreamListenerBase clientStreamListener = new ClientStreamListenerBase();
     clientStream.start(clientStreamListener);
     MockServerTransportListener serverTransportListener
@@ -1725,9 +1796,8 @@ public void transportTracer_server_streamEnded_nonOk() throws Exception {
 
     serverStream.close(Status.UNKNOWN, new Metadata());
     // do not validate stats until close() has been called on client
-    assertNotNull(clientStreamListener.status.get(TIMEOUT_MS, TimeUnit.MILLISECONDS));
-    assertNotNull(clientStreamListener.trailers.get(TIMEOUT_MS, TimeUnit.MILLISECONDS));
-
+    assertNotNull(clientStreamListener.awaitClose(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+    assertNotNull(clientStreamListener.awaitTrailers(TIMEOUT_MS, TimeUnit.MILLISECONDS));
 
     TransportStats serverAfter = getTransportStats(serverTransportListener.transport);
     assertEquals(1, serverAfter.streamsFailed);
@@ -1744,7 +1814,8 @@ 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);
+    ClientStream clientStream = client.newStream(
+        methodDescriptor, new Metadata(), callOptions, tracers);
     ClientStreamListenerBase clientStreamListener = new ClientStreamListenerBase();
     clientStream.start(clientStreamListener);
     MockServerTransportListener serverTransportListener =
@@ -1764,7 +1835,7 @@ public void transportTracer_client_streamEnded_nonOk() throws Exception {
 
     clientStream.cancel(Status.UNKNOWN);
     // do not validate stats until close() has been called on server
-    assertNotNull(serverStreamCreation.listener.status.get(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+    assertNotNull(serverStreamCreation.listener.awaitClose(TIMEOUT_MS, TimeUnit.MILLISECONDS));
 
     TransportStats serverAfter = getTransportStats(serverTransportListener.transport);
     assertEquals(1, serverAfter.streamsFailed);
@@ -1779,7 +1850,8 @@ 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);
+    ClientStream clientStream = client.newStream(
+        methodDescriptor, new Metadata(), callOptions, tracers);
     ClientStreamListenerBase clientStreamListener = new ClientStreamListenerBase();
     clientStream.start(clientStreamListener);
     MockServerTransportListener serverTransportListener
@@ -1820,7 +1892,8 @@ 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);
+    ClientStream clientStream = client.newStream(
+        methodDescriptor, new Metadata(), callOptions, tracers);
     ClientStreamListenerBase clientStreamListener = new ClientStreamListenerBase();
     clientStream.start(clientStreamListener);
     MockServerTransportListener serverTransportListener
@@ -1840,7 +1913,7 @@ public void transportTracer_server_send_msg() throws Exception {
     assertEquals(0, clientBefore.lastMessageReceivedTimeNanos);
 
     clientStream.request(1);
-    serverStream.writeHeaders(new Metadata());
+    serverStream.writeHeaders(new Metadata(), true);
     serverStream.writeMessage(methodDescriptor.streamResponse("response"));
     serverStream.flush();
     verifyMessageCountAndClose(clientStreamListener.messageQueue, 1);
@@ -1860,7 +1933,8 @@ public void socketStats() throws Exception {
     server.start(serverListener);
     ManagedClientTransport client = newClientTransport(server);
     startTransport(client, mockClientTransportListener);
-    ClientStream clientStream = client.newStream(methodDescriptor, new Metadata(), callOptions);
+    ClientStream clientStream = client.newStream(
+        methodDescriptor, new Metadata(), callOptions, tracers);
     ClientStreamListenerBase clientStreamListener = new ClientStreamListenerBase();
     clientStream.start(clientStreamListener);
 
@@ -1907,8 +1981,8 @@ public void serverChecksInboundMetadataSize() throws Exception {
         Metadata.Key.of("foo-bin", Metadata.BINARY_BYTE_MARSHALLER),
         new byte[GrpcUtil.DEFAULT_MAX_HEADER_LIST_SIZE]);
 
-    ClientStream clientStream =
-        client.newStream(methodDescriptor, tooLargeMetadata, callOptions);
+    ClientStream clientStream = client.newStream(
+        methodDescriptor, tooLargeMetadata, callOptions, tracers);
     ClientStreamListenerBase clientStreamListener = new ClientStreamListenerBase();
     clientStream.start(clientStreamListener);
 
@@ -1918,7 +1992,7 @@ public void serverChecksInboundMetadataSize() throws Exception {
     // 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.status.get(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    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())) {
@@ -1942,7 +2016,8 @@ public void clientChecksInboundMetadataSize_header() throws Exception {
         new byte[GrpcUtil.DEFAULT_MAX_HEADER_LIST_SIZE]);
 
     ClientStream clientStream =
-        client.newStream(methodDescriptor, new Metadata(), callOptions);
+        client.newStream(
+        methodDescriptor, new Metadata(), callOptions, tracers);
     ClientStreamListenerBase clientStreamListener = new ClientStreamListenerBase();
     clientStream.start(clientStreamListener);
 
@@ -1954,17 +2029,17 @@ public void clientChecksInboundMetadataSize_header() throws Exception {
         = serverTransportListener.takeStreamOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
 
     serverStreamCreation.stream.request(1);
-    serverStreamCreation.stream.writeHeaders(tooLargeMetadata);
+    serverStreamCreation.stream.writeHeaders(tooLargeMetadata, true);
     serverStreamCreation.stream.writeMessage(methodDescriptor.streamResponse("response"));
     serverStreamCreation.stream.close(Status.OK, new Metadata());
 
-    Status status = clientStreamListener.status.get(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    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.headers.isDone());
+    assertFalse(clientStreamListener.hasHeaders());
   }
 
   /** This assumes the client limits metadata size to GrpcUtil.DEFAULT_MAX_HEADER_LIST_SIZE. */
@@ -1986,7 +2061,8 @@ public void clientChecksInboundMetadataSize_trailer() throws Exception {
         new byte[GrpcUtil.DEFAULT_MAX_HEADER_LIST_SIZE]);
 
     ClientStream clientStream =
-        client.newStream(methodDescriptor, new Metadata(), callOptions);
+        client.newStream(
+        methodDescriptor, new Metadata(), callOptions, tracers);
     ClientStreamListenerBase clientStreamListener = new ClientStreamListenerBase();
     clientStream.start(clientStreamListener);
 
@@ -1998,17 +2074,17 @@ public void clientChecksInboundMetadataSize_trailer() throws Exception {
         = serverTransportListener.takeStreamOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
 
     serverStreamCreation.stream.request(1);
-    serverStreamCreation.stream.writeHeaders(new Metadata());
+    serverStreamCreation.stream.writeHeaders(new Metadata(), true);
     serverStreamCreation.stream.writeMessage(methodDescriptor.streamResponse("response"));
     serverStreamCreation.stream.close(Status.OK, tooLargeMetadata);
 
-    Status status = clientStreamListener.status.get(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    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.trailers.get(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    Metadata metadata = clientStreamListener.awaitTrailers(TIMEOUT_MS, TimeUnit.MILLISECONDS);
     assertNull(metadata.get(tellTaleKey));
   }
 
@@ -2022,7 +2098,9 @@ 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);
+    ClientStream clientStream = client.newStream(
+        methodDescriptor, new Metadata(), callOptions,
+        new ClientStreamTracer[] { new ClientStreamTracer() {} });
     ClientStreamListenerBase clientStreamListener = new ClientStreamListenerBase();
     clientStream.start(clientStreamListener);
 
@@ -2034,9 +2112,9 @@ private void doPingPong(MockServerListener serverListener) throws Exception {
     ServerStreamListenerBase serverStreamListener = serverStreamCreation.listener;
 
     serverStream.close(Status.OK, new Metadata());
-    assertNotNull(clientStreamListener.status.get(TIMEOUT_MS, TimeUnit.MILLISECONDS));
-    assertNotNull(clientStreamListener.trailers.get(TIMEOUT_MS, TimeUnit.MILLISECONDS));
-    assertNotNull(serverStreamListener.status.get(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+    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);
   }
 
@@ -2073,12 +2151,15 @@ private static void assertStatusEquals(Status expected, Status actual) {
    * 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());
   }
 
-  private static boolean waitForFuture(Future<?> future, long timeout, TimeUnit unit)
+  static boolean waitForFuture(Future<?> future, long timeout, TimeUnit unit)
       throws InterruptedException {
     try {
       future.get(timeout, unit);
@@ -2090,232 +2171,27 @@ private static boolean waitForFuture(Future<?> future, long timeout, TimeUnit un
     return true;
   }
 
-  private static void runIfNotNull(Runnable runnable) {
+  protected static void runIfNotNull(Runnable runnable) {
     if (runnable != null) {
       runnable.run();
     }
   }
 
-  private static void startTransport(
+  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 static class MockServerListener implements ServerListener {
-    public final BlockingQueue<MockServerTransportListener> listeners
-        = new LinkedBlockingQueue<>();
-    private final SettableFuture<?> shutdown = SettableFuture.create();
-
-    @Override
-    public ServerTransportListener transportCreated(ServerTransport transport) {
-      MockServerTransportListener listener = new MockServerTransportListener(transport);
-      listeners.add(listener);
-      return listener;
-    }
+  private final class TestHeaderClientStreamTracer extends TestClientStreamTracer {
+    Attributes transportAttrs;
 
     @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<>();
-    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) {
-      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 ServerStreamListenerBase implements ServerStreamListener {
-    private 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();
-
-    private boolean awaitOnReady(int timeout, TimeUnit unit) throws Exception {
-      return readyQueue.poll(timeout, unit) != null;
-    }
-
-    private boolean awaitOnReadyAndDrain(int timeout, TimeUnit unit) throws Exception {
-      if (!awaitOnReady(timeout, unit)) {
-        return false;
-      }
-      // Throw the rest away
-      readyQueue.drainTo(Lists.newArrayList());
-      return true;
-    }
-
-    private boolean awaitHalfClosed(int timeout, TimeUnit unit) throws Exception {
-      return halfClosedLatch.await(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);
-    }
-  }
-
-  private static class ClientStreamListenerBase implements ClientStreamListener {
-    private 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();
-
-    private boolean awaitOnReady(int timeout, TimeUnit unit) throws Exception {
-      return readyQueue.poll(timeout, unit) != null;
-    }
-
-    private 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, Metadata trailers) {
-      closed(status, RpcProgress.PROCESSED, trailers);
-    }
-
-    @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);
-    }
-  }
-
-  private 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;
+    public void streamCreated(Attributes transportAttrs, Metadata metadata) {
+      this.transportAttrs = transportAttrs;
+      metadata.put(tracerHeaderKey, tracerKeyValue);
     }
   }
 
@@ -2355,4 +2231,12 @@ private static TransportStats getTransportStats(InternalInstrumented<SocketStats
       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/test/java/io/grpc/internal/FakeClock.java b/core/src/testFixtures/java/io/grpc/internal/FakeClock.java
similarity index 84%
rename from core/src/test/java/io/grpc/internal/FakeClock.java
rename to core/src/testFixtures/java/io/grpc/internal/FakeClock.java
index d708af5f25d..1a3584f4e2c 100644
--- a/core/src/test/java/io/grpc/internal/FakeClock.java
+++ b/core/src/testFixtures/java/io/grpc/internal/FakeClock.java
@@ -88,13 +88,21 @@ public long currentTimeNanos() {
 
   public class ScheduledTask extends AbstractFuture<Void> implements ScheduledFuture<Void> {
     public final Runnable command;
-    public final long dueTimeNanos;
+    public long dueTimeNanos;
 
-    ScheduledTask(long dueTimeNanos, Runnable command) {
-      this.dueTimeNanos = 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);
@@ -116,10 +124,6 @@ public class ScheduledTask extends AbstractFuture<Void> implements ScheduledFutu
       }
     }
 
-    void complete() {
-      set(null);
-    }
-
     @Override
     public String toString() {
       return "[due=" + dueTimeNanos + ", task=" + command + "]";
@@ -132,24 +136,33 @@ private class ScheduledExecutorImpl implements ScheduledExecutorService {
       throw new UnsupportedOperationException();
     }
 
-    @Override public ScheduledFuture<?> schedule(Runnable cmd, long delay, TimeUnit unit) {
-      ScheduledTask task = new ScheduledTask(currentTimeNanos + unit.toNanos(delay), cmd);
+    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 command, long initialDelay, long period, TimeUnit unit) {
-      throw new UnsupportedOperationException();
+        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 command, long initialDelay, long delay, TimeUnit unit) {
-      throw new UnsupportedOperationException();
+        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) {
@@ -175,7 +188,8 @@ private class ScheduledExecutorImpl implements ScheduledExecutorService {
     }
 
     @Override public boolean isShutdown() {
-      throw new UnsupportedOperationException();
+      // If shutdown is not implemented, then it is never shutdown.
+      return false;
     }
 
     @Override public boolean isTerminated() {
@@ -206,6 +220,41 @@ private class ScheduledExecutorImpl implements ScheduledExecutorService {
       // 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);
+        }
+      }
+    }
   }
 
   /**
@@ -258,8 +307,7 @@ public int runDueTasks() {
       }
       ScheduledTask task;
       while ((task = dueTasks.poll()) != null) {
-        task.command.run();
-        task.complete();
+        task.run();
         count++;
       }
     }
@@ -357,7 +405,7 @@ public int numPendingTasks(TaskFilter filter) {
 
   public long currentTimeMillis() {
     // Normally millis and nanos are of different epochs. Add an offset to simulate that.
-    return TimeUnit.NANOSECONDS.toMillis(currentTimeNanos + 123456789L);
+    return TimeUnit.NANOSECONDS.toMillis(currentTimeNanos + 1234567890123456789L);
   }
 
   /**
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/test/java/io/grpc/internal/NoopClientStreamListener.java b/core/src/testFixtures/java/io/grpc/internal/NoopClientStreamListener.java
similarity index 93%
rename from core/src/test/java/io/grpc/internal/NoopClientStreamListener.java
rename to core/src/testFixtures/java/io/grpc/internal/NoopClientStreamListener.java
index 90a1c8cec10..5cd4f4f00d0 100644
--- a/core/src/test/java/io/grpc/internal/NoopClientStreamListener.java
+++ b/core/src/testFixtures/java/io/grpc/internal/NoopClientStreamListener.java
@@ -32,9 +32,6 @@ public void onReady() {}
   @Override
   public void headersRead(Metadata headers) {}
 
-  @Override
-  public void closed(Status status, Metadata trailers) {}
-
   @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/testing/src/main/java/io/grpc/internal/testing/SingleMessageProducer.java b/core/src/testFixtures/java/io/grpc/internal/SingleMessageProducer.java
similarity index 93%
rename from testing/src/main/java/io/grpc/internal/testing/SingleMessageProducer.java
rename to core/src/testFixtures/java/io/grpc/internal/SingleMessageProducer.java
index c621e501c78..8f89ed103ae 100644
--- a/testing/src/main/java/io/grpc/internal/testing/SingleMessageProducer.java
+++ b/core/src/testFixtures/java/io/grpc/internal/SingleMessageProducer.java
@@ -14,9 +14,8 @@
  * limitations under the License.
  */
 
-package io.grpc.internal.testing;
+package io.grpc.internal;
 
-import io.grpc.internal.StreamListener;
 import java.io.InputStream;
 import javax.annotation.Nullable;
 
diff --git a/core/src/test/java/io/grpc/internal/TestUtils.java b/core/src/testFixtures/java/io/grpc/internal/TestUtils.java
similarity index 87%
rename from core/src/test/java/io/grpc/internal/TestUtils.java
rename to core/src/testFixtures/java/io/grpc/internal/TestUtils.java
index 7152b4931fa..e5aab81c1bb 100644
--- a/core/src/test/java/io/grpc/internal/TestUtils.java
+++ b/core/src/testFixtures/java/io/grpc/internal/TestUtils.java
@@ -21,8 +21,11 @@
 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;
@@ -35,6 +38,7 @@
 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;
 
@@ -118,7 +122,8 @@ public ConnectionClientTransport answer(InvocationOnMock invocation) throws Thro
         when(mockTransport.getLogId())
             .thenReturn(InternalLogId.allocate("mocktransport", /*details=*/ null));
         when(mockTransport.newStream(
-                any(MethodDescriptor.class), any(Metadata.class), any(CallOptions.class)))
+                any(MethodDescriptor.class), any(Metadata.class), any(CallOptions.class),
+                ArgumentMatchers.<ClientStreamTracer[]>any()))
             .thenReturn(mock(ClientStream.class));
         // Save the listener
         doAnswer(new Answer<Runnable>() {
@@ -140,6 +145,23 @@ public Runnable answer(InvocationOnMock invocation) throws Throwable {
     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/test/java/io/grpc/internal/WritableBufferAllocatorTestBase.java b/core/src/testFixtures/java/io/grpc/internal/WritableBufferAllocatorTestBase.java
similarity index 100%
rename from core/src/test/java/io/grpc/internal/WritableBufferAllocatorTestBase.java
rename to core/src/testFixtures/java/io/grpc/internal/WritableBufferAllocatorTestBase.java
diff --git a/core/src/test/java/io/grpc/internal/WritableBufferTestBase.java b/core/src/testFixtures/java/io/grpc/internal/WritableBufferTestBase.java
similarity index 100%
rename from core/src/test/java/io/grpc/internal/WritableBufferTestBase.java
rename to core/src/testFixtures/java/io/grpc/internal/WritableBufferTestBase.java
diff --git a/cronet/README.md b/cronet/README.md
index a2178d71aa7..b62ed634b06 100644
--- a/cronet/README.md
+++ b/cronet/README.md
@@ -22,13 +22,9 @@ See the example app at https://github.com/GoogleChrome/cronet-sample/blob/master
 
 ## Example usage:
 
-In your app module's `build.gradle` file, include a dependency on both `grpc-cronet` and the 
-Google Play Services Client Library for Cronet
-
-```
-implementation 'io.grpc:grpc-cronet:1.36.0'
-implementation 'com.google.android.gms:play-services-cronet:16.0.0'
-```
+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` 
diff --git a/cronet/build.gradle b/cronet/build.gradle
index dcbb6b45ff8..e096761ddd2 100644
--- a/cronet/build.gradle
+++ b/cronet/build.gradle
@@ -2,21 +2,20 @@ plugins {
     id "maven-publish"
 
     id "com.android.library"
-    id "digital.wup.android-maven-publish"
 }
 
 description = "gRPC: Cronet Android"
 
 repositories {
     google()
-    jcenter()
 }
 
 android {
-    compileSdkVersion 29
+    namespace = 'io.grpc.cronet'
+    compileSdkVersion 33
     defaultConfig {
-        minSdkVersion 16
-        targetSdkVersion 29
+        minSdkVersion 23
+        targetSdkVersion 33
         versionCode 1
         versionName "1.0"
         testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
@@ -28,24 +27,33 @@ android {
             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-core'),
-            libraries.cronet_api
-    guavaDependency 'implementation'
+    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.cronet.embedded
 
     testImplementation libraries.junit
-    testImplementation libraries.mockito
-    testImplementation (libraries.robolectric) {
-        // Unreleased change: https://github.com/robolectric/robolectric/pull/5432
-        exclude group: 'com.google.auto.service', module: 'auto-service'
-    }
+    testImplementation libraries.mockito.core
+    testImplementation libraries.robolectric
 }
 
 task javadocs(type: Javadoc) {
@@ -66,22 +74,21 @@ task javadocs(type: Javadoc) {
 }
 
 task javadocJar(type: Jar, dependsOn: javadocs) {
-    classifier = 'javadoc'
+    archiveClassifier = 'javadoc'
     from javadocs.destinationDir
 }
 
 task sourcesJar(type: Jar) {
-    classifier = 'sources'
+    archiveClassifier = 'sources'
     from android.sourceSets.main.java.srcDirs
 }
 
 publishing {
     publications {
         maven {
-            from components.android
-
-            artifact javadocJar
-            artifact sourcesJar
+            afterEvaluate {
+                from components.release
+            }
         }
     }
 }
diff --git a/cronet/src/main/AndroidManifest.xml b/cronet/src/main/AndroidManifest.xml
index 5b77412a882..94cbbcfc396 100644
--- a/cronet/src/main/AndroidManifest.xml
+++ b/cronet/src/main/AndroidManifest.xml
@@ -1,2 +1 @@
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-    package="io.grpc.cronet" />
+<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
index 217928ae94a..7ea1bc891c2 100644
--- a/cronet/src/main/java/io/grpc/cronet/CronetChannelBuilder.java
+++ b/cronet/src/main/java/io/grpc/cronet/CronetChannelBuilder.java
@@ -20,16 +20,18 @@
 import static com.google.common.base.Preconditions.checkNotNull;
 import static io.grpc.internal.GrpcUtil.DEFAULT_MAX_MESSAGE_SIZE;
 
-import android.util.Log;
+import android.net.Network;
 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.AbstractManagedChannelImplBuilder;
 import io.grpc.internal.ClientTransportFactory;
 import io.grpc.internal.ConnectionClientTransport;
 import io.grpc.internal.GrpcUtil;
@@ -37,24 +39,19 @@
 import io.grpc.internal.ManagedChannelImplBuilder.ClientTransportFactoryBuilder;
 import io.grpc.internal.SharedResourceHolder;
 import io.grpc.internal.TransportTracer;
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
 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;
-import org.chromium.net.ExperimentalBidirectionalStream;
-import org.chromium.net.ExperimentalCronetEngine;
 
 /** 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 AbstractManagedChannelImplBuilder<CronetChannelBuilder> {
-
-  private static final String LOG_TAG = "CronetChannelBuilder";
+public final class CronetChannelBuilder extends ForwardingChannelBuilder2<CronetChannelBuilder> {
 
   /** BidirectionalStream.Builder factory used for getting the gRPC BidirectionalStream. */
   public static abstract class StreamBuilderFactory {
@@ -71,6 +68,7 @@ public static CronetChannelBuilder forAddress(String host, int port, CronetEngin
   /**
    * 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");
   }
@@ -78,6 +76,7 @@ public static CronetChannelBuilder forTarget(String target) {
   /**
    * 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");
   }
@@ -87,7 +86,7 @@ public static CronetChannelBuilder forAddress(String name, int port) {
 
   private final CronetEngine cronetEngine;
   private final ManagedChannelImplBuilder managedChannelImplBuilder;
-  private TransportTracer.Factory transportTracerFactory = TransportTracer.getDefaultFactory();
+  private final TransportTracer.Factory transportTracerFactory = TransportTracer.getDefaultFactory();
 
   private boolean alwaysUsePut = false;
 
@@ -108,6 +107,7 @@ public static CronetChannelBuilder forAddress(String name, int port) {
   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 {
@@ -135,7 +135,7 @@ protected ManagedChannelBuilder<?> delegate() {
    * 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 final CronetChannelBuilder maxMessageSize(int maxMessageSize) {
+  public CronetChannelBuilder maxMessageSize(int maxMessageSize) {
     checkArgument(maxMessageSize >= 0, "maxMessageSize must be >= 0");
     this.maxMessageSize = maxMessageSize;
     return this;
@@ -144,7 +144,7 @@ public final CronetChannelBuilder maxMessageSize(int maxMessageSize) {
   /**
    * Sets the Cronet channel to always use PUT instead of POST. Defaults to false.
    */
-  public final CronetChannelBuilder alwaysUsePut(boolean enable) {
+  public CronetChannelBuilder alwaysUsePut(boolean enable) {
     this.alwaysUsePut = enable;
     return this;
   }
@@ -166,7 +166,7 @@ public final CronetChannelBuilder alwaysUsePut(boolean enable) {
    *     application.
    * @return the builder to facilitate chaining.
    */
-  final CronetChannelBuilder setTrafficStatsTag(int tag) {
+  CronetChannelBuilder setTrafficStatsTag(int tag) {
     trafficStatsTagSet = true;
     trafficStatsTag = tag;
     return this;
@@ -176,7 +176,7 @@ final CronetChannelBuilder setTrafficStatsTag(int 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#MODIFY_NETWORK_ACCOUNTING} permission. By default traffic is
+   * 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
@@ -187,12 +187,19 @@ final CronetChannelBuilder setTrafficStatsTag(int tag) {
    * @param uid the UID to attribute socket traffic caused by this channel.
    * @return the builder to facilitate chaining.
    */
-  final CronetChannelBuilder setTrafficStatsUid(int uid) {
+  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.
    *
@@ -203,7 +210,7 @@ final CronetChannelBuilder setTrafficStatsUid(int uid) {
    *
    * @since 1.12.0
    */
-  public final CronetChannelBuilder scheduledExecutorService(
+  public CronetChannelBuilder scheduledExecutorService(
       ScheduledExecutorService scheduledExecutorService) {
     this.scheduledExecutorService =
         checkNotNull(scheduledExecutorService, "scheduledExecutorService");
@@ -213,7 +220,12 @@ public final CronetChannelBuilder scheduledExecutorService(
   ClientTransportFactory buildTransportFactory() {
     return new CronetTransportFactory(
         new TaggingStreamFactory(
-            cronetEngine, trafficStatsTagSet, trafficStatsTag, trafficStatsUidSet, trafficStatsUid),
+            cronetEngine,
+            trafficStatsTagSet,
+            trafficStatsTag,
+            trafficStatsUidSet,
+            trafficStatsUid,
+            network),
         MoreExecutors.directExecutor(),
         scheduledExecutorService,
         maxMessageSize,
@@ -281,107 +293,55 @@ public void close() {
         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 static volatile boolean loadSetTrafficStatsTagAttempted;
-    private static volatile boolean loadSetTrafficStatsUidAttempted;
-    private static volatile Method setTrafficStatsTagMethod;
-    private static volatile Method setTrafficStatsUidMethod;
-
     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) {
+        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) {
-      ExperimentalBidirectionalStream.Builder builder =
-          ((ExperimentalCronetEngine) cronetEngine)
+      BidirectionalStream.Builder builder =
+          cronetEngine
               .newBidirectionalStreamBuilder(url, callback, executor);
       if (trafficStatsTagSet) {
-        setTrafficStatsTag(builder, trafficStatsTag);
+        builder.setTrafficStatsTag(trafficStatsTag);
       }
       if (trafficStatsUidSet) {
-        setTrafficStatsUid(builder, trafficStatsUid);
+        builder.setTrafficStatsUid(trafficStatsUid);
       }
-      return builder;
-    }
-
-    private static void setTrafficStatsTag(ExperimentalBidirectionalStream.Builder builder,
-        int tag) {
-      if (!loadSetTrafficStatsTagAttempted) {
-        synchronized (TaggingStreamFactory.class) {
-          if (!loadSetTrafficStatsTagAttempted) {
-            try {
-              setTrafficStatsTagMethod = ExperimentalBidirectionalStream.Builder.class
-                  .getMethod("setTrafficStatsTag", int.class);
-            } catch (NoSuchMethodException e) {
-              Log.w(LOG_TAG,
-                  "Failed to load method ExperimentalBidirectionalStream.Builder.setTrafficStatsTag",
-                  e);
-            } finally {
-              loadSetTrafficStatsTagAttempted = true;
-            }
-          }
-        }
-      }
-      if (setTrafficStatsTagMethod != null) {
-        try {
-          setTrafficStatsTagMethod.invoke(builder, tag);
-        } catch (InvocationTargetException e) {
-          throw new RuntimeException(e.getCause() == null ? e.getTargetException() : e.getCause());
-        } catch (IllegalAccessException e) {
-          Log.w(LOG_TAG, "Failed to set traffic stats tag: " + tag, e);
-        }
-      }
-    }
-
-    private static void setTrafficStatsUid(ExperimentalBidirectionalStream.Builder builder,
-        int uid) {
-      if (!loadSetTrafficStatsUidAttempted) {
-        synchronized (TaggingStreamFactory.class) {
-          if (!loadSetTrafficStatsUidAttempted) {
-            try {
-              setTrafficStatsUidMethod = ExperimentalBidirectionalStream.Builder.class
-                  .getMethod("setTrafficStatsUid", int.class);
-            } catch (NoSuchMethodException e) {
-              Log.w(LOG_TAG,
-                  "Failed to load method ExperimentalBidirectionalStream.Builder.setTrafficStatsUid",
-                  e);
-            } finally {
-              loadSetTrafficStatsUidAttempted = true;
-            }
-          }
-        }
-      }
-      if (setTrafficStatsUidMethod != null) {
-        try {
-          setTrafficStatsUidMethod.invoke(builder, uid);
-        } catch (InvocationTargetException e) {
-          throw new RuntimeException(e.getCause() == null ? e.getTargetException() : e.getCause());
-        } catch (IllegalAccessException e) {
-          Log.w(LOG_TAG, "Failed to set traffic stats uid: " + uid, e);
-        }
+      if (network != null) {
+        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
index d44b716146e..07bbb953489 100644
--- a/cronet/src/main/java/io/grpc/cronet/CronetClientStream.java
+++ b/cronet/src/main/java/io/grpc/cronet/CronetClientStream.java
@@ -25,6 +25,7 @@
 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;
@@ -40,11 +41,9 @@
 import io.grpc.internal.TransportFrameUtil;
 import io.grpc.internal.TransportTracer;
 import io.grpc.internal.WritableBuffer;
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
 import java.nio.Buffer;
 import java.nio.ByteBuffer;
-import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
@@ -52,29 +51,29 @@
 import java.util.Map;
 import java.util.concurrent.Executor;
 import javax.annotation.Nullable;
-import javax.annotation.concurrent.GuardedBy;
 import org.chromium.net.BidirectionalStream;
 import org.chromium.net.CronetException;
-import org.chromium.net.ExperimentalBidirectionalStream;
 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";
 
-  private static volatile boolean loadAddRequestAnnotationAttempted;
-  private static volatile Method addRequestAnnotationMethod;
-
   @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");
+  /**
+   * Sets the read buffer size which the GRPC layer will use to read data from Cronet. Higher buffer
+   * size leads to less overhead but more memory consumption. The current default value is 4KB.
+   */
+  static final CallOptions.Key<Integer> CRONET_READ_BUFFER_SIZE_KEY =
+      CallOptions.Key.createWithDefault("cronet-read-buffer-size", 4 * 1024);
 
   private final String url;
   private final String userAgent;
@@ -91,6 +90,8 @@ class CronetClientStream extends AbstractClientStream {
   private final Collection<Object> annotations;
   private final TransportState state;
   private final Sink sink = new Sink();
+  @VisibleForTesting
+  final int readBufferSize;
   private StreamBuilderFactory streamFactory;
 
   CronetClientStream(
@@ -124,7 +125,9 @@ class CronetClientStream extends AbstractClientStream {
     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);
+    this.state = new TransportState(maxMessageSize, statsTraceCtx, lock, transportTracer,
+            callOptions);
+    this.readBufferSize = callOptions.getOption(CRONET_READ_BUFFER_SIZE_KEY);
 
     // Tests expect the "plain" deframer behavior, not MigratingDeframer
     // https://github.com/grpc/grpc-java/issues/7140
@@ -193,14 +196,12 @@ public void writeHeaders(Metadata metadata, byte[] payload) {
         builder.delayRequestHeadersUntilFirstFlush(true);
       }
       if (annotation != null || annotations != null) {
-        ExperimentalBidirectionalStream.Builder expBidiStreamBuilder =
-            (ExperimentalBidirectionalStream.Builder) builder;
         if (annotation != null) {
-          addRequestAnnotation(expBidiStreamBuilder, annotation);
+          builder.addRequestAnnotation(annotation);
         }
         if (annotations != null) {
           for (Object o : annotations) {
-            addRequestAnnotation(expBidiStreamBuilder, o);
+            builder.addRequestAnnotation(o);
           }
         }
       }
@@ -254,7 +255,7 @@ public void cancel(Status reason) {
   class TransportState extends Http2ClientStreamTransportState {
     private final Object lock;
     @GuardedBy("lock")
-    private Collection<PendingData> pendingData = new ArrayList<PendingData>();
+    private final Collection<PendingData> pendingData = new ArrayList<>();
     @GuardedBy("lock")
     private boolean streamReady;
     @GuardedBy("lock")
@@ -270,8 +271,8 @@ class TransportState extends Http2ClientStreamTransportState {
 
     public TransportState(
         int maxMessageSize, StatsTraceContext statsTraceCtx, Object lock,
-        TransportTracer transportTracer) {
-      super(maxMessageSize, statsTraceCtx, transportTracer);
+        TransportTracer transportTracer, CallOptions options) {
+      super(maxMessageSize, statsTraceCtx, transportTracer, options);
       this.lock = Preconditions.checkNotNull(lock, "lock");
     }
 
@@ -316,7 +317,7 @@ public void bytesRead(int processedBytes) {
         if (Log.isLoggable(LOG_TAG, Log.VERBOSE)) {
           Log.v(LOG_TAG, "BidirectionalStream.read");
         }
-        stream.read(ByteBuffer.allocateDirect(READ_BUFFER_CAPACITY));
+        stream.read(ByteBuffer.allocateDirect(readBufferSize));
       }
     }
 
@@ -366,39 +367,9 @@ private static boolean isApplicationHeader(String key) {
         && !TE_HEADER.name().equalsIgnoreCase(key);
   }
 
-  private static void addRequestAnnotation(ExperimentalBidirectionalStream.Builder builder,
-      Object annotation) {
-    if (!loadAddRequestAnnotationAttempted) {
-      synchronized (CronetClientStream.class) {
-        if (!loadAddRequestAnnotationAttempted) {
-          try {
-            addRequestAnnotationMethod = ExperimentalBidirectionalStream.Builder.class
-                .getMethod("addRequestAnnotation", Object.class);
-          } catch (NoSuchMethodException e) {
-            Log.w(LOG_TAG,
-                "Failed to load method ExperimentalBidirectionalStream.Builder.addRequestAnnotation",
-                e);
-          } finally {
-            loadAddRequestAnnotationAttempted = true;
-          }
-        }
-      }
-    }
-    if (addRequestAnnotationMethod != null) {
-      try {
-        addRequestAnnotationMethod.invoke(builder, annotation);
-      } catch (InvocationTargetException e) {
-        throw new RuntimeException(e.getCause() == null ? e.getTargetException() : e.getCause());
-      } catch (IllegalAccessException e) {
-        Log.w(LOG_TAG, "Failed to add request annotation: " + annotation, e);
-      }
-    }
-  }
-
   private void setGrpcHeaders(BidirectionalStream.Builder builder) {
     // Psuedo-headers are set by cronet.
     // All non-pseudo headers must come after pseudo headers.
-    // TODO(ericgribkoff): remove this and set it on CronetEngine after crbug.com/588204 gets fixed.
     builder.addHeader(USER_AGENT_KEY.name(), userAgent);
     builder.addHeader(CONTENT_TYPE_KEY.name(), GrpcUtil.CONTENT_TYPE_GRPC);
     builder.addHeader("te", GrpcUtil.TE_TRAILERS);
@@ -408,10 +379,10 @@ private void setGrpcHeaders(BidirectionalStream.Builder builder) {
     // String and byte array.
     byte[][] serializedHeaders = TransportFrameUtil.toHttp2Headers(headers);
     for (int i = 0; i < serializedHeaders.length; i += 2) {
-      String key = new String(serializedHeaders[i], Charset.forName("UTF-8"));
+      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], Charset.forName("UTF-8"));
+        String value = new String(serializedHeaders[i + 1], StandardCharsets.UTF_8);
         builder.addHeader(key, value);
       }
     }
@@ -466,7 +437,7 @@ public void onResponseHeadersReceived(BidirectionalStream stream, UrlResponseInf
         Log.v(LOG_TAG, "BidirectionalStream.read");
       }
       reportHeaders(info.getAllHeadersAsList(), false);
-      stream.read(ByteBuffer.allocateDirect(READ_BUFFER_CAPACITY));
+      stream.read(ByteBuffer.allocateDirect(readBufferSize));
     }
 
     @Override
@@ -588,8 +559,8 @@ private void reportHeaders(List<Map.Entry<String, String>> headers, boolean endO
 
       byte[][] headerValues = new byte[headerList.size()][];
       for (int i = 0; i < headerList.size(); i += 2) {
-        headerValues[i] = headerList.get(i).getBytes(Charset.forName("UTF-8"));
-        headerValues[i + 1] = headerList.get(i + 1).getBytes(Charset.forName("UTF-8"));
+        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));
diff --git a/cronet/src/main/java/io/grpc/cronet/CronetClientTransport.java b/cronet/src/main/java/io/grpc/cronet/CronetClientTransport.java
index dc4fc45ae4e..99eb88737aa 100644
--- a/cronet/src/main/java/io/grpc/cronet/CronetClientTransport.java
+++ b/cronet/src/main/java/io/grpc/cronet/CronetClientTransport.java
@@ -19,8 +19,10 @@
 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;
@@ -32,6 +34,7 @@
 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;
@@ -41,7 +44,6 @@
 import java.util.Set;
 import java.util.concurrent.Executor;
 import javax.annotation.Nullable;
-import javax.annotation.concurrent.GuardedBy;
 
 /**
  * A cronet-based {@link ConnectionClientTransport} implementation.
@@ -55,14 +57,15 @@ class CronetClientTransport implements ConnectionClientTransport {
   private final Object lock = new Object();
   @GuardedBy("lock")
   private final Set<CronetClientStream> streams = Collections.newSetFromMap(
-          new IdentityHashMap<CronetClientStream, Boolean>());
+          new IdentityHashMap<>());
   private final Executor executor;
   private final int maxMessageSize;
   private final boolean alwaysUsePut;
   private final TransportTracer transportTracer;
-  private final Attributes attrs;
+  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")
@@ -78,7 +81,6 @@ class CronetClientTransport implements ConnectionClientTransport {
   @GuardedBy("lock")
   // Whether this transport has started.
   private boolean started;
-  private StreamBuilderFactory streamFactory;
 
   CronetClientTransport(
       StreamBuilderFactory streamFactory,
@@ -118,7 +120,7 @@ public ListenableFuture<SocketStats> getStats() {
 
   @Override
   public CronetClientStream newStream(final MethodDescriptor<?, ?> method, final Metadata headers,
-      final CallOptions callOptions) {
+      final CallOptions callOptions, ClientStreamTracer[] tracers) {
     Preconditions.checkNotNull(method, "method");
     Preconditions.checkNotNull(headers, "headers");
 
@@ -126,7 +128,7 @@ public CronetClientStream newStream(final MethodDescriptor<?, ?> method, final M
     final String url = "https://" + authority + defaultPath;
 
     final StatsTraceContext statsTraceCtx =
-        StatsTraceContext.newClientContext(callOptions, attrs, headers);
+        StatsTraceContext.newClientContext(tracers, attrs, headers);
     class StartCallback implements Runnable {
       final CronetClientStream clientStream = new CronetClientStream(
           url, userAgent, executor, headers, CronetClientTransport.this, this, lock, maxMessageSize,
@@ -168,6 +170,7 @@ public Runnable start(Listener listener) {
     return new Runnable() {
       @Override
       public void run() {
+        attrs = CronetClientTransport.this.listener.filterTransport(attrs);
         // Listener callbacks should not be called simultaneously
         CronetClientTransport.this.listener.transportReady();
       }
@@ -203,9 +206,9 @@ public void shutdownNow(Status status) {
       // streams.remove()
       streamsCopy = new ArrayList<>(streams);
     }
-    for (int i = 0; i < streamsCopy.size(); i++) {
+    for (CronetClientStream cronetClientStream : streamsCopy) {
       // Avoid deadlock by calling into stream without lock held
-      streamsCopy.get(i).cancel(status);
+      cronetClientStream.cancel(status);
     }
     stopIfNecessary();
   }
@@ -227,7 +230,7 @@ private void startGoAway(Status status) {
       startedGoAway = true;
     }
 
-    listener.transportShutdown(status);
+    listener.transportShutdown(status, SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
 
     synchronized (lock) {
       goAway = true;
@@ -253,7 +256,7 @@ public InternalLogId getLogId() {
    */
   void stopIfNecessary() {
     synchronized (lock) {
-      if (goAway && !stopped && streams.size() == 0) {
+      if (goAway && !stopped && streams.isEmpty()) {
         stopped = true;
       } else {
         return;
diff --git a/cronet/src/main/java/io/grpc/cronet/InternalCronetCallOptions.java b/cronet/src/main/java/io/grpc/cronet/InternalCronetCallOptions.java
index e7c4144e63a..9261a0a8f4b 100644
--- a/cronet/src/main/java/io/grpc/cronet/InternalCronetCallOptions.java
+++ b/cronet/src/main/java/io/grpc/cronet/InternalCronetCallOptions.java
@@ -36,6 +36,18 @@ public static CallOptions withAnnotation(CallOptions callOptions, Object annotat
     return CronetClientStream.withAnnotation(callOptions, annotation);
   }
 
+  public static CallOptions withReadBufferSize(CallOptions callOptions, int size) {
+    return callOptions.withOption(CronetClientStream.CRONET_READ_BUFFER_SIZE_KEY, size);
+  }
+
+  /**
+   * Returns Cronet read buffer size for gRPC included in the given {@code callOptions}. Read
+   * buffer can be customized via {@link #withReadBufferSize(CallOptions, int)}.
+   */
+  public static int getReadBufferSize(CallOptions callOptions) {
+    return callOptions.getOption(CronetClientStream.CRONET_READ_BUFFER_SIZE_KEY);
+  }
+
   /**
    * Returns Cronet annotations for gRPC included in the given {@code callOptions}. Annotations
    * are attached via {@link #withAnnotation(CallOptions, Object)}.
diff --git a/cronet/src/main/java/io/grpc/cronet/InternalCronetChannelBuilder.java b/cronet/src/main/java/io/grpc/cronet/InternalCronetChannelBuilder.java
index f61685937a8..7e5e610ca67 100644
--- a/cronet/src/main/java/io/grpc/cronet/InternalCronetChannelBuilder.java
+++ b/cronet/src/main/java/io/grpc/cronet/InternalCronetChannelBuilder.java
@@ -16,7 +16,9 @@
 
 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
@@ -47,7 +49,7 @@ public static void setTrafficStatsTag(CronetChannelBuilder builder, int 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#MODIFY_NETWORK_ACCOUNTING} permission. By default traffic is
+   * 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
@@ -58,4 +60,9 @@ public static void setTrafficStatsTag(CronetChannelBuilder builder, int tag) {
   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
index 39fe03991e4..be437b3c80b 100644
--- a/cronet/src/test/java/io/grpc/cronet/CronetChannelBuilderTest.java
+++ b/cronet/src/test/java/io/grpc/cronet/CronetChannelBuilderTest.java
@@ -16,7 +16,9 @@
 
 package io.grpc.cronet;
 
+import static io.grpc.cronet.CronetClientStream.CRONET_READ_BUFFER_SIZE_KEY;
 import static io.grpc.internal.GrpcUtil.TIMER_SERVICE;
+import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertSame;
 import static org.junit.Assert.assertTrue;
@@ -25,6 +27,7 @@
 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;
@@ -34,29 +37,28 @@
 import io.grpc.testing.TestMethodDescriptors;
 import java.net.InetSocketAddress;
 import java.util.concurrent.ScheduledExecutorService;
-import org.chromium.net.ExperimentalCronetEngine;
-import org.junit.Before;
+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.MockitoAnnotations;
+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 ExperimentalCronetEngine mockEngine;
+  @Mock private CronetEngine mockEngine;
   @Mock private ChannelLogger channelLogger;
 
+  private final ClientStreamTracer[] tracers =
+      new ClientStreamTracer[]{ new ClientStreamTracer() {} };
   private MethodDescriptor<?, ?> method = TestMethodDescriptors.voidMethod();
 
-  @Before
-  public void setUp() {
-    MockitoAnnotations.initMocks(this);
-  }
-
   @Test
   public void alwaysUsePutTrue_cronetStreamIsIdempotent() throws Exception {
     CronetChannelBuilder builder =
@@ -69,7 +71,8 @@ public void alwaysUsePutTrue_cronetStreamIsIdempotent() throws Exception {
                 new InetSocketAddress("localhost", 443),
                 new ClientTransportOptions(),
                 channelLogger);
-    CronetClientStream stream = transport.newStream(method, new Metadata(), CallOptions.DEFAULT);
+    CronetClientStream stream = transport.newStream(
+        method, new Metadata(), CallOptions.DEFAULT, tracers);
 
     assertTrue(stream.idempotent);
   }
@@ -85,11 +88,47 @@ public void alwaysUsePut_defaultsToFalse() throws Exception {
                 new InetSocketAddress("localhost", 443),
                 new ClientTransportOptions(),
                 channelLogger);
-    CronetClientStream stream = transport.newStream(method, new Metadata(), CallOptions.DEFAULT);
+    CronetClientStream stream = transport.newStream(
+        method, new Metadata(), CallOptions.DEFAULT, tracers);
 
     assertFalse(stream.idempotent);
   }
 
+  @Test
+  public void channelBuilderReadBufferSize_defaultsTo4Kb() 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);
+
+    assertEquals(4 * 1024, stream.readBufferSize);
+  }
+
+  @Test
+  public void channelBuilderReadBufferSize_changeReflected() 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.withOption(CRONET_READ_BUFFER_SIZE_KEY, 32 * 1024), tracers);
+
+    assertEquals(32 * 1024, stream.readBufferSize);
+  }
+
   @Test
   public void scheduledExecutorService_default() {
     CronetChannelBuilder builder = CronetChannelBuilder.forAddress("address", 1234, mockEngine);
diff --git a/cronet/src/test/java/io/grpc/cronet/CronetClientStreamTest.java b/cronet/src/test/java/io/grpc/cronet/CronetClientStreamTest.java
index 48ce71c493f..e2b0e0b26ca 100644
--- a/cronet/src/test/java/io/grpc/cronet/CronetClientStreamTest.java
+++ b/cronet/src/test/java/io/grpc/cronet/CronetClientStreamTest.java
@@ -18,6 +18,7 @@
 
 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;
@@ -46,7 +47,7 @@
 import java.io.ByteArrayInputStream;
 import java.nio.Buffer;
 import java.nio.ByteBuffer;
-import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
@@ -54,31 +55,33 @@
 import java.util.concurrent.Executor;
 import org.chromium.net.BidirectionalStream;
 import org.chromium.net.CronetException;
-import org.chromium.net.ExperimentalBidirectionalStream;
 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.MockitoAnnotations;
+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 ExperimentalBidirectionalStream cronetStream;
-  @Mock private Executor executor;
+  @Mock private BidirectionalStream cronetStream;
   @Mock private ClientStreamListener clientListener;
-  @Mock private ExperimentalBidirectionalStream.Builder builder;
+  @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();
@@ -100,15 +103,13 @@ void setStream(CronetClientStream stream) {
     @Override
     @SuppressWarnings("GuardedBy")
     public void run() {
-      assertTrue(stream != null);
+      assertNotNull(stream);
       stream.transportState().start(factory);
     }
   }
 
   @Before
   public void setUp() {
-    MockitoAnnotations.initMocks(this);
-
     SetStreamFactoryRunnable callback = new SetStreamFactoryRunnable(factory);
     clientStream =
         new CronetClientStream(
@@ -166,9 +167,9 @@ public void write() {
     String[] requests = new String[5];
     WritableBuffer[] buffers = new WritableBuffer[5];
     for (int i = 0; i < 5; ++i) {
-      requests[i] = new String("request" + String.valueOf(i));
+      requests[i] = "request" + i;
       buffers[i] = allocator.allocate(requests[i].length());
-      buffers[i].write(requests[i].getBytes(Charset.forName("UTF-8")), 0, 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);
     }
@@ -201,27 +202,19 @@ public void write() {
   }
 
   private static List<Map.Entry<String, String>> responseHeader(String status) {
-    Map<String, String> headers = new HashMap<String, String>();
+    Map<String, String> headers = new HashMap<>();
     headers.put(":status", status);
     headers.put("content-type", "application/grpc");
     headers.put("test-key", "test-value");
-    List<Map.Entry<String, String>> headerList = new ArrayList<Map.Entry<String, String>>(3);
-    for (Map.Entry<String, String> entry : headers.entrySet()) {
-      headerList.add(entry);
-    }
-    return headerList;
+    return new ArrayList<>(headers.entrySet());
   }
 
   private static List<Map.Entry<String, String>> trailers(int status) {
-    Map<String, String> trailers = new HashMap<String, String>();
+    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");
-    List<Map.Entry<String, String>> trailerList = new ArrayList<Map.Entry<String, String>>(3);
-    for (Map.Entry<String, String> entry : trailers.entrySet()) {
-      trailerList.add(entry);
-    }
-    return trailerList;
+    return new ArrayList<>(trailers.entrySet());
   }
 
   private static ByteBuffer createMessageFrame(byte[] bytes) {
@@ -245,7 +238,7 @@ public void read() {
     verify(cronetStream, times(0)).read(isA(ByteBuffer.class));
     UrlResponseInfo info =
         new UrlResponseInfoImpl(
-            new ArrayList<String>(), 200, "", responseHeader("200"), false, "", "");
+            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);
@@ -261,7 +254,7 @@ public void read() {
     callback.onReadCompleted(
         cronetStream,
         info,
-        createMessageFrame(new String("response1").getBytes(Charset.forName("UTF-8"))),
+        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));
@@ -291,9 +284,9 @@ public void streamSucceeded() {
     verify(cronetStream, times(0)).write(isA(ByteBuffer.class), isA(Boolean.class));
     // Send the first data frame.
     CronetWritableBufferAllocator allocator = new CronetWritableBufferAllocator();
-    String request = new String("request");
+    String request = "request";
     WritableBuffer writableBuffer = allocator.allocate(request.length());
-    writableBuffer.write(request.getBytes(Charset.forName("UTF-8")), 0, 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));
@@ -305,14 +298,14 @@ public void streamSucceeded() {
     clientStream.request(2);
     UrlResponseInfo info =
         new UrlResponseInfoImpl(
-            new ArrayList<String>(), 200, "", responseHeader("200"), false, "", "");
+            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(new String("response").getBytes(Charset.forName("UTF-8"))),
+        createMessageFrame("response".getBytes(StandardCharsets.UTF_8)),
         false);
     verify(clientListener, times(1)).messagesAvailable(isA(MessageProducer.class));
     verify(cronetStream, times(2)).read(isA(ByteBuffer.class));
@@ -363,7 +356,7 @@ public void streamSucceededWithGrpcError() {
     clientStream.request(2);
     UrlResponseInfo info =
         new UrlResponseInfoImpl(
-            new ArrayList<String>(), 200, "", responseHeader("200"), false, "", "");
+            new ArrayList<>(), 200, "", responseHeader("200"), false, "", "", 0);
     callback.onResponseHeadersReceived(cronetStream, info);
     verify(cronetStream, times(1)).read(isA(ByteBuffer.class));
 
@@ -418,7 +411,7 @@ public void streamFailedAfterResponseHeaderReceived() {
     // Receive response header
     UrlResponseInfo info =
         new UrlResponseInfoImpl(
-            new ArrayList<String>(), 200, "", responseHeader("200"), false, "", "");
+            new ArrayList<>(), 200, "", responseHeader("200"), false, "", "", 0);
     callback.onResponseHeadersReceived(cronetStream, info);
 
     CronetException exception = mock(CronetException.class);
@@ -446,7 +439,7 @@ public void streamFailedAfterTrailerReceived() {
     // Receive response header
     UrlResponseInfo info =
         new UrlResponseInfoImpl(
-            new ArrayList<String>(), 200, "", responseHeader("200"), false, "", "");
+            new ArrayList<>(), 200, "", responseHeader("200"), false, "", "", 0);
     callback.onResponseHeadersReceived(cronetStream, info);
 
     // Report trailer but not endOfStream.
@@ -478,7 +471,7 @@ public void streamFailedAfterTrailerAndEndOfStreamReceived() {
     // Receive response header
     UrlResponseInfo info =
         new UrlResponseInfoImpl(
-            new ArrayList<String>(), 200, "", responseHeader("200"), false, "", "");
+            new ArrayList<>(), 200, "", responseHeader("200"), false, "", "", 0);
     callback.onResponseHeadersReceived(cronetStream, info);
 
     // Report trailer and endOfStream
@@ -531,7 +524,7 @@ public void reportTrailersWhenTrailersReceivedBeforeReadClosed() {
     callback.onStreamReady(cronetStream);
     UrlResponseInfo info =
         new UrlResponseInfoImpl(
-            new ArrayList<String>(), 200, "", responseHeader("200"), false, "", "");
+            new ArrayList<>(), 200, "", responseHeader("200"), false, "", "", 0);
     callback.onResponseHeadersReceived(cronetStream, info);
     // Receive trailer first
     ((CronetClientStream.BidirectionalStreamCallback) callback)
@@ -560,7 +553,7 @@ public void reportTrailersWhenTrailersReceivedAfterReadClosed() {
     callback.onStreamReady(cronetStream);
     UrlResponseInfo info =
         new UrlResponseInfoImpl(
-            new ArrayList<String>(), 200, "", responseHeader("200"), false, "", "");
+            new ArrayList<>(), 200, "", responseHeader("200"), false, "", "", 0);
     callback.onResponseHeadersReceived(cronetStream, info);
     // Receive cronet's endOfStream
     callback.onReadCompleted(cronetStream, null, ByteBuffer.allocate(0), true);
@@ -675,8 +668,8 @@ public void getUnaryRequest() {
             true,
             false);
     callback.setStream(stream);
-    ExperimentalBidirectionalStream.Builder getBuilder =
-        mock(ExperimentalBidirectionalStream.Builder.class);
+    BidirectionalStream.Builder getBuilder =
+        mock(BidirectionalStream.Builder.class);
     when(getFactory.newBidirectionalStreamBuilder(
             any(String.class), any(BidirectionalStream.Callback.class), any(Executor.class)))
         .thenReturn(getBuilder);
@@ -688,7 +681,7 @@ public void getUnaryRequest() {
         .newBidirectionalStreamBuilder(
             isA(String.class), isA(BidirectionalStream.Callback.class), isA(Executor.class));
 
-    byte[] msg = "request".getBytes(Charset.forName("UTF-8"));
+    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));
@@ -732,8 +725,8 @@ public void idempotentMethod_usesHttpPut() {
             true,
             true);
     callback.setStream(stream);
-    ExperimentalBidirectionalStream.Builder builder =
-        mock(ExperimentalBidirectionalStream.Builder.class);
+    BidirectionalStream.Builder builder =
+        mock(BidirectionalStream.Builder.class);
     when(factory.newBidirectionalStreamBuilder(
             any(String.class), any(BidirectionalStream.Callback.class), any(Executor.class)))
         .thenReturn(builder);
@@ -764,8 +757,8 @@ public void alwaysUsePutOption_usesHttpPut() {
             true,
             true);
     callback.setStream(stream);
-    ExperimentalBidirectionalStream.Builder builder =
-        mock(ExperimentalBidirectionalStream.Builder.class);
+    BidirectionalStream.Builder builder =
+        mock(BidirectionalStream.Builder.class);
     when(factory.newBidirectionalStreamBuilder(
             any(String.class), any(BidirectionalStream.Callback.class), any(Executor.class)))
         .thenReturn(builder);
@@ -804,8 +797,8 @@ public void reservedHeadersStripped() {
             false,
             false);
     callback.setStream(stream);
-    ExperimentalBidirectionalStream.Builder builder =
-        mock(ExperimentalBidirectionalStream.Builder.class);
+    BidirectionalStream.Builder builder =
+        mock(BidirectionalStream.Builder.class);
     when(factory.newBidirectionalStreamBuilder(
             any(String.class), any(BidirectionalStream.Callback.class), any(Executor.class)))
         .thenReturn(builder);
diff --git a/cronet/src/test/java/io/grpc/cronet/CronetClientTransportTest.java b/cronet/src/test/java/io/grpc/cronet/CronetClientTransportTest.java
index 69e4b26a47b..3a79cc0b6a8 100644
--- a/cronet/src/test/java/io/grpc/cronet/CronetClientTransportTest.java
+++ b/cronet/src/test/java/io/grpc/cronet/CronetClientTransportTest.java
@@ -17,7 +17,7 @@
 package io.grpc.cronet;
 
 import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.assertNotNull;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.times;
@@ -27,12 +27,14 @@
 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;
@@ -41,17 +43,20 @@
 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.MockitoAnnotations;
+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 =
@@ -60,17 +65,19 @@ public final class CronetClientTransportTest {
   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;
-  @Mock private Executor executor;
   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() {
-    MockitoAnnotations.initMocks(this);
-
+    when(clientTransportListener.filterTransport(any()))
+        .thenAnswer(i -> i.getArgument(0, Attributes.class));
     transport =
         new CronetClientTransport(
             streamFactory,
@@ -85,7 +92,7 @@ public void setUp() {
             false,
             false);
     Runnable callback = transport.start(clientTransportListener);
-    assertTrue(callback != null);
+    assertNotNull(callback);
     callback.run();
     verify(clientTransportListener).transportReady();
   }
@@ -101,9 +108,9 @@ public void transportAttributes() {
   @Test
   public void shutdownTransport() throws Exception {
     CronetClientStream stream1 =
-        transport.newStream(descriptor, new Metadata(), CallOptions.DEFAULT);
+        transport.newStream(descriptor, new Metadata(), CallOptions.DEFAULT, tracers);
     CronetClientStream stream2 =
-        transport.newStream(descriptor, new Metadata(), CallOptions.DEFAULT);
+        transport.newStream(descriptor, new Metadata(), CallOptions.DEFAULT, tracers);
 
     // Create a transport and start two streams on it.
     ArgumentCaptor<BidirectionalStream.Callback> callbackCaptor =
@@ -122,7 +129,8 @@ public void shutdownTransport() throws Exception {
     BidirectionalStream.Callback callback2 = callbackCaptor.getValue();
     // Shut down the transport. transportShutdown should be called immediately.
     transport.shutdown();
-    verify(clientTransportListener).transportShutdown(any(Status.class));
+    verify(clientTransportListener).transportShutdown(any(Status.class),
+        any(DisconnectError.class));
     // Have two live streams. Transport has not been terminated.
     verify(clientTransportListener, times(0)).transportTerminated();
 
@@ -137,7 +145,7 @@ public void shutdownTransport() throws Exception {
   @Test
   public void startStreamAfterShutdown() throws Exception {
     CronetClientStream stream =
-        transport.newStream(descriptor, new Metadata(), CallOptions.DEFAULT);
+        transport.newStream(descriptor, new Metadata(), CallOptions.DEFAULT, tracers);
     transport.shutdown();
     BaseClientStreamListener listener = new BaseClientStreamListener();
     stream.start(listener);
@@ -157,9 +165,6 @@ public void onReady() {}
     @Override
     public void headersRead(Metadata headers) {}
 
-    @Override
-    public void closed(Status status, Metadata trailers) {}
-
     @Override
     public void closed(Status status, RpcProgress rpcProgress, Metadata trailers) {
       this.status = status;
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
index d5dad50e0f2..d7b07908d15 100644
--- a/documentation/android-channel-builder.md
+++ b/documentation/android-channel-builder.md
@@ -32,13 +32,8 @@ connection management on Android devices.*
 
 ## Example usage:
 
-In your `build.gradle` file, include a dependency on both `grpc-android` and
-`grpc-okhttp`:
-
-```
-implementation 'io.grpc:grpc-android:1.36.0'
-implementation 'io.grpc:grpc-okhttp:1.36.0'
-```
+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`:
diff --git a/documentation/server-reflection-tutorial.md b/documentation/server-reflection-tutorial.md
index 5fad5a22333..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.services.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
@@ -28,14 +28,14 @@ need to make the following changes:
 +  compile "io.grpc:grpc-services:${grpcVersion}"
    compile "io.grpc:grpc-stub:${grpcVersion}"
  
-   testCompile "junit:junit:4.12"
+   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.services.ProtoReflectionService;
++import io.grpc.protobuf.services.ProtoReflectionServiceV1;
  import io.grpc.stub.StreamObserver;
  import java.io.IOException;
  import java.util.logging.Logger;
@@ -43,7 +43,7 @@ need to make the following changes:
      int port = 50051;
      server = ServerBuilder.forPort(port)
          .addService(new GreeterImpl())
-+        .addService(ProtoReflectionService.newInstance())
++        .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
index e7f00381ad1..e3ef8c5ac5d 100644
--- a/examples/BUILD.bazel
+++ b/examples/BUILD.bazel
@@ -1,5 +1,8 @@
-load("@rules_proto//proto:defs.bzl", "proto_library")
+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",
@@ -51,6 +54,22 @@ java_grpc_library(
     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,
@@ -64,6 +83,9 @@ java_library(
         "@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",
@@ -73,8 +95,13 @@ java_library(
         "@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",
@@ -135,3 +162,119 @@ java_binary(
         ":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..105fcecaafe
--- /dev/null
+++ b/examples/MODULE.bazel
@@ -0,0 +1,32 @@
+bazel_dep(name = "grpc-java", version = "1.82.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 f57ad169897..91fde2c045c 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -23,99 +23,35 @@ before trying out the examples.
 
 - [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)
 
-- <details>
-  <summary>Hedging</summary>
-
-  The [hedging example](src/main/java/io/grpc/examples/hedging) 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
-  ========================
-  ```
-
-</details>
-
-- <details>
-  <summary>Retrying</summary>
-
-  The [retrying example](src/main/java/io/grpc/examples/retrying) provides a HelloWorld gRPC client &
-  server which demos the effect of client retry policy configured on the [ManagedChannel](
-  ../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](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](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](
-  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 below](#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`.
-
-</details>
+- [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
 
@@ -187,6 +123,10 @@ $ bazel-bin/hello-world-client
 
 - [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).
@@ -213,9 +153,9 @@ Example bugs not caught by mocked stub tests include:
 
 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,
diff --git a/examples/WORKSPACE b/examples/WORKSPACE
index 36a002b4ee0..1387cc4cf12 100644
--- a/examples/WORKSPACE
+++ b/examples/WORKSPACE
@@ -1,7 +1,9 @@
 workspace(name = "examples")
 
+load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
+
 # For released versions, use release tag:
-# http_repository(
+# http_archive(
 #     name = "io_grpc_grpc_java",
 #     sha256 = "<SHA>",
 #     strip_prefix = "grpc-java-<TAG>",
@@ -12,39 +14,64 @@ local_repository(
     path = "..",
 )
 
-load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
+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 = "62133c125bf4109dfd9d2af64830208356ce4ef8b165a6ef15bbff7460b35c3a",
-    strip_prefix = "rules_jvm_external-3.0",
-    url = "https://github.com/bazelbuild/rules_jvm_external/archive/3.0.zip",
+    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")
-load("@io_grpc_grpc_java//:repositories.bzl", "IO_GRPC_GRPC_JAVA_ARTIFACTS")
-load("@io_grpc_grpc_java//:repositories.bzl", "IO_GRPC_GRPC_JAVA_OVERRIDE_TARGETS")
 
 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,
-    generate_compat_repositories = True,
+    ] + IO_GRPC_GRPC_JAVA_ARTIFACTS + PROTOBUF_MAVEN_ARTIFACTS,
     override_targets = IO_GRPC_GRPC_JAVA_OVERRIDE_TARGETS,
     repositories = [
         "https://repo.maven.apache.org/maven2/",
     ],
 )
-
-load("@maven//:compat.bzl", "compat_repositories")
-
-compat_repositories()
-
-load("@io_grpc_grpc_java//:repositories.bzl", "grpc_java_repositories")
-
-grpc_java_repositories()
-
-load("@com_google_protobuf//:protobuf_deps.bzl", "protobuf_deps")
-
-protobuf_deps()
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/clientcache/app/build.gradle b/examples/android/clientcache/app/build.gradle
index 1683f8ee180..0219e73ff89 100644
--- a/examples/android/clientcache/app/build.gradle
+++ b/examples/android/clientcache/app/build.gradle
@@ -2,13 +2,16 @@ apply plugin: 'com.android.application'
 apply plugin: 'com.google.protobuf'
 
 android {
-    compileSdkVersion 27
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_8
+        targetCompatibility JavaVersion.VERSION_1_8
+    }
+    compileSdkVersion 34
 
     defaultConfig {
         applicationId "io.grpc.clientcacheexample"
-        minSdkVersion 19
-        targetSdkVersion 27
-        multiDexEnabled true
+        minSdkVersion 23
+        targetSdkVersion 33
         versionCode 1
         versionName "1.0"
         testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
@@ -28,9 +31,9 @@ android {
 }
 
 protobuf {
-    protoc { artifact = 'com.google.protobuf:protoc:3.12.0' }
+    protoc { artifact = 'com.google.protobuf:protoc:3.25.1' }
     plugins {
-        grpc { artifact = 'io.grpc:protoc-gen-grpc-java:1.37.0-SNAPSHOT' // CURRENT_GRPC_VERSION
+        grpc { artifact = 'io.grpc:protoc-gen-grpc-java:1.82.0-SNAPSHOT' // CURRENT_GRPC_VERSION
         }
     }
     generateProtoTasks {
@@ -47,15 +50,14 @@ protobuf {
 }
 
 dependencies {
-    implementation 'com.android.support:appcompat-v7:27.0.2'
+    implementation 'androidx.appcompat:appcompat:1.0.0'
 
     // You need to build grpc-java to obtain these libraries below.
-    implementation 'io.grpc:grpc-okhttp:1.37.0-SNAPSHOT' // CURRENT_GRPC_VERSION
-    implementation 'io.grpc:grpc-protobuf-lite:1.37.0-SNAPSHOT' // CURRENT_GRPC_VERSION
-    implementation 'io.grpc:grpc-stub:1.37.0-SNAPSHOT' // CURRENT_GRPC_VERSION
-    implementation 'org.apache.tomcat:annotations-api:6.0.53'
+    implementation 'io.grpc:grpc-okhttp:1.82.0-SNAPSHOT' // CURRENT_GRPC_VERSION
+    implementation 'io.grpc:grpc-protobuf-lite:1.82.0-SNAPSHOT' // CURRENT_GRPC_VERSION
+    implementation 'io.grpc:grpc-stub:1.82.0-SNAPSHOT' // CURRENT_GRPC_VERSION
 
-    testImplementation 'junit:junit:4.12'
-    testImplementation 'com.google.truth:truth:1.0.1'
-    testImplementation 'io.grpc:grpc-testing:1.37.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.82.0-SNAPSHOT' // CURRENT_GRPC_VERSION
 }
diff --git a/examples/android/clientcache/app/src/main/AndroidManifest.xml b/examples/android/clientcache/app/src/main/AndroidManifest.xml
index 6fc8e940da0..ddf863e9912 100644
--- a/examples/android/clientcache/app/src/main/AndroidManifest.xml
+++ b/examples/android/clientcache/app/src/main/AndroidManifest.xml
@@ -11,7 +11,8 @@
         android:theme="@style/Base.V7.Theme.AppCompat.Light" >
         <activity
             android:name="io.grpc.clientcacheexample.ClientCacheExampleActivity"
-            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/clientcache/app/src/main/java/io/grpc/clientcacheexample/ClientCacheExampleActivity.java b/examples/android/clientcache/app/src/main/java/io/grpc/clientcacheexample/ClientCacheExampleActivity.java
index 232ab6e1807..74b89b7a958 100644
--- 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
@@ -20,7 +20,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.util.Log;
diff --git a/examples/android/clientcache/build.gradle b/examples/android/clientcache/build.gradle
index 5027ad9fc84..6db6a9bced1 100644
--- a/examples/android/clientcache/build.gradle
+++ b/examples/android/clientcache/build.gradle
@@ -3,11 +3,11 @@
 buildscript {
     repositories {
         google()
-        jcenter()
+        mavenCentral()
     }
     dependencies {
-        classpath 'com.android.tools.build:gradle:4.0.0'
-        classpath "com.google.protobuf:protobuf-gradle-plugin:0.8.15"
+        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
@@ -17,9 +17,6 @@ buildscript {
 allprojects {
     repositories {
         google()
-        jcenter()
-        // Some grpc-java releases may be missing in JCenter.
-        // See https://github.com/grpc/grpc-java/issues/5782
         mavenCentral()
         mavenLocal()
     }
diff --git a/examples/android/clientcache/settings.gradle b/examples/android/clientcache/settings.gradle
index e7b4def49cb..6208d70e838 100644
--- a/examples/android/clientcache/settings.gradle
+++ b/examples/android/clientcache/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/helloworld/app/build.gradle b/examples/android/helloworld/app/build.gradle
index d9bd33576dd..1e81415e483 100644
--- a/examples/android/helloworld/app/build.gradle
+++ b/examples/android/helloworld/app/build.gradle
@@ -2,12 +2,16 @@ apply plugin: 'com.android.application'
 apply plugin: 'com.google.protobuf'
 
 android {
-    compileSdkVersion 27
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_8
+        targetCompatibility JavaVersion.VERSION_1_8
+    }
+    compileSdkVersion 34
 
     defaultConfig {
         applicationId "io.grpc.helloworldexample"
-        minSdkVersion 16
-        targetSdkVersion 27
+        minSdkVersion 23
+        targetSdkVersion 33
         versionCode 1
         versionName "1.0"
     }
@@ -26,9 +30,9 @@ android {
 }
 
 protobuf {
-    protoc { artifact = 'com.google.protobuf:protoc:3.12.0' }
+    protoc { artifact = 'com.google.protobuf:protoc:3.25.1' }
     plugins {
-        grpc { artifact = 'io.grpc:protoc-gen-grpc-java:1.37.0-SNAPSHOT' // CURRENT_GRPC_VERSION
+        grpc { artifact = 'io.grpc:protoc-gen-grpc-java:1.82.0-SNAPSHOT' // CURRENT_GRPC_VERSION
         }
     }
     generateProtoTasks {
@@ -45,11 +49,10 @@ protobuf {
 }
 
 dependencies {
-    implementation 'com.android.support:appcompat-v7:27.0.2'
+    implementation 'androidx.appcompat:appcompat:1.0.0'
 
     // You need to build grpc-java to obtain these libraries below.
-    implementation 'io.grpc:grpc-okhttp:1.37.0-SNAPSHOT' // CURRENT_GRPC_VERSION
-    implementation 'io.grpc:grpc-protobuf-lite:1.37.0-SNAPSHOT' // CURRENT_GRPC_VERSION
-    implementation 'io.grpc:grpc-stub:1.37.0-SNAPSHOT' // CURRENT_GRPC_VERSION
-    implementation 'org.apache.tomcat:annotations-api:6.0.53'
+    implementation 'io.grpc:grpc-okhttp:1.82.0-SNAPSHOT' // CURRENT_GRPC_VERSION
+    implementation 'io.grpc:grpc-protobuf-lite:1.82.0-SNAPSHOT' // CURRENT_GRPC_VERSION
+    implementation 'io.grpc:grpc-stub:1.82.0-SNAPSHOT' // CURRENT_GRPC_VERSION
 }
diff --git a/examples/android/helloworld/app/src/main/AndroidManifest.xml b/examples/android/helloworld/app/src/main/AndroidManifest.xml
index eee4057cd0c..0beff2dc840 100644
--- a/examples/android/helloworld/app/src/main/AndroidManifest.xml
+++ b/examples/android/helloworld/app/src/main/AndroidManifest.xml
@@ -11,7 +11,8 @@
         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 28cd488f87b..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
@@ -20,7 +20,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;
@@ -50,6 +50,13 @@ 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);
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 5027ad9fc84..6db6a9bced1 100644
--- a/examples/android/helloworld/build.gradle
+++ b/examples/android/helloworld/build.gradle
@@ -3,11 +3,11 @@
 buildscript {
     repositories {
         google()
-        jcenter()
+        mavenCentral()
     }
     dependencies {
-        classpath 'com.android.tools.build:gradle:4.0.0'
-        classpath "com.google.protobuf:protobuf-gradle-plugin:0.8.15"
+        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
@@ -17,9 +17,6 @@ buildscript {
 allprojects {
     repositories {
         google()
-        jcenter()
-        // Some grpc-java releases may be missing in JCenter.
-        // See https://github.com/grpc/grpc-java/issues/5782
         mavenCentral()
         mavenLocal()
     }
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 768ae136f9d..7152add7858 100644
--- a/examples/android/routeguide/app/build.gradle
+++ b/examples/android/routeguide/app/build.gradle
@@ -2,12 +2,16 @@ apply plugin: 'com.android.application'
 apply plugin: 'com.google.protobuf'
 
 android {
-    compileSdkVersion 27
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_8
+        targetCompatibility JavaVersion.VERSION_1_8
+    }
+    compileSdkVersion 34
 
     defaultConfig {
         applicationId "io.grpc.routeguideexample"
-        minSdkVersion 16
-        targetSdkVersion 27
+        minSdkVersion 23
+        targetSdkVersion 33
         versionCode 1
         versionName "1.0"
     }
@@ -26,9 +30,9 @@ android {
 }
 
 protobuf {
-    protoc { artifact = 'com.google.protobuf:protoc:3.12.0' }
+    protoc { artifact = 'com.google.protobuf:protoc:3.25.1' }
     plugins {
-        grpc { artifact = 'io.grpc:protoc-gen-grpc-java:1.37.0-SNAPSHOT' // CURRENT_GRPC_VERSION
+        grpc { artifact = 'io.grpc:protoc-gen-grpc-java:1.82.0-SNAPSHOT' // CURRENT_GRPC_VERSION
         }
     }
     generateProtoTasks {
@@ -45,11 +49,10 @@ protobuf {
 }
 
 dependencies {
-    implementation 'com.android.support:appcompat-v7:27.0.2'
+    implementation 'androidx.appcompat:appcompat:1.0.0'
 
     // You need to build grpc-java to obtain these libraries below.
-    implementation 'io.grpc:grpc-okhttp:1.37.0-SNAPSHOT' // CURRENT_GRPC_VERSION
-    implementation 'io.grpc:grpc-protobuf-lite:1.37.0-SNAPSHOT' // CURRENT_GRPC_VERSION
-    implementation 'io.grpc:grpc-stub:1.37.0-SNAPSHOT' // CURRENT_GRPC_VERSION
-    implementation 'org.apache.tomcat:annotations-api:6.0.53'
+    implementation 'io.grpc:grpc-okhttp:1.82.0-SNAPSHOT' // CURRENT_GRPC_VERSION
+    implementation 'io.grpc:grpc-protobuf-lite:1.82.0-SNAPSHOT' // CURRENT_GRPC_VERSION
+    implementation 'io.grpc:grpc-stub:1.82.0-SNAPSHOT' // CURRENT_GRPC_VERSION
 }
diff --git a/examples/android/routeguide/app/src/main/AndroidManifest.xml b/examples/android/routeguide/app/src/main/AndroidManifest.xml
index f7409758aea..2031166ea2b 100644
--- a/examples/android/routeguide/app/src/main/AndroidManifest.xml
+++ b/examples/android/routeguide/app/src/main/AndroidManifest.xml
@@ -10,7 +10,8 @@
         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 f892057fe00..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
@@ -19,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;
diff --git a/examples/android/routeguide/build.gradle b/examples/android/routeguide/build.gradle
index 287fd748fa2..8fc1d293228 100644
--- a/examples/android/routeguide/build.gradle
+++ b/examples/android/routeguide/build.gradle
@@ -3,11 +3,11 @@
 buildscript {
     repositories {
         google()
-        jcenter()
+        mavenCentral()
     }
     dependencies {
-        classpath 'com.android.tools.build:gradle:4.0.0'
-        classpath "com.google.protobuf:protobuf-gradle-plugin:0.8.15"
+        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
@@ -17,9 +17,6 @@ buildscript {
 allprojects {
     repositories {
         google()
-        jcenter()
-        // Some grpc-java releases may be missing in JCenter.
-        // See https://github.com/grpc/grpc-java/issues/5782
         mavenCentral()
         mavenLocal()
     }
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/app/build.gradle b/examples/android/strictmode/app/build.gradle
index 484600adf8b..cc54d274a29 100644
--- a/examples/android/strictmode/app/build.gradle
+++ b/examples/android/strictmode/app/build.gradle
@@ -2,13 +2,17 @@ apply plugin: 'com.android.application'
 apply plugin: 'com.google.protobuf'
 
 android {
-    compileSdkVersion 28
+    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 28
+        targetSdkVersion 33
         versionCode 1
         versionName "1.0"
     }
@@ -27,9 +31,9 @@ android {
 }
 
 protobuf {
-    protoc { artifact = 'com.google.protobuf:protoc:3.12.0' }
+    protoc { artifact = 'com.google.protobuf:protoc:3.25.1' }
     plugins {
-        grpc { artifact = 'io.grpc:protoc-gen-grpc-java:1.37.0-SNAPSHOT' // CURRENT_GRPC_VERSION
+        grpc { artifact = 'io.grpc:protoc-gen-grpc-java:1.82.0-SNAPSHOT' // CURRENT_GRPC_VERSION
         }
     }
     generateProtoTasks {
@@ -46,11 +50,10 @@ protobuf {
 }
 
 dependencies {
-    implementation 'com.android.support:appcompat-v7:28.0.0'
+    implementation 'androidx.appcompat:appcompat:1.0.0'
 
     // You need to build grpc-java to obtain these libraries below.
-    implementation 'io.grpc:grpc-okhttp:1.37.0-SNAPSHOT' // CURRENT_GRPC_VERSION
-    implementation 'io.grpc:grpc-protobuf-lite:1.37.0-SNAPSHOT' // CURRENT_GRPC_VERSION
-    implementation 'io.grpc:grpc-stub:1.37.0-SNAPSHOT' // CURRENT_GRPC_VERSION
-    implementation 'org.apache.tomcat:annotations-api:6.0.53'
+    implementation 'io.grpc:grpc-okhttp:1.82.0-SNAPSHOT' // CURRENT_GRPC_VERSION
+    implementation 'io.grpc:grpc-protobuf-lite:1.82.0-SNAPSHOT' // CURRENT_GRPC_VERSION
+    implementation 'io.grpc:grpc-stub:1.82.0-SNAPSHOT' // CURRENT_GRPC_VERSION
 }
diff --git a/examples/android/strictmode/app/src/main/AndroidManifest.xml b/examples/android/strictmode/app/src/main/AndroidManifest.xml
index 41c63f0554b..d2ff3b2d077 100644
--- a/examples/android/strictmode/app/src/main/AndroidManifest.xml
+++ b/examples/android/strictmode/app/src/main/AndroidManifest.xml
@@ -11,7 +11,8 @@
         android:theme="@style/Base.V7.Theme.AppCompat.Light" >
         <activity
             android:name=".StrictModeHelloworldActivity"
-            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/strictmode/app/src/main/java/io/grpc/strictmodehelloworldexample/StrictModeHelloworldActivity.java b/examples/android/strictmode/app/src/main/java/io/grpc/strictmodehelloworldexample/StrictModeHelloworldActivity.java
index 64bbf663f32..c9e6675d221 100644
--- 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
@@ -26,7 +26,7 @@
 import android.os.StrictMode.OnVmViolationListener;
 import android.os.StrictMode.VmPolicy;
 import android.os.strictmode.Violation;
-import android.support.v7.app.AppCompatActivity;
+import androidx.appcompat.app.AppCompatActivity;
 import android.text.TextUtils;
 import android.text.method.ScrollingMovementMethod;
 import android.view.View;
diff --git a/examples/android/strictmode/build.gradle b/examples/android/strictmode/build.gradle
index 5027ad9fc84..6db6a9bced1 100644
--- a/examples/android/strictmode/build.gradle
+++ b/examples/android/strictmode/build.gradle
@@ -3,11 +3,11 @@
 buildscript {
     repositories {
         google()
-        jcenter()
+        mavenCentral()
     }
     dependencies {
-        classpath 'com.android.tools.build:gradle:4.0.0'
-        classpath "com.google.protobuf:protobuf-gradle-plugin:0.8.15"
+        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
@@ -17,9 +17,6 @@ buildscript {
 allprojects {
     repositories {
         google()
-        jcenter()
-        // Some grpc-java releases may be missing in JCenter.
-        // See https://github.com/grpc/grpc-java/issues/5782
         mavenCentral()
         mavenLocal()
     }
diff --git a/examples/android/strictmode/settings.gradle b/examples/android/strictmode/settings.gradle
index e7b4def49cb..6208d70e838 100644
--- a/examples/android/strictmode/settings.gradle
+++ b/examples/android/strictmode/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/build.gradle b/examples/build.gradle
index afb26b53d75..0ad62bb9ef0 100644
--- a/examples/build.gradle
+++ b/examples/build.gradle
@@ -1,35 +1,36 @@
 plugins {
     // Provide convenience executables for trying out the examples.
     id 'application'
-    // ASSUMES GRADLE 5.6 OR HIGHER. Use plugin version 0.8.10 with earlier gradle versions
-    id 'com.google.protobuf' version '0.8.15'
+    id 'com.google.protobuf' version '0.9.5'
     // Generate IntelliJ IDEA's .idea & .iml project files
     id 'idea'
 }
 
 repositories {
-    maven { // The google mirror is less flaky than mavenCentral()
-        url "https://maven-central.storage-download.googleapis.com/maven2/" }
     mavenCentral()
     mavenLocal()
 }
 
-sourceCompatibility = 1.7
-targetCompatibility = 1.7
+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.37.0-SNAPSHOT' // CURRENT_GRPC_VERSION
-def protobufVersion = '3.12.0'
+def grpcVersion = '1.82.0-SNAPSHOT' // CURRENT_GRPC_VERSION
+def protobufVersion = '3.25.8'
 def protocVersion = protobufVersion
 
 dependencies {
     implementation "io.grpc:grpc-protobuf:${grpcVersion}"
+    // Even though client-side won't call grpc-services directly, it needs the
+    // dependency to enable the health-aware round_robin implementation
+    implementation "io.grpc:grpc-services:${grpcVersion}"
     implementation "io.grpc:grpc-stub:${grpcVersion}"
-    compileOnly "org.apache.tomcat:annotations-api:6.0.53"
 
     // examples/advanced need this for JsonFormat
     implementation "com.google.protobuf:protobuf-java-util:${protobufVersion}"
@@ -37,8 +38,9 @@ dependencies {
     runtimeOnly "io.grpc:grpc-netty-shaded:${grpcVersion}"
 
     testImplementation "io.grpc:grpc-testing:${grpcVersion}"
-    testImplementation "junit:junit:4.12"
-    testImplementation "org.mockito:mockito-core:3.4.0"
+    testImplementation "io.grpc:grpc-inprocess:${grpcVersion}"
+    testImplementation "junit:junit:4.13.2"
+    testImplementation "org.mockito:mockito-core:4.4.0"
 }
 
 protobuf {
@@ -51,90 +53,71 @@ protobuf {
     }
 }
 
-// Inform IDEs like IntelliJ IDEA, Eclipse or NetBeans about the generated code.
-sourceSets {
-    main {
-        java {
-            srcDirs 'build/generated/source/proto/main/grpc'
-            srcDirs 'build/generated/source/proto/main/java'
-        }
-    }
-}
+// 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 = startScripts.classpath
-}
-
-task routeGuideClient(type: CreateStartScripts) {
-    mainClassName = 'io.grpc.examples.routeguide.RouteGuideClient'
-    applicationName = 'route-guide-client'
-    outputDir = new File(project.buildDir, 'tmp')
-    classpath = startScripts.classpath
-}
-
-task helloWorldServer(type: CreateStartScripts) {
-    mainClassName = 'io.grpc.examples.helloworld.HelloWorldServer'
-    applicationName = 'hello-world-server'
-    outputDir = new File(project.buildDir, 'tmp')
-    classpath = startScripts.classpath
-}
-
-task helloWorldClient(type: CreateStartScripts) {
-    mainClassName = 'io.grpc.examples.helloworld.HelloWorldClient'
-    applicationName = 'hello-world-client'
-    outputDir = new File(project.buildDir, 'tmp')
-    classpath = startScripts.classpath
-}
-
-task retryingHelloWorldServer(type: CreateStartScripts) {
-    mainClassName = 'io.grpc.examples.retrying.RetryingHelloWorldServer'
-    applicationName = 'retrying-hello-world-server'
-    outputDir = new File(project.buildDir, 'tmp')
-    classpath = startScripts.classpath
-}
-
-task retryingHelloWorldClient(type: CreateStartScripts) {
-    mainClassName = 'io.grpc.examples.retrying.RetryingHelloWorldClient'
-    applicationName = 'retrying-hello-world-client'
-    outputDir = new File(project.buildDir, 'tmp')
-    classpath = startScripts.classpath
-}
-
-task hedgingHelloWorldServer(type: CreateStartScripts) {
-    mainClassName = 'io.grpc.examples.hedging.HedgingHelloWorldServer'
-    applicationName = 'hedging-hello-world-server'
-    outputDir = new File(project.buildDir, 'tmp')
-    classpath = startScripts.classpath
-}
-
-task hedgingHelloWorldClient(type: CreateStartScripts) {
-    mainClassName = 'io.grpc.examples.hedging.HedgingHelloWorldClient'
-    applicationName = 'hedging-hello-world-client'
-    outputDir = new File(project.buildDir, 'tmp')
-    classpath = startScripts.classpath
-}
-
-task compressingHelloWorldClient(type: CreateStartScripts) {
-    mainClassName = 'io.grpc.examples.experimental.CompressingHelloWorldClient'
-    applicationName = 'compressing-hello-world-client'
-    outputDir = new File(project.buildDir, 'tmp')
-    classpath = startScripts.classpath
+// 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(hedgingHelloWorldClient)
-    from(hedgingHelloWorldServer)
-    from(retryingHelloWorldClient)
-    from(retryingHelloWorldServer)
-    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
index 0404dcccf81..4d66accfc19 100644
--- a/examples/example-alts/BUILD.bazel
+++ b/examples/example-alts/BUILD.bazel
@@ -1,5 +1,8 @@
-load("@rules_proto//proto:defs.bzl", "proto_library")
+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",
diff --git a/examples/example-alts/example-alts/README.md b/examples/example-alts/README.md
similarity index 100%
rename from examples/example-alts/example-alts/README.md
rename to examples/example-alts/README.md
diff --git a/examples/example-alts/build.gradle b/examples/example-alts/build.gradle
index 5cfea393f9e..3fea622b923 100644
--- a/examples/example-alts/build.gradle
+++ b/examples/example-alts/build.gradle
@@ -1,35 +1,32 @@
 plugins {
     // Provide convenience executables for trying out the examples.
     id 'application'
-    // ASSUMES GRADLE 5.6 OR HIGHER. Use plugin version 0.8.10 with earlier gradle versions
-    id 'com.google.protobuf' version '0.8.15'
+    id 'com.google.protobuf' version '0.9.5'
     // Generate IntelliJ IDEA's .idea & .iml project files
     id 'idea'
 }
 
 repositories {
-    maven { // The google mirror is less flaky than mavenCentral()
-        url "https://maven-central.storage-download.googleapis.com/maven2/"
-    }
     mavenCentral()
     mavenLocal()
 }
 
-sourceCompatibility = 1.7
-targetCompatibility = 1.7
+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.37.0-SNAPSHOT' // CURRENT_GRPC_VERSION
-def protocVersion = '3.12.0'
+def grpcVersion = '1.82.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}"
-    compileOnly "org.apache.tomcat:annotations-api:6.0.53"
 }
 
 protobuf {
@@ -42,35 +39,29 @@ protobuf {
     }
 }
 
-// Inform IDEs like IntelliJ IDEA, Eclipse or NetBeans about the generated code.
-sourceSets {
-    main {
-        java {
-            srcDirs 'build/generated/source/proto/main/grpc'
-            srcDirs 'build/generated/source/proto/main/java'
-        }
-    }
-}
-
 startScripts.enabled = false
 
 
 task helloWorldAltsServer(type: CreateStartScripts) {
-    mainClassName = 'io.grpc.examples.alts.HelloWorldAltsServer'
+    mainClass = 'io.grpc.examples.alts.HelloWorldAltsServer'
     applicationName = 'hello-world-alts-server'
-    outputDir = new File(project.buildDir, 'tmp')
+    outputDir = new File(project.buildDir, 'tmp/scripts/' + name)
     classpath = startScripts.classpath
 }
 
 task helloWorldAltsClient(type: CreateStartScripts) {
-    mainClassName = 'io.grpc.examples.alts.HelloWorldAltsClient'
+    mainClass = 'io.grpc.examples.alts.HelloWorldAltsClient'
     applicationName = 'hello-world-alts-client'
-    outputDir = new File(project.buildDir, 'tmp')
+    outputDir = new File(project.buildDir, 'tmp/scripts/' + name)
     classpath = startScripts.classpath
 }
 
-applicationDistribution.into('bin') {
-    from(helloWorldAltsServer)
-    from(helloWorldAltsClient)
-    fileMode = 0755
+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
index 273558dd9cf..6bd0f0cdc2d 100644
--- a/examples/example-alts/settings.gradle
+++ b/examples/example-alts/settings.gradle
@@ -1,8 +1,19 @@
 pluginManagement {
-    repositories {
-        maven { // The google mirror is less flaky than mavenCentral()
-            url "https://maven-central.storage-download.googleapis.com/maven2/"
+    // 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
index 96351808b25..991ad777309 100644
--- 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
@@ -16,7 +16,8 @@
 
 package io.grpc.examples.alts;
 
-import io.grpc.alts.AltsChannelBuilder;
+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;
@@ -81,7 +82,8 @@ private void parseArgs(String[] args) {
   private void run(String[] args) throws InterruptedException {
     parseArgs(args);
     ExecutorService executor = Executors.newFixedThreadPool(1);
-    ManagedChannel channel = AltsChannelBuilder.forTarget(serverAddress).executor(executor).build();
+    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());
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
index fd662069cfd..6bc5226bf59 100644
--- 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
@@ -16,7 +16,8 @@
 
 package io.grpc.examples.alts;
 
-import io.grpc.alts.AltsServerBuilder;
+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;
@@ -82,7 +83,7 @@ private void parseArgs(String[] args) {
   private void start(String[] args) throws IOException, InterruptedException {
     parseArgs(args);
     server =
-        AltsServerBuilder.forPort(port)
+        Grpc.newServerBuilderForPort(port, AltsServerCredentials.create())
             .addService(this)
             .executor(Executors.newFixedThreadPool(1))
             .build();
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..e4edc0704d0
--- /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.82.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..ccb9977f679
--- /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.82.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.82.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..f79888831dc
--- /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.82.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..99c0da77a22
--- /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.82.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.82.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
index edc4a291e27..033c51f8856 100644
--- a/examples/example-gauth/BUILD.bazel
+++ b/examples/example-gauth/BUILD.bazel
@@ -1,4 +1,5 @@
-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")
 
 java_library(
     name = "example-gauth",
diff --git a/examples/example-gauth/README.md b/examples/example-gauth/README.md
index 622c14cb57b..b49d346a9be 100644
--- a/examples/example-gauth/README.md
+++ b/examples/example-gauth/README.md
@@ -43,13 +43,13 @@ 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).
-Assign the [role](https://cloud.google.com/iam/docs/granting-roles-to-service-accounts) `Project -> Owner`
+(**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`. 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)
-and [the JSON file](https://cloud.google.com/iam/docs/creating-managing-service-account-keys#iam-service-account-keys-create-gcloud).
+`/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
 
@@ -62,19 +62,18 @@ $ ../gradlew installDist
 
 
 #### How to run the example:
-`google-auth-client` requires two command line arguments for the location of the JSON file and the project ID:
+`google-auth-client` requires one command line argument for the project ID:
 
  ```text
-USAGE: GoogleAuthClient <path-to-JSON-file> <project-ID>
+USAGE: GoogleAuthClient <project-ID>
 ```
 
-The first argument <path-to-JSON-file> is the location of the JSON file you created in step 5 above.
-The second argument <project-ID> is the project ID in the form "projects/xyz123" where "xyz123" is
+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 /path/to/JSON/file projects/xyz123
+./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:
 
@@ -93,7 +92,7 @@ the project ID of the project you created (or used) in step 2 above.
  ```
  $ mvn verify
  $ # Run the client
- $ mvn exec:java -Dexec.mainClass=io.grpc.examples.googleAuth.GoogleAuthClient -Dexec.args="/path/to/JSON/file projects/xyz123"
+ $ mvn exec:java -Dexec.mainClass=io.grpc.examples.googleAuth.GoogleAuthClient -Dexec.args="projects/xyz123"
  ```
 
  ## Bazel
@@ -101,5 +100,5 @@ the project ID of the project you created (or used) in step 2 above.
  ```
  $ bazel build :google-auth-client
  $ # Run the client
- $ ../bazel-bin/google-auth-client /path/to/JSON/file projects/xyz123
+ $ ../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
index 11239ecf1c8..5ab563479a4 100644
--- a/examples/example-gauth/build.gradle
+++ b/examples/example-gauth/build.gradle
@@ -1,30 +1,28 @@
 plugins {
     // Provide convenience executables for trying out the examples.
     id 'application'
-    // ASSUMES GRADLE 5.6 OR HIGHER. Use plugin version 0.8.10 with earlier gradle versions
-    id 'com.google.protobuf' version '0.8.15'
+    id 'com.google.protobuf' version '0.9.5'
     // Generate IntelliJ IDEA's .idea & .iml project files
     id 'idea'
 }
 
 repositories {
-    maven { // The google mirror is less flaky than mavenCentral()
-        url "https://maven-central.storage-download.googleapis.com/maven2/"
-    }
     mavenCentral()
     mavenLocal()
 }
 
-sourceCompatibility = 1.7
-targetCompatibility = 1.7
+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.37.0-SNAPSHOT' // CURRENT_GRPC_VERSION
-def protobufVersion = '3.12.0'
+def grpcVersion = '1.82.0-SNAPSHOT' // CURRENT_GRPC_VERSION
+def protobufVersion = '3.25.8'
 def protocVersion = protobufVersion
 
 
@@ -32,8 +30,7 @@ dependencies {
     implementation "io.grpc:grpc-protobuf:${grpcVersion}"
     implementation "io.grpc:grpc-stub:${grpcVersion}"
     implementation "io.grpc:grpc-auth:${grpcVersion}"
-    compileOnly "org.apache.tomcat:annotations-api:6.0.53"
-    implementation "com.google.auth:google-auth-library-oauth2-http:0.9.0"
+    implementation "com.google.auth:google-auth-library-oauth2-http:1.42.1"
     implementation "com.google.api.grpc:grpc-google-cloud-pubsub-v1:0.1.24"
     runtimeOnly "io.grpc:grpc-netty-shaded:${grpcVersion}"
 }
@@ -48,26 +45,20 @@ protobuf {
     }
 }
 
-// Inform IDEs like IntelliJ IDEA, Eclipse or NetBeans about the generated code.
-sourceSets {
-    main {
-        java {
-            srcDirs 'build/generated/source/proto/main/grpc'
-            srcDirs 'build/generated/source/proto/main/java'
-        }
-    }
-}
-
 startScripts.enabled = false
 
 task googleAuthClient(type: CreateStartScripts) {
-    mainClassName = 'io.grpc.examples.googleAuth.GoogleAuthClient'
+    mainClass = 'io.grpc.examples.googleAuth.GoogleAuthClient'
     applicationName = 'google-auth-client'
-    outputDir = new File(project.buildDir, 'tmp')
+    outputDir = new File(project.buildDir, 'tmp/scripts/' + name)
     classpath = startScripts.classpath
 }
 
-applicationDistribution.into('bin') {
-    from(googleAuthClient)
-    fileMode = 0755
+application {
+    applicationDistribution.into('bin') {
+        from(googleAuthClient)
+        filePermissions {
+            unix(0755)
+        }
+    }
 }
diff --git a/examples/example-gauth/pom.xml b/examples/example-gauth/pom.xml
index 1557eacb2ce..66e0f3be563 100644
--- a/examples/example-gauth/pom.xml
+++ b/examples/example-gauth/pom.xml
@@ -6,17 +6,17 @@
   <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.37.0-SNAPSHOT</version><!-- CURRENT_GRPC_VERSION -->
+  <version>1.82.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.37.0-SNAPSHOT</grpc.version><!-- CURRENT_GRPC_VERSION -->
-    <protobuf.version>3.12.0</protobuf.version>
+    <grpc.version>1.82.0-SNAPSHOT</grpc.version><!-- CURRENT_GRPC_VERSION -->
+    <protobuf.version>3.25.8</protobuf.version>
     <!-- required for jdk9 -->
-    <maven.compiler.source>1.7</maven.compiler.source>
-    <maven.compiler.target>1.7</maven.compiler.target>
+    <maven.compiler.source>1.8</maven.compiler.source>
+    <maven.compiler.target>1.8</maven.compiler.target>
   </properties>
 
   <dependencyManagement>
@@ -28,6 +28,11 @@
         <type>pom</type>
         <scope>import</scope>
       </dependency>
+      <dependency><!-- upgrade version from google-auth-library-oauth2-http -->
+        <groupId>com.google.code.gson</groupId>
+        <artifactId>gson</artifactId>
+        <version>2.13.2</version>
+      </dependency>
     </dependencies>
   </dependencyManagement>
 
@@ -49,17 +54,6 @@
       <groupId>io.grpc</groupId>
       <artifactId>grpc-auth</artifactId>
     </dependency>
-    <dependency>
-      <groupId>com.google.protobuf</groupId>
-      <artifactId>protobuf-java-util</artifactId>
-      <version>${protobuf.version}</version>
-    </dependency>
-    <dependency>
-      <groupId>org.apache.tomcat</groupId>
-      <artifactId>annotations-api</artifactId>
-      <version>6.0.53</version>
-      <scope>provided</scope> <!-- not needed at runtime -->
-    </dependency>
     <dependency>
       <groupId>io.grpc</groupId>
       <artifactId>grpc-testing</artifactId>
@@ -68,7 +62,7 @@
     <dependency>
       <groupId>com.google.auth</groupId>
       <artifactId>google-auth-library-oauth2-http</artifactId>
-      <version>0.9.0</version>
+      <version>1.40.0</version>
     </dependency>
     <dependency>
       <groupId>com.google.api.grpc</groupId>
@@ -78,13 +72,13 @@
     <dependency>
       <groupId>junit</groupId>
       <artifactId>junit</artifactId>
-      <version>4.12</version>
+      <version>4.13.2</version>
       <scope>test</scope>
     </dependency>
     <dependency>
       <groupId>org.mockito</groupId>
       <artifactId>mockito-core</artifactId>
-      <version>3.4.0</version>
+      <version>4.4.0</version>
       <scope>test</scope>
     </dependency>
   </dependencies>
@@ -94,14 +88,14 @@
       <extension>
         <groupId>kr.motd.maven</groupId>
         <artifactId>os-maven-plugin</artifactId>
-        <version>1.6.2</version>
+        <version>1.7.1</version>
       </extension>
     </extensions>
     <plugins>
       <plugin>
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-enforcer-plugin</artifactId>
-        <version>1.4.1</version>
+        <version>3.5.0</version>
         <executions>
           <execution>
             <id>enforce</id>
diff --git a/examples/example-gauth/settings.gradle b/examples/example-gauth/settings.gradle
index 273558dd9cf..6bd0f0cdc2d 100644
--- a/examples/example-gauth/settings.gradle
+++ b/examples/example-gauth/settings.gradle
@@ -1,8 +1,19 @@
 pluginManagement {
-    repositories {
-        maven { // The google mirror is less flaky than mavenCentral()
-            url "https://maven-central.storage-download.googleapis.com/maven2/"
+    // 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
index 4d3dd044376..eb0d9feedfc 100644
--- 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
@@ -33,7 +33,7 @@
 
 /**
  * Example to illustrate use of Google credentials as described in
- * @see <a href="../../../../../../GOOGLE_AUTH_EXAMPLE.md">Google Auth Example README</a>
+ * @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>
  */
@@ -52,7 +52,7 @@ public class GoogleAuthClient {
    *
    * @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 created from a JSON file
+   * @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)
@@ -63,7 +63,7 @@ public GoogleAuthClient(String host, int port, CallCredentials 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 created from a JSON file
+   * @param callCredentials  the Google call credentials
    */
   GoogleAuthClient(ManagedChannel channel, CallCredentials callCredentials) {
     this.channel = channel;
@@ -101,32 +101,30 @@ public void getTopics(String projectID) {
 
   /**
    * The app requires 2 arguments as described in
-   * @see <a href="../../../../../../GOOGLE_AUTH_EXAMPLE.md">Google Auth Example README</a>
+   * @see <a href="../../../../../../README.md">Google Auth Example README</a>
    *
-   * arg0 = location of the JSON file for the service account you created in the GCP console
-   * arg1 = project name in the form "projects/balmy-cirrus-225307" where "balmy-cirrus-225307" is
+   * 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 < 2) {
-      logger.severe("Usage: please pass 2 arguments:\n" +
-                    "arg0 = location of the JSON file for the service account you created in the GCP console\n" +
-                    "arg1 = project name in the form \"projects/xyz\" where \"xyz\" is the project ID of the project you created.\n");
+    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.fromStream(new FileInputStream(args[0]));
+    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"));
 
-    // credentials must be refreshed before the access token is available
-    credentials.refreshAccessToken();
     GoogleAuthClient client =
             new GoogleAuthClient("pubsub.googleapis.com", 443, MoreCallCredentials.from(credentials));
 
     try {
-      client.getTopics(args[1]);
+      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..2ddfd995cd3
--- /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.82.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..531a5c2f9de
--- /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.82.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
index 8b76f790983..d5bd3aba94c 100644
--- a/examples/example-hostname/BUILD.bazel
+++ b/examples/example-hostname/BUILD.bazel
@@ -1,5 +1,8 @@
-load("@rules_proto//proto:defs.bzl", "proto_library")
+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",
diff --git a/examples/example-hostname/README.md b/examples/example-hostname/README.md
index 9d47c12445f..8794937d280 100644
--- a/examples/example-hostname/README.md
+++ b/examples/example-hostname/README.md
@@ -24,7 +24,7 @@ runs the example.
 To run the hostname example, run:
 
 ```
-$ ./build/install/hostname/bin/hostname-server
+$ ./build/install/hostname-server/bin/hostname-server
 ```
 
 And in a different terminal window run the hello-world client:
diff --git a/examples/example-hostname/build.gradle b/examples/example-hostname/build.gradle
index b7ac008c617..f776de41511 100644
--- a/examples/example-hostname/build.gradle
+++ b/examples/example-hostname/build.gradle
@@ -2,37 +2,37 @@ plugins {
     id 'application' // Provide convenience executables for trying out the examples.
     id 'java'
 
-    id "com.google.protobuf" version "0.8.15"
-    id 'com.google.cloud.tools.jib' version '2.7.0' // For releasing to Docker Hub
+    id "com.google.protobuf" version "0.9.5"
+    id 'com.google.cloud.tools.jib' version '3.4.4' // For releasing to Docker Hub
 }
 
 repositories {
-    maven { // The google mirror is less flaky than mavenCentral()
-        url "https://maven-central.storage-download.googleapis.com/maven2/" }
     mavenCentral()
     mavenLocal()
 }
 
-sourceCompatibility = 1.7
-targetCompatibility = 1.7
+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.37.0-SNAPSHOT' // CURRENT_GRPC_VERSION
-def protobufVersion = '3.12.0'
+def grpcVersion = '1.82.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}"
-    compileOnly "org.apache.tomcat:annotations-api:6.0.53"
     runtimeOnly "io.grpc:grpc-netty-shaded:${grpcVersion}"
 
-    testImplementation 'junit:junit:4.12'
+    testImplementation 'junit:junit:4.13.2'
     testImplementation "io.grpc:grpc-testing:${grpcVersion}"
+    testImplementation "io.grpc:grpc-inprocess:${grpcVersion}"
 }
 
 protobuf {
@@ -56,6 +56,7 @@ 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'
diff --git a/examples/example-hostname/pom.xml b/examples/example-hostname/pom.xml
index f9d2c683583..8a3c231e3eb 100644
--- a/examples/example-hostname/pom.xml
+++ b/examples/example-hostname/pom.xml
@@ -6,17 +6,17 @@
   <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.37.0-SNAPSHOT</version><!-- CURRENT_GRPC_VERSION -->
+  <version>1.82.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.37.0-SNAPSHOT</grpc.version><!-- CURRENT_GRPC_VERSION -->
-    <protoc.version>3.12.0</protoc.version>
+    <grpc.version>1.82.0-SNAPSHOT</grpc.version><!-- CURRENT_GRPC_VERSION -->
+    <protoc.version>3.25.8</protoc.version>
     <!-- required for jdk9 -->
-    <maven.compiler.source>1.7</maven.compiler.source>
-    <maven.compiler.target>1.7</maven.compiler.target>
+    <maven.compiler.source>1.8</maven.compiler.source>
+    <maven.compiler.target>1.8</maven.compiler.target>
   </properties>
 
   <dependencyManagement>
@@ -34,21 +34,15 @@
   <dependencies>
     <dependency>
       <groupId>io.grpc</groupId>
-      <artifactId>grpc-protobuf</artifactId>
+      <artifactId>grpc-services</artifactId>
     </dependency>
     <dependency>
       <groupId>io.grpc</groupId>
-      <artifactId>grpc-stub</artifactId>
+      <artifactId>grpc-protobuf</artifactId>
     </dependency>
     <dependency>
       <groupId>io.grpc</groupId>
-      <artifactId>grpc-services</artifactId>
-    </dependency>
-    <dependency>
-      <groupId>org.apache.tomcat</groupId>
-      <artifactId>annotations-api</artifactId>
-      <version>6.0.53</version>
-      <scope>provided</scope> <!-- not needed at runtime -->
+      <artifactId>grpc-stub</artifactId>
     </dependency>
     <dependency>
       <groupId>io.grpc</groupId>
@@ -58,7 +52,7 @@
     <dependency>
       <groupId>junit</groupId>
       <artifactId>junit</artifactId>
-      <version>4.12</version>
+      <version>4.13.2</version>
       <scope>test</scope>
     </dependency>
     <dependency>
@@ -73,7 +67,7 @@
       <extension>
         <groupId>kr.motd.maven</groupId>
         <artifactId>os-maven-plugin</artifactId>
-        <version>1.6.2</version>
+        <version>1.7.1</version>
       </extension>
     </extensions>
     <plugins>
@@ -98,7 +92,7 @@
       <plugin>
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-enforcer-plugin</artifactId>
-        <version>1.4.1</version>
+        <version>3.5.0</version>
         <executions>
           <execution>
             <id>enforce</id>
diff --git a/examples/example-hostname/settings.gradle b/examples/example-hostname/settings.gradle
index aa159eb0946..5bd641b3fc1 100644
--- a/examples/example-hostname/settings.gradle
+++ b/examples/example-hostname/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")
+        }
+    }
+}
+
 rootProject.name = 'hostname'
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
index a6f2175914e..7baa2d4733d 100644
--- 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
@@ -16,10 +16,12 @@
 
 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.ProtoReflectionService;
+import io.grpc.protobuf.services.ProtoReflectionServiceV1;
 import io.grpc.services.HealthStatusManager;
 import java.io.IOException;
 import java.util.concurrent.TimeUnit;
@@ -49,9 +51,9 @@ public static void main(String[] args) throws IOException, InterruptedException
       hostname = args[1];
     }
     HealthStatusManager health = new HealthStatusManager();
-    final Server server = ServerBuilder.forPort(port)
+    final Server server = Grpc.newServerBuilderForPort(port, InsecureServerCredentials.create())
         .addService(new HostnameGreeter(hostname))
-        .addService(ProtoReflectionService.newInstance())
+        .addService(ProtoReflectionServiceV1.newInstance())
         .addService(health.getHealthService())
         .build()
         .start();
@@ -62,17 +64,17 @@ 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);
-          }
+          // Wait up to 30 seconds for RPCs to complete processing.
+          server.awaitTermination(30, TimeUnit.SECONDS);
         } catch (InterruptedException ex) {
-          server.shutdownNow();
+          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
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
index 5420678d036..4165064b4b1 100644
--- 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
@@ -62,7 +62,7 @@ public void sayHello_dynamicHostname() throws Exception {
         InProcessServerBuilder.forName("hostname")
           .directExecutor().addService(new HostnameGreeter(null)).build().start());
 
-    // Just verifing the service doesn't crash
+    // 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/build.gradle b/examples/example-jwt-auth/build.gradle
index ab18ee9fbb6..36e6f08b3cc 100644
--- a/examples/example-jwt-auth/build.gradle
+++ b/examples/example-jwt-auth/build.gradle
@@ -1,29 +1,28 @@
 plugins {
     // Provide convenience executables for trying out the examples.
     id 'application'
-    // ASSUMES GRADLE 5.6 OR HIGHER. Use plugin version 0.8.10 with earlier gradle versions
-    id 'com.google.protobuf' version '0.8.15'
+    id 'com.google.protobuf' version '0.9.5'
     // Generate IntelliJ IDEA's .idea & .iml project files
     id 'idea'
 }
 
 repositories {
-    maven { // The google mirror is less flaky than mavenCentral()
-        url "https://maven-central.storage-download.googleapis.com/maven2/"
-    }
+    mavenCentral()
     mavenLocal()
 }
 
-sourceCompatibility = 1.7
-targetCompatibility = 1.7
+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.37.0-SNAPSHOT' // CURRENT_GRPC_VERSION
-def protobufVersion = '3.12.0'
+def grpcVersion = '1.82.0-SNAPSHOT' // CURRENT_GRPC_VERSION
+def protobufVersion = '3.25.8'
 def protocVersion = protobufVersion
 
 dependencies {
@@ -32,13 +31,12 @@ dependencies {
     implementation "io.jsonwebtoken:jjwt:0.9.1"
     implementation "javax.xml.bind:jaxb-api:2.3.1"
 
-    compileOnly "org.apache.tomcat:annotations-api:6.0.53"
-
     runtimeOnly "io.grpc:grpc-netty-shaded:${grpcVersion}"
 
     testImplementation "io.grpc:grpc-testing:${grpcVersion}"
-    testImplementation "junit:junit:4.12"
-    testImplementation "org.mockito:mockito-core:3.4.0"
+    testImplementation "io.grpc:grpc-inprocess:${grpcVersion}"
+    testImplementation "junit:junit:4.13.2"
+    testImplementation "org.mockito:mockito-core:4.4.0"
 }
 
 protobuf {
@@ -51,34 +49,28 @@ protobuf {
     }
 }
 
-// Inform IDEs like IntelliJ IDEA, Eclipse or NetBeans about the generated code.
-sourceSets {
-    main {
-        java {
-            srcDirs 'build/generated/source/proto/main/grpc'
-            srcDirs 'build/generated/source/proto/main/java'
-        }
-    }
-}
-
 startScripts.enabled = false
 
 task hellowWorldJwtAuthServer(type: CreateStartScripts) {
-    mainClassName = 'io.grpc.examples.jwtauth.AuthServer'
+    mainClass = 'io.grpc.examples.jwtauth.AuthServer'
     applicationName = 'auth-server'
-    outputDir = new File(project.buildDir, 'tmp')
+    outputDir = new File(project.buildDir, 'tmp/scripts/' + name)
     classpath = startScripts.classpath
 }
 
 task hellowWorldJwtAuthClient(type: CreateStartScripts) {
-    mainClassName = 'io.grpc.examples.jwtauth.AuthClient'
+    mainClass = 'io.grpc.examples.jwtauth.AuthClient'
     applicationName = 'auth-client'
-    outputDir = new File(project.buildDir, 'tmp')
+    outputDir = new File(project.buildDir, 'tmp/scripts/' + name)
     classpath = startScripts.classpath
 }
 
-applicationDistribution.into('bin') {
-    from(hellowWorldJwtAuthServer)
-    from(hellowWorldJwtAuthClient)
-    fileMode = 0755
+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
index 9dcf0088782..2989f61d4a0 100644
--- a/examples/example-jwt-auth/pom.xml
+++ b/examples/example-jwt-auth/pom.xml
@@ -7,18 +7,18 @@
   <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.37.0-SNAPSHOT</version><!-- CURRENT_GRPC_VERSION -->
+  <version>1.82.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.37.0-SNAPSHOT</grpc.version><!-- CURRENT_GRPC_VERSION -->
-    <protobuf.version>3.12.0</protobuf.version>
-    <protoc.version>3.12.0</protoc.version>
+    <grpc.version>1.82.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.7</maven.compiler.source>
-    <maven.compiler.target>1.7</maven.compiler.target>
+    <maven.compiler.source>1.8</maven.compiler.source>
+    <maven.compiler.target>1.8</maven.compiler.target>
   </properties>
 
   <dependencyManagement>
@@ -57,12 +57,6 @@
       <artifactId>jaxb-api</artifactId>
       <version>2.3.1</version>
     </dependency>
-    <dependency>
-      <groupId>org.apache.tomcat</groupId>
-      <artifactId>annotations-api</artifactId>
-      <version>6.0.53</version>
-      <scope>provided</scope> <!-- not needed at runtime -->
-    </dependency>
     <dependency>
       <groupId>io.grpc</groupId>
       <artifactId>grpc-testing</artifactId>
@@ -71,13 +65,13 @@
     <dependency>
       <groupId>junit</groupId>
       <artifactId>junit</artifactId>
-      <version>4.12</version>
+      <version>4.13.2</version>
       <scope>test</scope>
     </dependency>
     <dependency>
       <groupId>org.mockito</groupId>
       <artifactId>mockito-core</artifactId>
-      <version>3.4.0</version>
+      <version>4.4.0</version>
       <scope>test</scope>
     </dependency>
   </dependencies>
@@ -87,14 +81,14 @@
       <extension>
         <groupId>kr.motd.maven</groupId>
         <artifactId>os-maven-plugin</artifactId>
-        <version>1.5.0.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.1</version>
+        <version>0.6.1</version>
         <configuration>
           <protocArtifact>
             com.google.protobuf:protoc:${protoc.version}:exe:${os.detected.classifier}
@@ -116,7 +110,7 @@
       <plugin>
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-enforcer-plugin</artifactId>
-        <version>1.4.1</version>
+        <version>3.5.0</version>
         <executions>
           <execution>
             <id>enforce</id>
diff --git a/examples/example-jwt-auth/settings.gradle b/examples/example-jwt-auth/settings.gradle
index 273558dd9cf..6bd0f0cdc2d 100644
--- a/examples/example-jwt-auth/settings.gradle
+++ b/examples/example-jwt-auth/settings.gradle
@@ -1,8 +1,19 @@
 pluginManagement {
-    repositories {
-        maven { // The google mirror is less flaky than mavenCentral()
-            url "https://maven-central.storage-download.googleapis.com/maven2/"
+    // 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
index f6ea4c57e45..c5769625807 100644
--- 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
@@ -17,8 +17,9 @@
 package io.grpc.examples.jwtauth;
 
 import io.grpc.CallCredentials;
+import io.grpc.Grpc;
+import io.grpc.InsecureChannelCredentials;
 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;
@@ -42,12 +43,9 @@ public class AuthClient {
   AuthClient(CallCredentials callCredentials, String host, int port) {
     this(
         callCredentials,
-        ManagedChannelBuilder
-            .forAddress(host, port)
-            // Channels are secure by default (via SSL/TLS). For this example we disable TLS
-            // to avoid needing certificates, but it is recommended to use a secure channel
-            // while passing credentials.
-            .usePlaintext()
+        // For this example we use plaintext to avoid needing certificates, but it is
+        // recommended to use TlsChannelCredentials.
+        Grpc.newChannelBuilderForAddress(host, port, InsecureChannelCredentials.create())
             .build());
   }
 
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
index 90e7dff1458..208645e4fad 100644
--- 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
@@ -16,8 +16,9 @@
 
 package io.grpc.examples.jwtauth;
 
+import io.grpc.Grpc;
+import io.grpc.InsecureServerCredentials;
 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;
@@ -41,7 +42,7 @@ public AuthServer(int port) {
   }
 
   private void start() throws IOException {
-    server = ServerBuilder.forPort(port)
+    server = Grpc.newServerBuilderForPort(port, InsecureServerCredentials.create())
         .addService(new GreeterImpl())
         .intercept(new JwtServerInterceptor())  // add the JwtServerInterceptor
         .build()
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
index 4975b4a0ab3..bf6243224d2 100644
--- 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
@@ -60,9 +60,4 @@ public void run() {
       }
     });
   }
-
-  @Override
-  public void thisUsesUnstableApi() {
-    // noop
-  }
 }
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..3ad99a51d5d
--- /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.82.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.42.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 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..3d88e732829
--- /dev/null
+++ b/examples/example-oauth/pom.xml
@@ -0,0 +1,134 @@
+<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.82.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.82.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>
+      <dependency><!-- upgrade version from google-auth-library-oauth2-http -->
+        <groupId>com.google.code.gson</groupId>
+        <artifactId>gson</artifactId>
+        <version>2.13.2</version>
+      </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..8515f015c92
--- /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.82.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..65627159c9c
--- /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.82.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..7c54ea281d5
--- /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.82.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..b83d38be5b5
--- /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.82.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
index 3daa305c167..cb46ef5bb30 100644
--- a/examples/example-tls/BUILD.bazel
+++ b/examples/example-tls/BUILD.bazel
@@ -1,5 +1,8 @@
-load("@rules_proto//proto:defs.bzl", "proto_library")
+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",
@@ -25,6 +28,7 @@ java_library(
     ),
     runtime_deps = [
         "@maven//:io_netty_netty_tcnative_boringssl_static",
+        "@maven//:io_netty_netty_tcnative_classes",
     ],
     deps = [
         ":helloworld_java_grpc",
diff --git a/examples/example-tls/build.gradle b/examples/example-tls/build.gradle
index 7b13d94223b..4fe0794d62b 100644
--- a/examples/example-tls/build.gradle
+++ b/examples/example-tls/build.gradle
@@ -1,38 +1,33 @@
 plugins {
     // Provide convenience executables for trying out the examples.
     id 'application'
-    // ASSUMES GRADLE 5.6 OR HIGHER. Use plugin version 0.8.10 with earlier gradle versions
-    id 'com.google.protobuf' version '0.8.15'
+    id 'com.google.protobuf' version '0.9.5'
     // Generate IntelliJ IDEA's .idea & .iml project files
     id 'idea'
 }
 
 repositories {
-    maven { // The google mirror is less flaky than mavenCentral()
-        url "https://maven-central.storage-download.googleapis.com/maven2/"
-    }
     mavenCentral()
     mavenLocal()
 }
 
-sourceCompatibility = 1.7
-targetCompatibility = 1.7
+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.37.0-SNAPSHOT' // CURRENT_GRPC_VERSION
-def nettyTcNativeVersion = '2.0.34.Final'
-def protocVersion = '3.12.0'
+def grpcVersion = '1.82.0-SNAPSHOT' // CURRENT_GRPC_VERSION
+def protocVersion = '3.25.8'
 
 dependencies {
-    implementation "io.grpc:grpc-netty:${grpcVersion}"
     implementation "io.grpc:grpc-protobuf:${grpcVersion}"
     implementation "io.grpc:grpc-stub:${grpcVersion}"
-    compileOnly "org.apache.tomcat:annotations-api:6.0.53"
-    runtimeOnly "io.netty:netty-tcnative-boringssl-static:${nettyTcNativeVersion}"
+    runtimeOnly "io.grpc:grpc-netty-shaded:${grpcVersion}"
 }
 
 protobuf {
@@ -45,34 +40,28 @@ protobuf {
     }
 }
 
-// Inform IDEs like IntelliJ IDEA, Eclipse or NetBeans about the generated code.
-sourceSets {
-    main {
-        java {
-            srcDirs 'build/generated/source/proto/main/grpc'
-            srcDirs 'build/generated/source/proto/main/java'
-        }
-    }
-}
-
 startScripts.enabled = false
 
 task helloWorldTlsServer(type: CreateStartScripts) {
-    mainClassName = 'io.grpc.examples.helloworldtls.HelloWorldServerTls'
+    mainClass = 'io.grpc.examples.helloworldtls.HelloWorldServerTls'
     applicationName = 'hello-world-tls-server'
-    outputDir = new File(project.buildDir, 'tmp')
+    outputDir = new File(project.buildDir, 'tmp/scripts/' + name)
     classpath = startScripts.classpath
 }
 
 task helloWorldTlsClient(type: CreateStartScripts) {
-    mainClassName = 'io.grpc.examples.helloworldtls.HelloWorldClientTls'
+    mainClass = 'io.grpc.examples.helloworldtls.HelloWorldClientTls'
     applicationName = 'hello-world-tls-client'
-    outputDir = new File(project.buildDir, 'tmp')
+    outputDir = new File(project.buildDir, 'tmp/scripts/' + name)
     classpath = startScripts.classpath
 }
 
-applicationDistribution.into('bin') {
-    from(helloWorldTlsServer)
-    from(helloWorldTlsClient)
-    fileMode = 0755
+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
index 7100f199041..dfe611e4fe7 100644
--- a/examples/example-tls/pom.xml
+++ b/examples/example-tls/pom.xml
@@ -6,18 +6,17 @@
   <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.37.0-SNAPSHOT</version><!-- CURRENT_GRPC_VERSION -->
+  <version>1.82.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.37.0-SNAPSHOT</grpc.version><!-- CURRENT_GRPC_VERSION -->
-    <protoc.version>3.12.0</protoc.version>
-    <netty.tcnative.version>2.0.34.Final</netty.tcnative.version>
+    <grpc.version>1.82.0-SNAPSHOT</grpc.version><!-- CURRENT_GRPC_VERSION -->
+    <protoc.version>3.25.8</protoc.version>
     <!-- required for jdk9 -->
-    <maven.compiler.source>1.7</maven.compiler.source>
-    <maven.compiler.target>1.7</maven.compiler.target>
+    <maven.compiler.source>1.8</maven.compiler.source>
+    <maven.compiler.target>1.8</maven.compiler.target>
   </properties>
 
   <dependencyManagement>
@@ -41,21 +40,9 @@
       <groupId>io.grpc</groupId>
       <artifactId>grpc-stub</artifactId>
     </dependency>
-    <dependency>
-      <groupId>org.apache.tomcat</groupId>
-      <artifactId>annotations-api</artifactId>
-      <version>6.0.53</version>
-      <scope>provided</scope> <!-- not needed at runtime -->
-    </dependency>
     <dependency>
       <groupId>io.grpc</groupId>
-      <artifactId>grpc-netty</artifactId>
-    </dependency>
-    <dependency>
-      <groupId>io.netty</groupId>
-      <artifactId>netty-tcnative-boringssl-static</artifactId>
-      <version>${netty.tcnative.version}</version>
-      <scope>runtime</scope>
+      <artifactId>grpc-netty-shaded</artifactId>
     </dependency>
   </dependencies>
 
@@ -64,7 +51,7 @@
       <extension>
         <groupId>kr.motd.maven</groupId>
         <artifactId>os-maven-plugin</artifactId>
-        <version>1.6.2</version>
+        <version>1.7.1</version>
       </extension>
     </extensions>
     <plugins>
@@ -89,7 +76,7 @@
       <plugin>
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-enforcer-plugin</artifactId>
-        <version>1.4.1</version>
+        <version>3.5.0</version>
         <executions>
           <execution>
             <id>enforce</id>
diff --git a/examples/example-tls/settings.gradle b/examples/example-tls/settings.gradle
index 273558dd9cf..6bd0f0cdc2d 100644
--- a/examples/example-tls/settings.gradle
+++ b/examples/example-tls/settings.gradle
@@ -1,8 +1,19 @@
 pluginManagement {
-    repositories {
-        maven { // The google mirror is less flaky than mavenCentral()
-            url "https://maven-central.storage-download.googleapis.com/maven2/"
+    // 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
index 2306156fcb9..4ff7e23a299 100644
--- 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
@@ -16,20 +16,18 @@
 
 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 io.grpc.netty.GrpcSslContexts;
-import io.grpc.netty.NettyChannelBuilder;
-import io.netty.handler.ssl.SslContext;
-import io.netty.handler.ssl.SslContextBuilder;
 import java.io.File;
 import java.util.concurrent.TimeUnit;
 import java.util.logging.Level;
 import java.util.logging.Logger;
-import javax.net.ssl.SSLException;
 
 /**
  * A simple client that requests a greeting from the {@link HelloWorldServerTls} with TLS.
@@ -37,47 +35,15 @@
 public class HelloWorldClientTls {
     private static final Logger logger = Logger.getLogger(HelloWorldClientTls.class.getName());
 
-    private final ManagedChannel channel;
     private final GreeterGrpc.GreeterBlockingStub blockingStub;
 
-    private static SslContext buildSslContext(String trustCertCollectionFilePath,
-                                              String clientCertChainFilePath,
-                                              String clientPrivateKeyFilePath) throws SSLException {
-        SslContextBuilder builder = GrpcSslContexts.forClient();
-        if (trustCertCollectionFilePath != null) {
-            builder.trustManager(new File(trustCertCollectionFilePath));
-        }
-        if (clientCertChainFilePath != null && clientPrivateKeyFilePath != null) {
-            builder.keyManager(new File(clientCertChainFilePath), new File(clientPrivateKeyFilePath));
-        }
-        return builder.build();
-    }
-
-    /**
-     * Construct client connecting to HelloWorld server at {@code host:port}.
-     */
-    public HelloWorldClientTls(String host,
-                               int port,
-                               SslContext sslContext) throws SSLException {
-
-        this(NettyChannelBuilder.forAddress(host, port)
-                .overrideAuthority("foo.test.google.fr")  /* Only for using provided test certs. */
-                .sslContext(sslContext)
-                .build());
-    }
-
     /**
      * Construct client for accessing RouteGuide server using the existing channel.
      */
-    HelloWorldClientTls(ManagedChannel channel) {
-        this.channel = channel;
+    public HelloWorldClientTls(Channel channel) {
         blockingStub = GreeterGrpc.newBlockingStub(channel);
     }
 
-    public void shutdown() throws InterruptedException {
-        channel.shutdown().awaitTermination(5, TimeUnit.SECONDS);
-    }
-
     /**
      * Say hello to server.
      */
@@ -107,26 +73,29 @@ public static void main(String[] args) throws Exception {
             System.exit(0);
         }
 
-        HelloWorldClientTls client;
+        // 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 2:
-                /* Use default CA. Only for real server certificates. */
-                client = new HelloWorldClientTls(args[0], Integer.parseInt(args[1]),
-                        buildSslContext(null, null, null));
-                break;
+            case 5:
+                tlsBuilder.keyManager(new File(args[3]), new File(args[4]));
+                // fallthrough
             case 3:
-                client = new HelloWorldClientTls(args[0], Integer.parseInt(args[1]),
-                        buildSslContext(args[2], null, null));
-                break;
+                tlsBuilder.trustManager(new File(args[2]));
+                // fallthrough
             default:
-                client = new HelloWorldClientTls(args[0], Integer.parseInt(args[1]),
-                        buildSslContext(args[2], args[3], args[4]));
         }
-
+        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 {
-            client.greet(args[0]);
+            HelloWorldClientTls client = new HelloWorldClientTls(channel);
+            client.greet(host);
         } finally {
-            client.shutdown();
+            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
index 4f8a59abc08..83ac012cc99 100644
--- 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
@@ -16,19 +16,16 @@
 
 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.netty.GrpcSslContexts;
-import io.grpc.netty.NettyServerBuilder;
 import io.grpc.stub.StreamObserver;
-import io.netty.handler.ssl.ClientAuth;
-import io.netty.handler.ssl.SslContextBuilder;
-
 import java.io.File;
 import java.io.IOException;
-import java.net.InetSocketAddress;
 import java.util.logging.Logger;
 
 /**
@@ -40,34 +37,16 @@ public class HelloWorldServerTls {
     private Server server;
 
     private final int port;
-    private final String certChainFilePath;
-    private final String privateKeyFilePath;
-    private final String trustCertCollectionFilePath;
+    private final ServerCredentials creds;
 
-    public HelloWorldServerTls(int port,
-                               String certChainFilePath,
-                               String privateKeyFilePath,
-                               String trustCertCollectionFilePath) {
+    public HelloWorldServerTls(int port, ServerCredentials creds) {
         this.port = port;
-        this.certChainFilePath = certChainFilePath;
-        this.privateKeyFilePath = privateKeyFilePath;
-        this.trustCertCollectionFilePath = trustCertCollectionFilePath;
-    }
-
-    private SslContextBuilder getSslContextBuilder() {
-        SslContextBuilder sslClientContextBuilder = SslContextBuilder.forServer(new File(certChainFilePath),
-                new File(privateKeyFilePath));
-        if (trustCertCollectionFilePath != null) {
-            sslClientContextBuilder.trustManager(new File(trustCertCollectionFilePath));
-            sslClientContextBuilder.clientAuth(ClientAuth.REQUIRE);
-        }
-        return GrpcSslContexts.configure(sslClientContextBuilder);
+        this.creds = creds;
     }
 
     private void start() throws IOException {
-        server = NettyServerBuilder.forPort(port)
+        server = Grpc.newServerBuilderForPort(port, creds)
                 .addService(new GreeterImpl())
-                .sslContext(getSslContextBuilder().build())
                 .build()
                 .start();
         logger.info("Server started, listening on " + port);
@@ -110,11 +89,16 @@ public static void main(String[] args) throws IOException, InterruptedException
             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]),
-                args[1],
-                args[2],
-                args.length == 4 ? args[3] : null);
+                Integer.parseInt(args[0]), tlsBuilder.build());
         server.start();
         server.blockUntilShutdown();
     }
diff --git a/examples/example-xds/build.gradle b/examples/example-xds/build.gradle
index 4449ec2ce2b..1974c86798e 100644
--- a/examples/example-xds/build.gradle
+++ b/examples/example-xds/build.gradle
@@ -1,37 +1,34 @@
 plugins {
     id 'application' // Provide convenience executables for trying out the examples.
-    // ASSUMES GRADLE 5.6 OR HIGHER. Use plugin version 0.8.10 with earlier gradle versions
-    id 'com.google.protobuf' version '0.8.15'
+    id 'com.google.protobuf' version '0.9.5'
     // Generate IntelliJ IDEA's .idea & .iml project files
     id 'idea'
     id 'java'
 }
 
 repositories {
-    maven { // The google mirror is less flaky than mavenCentral()
-        url "https://maven-central.storage-download.googleapis.com/maven2/" }
     mavenCentral()
     mavenLocal()
 }
 
-sourceCompatibility = 1.7
-targetCompatibility = 1.7
+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.37.0-SNAPSHOT' // CURRENT_GRPC_VERSION
-def nettyTcNativeVersion = '2.0.31.Final'
-def protocVersion = '3.12.0'
+def grpcVersion = '1.82.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}"
-    compileOnly "org.apache.tomcat:annotations-api:6.0.53"
 
     runtimeOnly "io.grpc:grpc-netty-shaded:${grpcVersion}"
 }
@@ -49,21 +46,25 @@ protobuf {
 startScripts.enabled = false
 
 task xdsHelloWorldClient(type: CreateStartScripts) {
-    mainClassName = 'io.grpc.examples.helloworldxds.XdsHelloWorldClient'
+    mainClass = 'io.grpc.examples.helloworldxds.XdsHelloWorldClient'
     applicationName = 'xds-hello-world-client'
-    outputDir = new File(project.buildDir, 'tmp')
+    outputDir = new File(project.buildDir, 'tmp/scripts/' + name)
     classpath = startScripts.classpath
 }
 
 task xdsHelloWorldServer(type: CreateStartScripts) {
-    mainClassName = 'io.grpc.examples.helloworldxds.XdsHelloWorldServer'
+    mainClass = 'io.grpc.examples.helloworldxds.XdsHelloWorldServer'
     applicationName = 'xds-hello-world-server'
-    outputDir = new File(project.buildDir, 'tmp')
+    outputDir = new File(project.buildDir, 'tmp/scripts/' + name)
     classpath = startScripts.classpath
 }
 
-applicationDistribution.into('bin') {
-    from(xdsHelloWorldClient)
-    from(xdsHelloWorldServer)
-    fileMode = 0755
+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
index 9f46a95b6f5..4197fa6760d 100644
--- a/examples/example-xds/settings.gradle
+++ b/examples/example-xds/settings.gradle
@@ -1,3 +1,17 @@
-rootProject.name = 'example-xds'
+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")
+        }
+    }
+}
 
-includeBuild '..'
+rootProject.name = 'example-xds'
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
index 93317dda23e..c7c67f8d681 100644
--- 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
@@ -20,7 +20,7 @@
 import io.grpc.Server;
 import io.grpc.ServerCredentials;
 import io.grpc.health.v1.HealthCheckResponse.ServingStatus;
-import io.grpc.protobuf.services.ProtoReflectionService;
+import io.grpc.protobuf.services.ProtoReflectionServiceV1;
 import io.grpc.services.HealthStatusManager;
 import io.grpc.xds.XdsServerBuilder;
 import io.grpc.xds.XdsServerCredentials;
@@ -66,7 +66,7 @@ public static void main(String[] args) throws IOException, InterruptedException
     final HealthStatusManager health = new HealthStatusManager();
     final Server server = XdsServerBuilder.forPort(port, credentials)
         .addService(new HostnameGreeter(hostname))
-        .addService(ProtoReflectionService.newInstance()) // convenient for command line tools
+        .addService(ProtoReflectionServiceV1.newInstance()) // convenient for command line tools
         .addService(health.getHealthService()) // allow management servers to monitor health
         .build()
         .start();
diff --git a/examples/gradle/wrapper/gradle-wrapper.properties b/examples/gradle/wrapper/gradle-wrapper.properties
index 4d9ca164914..1e2fbf0d458 100644
--- a/examples/gradle/wrapper/gradle-wrapper.properties
+++ b/examples/gradle/wrapper/gradle-wrapper.properties
@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-6.7.1-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.10.2-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
diff --git a/examples/gradlew b/examples/gradlew
index cccdd3d517f..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 () {
     echo "$*"
-}
+} >&2
 
 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,84 +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
-save () {
-    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
-    echo " "
-}
-APP_ARGS=$(save "$@")
-
-# 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 722c563933f..943182b60fe 100644
--- a/examples/pom.xml
+++ b/examples/pom.xml
@@ -6,18 +6,18 @@
   <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.37.0-SNAPSHOT</version><!-- CURRENT_GRPC_VERSION -->
+  <version>1.82.0-SNAPSHOT</version><!-- CURRENT_GRPC_VERSION -->
   <name>examples</name>
   <url>https://github.com/grpc/grpc-java</url>
 
   <properties>
     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
-    <grpc.version>1.37.0-SNAPSHOT</grpc.version><!-- CURRENT_GRPC_VERSION -->
-    <protobuf.version>3.12.0</protobuf.version>
-    <protoc.version>3.12.0</protoc.version>
-    <!-- required for jdk9 -->
-    <maven.compiler.source>1.7</maven.compiler.source>
-    <maven.compiler.target>1.7</maven.compiler.target>
+    <grpc.version>1.82.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>
@@ -33,6 +33,10 @@
   </dependencyManagement>
 
   <dependencies>
+    <dependency>
+      <groupId>io.grpc</groupId>
+      <artifactId>grpc-services</artifactId>
+    </dependency>
     <dependency>
       <groupId>io.grpc</groupId>
       <artifactId>grpc-netty-shaded</artifactId>
@@ -51,11 +55,10 @@
       <artifactId>protobuf-java-util</artifactId>
       <version>${protobuf.version}</version>
     </dependency>
-    <dependency>
-      <groupId>org.apache.tomcat</groupId>
-      <artifactId>annotations-api</artifactId>
-      <version>6.0.53</version>
-      <scope>provided</scope> <!-- not needed at runtime -->
+    <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>
@@ -65,13 +68,13 @@
     <dependency>
       <groupId>junit</groupId>
       <artifactId>junit</artifactId>
-      <version>4.12</version>
+      <version>4.13.2</version>
       <scope>test</scope>
     </dependency>
     <dependency>
       <groupId>org.mockito</groupId>
       <artifactId>mockito-core</artifactId>
-      <version>3.4.0</version>
+      <version>4.4.0</version>
       <scope>test</scope>
     </dependency>
   </dependencies>
@@ -81,7 +84,7 @@
       <extension>
         <groupId>kr.motd.maven</groupId>
         <artifactId>os-maven-plugin</artifactId>
-        <version>1.6.2</version>
+        <version>1.7.1</version>
       </extension>
     </extensions>
     <plugins>
@@ -106,7 +109,7 @@
       <plugin>
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-enforcer-plugin</artifactId>
-        <version>1.4.1</version>
+        <version>3.5.0</version>
         <executions>
           <execution>
             <id>enforce</id>
@@ -121,6 +124,35 @@
           </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 0473750a54f..4d39e8b45ba 100644
--- a/examples/settings.gradle
+++ b/examples/settings.gradle
@@ -1,8 +1,19 @@
 pluginManagement {
-    repositories {
-        maven { // The google mirror is less flaky than mavenCentral()
-            url "https://maven-central.storage-download.googleapis.com/maven2/"
+    // 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/src/main/java/io/grpc/examples/advanced/HelloJsonClient.java b/examples/src/main/java/io/grpc/examples/advanced/HelloJsonClient.java
index 264fe76b7d3..9291e45bafe 100644
--- a/examples/src/main/java/io/grpc/examples/advanced/HelloJsonClient.java
+++ b/examples/src/main/java/io/grpc/examples/advanced/HelloJsonClient.java
@@ -20,8 +20,9 @@
 
 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;
@@ -49,8 +50,7 @@ public final class HelloJsonClient {
 
   /** Construct client connecting to HelloWorld server at {@code host:port}. */
   public HelloJsonClient(String host, int port) {
-    channel = ManagedChannelBuilder.forAddress(host, port)
-        .usePlaintext()
+    channel = Grpc.newChannelBuilderForAddress(host, port, InsecureChannelCredentials.create())
         .build();
     blockingStub = new HelloJsonStub(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 0a656dd52b8..0f4e5d28f16 100644
--- a/examples/src/main/java/io/grpc/examples/advanced/HelloJsonServer.java
+++ b/examples/src/main/java/io/grpc/examples/advanced/HelloJsonServer.java
@@ -19,8 +19,9 @@
 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;
@@ -50,7 +51,7 @@ public class HelloJsonServer {
   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();
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 b743b46b471..b026b6f32dc 100644
--- a/examples/src/main/java/io/grpc/examples/errorhandling/DetailErrorSample.java
+++ b/examples/src/main/java/io/grpc/examples/errorhandling/DetailErrorSample.java
@@ -27,11 +27,12 @@
 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;
@@ -73,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();
@@ -82,8 +84,8 @@ public void sayHello(HelloRequest request, StreamObserver<HelloReply> responseOb
             .asRuntimeException(trailers));
       }
     }).build().start();
-    channel =
-        ManagedChannelBuilder.forAddress("localhost", server.getPort()).usePlaintext().build();
+    channel = Grpc.newChannelBuilderForAddress(
+          "localhost", server.getPort(), InsecureChannelCredentials.create()).build();
 
     blockingCall();
     futureCallDirect();
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 4afd39b08fa..9f86e9ceac8 100644
--- a/examples/src/main/java/io/grpc/examples/errorhandling/ErrorHandlingClient.java
+++ b/examples/src/main/java/io/grpc/examples/errorhandling/ErrorHandlingClient.java
@@ -25,11 +25,12 @@
 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;
@@ -44,7 +45,7 @@
 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 {
@@ -55,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().build();
+    channel = Grpc.newChannelBuilderForAddress(
+        "localhost", server.getPort(), InsecureChannelCredentials.create()).build();
 
     blockingCall();
     futureCallDirect();
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 410b0c7c14c..49e9cb36d53 100644
--- a/examples/src/main/java/io/grpc/examples/experimental/CompressingHelloWorldClient.java
+++ b/examples/src/main/java/io/grpc/examples/experimental/CompressingHelloWorldClient.java
@@ -16,8 +16,9 @@
 
 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;
@@ -42,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()
+    channel = Grpc.newChannelBuilderForAddress(host, port, InsecureChannelCredentials.create())
         .build();
     blockingStub = GreeterGrpc.newBlockingStub(channel);
   }
diff --git a/examples/src/main/java/io/grpc/examples/experimental/CompressingHelloWorldServerAllMethods.java b/examples/src/main/java/io/grpc/examples/experimental/CompressingHelloWorldServerAllMethods.java
index 23c51a6d26c..794d7196f35 100644
--- a/examples/src/main/java/io/grpc/examples/experimental/CompressingHelloWorldServerAllMethods.java
+++ b/examples/src/main/java/io/grpc/examples/experimental/CompressingHelloWorldServerAllMethods.java
@@ -20,9 +20,10 @@
 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.ServerBuilder;
 import io.grpc.ServerCall;
 import io.grpc.ServerCall.Listener;
 import io.grpc.ServerCallHandler;
@@ -44,7 +45,7 @@ public class CompressingHelloWorldServerAllMethods {
   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())
         /* This method call adds the Interceptor to enable compressed server responses for all RPCs */
         .intercept(new ServerInterceptor() {
           @Override
diff --git a/examples/src/main/java/io/grpc/examples/experimental/CompressingHelloWorldServerPerMethod.java b/examples/src/main/java/io/grpc/examples/experimental/CompressingHelloWorldServerPerMethod.java
index 0ccf38184d3..b7faa96d7b4 100644
--- a/examples/src/main/java/io/grpc/examples/experimental/CompressingHelloWorldServerPerMethod.java
+++ b/examples/src/main/java/io/grpc/examples/experimental/CompressingHelloWorldServerPerMethod.java
@@ -20,8 +20,9 @@
 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.ServerBuilder;
 import io.grpc.examples.helloworld.GreeterGrpc;
 import io.grpc.examples.helloworld.HelloReply;
 import io.grpc.examples.helloworld.HelloRequest;
@@ -40,7 +41,7 @@ public class CompressingHelloWorldServerPerMethod {
   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();
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 93d106dba9e..52287040ba0 100644
--- a/examples/src/main/java/io/grpc/examples/header/CustomHeaderClient.java
+++ b/examples/src/main/java/io/grpc/examples/header/CustomHeaderClient.java
@@ -19,8 +19,9 @@
 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;
@@ -43,8 +44,8 @@ public class CustomHeaderClient {
    * A custom client.
    */
   private CustomHeaderClient(String host, int port) {
-    originChannel = ManagedChannelBuilder.forAddress(host, port)
-        .usePlaintext()
+    originChannel = Grpc
+        .newChannelBuilderForAddress(host, port, InsecureChannelCredentials.create())
         .build();
     ClientInterceptor interceptor = new HeaderClientInterceptor();
     Channel channel = ClientInterceptors.intercept(originChannel, interceptor);
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 ae80045603c..75a3d24934f 100644
--- a/examples/src/main/java/io/grpc/examples/header/CustomHeaderServer.java
+++ b/examples/src/main/java/io/grpc/examples/header/CustomHeaderServer.java
@@ -16,8 +16,9 @@
 
 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;
@@ -39,7 +40,7 @@ public class CustomHeaderServer {
   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();
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 b9a73931299..2a60eeda6c4 100644
--- a/examples/src/main/java/io/grpc/examples/header/HeaderClientInterceptor.java
+++ b/examples/src/main/java/io/grpc/examples/header/HeaderClientInterceptor.java
@@ -52,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/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..a7963630965
--- /dev/null
+++ b/examples/src/main/java/io/grpc/examples/healthservice/HealthServiceClient.java
@@ -0,0 +1,193 @@
+/*
+ * 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.Collections;
+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.HealthBlockingStub healthBlockingStub;
+
+  /** Construct client for accessing HelloWorld server using the existing channel. */
+  public HealthServiceClient(Channel channel) {
+    greeterBlockingStub = GreeterGrpc.newBlockingStub(channel);
+    healthBlockingStub = HealthGrpc.newBlockingStub(channel);
+  }
+
+  private ServingStatus checkHealth(String prefix) {
+    HealthCheckResponse response =
+        healthBlockingStub.check(HealthCheckRequest.getDefaultInstance());
+    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 enableHealthChecking)
+      throws InterruptedException {
+    String healthServiceName;
+    if (enableHealthChecking) {
+        healthServiceName = ""; // requests the backend's "overall health status"
+    } else {
+        healthServiceName = null; // disables health checking in generateServiceConfig()
+    }
+    ManagedChannel channel =
+        Grpc.newChannelBuilder(target, InsecureChannelCredentials.create())
+        // Enable the round_robin load balancer, with or without health checking
+        .defaultServiceConfig(generateServiceConfig(healthServiceName))
+        .build();
+
+    // Round Robin, when a healthCheckConfig is present in the 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.
+
+    System.out.println("\nDoing test with" + (enableHealthChecking ? "" : "out")
+      + " health checking\n");
+
+    try {
+      HealthServiceClient client = new HealthServiceClient(channel);
+      if (!enableHealthChecking) {
+        client.checkHealth("Before call");
+      }
+      client.greet(users[0]);
+      if (!enableHealthChecking) {
+        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 (!enableHealthChecking) {
+        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> generateServiceConfig(String healthServiceName) {
+    Map<String, Object> config = new HashMap<>();
+    if (healthServiceName != null) {
+      config.put("healthCheckConfig", Collections.singletonMap("serviceName", healthServiceName));
+    }
+    // There is more than one round_robin implementation. If the client doesn't depend on
+    // io.grpc:grpc-services, then the round_robin implementation does not support health watching
+    // (to avoid a Protobuf dependency). When the client depends on grpc-services the
+    // health-supporting round_robin implementation is used instead.
+    config.put("loadBalancingConfig", Arrays.asList(
+        Collections.singletonMap("round_robin", Collections.emptyMap())));
+    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..2170c9d3e08
--- /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 {
+    private volatile 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 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..9b17f96a624
--- /dev/null
+++ b/examples/src/main/java/io/grpc/examples/healthservice/README.md
@@ -0,0 +1,13 @@
+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.
+
+Note that clients must depend on `io.grpc:grpc-services` for the health-aware
+round_robin implementation to be used.
diff --git a/examples/src/main/java/io/grpc/examples/hedging/HedgingHelloWorldClient.java b/examples/src/main/java/io/grpc/examples/hedging/HedgingHelloWorldClient.java
index 30f7beb49a0..429cceb50c3 100644
--- a/examples/src/main/java/io/grpc/examples/hedging/HedgingHelloWorldClient.java
+++ b/examples/src/main/java/io/grpc/examples/hedging/HedgingHelloWorldClient.java
@@ -20,6 +20,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;
@@ -51,11 +53,8 @@ public class HedgingHelloWorldClient {
 
   /** Construct client connecting to HelloWorld server at {@code host:port}. */
   public HedgingHelloWorldClient(String host, int port, boolean hedging) {
-
-    ManagedChannelBuilder<?> channelBuilder = ManagedChannelBuilder.forAddress(host, port)
-        // Channels are secure by default (via SSL/TLS). For the example we disable TLS to avoid
-        // needing certificates.
-        .usePlaintext();
+    ManagedChannelBuilder<?> channelBuilder
+        = Grpc.newChannelBuilderForAddress(host, port, InsecureChannelCredentials.create());
     if (hedging) {
       Map<String, ?> hedgingServiceConfig =
           new Gson()
diff --git a/examples/src/main/java/io/grpc/examples/hedging/HedgingHelloWorldServer.java b/examples/src/main/java/io/grpc/examples/hedging/HedgingHelloWorldServer.java
index b934e8514ac..784269eea1c 100644
--- a/examples/src/main/java/io/grpc/examples/hedging/HedgingHelloWorldServer.java
+++ b/examples/src/main/java/io/grpc/examples/hedging/HedgingHelloWorldServer.java
@@ -16,9 +16,10 @@
 
 package io.grpc.examples.hedging;
 
+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.ServerCall.Listener;
 import io.grpc.ServerCallHandler;
@@ -43,7 +44,7 @@ public class HedgingHelloWorldServer {
   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())
         .intercept(new LatencyInjectionInterceptor())
         .build()
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 d00bca1e216..6b186facf46 100644
--- a/examples/src/main/java/io/grpc/examples/helloworld/HelloWorldClient.java
+++ b/examples/src/main/java/io/grpc/examples/helloworld/HelloWorldClient.java
@@ -17,8 +17,9 @@
 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;
@@ -81,10 +82,10 @@ public static void main(String[] args) throws Exception {
     // 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.
-    ManagedChannel channel = ManagedChannelBuilder.forTarget(target)
-        // Channels are secure by default (via SSL/TLS). For the example we disable TLS to avoid
-        // needing certificates.
-        .usePlaintext()
+    //
+    // 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);
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 12836a4c828..0e39581c98f 100644
--- a/examples/src/main/java/io/grpc/examples/helloworld/HelloWorldServer.java
+++ b/examples/src/main/java/io/grpc/examples/helloworld/HelloWorldServer.java
@@ -16,12 +16,15 @@
 
 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.
@@ -30,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();
@@ -47,7 +59,12 @@ public void run() {
         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");
       }
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/ManualFlowControlServer.java b/examples/src/main/java/io/grpc/examples/manualflowcontrol/ManualFlowControlServer.java
index de8142596ea..3b7f980e08c 100644
--- a/examples/src/main/java/io/grpc/examples/manualflowcontrol/ManualFlowControlServer.java
+++ b/examples/src/main/java/io/grpc/examples/manualflowcontrol/ManualFlowControlServer.java
@@ -72,6 +72,7 @@ public void run() {
 
         // 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.
@@ -81,7 +82,8 @@ public void onNext(HelloRequest request) {
               logger.info("--> " + name);
 
               // Simulate server "work"
-              Thread.sleep(100);
+              int sleepMillis = ++cnt % 20 == 0 ? 2000 : 100;
+              Thread.sleep(sleepMillis);
 
               // Send a response.
               String message = "Hello " + name;
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..f700d428aca
--- /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) manages a buffer for outgoing messages. If
+you write messages faster than they can be sent over the network, this buffer
+will grow, which can eventually lead to an OutOfMemoryError. The outgoing onNext
+method invocation does not block when this happens. Therefore, you should
+explicitly check that the stream is ready for writing via
+`CallStreamObserver.isReady()` before generating messages to avoid buffering
+excessive amounts of data in memory.
+
+### 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
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
index d8f2e72441b..20c9e5893fb 100644
--- a/examples/src/main/java/io/grpc/examples/retrying/RetryingHelloWorldClient.java
+++ b/examples/src/main/java/io/grpc/examples/retrying/RetryingHelloWorldClient.java
@@ -20,6 +20,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;
@@ -64,10 +66,8 @@ public class RetryingHelloWorldClient {
    */
   public RetryingHelloWorldClient(String host, int port, boolean enableRetries) {
 
-    ManagedChannelBuilder<?> channelBuilder = ManagedChannelBuilder.forAddress(host, port)
-        // Channels are secure by default (via SSL/TLS). For the example we disable TLS to avoid
-        // needing certificates.
-        .usePlaintext();
+    ManagedChannelBuilder<?> channelBuilder
+        = Grpc.newChannelBuilderForAddress(host, port, InsecureChannelCredentials.create());
     if (enableRetries) {
       Map<String, ?> serviceConfig = getRetryingServiceConfig();
       logger.info("Client started with retrying configuration: " + serviceConfig);
diff --git a/examples/src/main/java/io/grpc/examples/retrying/RetryingHelloWorldServer.java b/examples/src/main/java/io/grpc/examples/retrying/RetryingHelloWorldServer.java
index 0bff00a6988..165cc72ffa3 100644
--- a/examples/src/main/java/io/grpc/examples/retrying/RetryingHelloWorldServer.java
+++ b/examples/src/main/java/io/grpc/examples/retrying/RetryingHelloWorldServer.java
@@ -19,8 +19,9 @@
 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.ServerBuilder;
 import io.grpc.Status;
 import io.grpc.examples.helloworld.GreeterGrpc;
 import io.grpc.examples.helloworld.HelloReply;
@@ -43,7 +44,7 @@ public class RetryingHelloWorldServer {
   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();
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 6958c643da7..f65b1215359 100644
--- a/examples/src/main/java/io/grpc/examples/routeguide/RouteGuideClient.java
+++ b/examples/src/main/java/io/grpc/examples/routeguide/RouteGuideClient.java
@@ -19,8 +19,9 @@
 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;
@@ -259,7 +260,8 @@ public static void main(String[] args) throws InterruptedException {
       return;
     }
 
-    ManagedChannel channel = ManagedChannelBuilder.forTarget(target).usePlaintext().build();
+    ManagedChannel channel = Grpc.newChannelBuilder(target, InsecureChannelCredentials.create())
+        .build();
     try {
       RouteGuideClient client = new RouteGuideClient(channel);
       // Looking for a valid feature
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 c91544ae45d..1a3ecb0f882 100644
--- a/examples/src/main/java/io/grpc/examples/routeguide/RouteGuideServer.java
+++ b/examples/src/main/java/io/grpc/examples/routeguide/RouteGuideServer.java
@@ -25,6 +25,8 @@
 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;
@@ -55,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. */
@@ -248,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;
     }
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/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
index 325b9093b0c..b4f0f5287dd 100644
--- a/examples/src/main/proto/hello_streaming.proto
+++ b/examples/src/main/proto/hello_streaming.proto
@@ -29,6 +29,7 @@ service StreamingGreeter {
 // The request message containing the user's name.
 message HelloRequest {
   string name = 1;
+  bytes padding = 2;
 }
 
 // The response message containing the greetings
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 d0262d687ee..8c6cf60279a 100644
--- a/examples/src/test/java/io/grpc/examples/helloworld/HelloWorldClientTest.java
+++ b/examples/src/test/java/io/grpc/examples/helloworld/HelloWorldClientTest.java
@@ -40,8 +40,6 @@
  * Not intended to provide a high code coverage or to test every major usecase.
  *
  * directExecutor() makes it easier to have deterministic tests.
- * However, if your implementation uses another thread and uses streaming it is better to use
- * the default executor, to avoid hitting bug #3084.
  *
  * <p>For more unit test examples see {@link io.grpc.examples.routeguide.RouteGuideClientTest} and
  * {@link io.grpc.examples.routeguide.RouteGuideServerTest}.
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 9a20476772c..63281eeba1a 100644
--- a/examples/src/test/java/io/grpc/examples/helloworld/HelloWorldServerTest.java
+++ b/examples/src/test/java/io/grpc/examples/helloworld/HelloWorldServerTest.java
@@ -33,8 +33,6 @@
  * Not intended to provide a high code coverage or to test every major usecase.
  *
  * directExecutor() makes it easier to have deterministic tests.
- * However, if your implementation uses another thread and uses streaming it is better to use
- * the default executor, to avoid hitting bug #3084.
  *
  * <p>For more unit test examples see {@link io.grpc.examples.routeguide.RouteGuideClientTest} and
  * {@link io.grpc.examples.routeguide.RouteGuideServerTest}.
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 be2337cc4ce..4c184fb82ee 100644
--- a/examples/src/test/java/io/grpc/examples/routeguide/RouteGuideClientTest.java
+++ b/examples/src/test/java/io/grpc/examples/routeguide/RouteGuideClientTest.java
@@ -53,8 +53,6 @@
  * Not intended to provide a high code coverage or to test every major usecase.
  *
  * directExecutor() makes it easier to have deterministic tests.
- * However, if your implementation uses another thread and uses streaming it is better to use
- * the default executor, to avoid hitting bug #3084.
  *
  * <p>For basic unit test examples see {@link io.grpc.examples.helloworld.HelloWorldClientTest} and
  * {@link io.grpc.examples.helloworld.HelloWorldServerTest}.
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 19322c2d72c..a5a84824af6 100644
--- a/examples/src/test/java/io/grpc/examples/routeguide/RouteGuideServerTest.java
+++ b/examples/src/test/java/io/grpc/examples/routeguide/RouteGuideServerTest.java
@@ -50,8 +50,6 @@
  * Not intended to provide a high code coverage or to test every major usecase.
  *
  * directExecutor() makes it easier to have deterministic tests.
- * However, if your implementation uses another thread and uses streaming it is better to use
- * the default executor, to avoid hitting bug #3084.
  *
  * <p>For basic unit test examples see {@link io.grpc.examples.helloworld.HelloWorldClientTest} and
  * {@link io.grpc.examples.helloworld.HelloWorldServerTest}.
diff --git a/gae-interop-testing/gae-jdk8/build.gradle b/gae-interop-testing/gae-jdk8/build.gradle
index 8ed1bc5372b..07033f403de 100644
--- a/gae-interop-testing/gae-jdk8/build.gradle
+++ b/gae-interop-testing/gae-jdk8/build.gradle
@@ -14,13 +14,7 @@
 
 buildscript {
     // Configuration for building
-    repositories {
-        jcenter()    // Bintray's repository - a fast Maven Central mirror & more
-        maven { // The google mirror is less flaky than mavenCentral()
-            url "https://maven-central.storage-download.googleapis.com/maven2/" }
-    }
     dependencies {
-        classpath 'com.google.cloud.tools:appengine-gradle-plugin:2.3.0'
         classpath 'com.squareup.okhttp:okhttp:2.7.4'
     }
 }
@@ -28,19 +22,12 @@ buildscript {
 plugins {
     id "java"
     id "war"
-}
 
-description = 'gRPC: gae interop testing (jdk8)'
-
-repositories {
-    // repositories for Jar's you access in your code
-    mavenLocal()
-    maven { // The google mirror is less flaky than mavenCentral()
-        url "https://maven-central.storage-download.googleapis.com/maven2/" }
-    jcenter()
+    id "ru.vyarus.animalsniffer"
+    id 'com.google.cloud.tools.appengine'
 }
 
-apply plugin: 'com.google.cloud.tools.appengine'  // App Engine tasks
+description = 'gRPC: gae interop testing (jdk8)'
 
 dependencies {
     providedCompile group: 'javax.servlet', name: 'servlet-api', version:'2.5'
@@ -53,11 +40,16 @@ dependencies {
         exclude group: 'io.grpc', module: 'grpc-xds'
     }
     implementation libraries.junit
-    implementation libraries.protobuf
-    runtimeOnly libraries.netty_tcnative
+    implementation libraries.protobuf.java
+    runtimeOnly libraries.netty.tcnative, libraries.netty.tcnative.classes
+    signature (libraries.signature.java) {
+        artifact {
+            extension = "signature"
+        }
+    }
 }
 
-compileJava {
+tasks.named("compileJava").configure {
     // Disable "No processor claimed any of these annotations: org.junit.Ignore"
     options.compilerArgs += ["-Xlint:-processing"]
 }
@@ -66,6 +58,7 @@ def createDefaultVersion() {
     return new java.text.SimpleDateFormat("yyyyMMdd't'HHmmss").format(new Date())
 }
 
+def nonShadowedProject = project
 // [START model]
 appengine {
     // App Engine tasks configuration
@@ -75,13 +68,13 @@ appengine {
 
     deploy {
         // deploy configuration
-        projectId = 'GCLOUD_CONFIG'
+        projectId = nonShadowedProject.findProperty('gaeProjectId') ?: 'GCLOUD_CONFIG'
         // default - stop the current version
-        stopPreviousVersion = System.getProperty('gaeStopPreviousVersion') ?: true
+        stopPreviousVersion = nonShadowedProject.findProperty('gaeStopPreviousVersion') ?: true
         // default - do not make this the promoted version
-        promote = System.getProperty('gaePromote') ?: false
-        // Use -DgaeDeployVersion if set, otherwise the version is null and the plugin will generate it
-        version = System.getProperty('gaeDeployVersion', createDefaultVersion())
+        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]
@@ -89,11 +82,12 @@ appengine {
 group = 'io.grpc'   // Generated output GroupId
 version = '1.0-SNAPSHOT'          // Version in generated output
 
-sourceCompatibility = 1.8
-targetCompatibility = 1.8
-
 /** 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'
@@ -120,11 +114,9 @@ String getAppUrl(String project, String service, String version) {
     return "http://${version}.${service}.${project}.appspot.com"
 }
 
-task runInteropTestRemote(dependsOn: 'appengineDeploy') {
+tasks.register("runInteropTestRemote") {
+    mustRunAfter appengineDeploy
     doLast {
-        // give remote app some time to settle down
-        sleep(20000)
-
         def appUrl = getAppUrl(
                 getGaeProject(),
                 getService(project.getProjectDir().toPath()),
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
index 6af02227143..5a388d27ce9 100644
--- 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
@@ -16,9 +16,6 @@
 
 package io.grpc.testing.integration;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-
 import io.grpc.Grpc;
 import io.grpc.ManagedChannelBuilder;
 import io.grpc.TlsChannelCredentials;
@@ -28,6 +25,7 @@
 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;
@@ -102,6 +100,7 @@ private void doGetHelper(HttpServletResponse resp) throws IOException {
       resp.setStatus(200);
       writer.println(
           String.format(
+              Locale.US,
               "PASS! Tests ran %d, tests ignored %d",
               result.getRunCount(),
               result.getIgnoreCount()));
@@ -109,6 +108,7 @@ private void doGetHelper(HttpServletResponse resp) throws IOException {
       resp.setStatus(500);
       writer.println(
           String.format(
+              Locale.US,
               "FAILED! Tests ran %d, tests failed %d, tests ignored %d",
               result.getRunCount(),
               result.getFailureCount(),
@@ -128,14 +128,9 @@ private void doGetHelper(HttpServletResponse resp) throws IOException {
   public static final class Tester extends AbstractInteropTest {
     @Override
     protected ManagedChannelBuilder<?> createChannelBuilder() {
-      assertEquals(
-          "jdk8 required",
-          "1.8",
-          System.getProperty("java.specification.version"));
       ManagedChannelBuilder<?> builder =
           Grpc.newChannelBuilder(INTEROP_TEST_ADDRESS, TlsChannelCredentials.create())
               .maxInboundMessageSize(AbstractInteropTest.MAX_MESSAGE_SIZE);
-      assertTrue(builder instanceof NettyChannelBuilder);
       ((NettyChannelBuilder) builder)
           .flowControlWindow(AbstractInteropTest.TEST_FLOW_CONTROL_WINDOW);
       return builder;
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
index d8532dfc69e..715906ada47 100644
--- 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
@@ -13,8 +13,7 @@
 -->
 <!-- [START config] -->
 <appengine-web-app xmlns='http://appengine.google.com/ns/1.0'>
-  <threadsafe>true</threadsafe>
   <service>java-gae-interop-test</service>
-  <runtime>java8</runtime>
+  <runtime>java17</runtime>
 </appengine-web-app>
 <!-- [END config] -->
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..db674aeb2ee
--- /dev/null
+++ b/googleapis/src/main/java/io/grpc/googleapis/GoogleCloudToProdExperimentalNameResolverProvider.java
@@ -0,0 +1,58 @@
+/*
+ * 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 io.grpc.Uri;
+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 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..427c0658531
--- /dev/null
+++ b/googleapis/src/main/java/io/grpc/googleapis/GoogleCloudToProdNameResolver.java
@@ -0,0 +1,413 @@
+/*
+ * 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.Uri;
+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.List;
+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());
+  }
+
+  // TODO(jdcormie): Remove after io.grpc.Uri migration.
+  @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;
+  }
+
+  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");
+    Preconditions.checkArgument(
+        targetUri.isPathAbsolute(),
+        "the path component of the target (%s) must start with '/'",
+        targetUri);
+    List<String> pathSegments = targetUri.getPathSegments();
+    Preconditions.checkArgument(
+        pathSegments.size() == 1,
+        "the path component of the target (%s) must have exactly one segment",
+        targetUri);
+    authority = GrpcUtil.checkAuthority(pathSegments.get(0));
+    syncContext = checkNotNull(args, "args").getSynchronizationContext();
+    Uri.Builder modifiedTargetBuilder = targetUri.toBuilder().setScheme(schemeOverride);
+    if (schemeOverride.equals("xds")) {
+      modifiedTargetBuilder.setRawAuthority(C2P_AUTHORITY);
+      args =
+          args.toBuilder()
+              .setArg(XdsNameResolverProvider.XDS_CLIENT_SUPPLIER, () -> xdsClient)
+              .build();
+    }
+    targetUri = modifiedTargetBuilder.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..f936de086e9
--- /dev/null
+++ b/googleapis/src/main/java/io/grpc/googleapis/GoogleCloudToProdNameResolverProvider.java
@@ -0,0 +1,88 @@
+/*
+ * 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.Uri;
+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");
+  }
+
+  // TODO(jdcormie): Remove after io.grpc.Uri migration is complete.
+  @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 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..39468472985
--- /dev/null
+++ b/googleapis/src/test/java/io/grpc/googleapis/GoogleCloudToProdNameResolverProviderTest.java
@@ -0,0 +1,117 @@
+/*
+ * 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.Args;
+import io.grpc.NameResolver.ServiceConfigParser;
+import io.grpc.NameResolverProvider;
+import io.grpc.SynchronizationContext;
+import io.grpc.Uri;
+import io.grpc.internal.FakeClock;
+import io.grpc.internal.GrpcUtil;
+import java.net.URI;
+import java.util.Arrays;
+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 GoogleCloudToProdNameResolverProvider}. */
+@RunWith(Parameterized.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();
+
+  @Parameters(name = "enableRfc3986UrisParam={0}")
+  public static Iterable<Object[]> data() {
+    return Arrays.asList(new Object[][] {{true}, {false}});
+  }
+
+  @Parameter public boolean enableRfc3986UrisParam;
+
+  @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 shouldProvideNameResolverOfExpectedType() {
+    assertThat(newNameResolver(provider, "google-c2p:///foo.googleapis.com", args))
+        .isInstanceOf(GoogleCloudToProdNameResolver.class);
+  }
+
+  @Test
+  public void shouldProvideExperimentalNameResolverOfExpectedType() {
+    assertThat(
+            newNameResolver(
+                new GoogleCloudToProdExperimentalNameResolverProvider(),
+                "google-c2p-experimental:///foo.googleapis.com",
+                args))
+        .isInstanceOf(GoogleCloudToProdNameResolver.class);
+  }
+
+  private NameResolver newNameResolver(NameResolverProvider provider, String uri, Args args) {
+    return enableRfc3986UrisParam
+        ? provider.newNameResolver(Uri.create(uri), args)
+        : provider.newNameResolver(URI.create(uri), args);
+  }
+}
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..d3d3cfc4bff
--- /dev/null
+++ b/googleapis/src/test/java/io/grpc/googleapis/GoogleCloudToProdNameResolverTest.java
@@ -0,0 +1,295 @@
+/*
+ * 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.Uri;
+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.Arrays;
+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.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+@RunWith(Parameterized.class)
+public class GoogleCloudToProdNameResolverTest {
+
+  @Rule
+  public final MockitoRule mocks = MockitoJUnit.rule();
+
+  private static final String TARGET_URI = "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";
+
+  @Parameters(name = "enableRfc3986UrisParam={0}")
+  public static Iterable<Object[]> data() {
+    return Arrays.asList(new Object[][] {{true}, {false}});
+  }
+
+  @Parameter public boolean enableRfc3986UrisParam;
+
+  @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 =
+        enableRfc3986UrisParam
+            ? new GoogleCloudToProdNameResolver(
+                Uri.create(TARGET_URI), args, fakeExecutorResource, nsRegistry.asFactory())
+            : new GoogleCloudToProdNameResolver(
+                URI.create(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..a951303d209
--- /dev/null
+++ b/gradle/libs.versions.toml
@@ -0,0 +1,153 @@
+[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.14.x doesn't exist.
+# 1.15.0+ requires compileSdkVersion 35 which officially requires AGP 8.6.0+.
+# It might work before then, but AGP 7.4.1 fails with:
+#   RES_TABLE_TYPE_TYPE entry offsets overlap actual entry data.
+# 1.16.0+ requires AGP 8.6.0+
+# checkForUpdates: androidx-core:1.13.+
+androidx-core = "androidx.core:core:1.13.1"
+# 2.9+ requires AGP 8.1.1+
+# 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"
+androidx-test-rules = "androidx.test:rules:1.7.0"
+androidx-test-runner = "androidx.test:runner:1.7.0"
+animalsniffer = "org.codehaus.mojo:animal-sniffer:1.27"
+animalsniffer-annotations = "org.codehaus.mojo:animal-sniffer-annotations:1.27"
+assertj-core = "org.assertj:assertj-core:3.27.7"
+# 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 Java 17+
+# 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.48.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"
+# 2.65.0+ requires protobuf 4.x
+# checkForUpdates: google-api-protos:2.64.+
+google-api-protos = "com.google.api.grpc:proto-google-common-protos:2.64.1"
+# 1.43.0+ versions of google-auth-library requires protobuf 4.x
+# checkForUpdates: google-auth-credentials:1.42.+
+google-auth-credentials = "com.google.auth:google-auth-library-credentials:1.42.1"
+# checkForUpdates: google-auth-oauth2Http:1.42.+
+google-auth-oauth2Http = "com.google.auth:google-auth-library-oauth2-http:1.42.1"
+# Release notes: https://cloud.google.com/logging/docs/release-notes
+# 3.23.11+ require protobuf 4.x
+# checkForUpdates: google-cloud-logging:3.23.10
+google-cloud-logging = "com.google.cloud:google-cloud-logging:3.23.10"
+gson = "com.google.code.gson:gson:2.13.2"
+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.7"
+# 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.7"
+# 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.4"
+# 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.133.Final"
+# checkForUpdates: netty-handler-proxy:4.1.+
+netty-handler-proxy = "io.netty:netty-handler-proxy:4.1.133.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.75.Final"
+netty-tcnative-classes = "io.netty:netty-tcnative-classes:2.0.75.Final"
+# checkForUpdates: netty-transport-epoll:4.1.+
+netty-transport-epoll = "io.netty:netty-transport-native-epoll:4.1.133.Final"
+# checkForUpdates: netty-unix-common:4.1.+
+netty-unix-common = "io.netty:netty-transport-native-unix-common:4.1.133.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.60.1"
+opentelemetry-exporter-prometheus = "io.opentelemetry:opentelemetry-exporter-prometheus:1.60.1-alpha"
+opentelemetry-gcp-resources = "io.opentelemetry.contrib:opentelemetry-gcp-resources:1.54.0-alpha"
+opentelemetry-sdk-extension-autoconfigure = "io.opentelemetry:opentelemetry-sdk-extension-autoconfigure:1.60.1"
+opentelemetry-sdk-testing = "io.opentelemetry:opentelemetry-sdk-testing:1.60.1"
+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.1"
+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.52"
+# checkForUpdates: tomcat-embed-core9:9.+
+tomcat-embed-core9 = "org.apache.tomcat.embed:tomcat-embed-core:9.0.115"
+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 13536770052..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 4d9ca164914..d4081da476b 100644
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -1,5 +1,7 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-6.7.1-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.14.3-bin.zip
+networkTimeout=10000
+validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
diff --git a/gradlew b/gradlew
index cccdd3d517f..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 () {
     echo "$*"
-}
+} >&2
 
 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,92 +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
-save () {
-    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
-    echo " "
-}
-APP_ARGS=$(save "$@")
-
-# 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
index b69fb234733..ca9975b7ce6 100644
--- a/grpclb/BUILD.bazel
+++ b/grpclb/BUILD.bazel
@@ -1,3 +1,5 @@
+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(
@@ -5,18 +7,22 @@ java_library(
     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",
-        "//core:util",
         "//stub",
-        "@com_google_code_findbugs_jsr305//jar",
-        "@com_google_guava_guava//jar",
-        "@com_google_j2objc_j2objc_annotations//jar",
+        "//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"),
     ],
 )
 
diff --git a/grpclb/build.gradle b/grpclb/build.gradle
index 973770feb2f..e8896604f03 100644
--- a/grpclb/build.gradle
+++ b/grpclb/build.gradle
@@ -4,36 +4,45 @@ plugins {
 
     id "com.google.protobuf"
     id "me.champeau.gradle.japicmp"
+    id "ru.vyarus.animalsniffer"
 }
 
 description = "gRPC: GRPCLB LoadBalancer plugin"
 
-evaluationDependsOn(project(':grpc-core').path)
+tasks.named("jar").configure {
+    manifest {
+        attributes('Automatic-Module-Name': 'io.grpc.grpclb')
+    }
+}
 
 dependencies {
     implementation project(':grpc-core'),
             project(':grpc-protobuf'),
             project(':grpc-stub'),
-            libraries.protobuf
-    implementation (libraries.protobuf_util) {
-        // prefer our own versions instead of protobuf-util's dependency
-        exclude group: 'com.google.guava', module: 'guava'
-        exclude group: 'com.google.errorprone', module: 'error_prone_annotations'
-    }
-    guavaDependency 'implementation'
-    runtimeOnly libraries.errorprone
-    compileOnly libraries.javax_annotation
+            project(':grpc-util'),
+            libraries.guava,
+            libraries.protobuf.java,
+            libraries.protobuf.java.util
+    runtimeOnly libraries.errorprone.annotations
     testImplementation libraries.truth,
-            project(':grpc-core').sourceSets.test.output
+            project(':grpc-inprocess'),
+            testFixtures(project(':grpc-core'))
+
+    signature (libraries.signature.java) {
+        artifact {
+            extension = "signature"
+        }
+    }
 }
 
 configureProtoCompilation()
 
-javadoc {
+tasks.named("javadoc").configure {
     exclude 'io/grpc/grpclb/Internal*'
+    exclude 'io/grpc/grpclb/*Provider.java'
 }
 
-jacocoTestReport {
+tasks.named("jacocoTestReport").configure {
     classDirectories.from = sourceSets.main.output.collect {
         fileTree(dir: it,
         exclude: [
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
index 2f82579582d..b730eff7b37 100644
--- a/grpclb/src/generated/main/grpc/io/grpc/lb/v1/LoadBalancerGrpc.java
+++ b/grpclb/src/generated/main/grpc/io/grpc/lb/v1/LoadBalancerGrpc.java
@@ -4,14 +4,12 @@
 
 /**
  */
-@javax.annotation.Generated(
-    value = "by gRPC proto compiler",
-    comments = "Source: grpc/lb/v1/load_balancer.proto")
+@io.grpc.stub.annotations.GrpcGenerated
 public final class LoadBalancerGrpc {
 
   private LoadBalancerGrpc() {}
 
-  public static final String SERVICE_NAME = "grpc.lb.v1.LoadBalancer";
+  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,
@@ -59,6 +57,21 @@ public LoadBalancerStub newStub(io.grpc.Channel channel, io.grpc.CallOptions cal
     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
    */
@@ -91,34 +104,35 @@ public LoadBalancerFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptio
 
   /**
    */
-  public static abstract class LoadBalancerImplBase implements io.grpc.BindableService {
+  public interface AsyncService {
 
     /**
      * <pre>
      * Bidirectional rpc to get a list of servers.
      * </pre>
      */
-    public io.grpc.stub.StreamObserver<io.grpc.lb.v1.LoadBalanceRequest> balanceLoad(
+    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 io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
-          .addMethod(
-            getBalanceLoadMethod(),
-            io.grpc.stub.ServerCalls.asyncBidiStreamingCall(
-              new MethodHandlers<
-                io.grpc.lb.v1.LoadBalanceRequest,
-                io.grpc.lb.v1.LoadBalanceResponse>(
-                  this, METHODID_BALANCE_LOAD)))
-          .build();
+      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> {
+  public static final class LoadBalancerStub
+      extends io.grpc.stub.AbstractAsyncStub<LoadBalancerStub> {
     private LoadBalancerStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -143,8 +157,39 @@ public io.grpc.stub.StreamObserver<io.grpc.lb.v1.LoadBalanceRequest> balanceLoad
   }
 
   /**
+   * A stub to allow clients to do synchronous rpc calls to service LoadBalancer.
    */
-  public static final class LoadBalancerBlockingStub extends io.grpc.stub.AbstractBlockingStub<LoadBalancerBlockingStub> {
+  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);
@@ -158,8 +203,10 @@ protected LoadBalancerBlockingStub build(
   }
 
   /**
+   * 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> {
+  public static final class LoadBalancerFutureStub
+      extends io.grpc.stub.AbstractFutureStub<LoadBalancerFutureStub> {
     private LoadBalancerFutureStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -179,10 +226,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 LoadBalancerImplBase serviceImpl;
+    private final AsyncService serviceImpl;
     private final int methodId;
 
-    MethodHandlers(LoadBalancerImplBase serviceImpl, int methodId) {
+    MethodHandlers(AsyncService serviceImpl, int methodId) {
       this.serviceImpl = serviceImpl;
       this.methodId = methodId;
     }
@@ -210,6 +257,18 @@ public io.grpc.stub.StreamObserver<Req> invoke(
     }
   }
 
+  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() {}
@@ -233,9 +292,9 @@ private static final class LoadBalancerFileDescriptorSupplier
   private static final class LoadBalancerMethodDescriptorSupplier
       extends LoadBalancerBaseDescriptorSupplier
       implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
-    private final String methodName;
+    private final java.lang.String methodName;
 
-    LoadBalancerMethodDescriptorSupplier(String methodName) {
+    LoadBalancerMethodDescriptorSupplier(java.lang.String methodName) {
       this.methodName = methodName;
     }
 
diff --git a/grpclb/src/main/java/io/grpc/grpclb/GrpclbClientLoadRecorder.java b/grpclb/src/main/java/io/grpc/grpclb/GrpclbClientLoadRecorder.java
index d27c485dc13..fe928263ef9 100644
--- a/grpclb/src/main/java/io/grpc/grpclb/GrpclbClientLoadRecorder.java
+++ b/grpclb/src/main/java/io/grpc/grpclb/GrpclbClientLoadRecorder.java
@@ -18,6 +18,7 @@
 
 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;
@@ -29,7 +30,6 @@
 import java.util.HashMap;
 import java.util.Map;
 import java.util.concurrent.atomic.AtomicLongFieldUpdater;
-import javax.annotation.concurrent.GuardedBy;
 import javax.annotation.concurrent.ThreadSafe;
 
 /**
diff --git a/grpclb/src/main/java/io/grpc/grpclb/GrpclbConfig.java b/grpclb/src/main/java/io/grpc/grpclb/GrpclbConfig.java
index 60f22a2e0e8..1476e3e2f83 100644
--- a/grpclb/src/main/java/io/grpc/grpclb/GrpclbConfig.java
+++ b/grpclb/src/main/java/io/grpc/grpclb/GrpclbConfig.java
@@ -16,6 +16,7 @@
 
 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;
@@ -28,26 +29,33 @@ final class GrpclbConfig {
   private final Mode mode;
   @Nullable
   private final String serviceName;
+  private final long fallbackTimeoutMs;
 
-  private GrpclbConfig(Mode mode, @Nullable String serviceName) {
+  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);
+    return create(mode, null, GrpclbState.FALLBACK_TIMEOUT_MS);
   }
 
-  static GrpclbConfig create(Mode mode, @Nullable String serviceName) {
-    return new GrpclbConfig(mode, serviceName);
+  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 sevice name to be sent to the balancer. if not, the
+   * 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.
    */
@@ -65,12 +73,14 @@ public boolean equals(Object o) {
       return false;
     }
     GrpclbConfig that = (GrpclbConfig) o;
-    return mode == that.mode && Objects.equal(serviceName, that.serviceName);
+    return mode == that.mode
+        && Objects.equal(serviceName, that.serviceName)
+        && fallbackTimeoutMs == that.fallbackTimeoutMs;
   }
 
   @Override
   public int hashCode() {
-    return Objects.hashCode(mode, serviceName);
+    return Objects.hashCode(mode, serviceName, fallbackTimeoutMs);
   }
 
   @Override
@@ -78,6 +88,7 @@ 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 bda6473b0cc..be09b1ce306 100644
--- a/grpclb/src/main/java/io/grpc/grpclb/GrpclbConstants.java
+++ b/grpclb/src/main/java/io/grpc/grpclb/GrpclbConstants.java
@@ -46,7 +46,7 @@ public final class GrpclbConstants {
    * Attribute key for gRPC LB server addresses.
    */
   public static final Attributes.Key<List<EquivalentAddressGroup>> ATTR_LB_ADDRS =
-      Attributes.Key.create("io.grpc.grpclb.lbAddrs");
+      Attributes.Key.create("io.grpc.grpclb.GrpclbConstants.ATTR_LB_ADDRS");
 
   /**
    * The naming authority of a gRPC LB server address.  It is an address-group-level attribute,
@@ -54,7 +54,7 @@ public final class GrpclbConstants {
    */
   @EquivalentAddressGroup.Attr
   public static final Attributes.Key<String> ATTR_LB_ADDR_AUTHORITY =
-      Attributes.Key.create("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
@@ -62,7 +62,7 @@ public final class GrpclbConstants {
    */
   @EquivalentAddressGroup.Attr
   public static final Attributes.Key<Boolean> ATTR_LB_PROVIDED_BACKEND =
-      Attributes.Key.create("io.grpc.grpclb.lbProvidedBackend");
+      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 ddb4170c461..bf9eea69af0 100644
--- a/grpclb/src/main/java/io/grpc/grpclb/GrpclbLoadBalancer.java
+++ b/grpclb/src/main/java/io/grpc/grpclb/GrpclbLoadBalancer.java
@@ -23,6 +23,7 @@
 import com.google.common.base.Stopwatch;
 import io.grpc.Attributes;
 import io.grpc.ChannelLogger.ChannelLogLevel;
+import io.grpc.Context;
 import io.grpc.EquivalentAddressGroup;
 import io.grpc.LoadBalancer;
 import io.grpc.Status;
@@ -45,6 +46,7 @@ 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;
@@ -58,11 +60,13 @@ class GrpclbLoadBalancer extends LoadBalancer {
 
   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");
@@ -72,29 +76,32 @@ class GrpclbLoadBalancer extends LoadBalancer {
   }
 
   @Override
-  public void handleResolvedAddresses(ResolvedAddresses resolvedAddresses) {
+  public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
     Attributes attributes = resolvedAddresses.getAttributes();
     List<EquivalentAddressGroup> newLbAddresses = attributes.get(GrpclbConstants.ATTR_LB_ADDRS);
-    if ((newLbAddresses == null || newLbAddresses.isEmpty())
-        && resolvedAddresses.getAddresses().isEmpty()) {
-      handleNameResolutionError(
-          Status.UNAVAILABLE.withDescription("No backend or balancer addresses found"));
-      return;
+    if (newLbAddresses == null) {
+      newLbAddresses = Collections.emptyList();
     }
-    List<LbAddressGroup> newLbAddressGroups = new ArrayList<>();
-
-    if (newLbAddresses != null) {
-      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.");
-        }
-        newLbAddressGroups.add(new LbAddressGroup(lbAddr, lbAddrAuthority));
+    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));
     }
 
-    newLbAddressGroups = Collections.unmodifiableList(newLbAddressGroups);
     List<EquivalentAddressGroup> newBackendServers =
         Collections.unmodifiableList(resolvedAddresses.getAddresses());
     GrpclbConfig newConfig = (GrpclbConfig) resolvedAddresses.getLoadBalancingPolicyConfig();
@@ -106,7 +113,10 @@ public void handleResolvedAddresses(ResolvedAddresses resolvedAddresses) {
       helper.getChannelLogger().log(ChannelLogLevel.INFO, "Config: " + newConfig);
       recreateStates();
     }
-    grpclbState.handleAddresses(newLbAddressGroups, newBackendServers);
+    grpclbState.handleAddresses(Collections.unmodifiableList(overrideAuthorityLbAddresses),
+        newBackendServers);
+
+    return Status.OK;
   }
 
   @Override
@@ -128,7 +138,7 @@ private void recreateStates() {
     checkState(grpclbState == null, "Should've been cleared");
     grpclbState =
         new GrpclbState(
-            config, helper, subchannelPool, time, stopwatch, backoffPolicyProvider);
+            config, helper, context, subchannelPool, time, stopwatch, backoffPolicyProvider);
   }
 
   @Override
@@ -144,6 +154,8 @@ public void handleNameResolutionError(Status error) {
   }
 
   @Override
+  @Deprecated
+  @SuppressWarnings("InlineMeSuggester")
   public boolean canHandleEmptyAddressListFromNameResolution() {
     return true;
   }
diff --git a/grpclb/src/main/java/io/grpc/grpclb/GrpclbLoadBalancerProvider.java b/grpclb/src/main/java/io/grpc/grpclb/GrpclbLoadBalancerProvider.java
index badcfdcec7c..abb3be77407 100644
--- a/grpclb/src/main/java/io/grpc/grpclb/GrpclbLoadBalancerProvider.java
+++ b/grpclb/src/main/java/io/grpc/grpclb/GrpclbLoadBalancerProvider.java
@@ -17,6 +17,7 @@
 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;
@@ -62,6 +63,7 @@ public LoadBalancer newLoadBalancer(LoadBalancer.Helper helper) {
     return
         new GrpclbLoadBalancer(
             helper,
+            Context.ROOT,
             new CachedSubchannelPool(helper),
             TimeProvider.SYSTEM_TIME_PROVIDER,
             Stopwatch.createUnstarted(),
@@ -87,6 +89,13 @@ ConfigOrError parseLoadBalancingConfigPolicyInternal(
     }
     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 =
@@ -95,7 +104,8 @@ ConfigOrError parseLoadBalancingConfigPolicyInternal(
     }
 
     if (childPolicies == null || childPolicies.isEmpty()) {
-      return ConfigOrError.fromConfig(GrpclbConfig.create(DEFAULT_MODE, serviceName));
+      return ConfigOrError.fromConfig(
+          GrpclbConfig.create(DEFAULT_MODE, serviceName, timeoutMs));
     }
 
     List<String> policiesTried = new ArrayList<>();
@@ -103,16 +113,18 @@ ConfigOrError parseLoadBalancingConfigPolicyInternal(
       String childPolicyName = childPolicy.getPolicyName();
       switch (childPolicyName) {
         case "round_robin":
-          return ConfigOrError.fromConfig(GrpclbConfig.create(Mode.ROUND_ROBIN, serviceName));
+          return ConfigOrError.fromConfig(
+              GrpclbConfig.create(Mode.ROUND_ROBIN, serviceName, timeoutMs));
         case "pick_first":
-          return ConfigOrError.fromConfig(GrpclbConfig.create(Mode.PICK_FIRST, serviceName));
+          return ConfigOrError.fromConfig(
+              GrpclbConfig.create(Mode.PICK_FIRST, serviceName, timeoutMs));
         default:
           policiesTried.add(childPolicyName);
       }
     }
     return ConfigOrError.fromError(
         Status
-            .INVALID_ARGUMENT
+            .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
index 89615f1b65d..60d02220e64 100644
--- a/grpclb/src/main/java/io/grpc/grpclb/GrpclbNameResolver.java
+++ b/grpclb/src/main/java/io/grpc/grpclb/GrpclbNameResolver.java
@@ -21,6 +21,7 @@
 import io.grpc.Attributes;
 import io.grpc.EquivalentAddressGroup;
 import io.grpc.NameResolver;
+import io.grpc.StatusOr;
 import io.grpc.internal.DnsNameResolver;
 import io.grpc.internal.SharedResourceHolder.Resource;
 import java.net.InetAddress;
@@ -58,14 +59,22 @@ final class GrpclbNameResolver extends DnsNameResolver {
   }
 
   @Override
-  protected InternalResolutionResult doResolve(boolean forceTxt) {
+  protected ResolutionResult doResolve() {
+    ResolutionResult result = super.doResolve();
     List<EquivalentAddressGroup> balancerAddrs = resolveBalancerAddresses();
-    InternalResolutionResult result = super.doResolve(!balancerAddrs.isEmpty());
     if (!balancerAddrs.isEmpty()) {
-      result.attributes =
-          Attributes.newBuilder()
+      ResolutionResult.Builder resultBuilder = result.toBuilder()
+          .setAttributes(result.getAttributes().toBuilder()
               .set(GrpclbConstants.ATTR_LB_ADDRS, balancerAddrs)
-              .build();
+              .build());
+      if (!result.getAddressesOrError().hasValue()) {
+        // While ResolutionResult is powerful enough to communicate attributes simultaneously with
+        // an address resolution failure, LoadBalancer.ResolvedAddresses isn't yet and so the
+        // attributes are lost if addresses fail. GrpclbLB will be able to handle the lack of
+        // addresses since there are LB addresses, so discard the failure for now.
+        resultBuilder.setAddressesOrError(StatusOr.fromValue(Collections.emptyList()));
+      }
+      result = resultBuilder.build();
     }
     return result;
   }
@@ -76,7 +85,10 @@ private List<EquivalentAddressGroup> resolveBalancerAddresses() {
     ResourceResolver resourceResolver = getResourceResolver();
     if (resourceResolver != null) {
       try {
-        srvRecords = resourceResolver.resolveSrv(GRPCLB_NAME_PREFIX + getHost());
+        // 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;
       }
diff --git a/grpclb/src/main/java/io/grpc/grpclb/GrpclbState.java b/grpclb/src/main/java/io/grpc/grpclb/GrpclbState.java
index dc53be584cf..5ed84ade2f8 100644
--- a/grpclb/src/main/java/io/grpc/grpclb/GrpclbState.java
+++ b/grpclb/src/main/java/io/grpc/grpclb/GrpclbState.java
@@ -35,14 +35,18 @@
 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.CreateSubchannelArgs;
+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.LoadBalancer.SubchannelStateListener;
+import io.grpc.LoadBalancerProvider;
+import io.grpc.LoadBalancerRegistry;
 import io.grpc.ManagedChannel;
 import io.grpc.Metadata;
 import io.grpc.Status;
@@ -61,9 +65,9 @@
 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.SocketAddress;
 import java.net.UnknownHostException;
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -89,17 +93,37 @@ final class GrpclbState {
   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(Metadata headers) {
+      public PickResult picked(PickSubchannelArgs args) {
         return PickResult.withNoResult();
       }
 
@@ -108,6 +132,8 @@ public String toString() {
         return "BUFFER_ENTRY";
       }
     };
+  @VisibleForTesting
+  static final String NO_USE_AUTHORITY_SUFFIX = "-notIntendedToBeUsed";
 
   enum Mode {
     ROUND_ROBIN,
@@ -115,7 +141,9 @@ enum Mode {
   }
 
   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;
@@ -133,6 +161,10 @@ enum Mode {
   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;
@@ -143,7 +175,6 @@ enum Mode {
 
   @Nullable
   private ManagedChannel lbCommChannel;
-  private boolean lbSentEmptyBackends = false;
 
   @Nullable
   private LbStream lbStream;
@@ -156,19 +187,31 @@ enum Mode {
   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");
@@ -183,6 +226,9 @@ public void onSubchannelState(
     } 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");
@@ -192,6 +238,7 @@ public void onSubchannelState(
     } 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);
   }
@@ -203,6 +250,10 @@ void handleSubchannelState(Subchannel subchannel, ConnectivityStateInfo newState
     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
@@ -224,35 +275,48 @@ void handleSubchannelState(Subchannel subchannel, ConnectivityStateInfo newState
    * not yet connected.
    */
   void handleAddresses(
-      List<LbAddressGroup> newLbAddressGroups, List<EquivalentAddressGroup> newBackendServers) {
+      List<EquivalentAddressGroup> newLbAddressGroups,
+      List<EquivalentAddressGroup> newBackendServers) {
     logger.log(
         ChannelLogLevel.DEBUG,
-        "[grpclb-<{0}>] Resolved addresses: lb addresses {0}, backends: {1}",
+        "[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 enter fallback mode
-      // immediately.
+      // 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();
-      syncContext.execute(new FallbackModeTask());
+      if (!usingFallbackBackends) {
+        fallbackReason = NO_LB_ADDRESS_PROVIDED_STATUS;
+        cancelFallbackTimer();
+        maybeUseFallbackBackends();
+      }
     } else {
-      LbAddressGroup newLbAddressGroup = flattenLbAddressGroups(newLbAddressGroups);
-      startLbComm(newLbAddressGroup);
+      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
-      if (fallbackTimer == null) {
-        fallbackTimer = syncContext.schedule(
-            new FallbackModeTask(), FALLBACK_TIMEOUT_MS, TimeUnit.MILLISECONDS, timerService);
+      // 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);
       }
     }
-    fallbackBackendList = newBackendServers;
     if (usingFallbackBackends) {
       // Populate the new fallback backends to round-robin list.
       useFallbackBackends();
@@ -262,6 +326,12 @@ void handleAddresses(
 
   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();
@@ -271,23 +341,36 @@ void requestConnection() {
   }
 
   private void maybeUseFallbackBackends() {
-    if (balancerWorking) {
+    if (balancerWorking || usingFallbackBackends) {
       return;
     }
-    if (usingFallbackBackends) {
-      return;
-    }
-    for (Subchannel subchannel : subchannels.values()) {
-      if (subchannel.getAttributes().get(STATE_INFO).get().getState() == READY) {
+    // 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 the round-robin lists with the fallback backends.
+   * Populate backend servers to be used from the fallback backends.
    */
   private void useFallbackBackends() {
     usingFallbackBackends = true;
@@ -299,15 +382,16 @@ private void useFallbackBackends() {
       newDropList.add(null);
       newBackendAddrList.add(new BackendAddressGroup(eag, null));
     }
-    useRoundRobinLists(newDropList, newBackendAddrList, null);
+    updateServerList(newDropList, newBackendAddrList, null);
   }
 
   private void shutdownLbComm() {
+    shutdownLbRpc();
     if (lbCommChannel != null) {
-      lbCommChannel.shutdown();
+      // The channel should have no RPCs at this point
+      lbCommChannel.shutdownNow();
       lbCommChannel = null;
     }
-    shutdownLbRpc();
   }
 
   private void shutdownLbRpc() {
@@ -317,24 +401,20 @@ private void shutdownLbRpc() {
     }
   }
 
-  private void startLbComm(LbAddressGroup lbAddressGroup) {
-    checkNotNull(lbAddressGroup, "lbAddressGroup");
+  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(
-          lbAddressGroup.getAddresses(), lbAddressGroup.getAuthority());
+      lbCommChannel = helper.createOobChannel(overrideAuthorityEags, doNotUseAuthority);
       logger.log(
           ChannelLogLevel.DEBUG,
-          "[grpclb-<{0}>] Created grpclb channel: address={1}, authority={2}",
+          "[grpclb-<{0}>] Created grpclb channel: EAG={1}",
           serviceName,
-          lbAddressGroup.getAddresses(),
-          lbAddressGroup.getAuthority());
-    } else if (lbAddressGroup.getAuthority().equals(lbCommChannel.authority())) {
-      helper.updateOobChannelAddresses(lbCommChannel, lbAddressGroup.getAddresses());
+          overrideAuthorityEags);
     } else {
-      // Full restart of channel
-      shutdownLbComm();
-      lbCommChannel = helper.createOobChannel(
-          lbAddressGroup.getAddresses(), lbAddressGroup.getAuthority());
+      helper.updateOobChannelAddresses(lbCommChannel, overrideAuthorityEags);
     }
   }
 
@@ -342,7 +422,12 @@ private void startLbRpc() {
     checkState(lbStream == null, "previous lbStream has not been cleared yet");
     LoadBalancerGrpc.LoadBalancerStub stub = LoadBalancerGrpc.newStub(lbCommChannel);
     lbStream = new LbStream(stub);
-    lbStream.start();
+    Context prevContext = context.attach();
+    try {
+      lbStream.start();
+    } finally {
+      context.detach(prevContext);
+    }
     stopwatch.reset().start();
 
     LoadBalanceRequest initRequest = LoadBalanceRequest.newBuilder()
@@ -368,6 +453,7 @@ private void cancelFallbackTimer() {
   private void cancelLbRpcRetryTimer() {
     if (lbRpcRetryTimer != null) {
       lbRpcRetryTimer.cancel();
+      lbRpcRetryTimer = null;
     }
   }
 
@@ -384,9 +470,10 @@ void shutdown() {
         subchannelPool.clear();
         break;
       case PICK_FIRST:
-        if (!subchannels.isEmpty()) {
-          checkState(subchannels.size() == 1, "Excessive Subchannels: %s", subchannels);
-          subchannels.values().iterator().next().shutdown();
+        // Shutdown the child pick_first LB which manages its own subchannels.
+        if (pickFirstLb != null) {
+          pickFirstLb.shutdown();
+          pickFirstLb = null;
         }
         break;
       default:
@@ -400,8 +487,10 @@ void shutdown() {
   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(status))));
+          TRANSIENT_FAILURE, new RoundRobinPicker(dropList, Arrays.asList(new ErrorEntry(error))));
     }
   }
 
@@ -419,17 +508,11 @@ GrpclbClientLoadRecorder getLoadRecorder() {
   }
 
   /**
-   * Populate the round-robin lists with the given values.
+   * Populate backend servers to be used based on the given list of addresses.
    */
-  private void useRoundRobinLists(
+  private void updateServerList(
       List<DropEntry> newDropList, List<BackendAddressGroup> newBackendAddrList,
       @Nullable GrpclbClientLoadRecorder loadRecorder) {
-    logger.log(
-        ChannelLogLevel.INFO,
-        "[grpclb-<{0}>] Using RR list={1}, drop={2}",
-        serviceName,
-        newBackendAddrList,
-        newDropList);
     HashMap<List<EquivalentAddressGroup>, Subchannel> newSubchannelMap =
         new HashMap<>();
     List<BackendEntry> newBackendList = new ArrayList<>();
@@ -467,23 +550,17 @@ private void useRoundRobinLists(
         subchannels = Collections.unmodifiableMap(newSubchannelMap);
         break;
       case PICK_FIRST:
-        checkState(subchannels.size() <= 1, "Unexpected Subchannel count: %s", subchannels);
-        final Subchannel subchannel;
+        // Delegate to child pick_first LB for address management.
+        // Shutdown existing child LB if addresses become empty.
         if (newBackendAddrList.isEmpty()) {
-          if (subchannels.size() == 1) {
-            cancelFallbackTimer();
-            subchannel = subchannels.values().iterator().next();
-            subchannel.shutdown();
-            subchannels = Collections.emptyMap();
+          if (pickFirstLb != null) {
+            pickFirstLb.shutdown();
+            pickFirstLb = null;
           }
           break;
         }
         List<EquivalentAddressGroup> eagList = new ArrayList<>();
-        // Because for PICK_FIRST, we create a single Subchannel for all addresses, we have to
-        // attach the tokens to the EAG attributes and use TokenAttachingLoadRecorder to put them on
-        // headers.
-        //
-        // The PICK_FIRST code path doesn't cache Subchannels.
+        // Attach tokens to EAG attributes for TokenAttachingTracerFactory to retrieve.
         for (BackendAddressGroup bag : newBackendAddrList) {
           EquivalentAddressGroup origEag = bag.getAddresses();
           Attributes eagAttrs = origEag.getAttributes();
@@ -493,30 +570,22 @@ private void useRoundRobinLists(
           }
           eagList.add(new EquivalentAddressGroup(origEag.getAddresses(), eagAttrs));
         }
-        if (subchannels.isEmpty()) {
-          subchannel =
-              helper.createSubchannel(
-                  CreateSubchannelArgs.newBuilder()
-                      .setAddresses(eagList)
-                      .setAttributes(createSubchannelAttrs())
-                      .build());
-          subchannel.start(new SubchannelStateListener() {
-            @Override
-            public void onSubchannelState(ConnectivityStateInfo newState) {
-              handleSubchannelState(subchannel, newState);
-            }
-          });
-          if (requestConnectionPending) {
-            subchannel.requestConnection();
-            requestConnectionPending = false;
-          }
-        } else {
-          subchannel = subchannels.values().iterator().next();
-          subchannel.updateAddresses(eagList);
+
+        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;
         }
-        subchannels = Collections.singletonMap(eagList, subchannel);
-        newBackendList.add(
-            new BackendEntry(subchannel, new TokenAttachingTracerFactory(loadRecorder)));
+        // Store the load recorder for token attachment.
+        currentPickFirstLoadRecorder = loadRecorder;
         break;
       default:
         throw new AssertionError("Missing case for " + config.getMode());
@@ -528,8 +597,17 @@ public void onSubchannelState(ConnectivityStateInfo newState) {
 
   @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();
     }
@@ -637,11 +715,12 @@ private void handleResponse(LoadBalanceResponse response) {
       if (closed) {
         return;
       }
-      logger.log(
-          ChannelLogLevel.DEBUG, "[grpclb-<{0}>] Got an LB response: {1}", serviceName, response);
 
       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,
@@ -656,9 +735,17 @@ private void handleResponse(LoadBalanceResponse response) {
         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;
@@ -690,7 +777,7 @@ private void handleResponse(LoadBalanceResponse response) {
           } catch (UnknownHostException e) {
             propagateError(
                 Status.UNAVAILABLE
-                    .withDescription("Host for server not found: " + server)
+                    .withDescription("Invalid backend address: " + server)
                     .withCause(e));
             continue;
           }
@@ -701,11 +788,11 @@ private void handleResponse(LoadBalanceResponse response) {
           newBackendAddrList.add(new BackendAddressGroup(eag, token));
         }
       }
-      // Stop using fallback backends as soon as a new server list is received from the balancer.
+      // Exit fallback as soon as a new server list is received from the balancer.
       usingFallbackBackends = false;
-      lbSentEmptyBackends = serverList.getServersList().isEmpty();
+      fallbackReason = null;
       cancelFallbackTimer();
-      useRoundRobinLists(newDropList, newBackendAddrList, loadRecorder);
+      updateServerList(newDropList, newBackendAddrList, loadRecorder);
       maybeUpdatePicker();
     }
 
@@ -718,6 +805,8 @@ private void handleStreamClosed(Status error) {
       cleanUp();
       propagateError(error);
       balancerWorking = false;
+      fallbackReason = error;
+      cancelFallbackTimer();
       maybeUseFallbackBackends();
       maybeUpdatePicker();
 
@@ -773,11 +862,37 @@ private void cleanUp() {
   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 hasIdle = false;
+        boolean hasPending = false;
         for (BackendEntry entry : backendList) {
           Subchannel subchannel = entry.subchannel;
           Attributes attrs = subchannel.getAttributes();
@@ -786,57 +901,31 @@ private void maybeUpdatePicker() {
             pickList.add(entry);
           } else if (stateInfo.getState() == TRANSIENT_FAILURE) {
             error = stateInfo.getStatus();
-          } else if (stateInfo.getState() == IDLE) {
-            hasIdle = true;
+          } else {
+            hasPending = true;
           }
         }
         if (pickList.isEmpty()) {
-          if (error != null && !hasIdle) {
-            pickList.add(new ErrorEntry(error));
-            state = TRANSIENT_FAILURE;
-          } else {
+          if (hasPending) {
             pickList.add(BUFFER_ENTRY);
             state = CONNECTING;
+          } else {
+            pickList.add(new ErrorEntry(error));
+            state = TRANSIENT_FAILURE;
           }
         } else {
           state = READY;
         }
         break;
-      case PICK_FIRST:
-        if (backendList.isEmpty()) {
-          if (lbSentEmptyBackends) {
-            pickList =
-                Collections.<RoundRobinEntry>singletonList(
-                    new ErrorEntry(NO_AVAILABLE_BACKENDS_STATUS));
-            state = TRANSIENT_FAILURE;
-          } else {
-            pickList = Collections.singletonList(BUFFER_ENTRY);
-            // Have not received server addresses
-            state = CONNECTING;
-          }
-        } else {
-          checkState(backendList.size() == 1, "Excessive backend entries: %s", backendList);
-          BackendEntry onlyEntry = backendList.get(0);
-          ConnectivityStateInfo stateInfo =
-              onlyEntry.subchannel.getAttributes().get(STATE_INFO).get();
-          state = stateInfo.getState();
-          switch (state) {
-            case READY:
-              pickList = Collections.<RoundRobinEntry>singletonList(onlyEntry);
-              break;
-            case TRANSIENT_FAILURE:
-              pickList =
-                  Collections.<RoundRobinEntry>singletonList(new ErrorEntry(stateInfo.getStatus()));
-              break;
-            case CONNECTING:
-              pickList = Collections.singletonList(BUFFER_ENTRY);
-              break;
-            default:
-              pickList = Collections.<RoundRobinEntry>singletonList(
-                  new IdleSubchannelEntry(onlyEntry.subchannel, syncContext));
-          }
-        }
+      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());
     }
@@ -850,62 +939,16 @@ 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 (picker.dropList.equals(currentPicker.dropList)
+    if (state.equals(currentState)
+        && picker.dropList.equals(currentPicker.dropList)
         && picker.pickList.equals(currentPicker.pickList)) {
       return;
     }
+    currentState = state;
     currentPicker = picker;
-    logger.log(
-        ChannelLogLevel.INFO,
-        "[grpclb-<{0}>] Update balancing state to {1}: picks={2}, drops={3}",
-        serviceName,
-        state,
-        picker.pickList,
-        picker.dropList);
     helper.updateBalancingState(state, picker);
   }
 
-  private LbAddressGroup flattenLbAddressGroups(List<LbAddressGroup> groupList) {
-    assert !groupList.isEmpty();
-    List<EquivalentAddressGroup> eags = new ArrayList<>(groupList.size());
-    String authority = groupList.get(0).getAuthority();
-    for (LbAddressGroup group : groupList) {
-      if (!authority.equals(group.getAuthority())) {
-        // TODO(ejona): Allow different authorities for different addresses. Requires support from
-        // Helper.
-        logger.log(ChannelLogLevel.WARNING,
-            "[grpclb-<{0}>] Multiple authorities found for LB. "
-            + "Skipping addresses for {1} in preference to {2}",
-            serviceName,
-            group.getAuthority(),
-            authority);
-      } else {
-        eags.add(group.getAddresses());
-      }
-    }
-    // ALTS code can use the presence of ATTR_LB_ADDR_AUTHORITY to select ALTS instead of TLS, with
-    // Netty.
-    // TODO(ejona): The process here is a bit of a hack because ATTR_LB_ADDR_AUTHORITY isn't
-    // actually used in the normal case. https://github.com/grpc/grpc-java/issues/4618 should allow
-    // this to be more obvious.
-    Attributes attrs = Attributes.newBuilder()
-        .set(GrpclbConstants.ATTR_LB_ADDR_AUTHORITY, authority)
-        .build();
-    return new LbAddressGroup(flattenEquivalentAddressGroup(eags, attrs), authority);
-  }
-
-  /**
-   * Flattens list of EquivalentAddressGroup objects into one EquivalentAddressGroup object.
-   */
-  private static EquivalentAddressGroup flattenEquivalentAddressGroup(
-      List<EquivalentAddressGroup> groupList, Attributes attrs) {
-    List<SocketAddress> addrs = new ArrayList<>();
-    for (EquivalentAddressGroup group : groupList) {
-      addrs.addAll(group.getAddresses());
-    }
-    return new EquivalentAddressGroup(addrs, attrs);
-  }
-
   private static Attributes createSubchannelAttrs() {
     return Attributes.newBuilder()
         .set(STATE_INFO,
@@ -952,7 +995,7 @@ public boolean equals(Object other) {
 
   @VisibleForTesting
   interface RoundRobinEntry {
-    PickResult picked(Metadata headers);
+    PickResult picked(PickSubchannelArgs args);
   }
 
   @VisibleForTesting
@@ -993,7 +1036,8 @@ static final class BackendEntry implements RoundRobinEntry {
     }
 
     @Override
-    public PickResult picked(Metadata headers) {
+    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);
@@ -1034,7 +1078,7 @@ static final class IdleSubchannelEntry implements RoundRobinEntry {
     }
 
     @Override
-    public PickResult picked(Metadata headers) {
+    public PickResult picked(PickSubchannelArgs args) {
       if (connectionRequested.compareAndSet(false, true)) {
         syncContext.execute(new Runnable() {
             @Override
@@ -1077,7 +1121,7 @@ static final class ErrorEntry implements RoundRobinEntry {
     }
 
     @Override
-    public PickResult picked(Metadata headers) {
+    public PickResult picked(PickSubchannelArgs args) {
       return result;
     }
 
@@ -1101,6 +1145,58 @@ public String 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
@@ -1143,16 +1239,43 @@ public PickResult pickSubchannel(PickSubchannelArgs args) {
         if (pickIndex == pickList.size()) {
           pickIndex = 0;
         }
-        return pick.picked(args.getHeaders());
+        return pick.picked(args);
       }
     }
 
     @Override
     public String toString() {
-      return MoreObjects.toStringHelper(RoundRobinPicker.class)
-          .add("dropList", dropList)
-          .add("pickList", pickList)
-          .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/LbAddressGroup.java b/grpclb/src/main/java/io/grpc/grpclb/LbAddressGroup.java
deleted file mode 100644
index cca096f75a3..00000000000
--- a/grpclb/src/main/java/io/grpc/grpclb/LbAddressGroup.java
+++ /dev/null
@@ -1,42 +0,0 @@
-/*
- * 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.grpclb;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-import io.grpc.EquivalentAddressGroup;
-
-/**
- * Represents a balancer address entry.
- */
-final 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");
-  }
-
-  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
index bc25f28f94c..f394c812b28 100644
--- a/grpclb/src/main/java/io/grpc/grpclb/SecretGrpclbNameResolverProvider.java
+++ b/grpclb/src/main/java/io/grpc/grpclb/SecretGrpclbNameResolverProvider.java
@@ -19,10 +19,17 @@
 import com.google.common.base.Preconditions;
 import com.google.common.base.Stopwatch;
 import io.grpc.InternalServiceProviders;
+import io.grpc.NameResolver;
 import io.grpc.NameResolver.Args;
 import io.grpc.NameResolverProvider;
+import io.grpc.Uri;
 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;
+import java.util.List;
 
 /**
  * A provider for {@code io.grpc.grpclb.GrpclbNameResolver}.
@@ -49,27 +56,50 @@ 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 NameResolver newNameResolver(Uri targetUri, final NameResolver.Args args) {
+      if (SCHEME.equals(targetUri.getScheme())) {
+        List<String> pathSegments = targetUri.getPathSegments();
+        Preconditions.checkArgument(
+            pathSegments.size() == 1,
+            "expected 1 path segment in target %s but found %s",
+            targetUri,
+            pathSegments);
+        return newNameResolver(targetUri.getAuthority(), pathSegments.get(0), args);
+      } else {
+        return null;
+      }
+    }
+
     @Override
     public GrpclbNameResolver newNameResolver(URI targetUri, 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 GrpclbNameResolver(
-            targetUri.getAuthority(),
-            name,
-            args,
-            GrpcUtil.SHARED_CHANNEL_EXECUTOR,
-            Stopwatch.createUnstarted(),
-            InternalServiceProviders.isAndroid(getClass().getClassLoader()));
+        return newNameResolver(targetUri.getAuthority(), targetPath.substring(1), args);
       } else {
         return null;
       }
     }
 
+    private GrpclbNameResolver newNameResolver(
+        String authority, String domainNameToResolve, final NameResolver.Args args) {
+      return new GrpclbNameResolver(
+          authority,
+          domainNameToResolve,
+          args,
+          GrpcUtil.SHARED_CHANNEL_EXECUTOR,
+          Stopwatch.createUnstarted(),
+          IS_ANDROID);
+    }
+
     @Override
     public String getDefaultScheme() {
       return SCHEME;
@@ -85,5 +115,10 @@ 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/TokenAttachingTracerFactory.java b/grpclb/src/main/java/io/grpc/grpclb/TokenAttachingTracerFactory.java
index 03b9bdf7f1b..c00d988aa5d 100644
--- a/grpclb/src/main/java/io/grpc/grpclb/TokenAttachingTracerFactory.java
+++ b/grpclb/src/main/java/io/grpc/grpclb/TokenAttachingTracerFactory.java
@@ -22,6 +22,7 @@
 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;
 
@@ -42,19 +43,30 @@ final class TokenAttachingTracerFactory extends ClientStreamTracer.Factory {
   @Override
   public ClientStreamTracer newClientStreamTracer(
       ClientStreamTracer.StreamInfo info, Metadata headers) {
-    Attributes transportAttrs = checkNotNull(info.getTransportAttrs(), "transportAttrs");
-    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);
-    }
-    if (delegate != null) {
-      return delegate.newClientStreamTracer(info, headers);
-    } else {
+    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
diff --git a/grpclb/src/main/proto/grpc/lb/v1/load_balancer.proto b/grpclb/src/main/proto/grpc/lb/v1/load_balancer.proto
index a9588b0db94..00fc7096c9c 100644
--- a/grpclb/src/main/proto/grpc/lb/v1/load_balancer.proto
+++ b/grpclb/src/main/proto/grpc/lb/v1/load_balancer.proto
@@ -104,12 +104,7 @@ message LoadBalanceResponse {
 message FallbackResponse {}
 
 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. Its length should
-  // be less than 64 bytes.
-  string load_balancer_delegate = 1;
+  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
diff --git a/grpclb/src/test/java/io/grpc/grpclb/GrpclbLoadBalancerProviderTest.java b/grpclb/src/test/java/io/grpc/grpclb/GrpclbLoadBalancerProviderTest.java
index dda9700f64a..153ce5a86f1 100644
--- a/grpclb/src/test/java/io/grpc/grpclb/GrpclbLoadBalancerProviderTest.java
+++ b/grpclb/src/test/java/io/grpc/grpclb/GrpclbLoadBalancerProviderTest.java
@@ -18,7 +18,9 @@
 
 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;
@@ -30,6 +32,17 @@
 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\" : {}}]}";
@@ -41,6 +54,7 @@ public void retrieveModeFromLbConfig_pickFirst() throws Exception {
     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
@@ -54,6 +68,54 @@ public void retrieveModeFromLbConfig_roundRobin() throws Exception {
     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
@@ -65,6 +127,7 @@ public void retrieveModeFromLbConfig_nullConfigUseRoundRobin() throws Exception
     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
@@ -78,6 +141,7 @@ public void retrieveModeFromLbConfig_emptyConfigUseRoundRobin() throws Exception
     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
@@ -91,6 +155,7 @@ public void retrieveModeFromLbConfig_emptyChildPolicyUseRoundRobin() throws Exce
     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
@@ -117,6 +182,7 @@ public void retrieveModeFromLbConfig_skipUnsupportedChildPolicy() throws Excepti
     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
@@ -131,6 +197,7 @@ public void retrieveModeFromLbConfig_skipUnsupportedChildPolicyWithTarget() thro
     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
diff --git a/grpclb/src/test/java/io/grpc/grpclb/GrpclbLoadBalancerTest.java b/grpclb/src/test/java/io/grpc/grpclb/GrpclbLoadBalancerTest.java
index abc90743383..ef31b318cb5 100644
--- a/grpclb/src/test/java/io/grpc/grpclb/GrpclbLoadBalancerTest.java
+++ b/grpclb/src/test/java/io/grpc/grpclb/GrpclbLoadBalancerTest.java
@@ -25,6 +25,7 @@
 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.assertFalse;
 import static org.junit.Assert.assertNull;
@@ -54,6 +55,8 @@
 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.LoadBalancer.CreateSubchannelArgs;
 import io.grpc.LoadBalancer.Helper;
@@ -69,6 +72,7 @@
 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;
@@ -103,21 +107,26 @@
 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 {
+  @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
@@ -199,7 +208,6 @@ public void uncaughtException(Thread t, Throwable e) {
 
   @Before
   public void setUp() throws Exception {
-    MockitoAnnotations.initMocks(this);
     mockLbService = mock(LoadBalancerGrpc.LoadBalancerImplBase.class, delegatesTo(
         new LoadBalancerGrpc.LoadBalancerImplBase() {
           @Override
@@ -227,6 +235,7 @@ public Void answer(InvocationOnMock invocation) {
     when(backoffPolicyProvider.get()).thenReturn(backoffPolicy1, backoffPolicy2);
     balancer = new GrpclbLoadBalancer(
         helper,
+        Context.ROOT,
         subchannelPool,
         fakeClock.getTimeProvider(),
         fakeClock.getStopwatchSupplier().get(),
@@ -476,6 +485,7 @@ public void loadReporting() {
 
     ClientStreamTracer tracer1 =
         pick1.getStreamTracerFactory().newClientStreamTracer(STREAM_INFO, new Metadata());
+    tracer1.streamCreated(Attributes.EMPTY, new Metadata());
 
     PickResult pick2 = picker.pickSubchannel(args);
     assertNull(pick2.getSubchannel());
@@ -499,6 +509,7 @@ public void loadReporting() {
     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();
@@ -536,6 +547,7 @@ public void loadReporting() {
     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);
@@ -625,10 +637,6 @@ public void loadReporting() {
 
   @Test
   public void abundantInitialResponse() {
-    Metadata headers = new Metadata();
-    PickSubchannelArgs args = mock(PickSubchannelArgs.class);
-    when(args.getHeaders()).thenReturn(headers);
-
     List<EquivalentAddressGroup> grpclbBalancerList = createResolvedBalancerAddresses(1);
     deliverResolvedAddresses(Collections.<EquivalentAddressGroup>emptyList(), grpclbBalancerList);
     assertEquals(1, fakeOobChannels.size());
@@ -662,12 +670,55 @@ public void abundantInitialResponse() {
     assertEquals(1983, scheduledTask.getDelay(TimeUnit.MILLISECONDS));
   }
 
+  @SuppressWarnings("unchecked")
   @Test
-  public void raceBetweenLoadReportingAndLbStreamClosure() {
-    Metadata headers = new Metadata();
-    PickSubchannelArgs args = mock(PickSubchannelArgs.class);
-    when(args.getHeaders()).thenReturn(headers);
+  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();
+  }
+
+  @Test
+  public void raceBetweenLoadReportingAndLbStreamClosure() {
     List<EquivalentAddressGroup> grpclbBalancerList = createResolvedBalancerAddresses(1);
     deliverResolvedAddresses(Collections.<EquivalentAddressGroup>emptyList(), grpclbBalancerList);
     assertEquals(1, fakeOobChannels.size());
@@ -729,7 +780,9 @@ public void receiveNoBackendAndBalancerAddress() {
     verify(helper).updateBalancingState(eq(TRANSIENT_FAILURE), pickerCaptor.capture());
     RoundRobinPicker picker = (RoundRobinPicker) pickerCaptor.getValue();
     assertThat(picker.dropList).isEmpty();
-    Status error = Iterables.getOnlyElement(picker.pickList).picked(new Metadata()).getStatus();
+    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");
   }
@@ -739,26 +792,26 @@ 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,
-        "INFO: [grpclb-<api.google.com>] Update balancing state to TRANSIENT_FAILURE: picks="
-            + "[Status{code=NOT_FOUND, description=www.google.com not found, cause=null}],"
-            + " drops=[]")
+    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();
-    assertThat(picker.pickList).containsExactly(new ErrorEntry(error));
+    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);
-    EquivalentAddressGroup eag = grpclbBalancerList.get(0);
 
     deliverResolvedAddresses(Collections.<EquivalentAddressGroup>emptyList(), grpclbBalancerList);
 
-    verify(helper).createOobChannel(eq(eag), eq(lbAuthority(0)));
+    verify(helper).createOobChannel(eq(xattr(grpclbBalancerList)),
+        eq(lbAuthority(0) + NO_USE_AUTHORITY_SUFFIX));
     verify(mockLbService).balanceLoad(lbResponseObserverCaptor.capture());
   }
 
@@ -769,7 +822,8 @@ public void grpclbThenNameResolutionFails() {
     List<EquivalentAddressGroup> grpclbBalancerList = createResolvedBalancerAddresses(1);
     deliverResolvedAddresses(Collections.<EquivalentAddressGroup>emptyList(), grpclbBalancerList);
 
-    verify(helper).createOobChannel(eq(grpclbBalancerList.get(0)), eq(lbAuthority(0)));
+    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());
@@ -782,7 +836,9 @@ public void grpclbThenNameResolutionFails() {
     inOrder.verify(helper).updateBalancingState(eq(TRANSIENT_FAILURE), pickerCaptor.capture());
     RoundRobinPicker picker = (RoundRobinPicker) pickerCaptor.getValue();
     assertThat(picker.dropList).isEmpty();
-    assertThat(picker.pickList).containsExactly(new ErrorEntry(error));
+    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
@@ -806,28 +862,27 @@ public void grpclbUpdatedAddresses_avoidsReconnect() {
     List<EquivalentAddressGroup> grpclbBalancerList = createResolvedBalancerAddresses(1);
     deliverResolvedAddresses(backendList, grpclbBalancerList);
 
-    verify(helper).createOobChannel(eq(grpclbBalancerList.get(0)), eq(lbAuthority(0)));
+    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);
-    EquivalentAddressGroup combinedEag = new EquivalentAddressGroup(Arrays.asList(
-        grpclbBalancerList2.get(0).getAddresses().get(0),
-        grpclbBalancerList2.get(1).getAddresses().get(0)),
-        lbAttributes(lbAuthority(0)));
     deliverResolvedAddresses(backendList2, grpclbBalancerList2);
-    verify(helper).updateOobChannelAddresses(eq(oobChannel), eq(combinedEag));
+    verify(helper).updateOobChannelAddresses(eq(oobChannel), eq(xattr(grpclbBalancerList2)));
     assertEquals(1, lbRequestObservers.size()); // No additional RPC
   }
 
+
   @Test
   public void grpclbUpdatedAddresses_reconnectOnAuthorityChange() {
     List<EquivalentAddressGroup> backendList = createResolvedBackendAddresses(1);
     List<EquivalentAddressGroup> grpclbBalancerList = createResolvedBalancerAddresses(1);
     deliverResolvedAddresses(backendList, grpclbBalancerList);
 
-    verify(helper).createOobChannel(eq(grpclbBalancerList.get(0)), eq(lbAuthority(0)));
+    verify(helper).createOobChannel(eq(xattr(grpclbBalancerList)),
+        eq(lbAuthority(0) + NO_USE_AUTHORITY_SUFFIX));
     ManagedChannel oobChannel = fakeOobChannels.poll();
     assertEquals(1, lbRequestObservers.size());
 
@@ -838,9 +893,8 @@ public void grpclbUpdatedAddresses_reconnectOnAuthorityChange() {
             new EquivalentAddressGroup(
                 new FakeSocketAddress("somethingNew"), lbAttributes(newAuthority)));
     deliverResolvedAddresses(backendList2, grpclbBalancerList2);
-    assertTrue(oobChannel.isTerminated());
-    verify(helper).createOobChannel(eq(grpclbBalancerList2.get(0)), eq(newAuthority));
-    assertEquals(2, lbRequestObservers.size()); // An additional RPC
+    verify(helper).updateOobChannelAddresses(eq(oobChannel), eq(xattr(grpclbBalancerList2)));
+    assertEquals(1, lbRequestObservers.size()); // No additional RPC
   }
 
   @Test
@@ -852,7 +906,8 @@ public void grpclbWorking() {
     // Fallback timer is started as soon as the addresses are resolved.
     assertEquals(1, fakeClock.numPendingTasks(FALLBACK_MODE_TASK_FILTER));
 
-    verify(helper).createOobChannel(eq(grpclbBalancerList.get(0)), eq(lbAuthority(0)));
+    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());
@@ -873,7 +928,7 @@ public void grpclbWorking() {
     logs.clear();
     lbResponseObserver.onNext(buildInitialResponse());
     assertThat(logs).containsExactly(
-        "DEBUG: [grpclb-<api.google.com>] Got an LB response: " + buildInitialResponse());
+        "INFO: [grpclb-<api.google.com>] Got an LB initial response: " + buildInitialResponse());
     logs.clear();
     lbResponseObserver.onNext(buildLbResponse(backends1));
 
@@ -905,24 +960,13 @@ public void grpclbWorking() {
     inOrder.verifyNoMoreInteractions();
 
     assertThat(logs).containsExactly(
-            "DEBUG: [grpclb-<api.google.com>] Got an LB response: " + buildLbResponse(backends1),
-            "INFO: [grpclb-<api.google.com>] Using RR list="
-                + "[[[/127.0.0.1:2000]/{io.grpc.grpclb.lbProvidedBackend=true}](token0001),"
-                + " [[/127.0.0.1:2010]/{io.grpc.grpclb.lbProvidedBackend=true}](token0002)],"
-                + " drop=[null, null]",
-            "INFO: [grpclb-<api.google.com>]"
-                + " Update balancing state to CONNECTING: picks=[BUFFER_ENTRY], drops=[null, null]")
+        "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());
-    assertThat(logs).containsExactly(
-        "INFO: [grpclb-<api.google.com>] Update balancing state to READY: picks="
-            + "[[[[[/127.0.0.1:2010]/{io.grpc.grpclb.lbProvidedBackend=true}]](token0002)]],"
-            + " drops=[null, null]");
-    logs.clear();
 
     RoundRobinPicker picker1 = (RoundRobinPicker) pickerCaptor.getValue();
 
@@ -932,12 +976,6 @@ public void grpclbWorking() {
 
     deliverSubchannelState(subchannel1, ConnectivityStateInfo.forNonError(READY));
     inOrder.verify(helper).updateBalancingState(eq(READY), pickerCaptor.capture());
-    assertThat(logs).containsExactly(
-        "INFO: [grpclb-<api.google.com>] Update balancing state to READY: picks="
-            + "[[[[[/127.0.0.1:2000]/{io.grpc.grpclb.lbProvidedBackend=true}]](token0001)],"
-            + " [[[[/127.0.0.1:2010]/{io.grpc.grpclb.lbProvidedBackend=true}]](token0002)]],"
-            + " drops=[null, null]");
-    logs.clear();
 
     RoundRobinPicker picker2 = (RoundRobinPicker) pickerCaptor.getValue();
     assertThat(picker2.dropList).containsExactly(null, null);
@@ -950,12 +988,8 @@ public void grpclbWorking() {
     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());
-    assertThat(logs).containsExactly(
-        "INFO: [grpclb-<api.google.com>] Update balancing state to READY: picks="
-            + "[[[[[/127.0.0.1:2010]/{io.grpc.grpclb.lbProvidedBackend=true}]](token0002)]],"
-            + " drops=[null, null]");
-    logs.clear();
 
     RoundRobinPicker picker3 = (RoundRobinPicker) pickerCaptor.getValue();
     assertThat(picker3.dropList).containsExactly(null, null);
@@ -969,6 +1003,7 @@ public void grpclbWorking() {
     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
@@ -976,10 +1011,6 @@ public void grpclbWorking() {
     deliverSubchannelState(subchannel2, ConnectivityStateInfo.forNonError(IDLE));
     verify(subchannel2, times(2)).requestConnection();
     inOrder.verify(helper).updateBalancingState(eq(CONNECTING), pickerCaptor.capture());
-    assertThat(logs).containsExactly(
-        "INFO: [grpclb-<api.google.com>] "
-            + "Update balancing state to CONNECTING: picks=[BUFFER_ENTRY], drops=[null, null]");
-    logs.clear();
 
     RoundRobinPicker picker4 = (RoundRobinPicker) pickerCaptor.getValue();
     assertThat(picker4.dropList).containsExactly(null, null);
@@ -998,15 +1029,7 @@ public void grpclbWorking() {
 
     lbResponseObserver.onNext(buildLbResponse(backends2));
     assertThat(logs).containsExactly(
-            "DEBUG: [grpclb-<api.google.com>] Got an LB response: " + buildLbResponse(backends2),
-            "INFO: [grpclb-<api.google.com>] Using RR list="
-                + "[[[/127.0.0.1:2030]/{io.grpc.grpclb.lbProvidedBackend=true}](token0003),"
-                + " [[/127.0.0.1:2010]/{io.grpc.grpclb.lbProvidedBackend=true}](token0004),"
-                + " [[/127.0.0.1:2030]/{io.grpc.grpclb.lbProvidedBackend=true}](token0005)],"
-                + " drop=[null, drop(token0003), null, null, drop(token0006)]",
-            "INFO: [grpclb-<api.google.com>]"
-                + " Update balancing state to CONNECTING: picks=[BUFFER_ENTRY],"
-                + " drops=[null, drop(token0003), null, null, drop(token0006)]")
+        "DEBUG: [grpclb-<api.google.com>] Got an LB response: " + buildLbResponse(backends2))
         .inOrder();
     logs.clear();
 
@@ -1086,10 +1109,11 @@ public void grpclbWorking() {
         .returnSubchannel(same(subchannel2), eq(ConnectivityStateInfo.forNonError(READY)));
     verify(subchannelPool)
         .returnSubchannel(same(subchannel3), eq(ConnectivityStateInfo.forNonError(READY)));
-    inOrder.verify(helper).updateBalancingState(eq(CONNECTING), pickerCaptor.capture());
+    inOrder.verify(helper).updateBalancingState(eq(TRANSIENT_FAILURE), pickerCaptor.capture());
     RoundRobinPicker picker10 = (RoundRobinPicker) pickerCaptor.getValue();
     assertThat(picker10.dropList).isEmpty();
-    assertThat(picker10.pickList).containsExactly(BUFFER_ENTRY);
+    assertThat(picker10.pickList)
+        .containsExactly(new ErrorEntry(GrpclbState.NO_AVAILABLE_BACKENDS_STATUS));
 
     assertFalse(oobChannel.isShutdown());
     assertEquals(0, lbRequestObservers.size());
@@ -1126,9 +1150,12 @@ public void roundRobinMode_subchannelStayTransientFailureUntilReady() {
     deliverSubchannelState(subchannel2, ConnectivityStateInfo.forNonError(CONNECTING));
     inOrder.verify(helper).updateBalancingState(eq(CONNECTING), any(SubchannelPicker.class));
 
-    // Switch subchannel1 to TRANSIENT_FAILURE, making the general state TRANSIENT_FAILURE too.
-    Status error = Status.UNAVAILABLE.withDescription("error1");
+    // 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));
@@ -1136,6 +1163,7 @@ public void roundRobinMode_subchannelStayTransientFailureUntilReady() {
     // 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();
 
@@ -1149,26 +1177,36 @@ public void roundRobinMode_subchannelStayTransientFailureUntilReady() {
 
   @Test
   public void grpclbFallback_initialTimeout_serverListReceivedBeforeTimerExpires() {
-    subtestGrpclbFallbackInitialTimeout(false);
+    subtestGrpclbFallbackTimeout(false, GrpclbState.FALLBACK_TIMEOUT_MS);
   }
 
   @Test
   public void grpclbFallback_initialTimeout_timerExpires() {
-    subtestGrpclbFallbackInitialTimeout(true);
+    subtestGrpclbFallbackTimeout(true, GrpclbState.FALLBACK_TIMEOUT_MS);
+  }
+
+  @Test
+  public void grpclbFallback_timeout_serverListReceivedBeforeTimerExpires() {
+    subtestGrpclbFallbackTimeout(false, 12345);
+  }
+
+  @Test
+  public void grpclbFallback_timeout_timerExpires() {
+    subtestGrpclbFallbackTimeout(true, 12345);
   }
 
   // Fallback or not within the period of the initial timeout.
-  private void subtestGrpclbFallbackInitialTimeout(boolean timerExpires) {
+  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);
-
-    inOrder.verify(helper)
-        .createOobChannel(eq(grpclbBalancerList.get(0)), eq(lbAuthority(0)));
+    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());
@@ -1190,7 +1228,7 @@ private void subtestGrpclbFallbackInitialTimeout(boolean timerExpires) {
     inOrder.verifyNoMoreInteractions();
 
     assertEquals(1, fakeClock.numPendingTasks(FALLBACK_MODE_TASK_FILTER));
-    fakeClock.forwardTime(GrpclbState.FALLBACK_TIMEOUT_MS - 1, TimeUnit.MILLISECONDS);
+    fakeClock.forwardTime(timeout - 1, TimeUnit.MILLISECONDS);
     assertEquals(1, fakeClock.numPendingTasks(FALLBACK_MODE_TASK_FILTER));
 
     //////////////////////////////////
@@ -1201,20 +1239,12 @@ private void subtestGrpclbFallbackInitialTimeout(boolean timerExpires) {
       fakeClock.forwardTime(1, TimeUnit.MILLISECONDS);
 
       assertEquals(0, fakeClock.numPendingTasks(FALLBACK_MODE_TASK_FILTER));
-      List<EquivalentAddressGroup> fallbackList =
-          Arrays.asList(backendList.get(0), backendList.get(1));
-      assertThat(logs).containsExactly(
-              "INFO: [grpclb-<api.google.com>] Using fallback backends",
-              "INFO: [grpclb-<api.google.com>]"
-                  + " Using RR list=[[[FakeSocketAddress-fake-address-0]/{}], "
-                  + "[[FakeSocketAddress-fake-address-1]/{}]], drop=[null, null]",
-              "INFO: [grpclb-<api.google.com>] "
-                  + "Update balancing state to CONNECTING: picks=[BUFFER_ENTRY], "
-                  + "drops=[null, null]")
+      assertThat(logs)
+          .containsExactly("INFO: [grpclb-<api.google.com>] Using fallback backends")
           .inOrder();
 
       // Fall back to the backends from resolver
-      fallbackTestVerifyUseOfFallbackBackendLists(inOrder, fallbackList);
+      fallbackTestVerifyUseOfFallbackBackendLists(inOrder, backendList);
 
       assertFalse(oobChannel.isShutdown());
       verify(lbRequestObserver, never()).onCompleted();
@@ -1224,21 +1254,30 @@ private void subtestGrpclbFallbackInitialTimeout(boolean timerExpires) {
     // Name resolver sends new resolution results without any backend addr
     //////////////////////////////////////////////////////////////////////
     grpclbBalancerList = createResolvedBalancerAddresses(2);
-    deliverResolvedAddresses(Collections.<EquivalentAddressGroup>emptyList(),grpclbBalancerList);
+    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(new EquivalentAddressGroup(
-            Arrays.asList(
-                grpclbBalancerList.get(0).getAddresses().get(0),
-                grpclbBalancerList.get(1).getAddresses().get(0)),
-            lbAttributes(lbAuthority(0)))));
+        same(oobChannel), eq(xattr(grpclbBalancerList)));
 
     if (timerExpires) {
       // Still in fallback logic, except that the backend list is empty
-      fallbackTestVerifyUseOfFallbackBackendLists(
-          inOrder, Collections.<EquivalentAddressGroup>emptyList());
+      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());
     }
 
     ////////////////////////////////////////////////////////////////
@@ -1248,12 +1287,12 @@ private void subtestGrpclbFallbackInitialTimeout(boolean timerExpires) {
     subchannelPool.clear();
     backendList = createResolvedBackendAddresses(2);
     grpclbBalancerList = createResolvedBalancerAddresses(1);
-    deliverResolvedAddresses(backendList, grpclbBalancerList);
+    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(grpclbBalancerList.get(0)));
+        same(oobChannel), eq(xattr(grpclbBalancerList)));
 
     if (timerExpires) {
       // New backend addresses are used for fallback
@@ -1299,7 +1338,8 @@ private void subtestGrpclbFallbackInitialTimeout(boolean timerExpires) {
     ///////////////////////////////////////////////////////////////
     backendList = createResolvedBackendAddresses(1);
     grpclbBalancerList = createResolvedBalancerAddresses(1);
-    deliverResolvedAddresses(backendList, grpclbBalancerList);
+    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));
@@ -1318,7 +1358,8 @@ public void grpclbFallback_breakLbStreamBeforeFallbackTimerExpires() {
     List<EquivalentAddressGroup> grpclbBalancerList = createResolvedBalancerAddresses(1);
     deliverResolvedAddresses(backendList, grpclbBalancerList);
 
-    inOrder.verify(helper).createOobChannel(eq(grpclbBalancerList.get(0)), eq(lbAuthority(0)));
+    inOrder.verify(helper).createOobChannel(eq(xattr(grpclbBalancerList)),
+        eq(lbAuthority(0) + NO_USE_AUTHORITY_SUFFIX));
 
     // Attempted to connect to balancer
     assertThat(fakeOobChannels).hasSize(1);
@@ -1346,6 +1387,9 @@ public void grpclbFallback_breakLbStreamBeforeFallbackTimerExpires() {
     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)));
@@ -1358,24 +1402,38 @@ public void grpclbFallback_breakLbStreamBeforeFallbackTimerExpires() {
         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));
+    }
+
+    // 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 grpclbFallback_noBalancerAddress() {
     InOrder inOrder = inOrder(helper, subchannelPool);
 
-    // Create just backend addresses
-    List<EquivalentAddressGroup> backendList = createResolvedBackendAddresses(2);
+    // 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).containsAtLeast(
-            "INFO: [grpclb-<api.google.com>] Using fallback backends",
-            "INFO: [grpclb-<api.google.com>] "
-                + "Using RR list=[[[FakeSocketAddress-fake-address-0]/{}], "
-                + "[[FakeSocketAddress-fake-address-1]/{}]], drop=[null, null]",
-            "INFO: [grpclb-<api.google.com>] "
-                + "Update balancing state to CONNECTING: picks=[BUFFER_ENTRY], drops=[null, null]")
-        .inOrder();
+    assertThat(logs).contains("INFO: [grpclb-<api.google.com>] Using fallback backends");
 
     // Fall back to the backends from resolver
     fallbackTestVerifyUseOfFallbackBackendLists(inOrder, backendList);
@@ -1383,7 +1441,65 @@ public void grpclbFallback_noBalancerAddress() {
     // No fallback timeout timer scheduled.
     assertEquals(0, fakeClock.numPendingTasks(FALLBACK_MODE_TASK_FILTER));
     verify(helper, never())
-        .createOobChannel(any(EquivalentAddressGroup.class), anyString());
+        .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));
+  }
+
+  /**
+   * 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));
   }
 
   @Test
@@ -1412,7 +1528,8 @@ private void subtestGrpclbFallbackConnectionLost(
     List<EquivalentAddressGroup> grpclbBalancerList = createResolvedBalancerAddresses(1);
     deliverResolvedAddresses(backendList, grpclbBalancerList);
 
-    inOrder.verify(helper).createOobChannel(eq(grpclbBalancerList.get(0)), eq(lbAuthority(0)));
+    inOrder.verify(helper).createOobChannel(eq(xattr(grpclbBalancerList)),
+        eq(lbAuthority(0) + NO_USE_AUTHORITY_SUFFIX));
 
     // Attempted to connect to balancer
     assertEquals(1, fakeOobChannels.size());
@@ -1450,11 +1567,13 @@ private void subtestGrpclbFallbackConnectionLost(
       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();
       }
     }
 
@@ -1467,6 +1586,7 @@ private void subtestGrpclbFallbackConnectionLost(
       // 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
@@ -1480,6 +1600,7 @@ private void subtestGrpclbFallbackConnectionLost(
     }
     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));
@@ -1488,6 +1609,72 @@ private void subtestGrpclbFallbackConnectionLost(
     }
   }
 
+  @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));
+    }
+
+    // Recycle all subchannels
+    for (Subchannel subchannel : subchannels) {
+      verify(subchannelPool).returnSubchannel(eq(subchannel), any(ConnectivityStateInfo.class));
+    }
+
+    // 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());
+  }
+
   private List<Subchannel> fallbackTestVerifyUseOfFallbackBackendLists(
       InOrder inOrder, List<EquivalentAddressGroup> addrs) {
     return fallbackTestVerifyUseOfBackendLists(inOrder, addrs, null);
@@ -1562,16 +1749,36 @@ public void grpclbMultipleAuthorities() throws Exception {
             lbAttributes("fake-authority-2")),
         new EquivalentAddressGroup(
             new FakeSocketAddress("fake-address-3"),
-            lbAttributes("fake-authority-1")));
-    final EquivalentAddressGroup goldenOobChannelEag = new EquivalentAddressGroup(
-        Arrays.<SocketAddress>asList(
-            new FakeSocketAddress("fake-address-1"),
-            new FakeSocketAddress("fake-address-3")),
-        lbAttributes("fake-authority-1")); // Supporting multiple authorities would be good, one day
-
+            lbAttributes("fake-authority-1").toBuilder()
+                .set(GrpclbConstants.TOKEN_ATTRIBUTE_KEY, "value").build()
+            ));
     deliverResolvedAddresses(backendList, grpclbBalancerList);
 
-    verify(helper).createOobChannel(goldenOobChannelEag, "fake-authority-1");
+    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));
   }
 
   @Test
@@ -1711,6 +1918,7 @@ public void grpclbWorking_pickFirstMode() throws Exception {
     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())
@@ -1718,42 +1926,41 @@ public void grpclbWorking_pickFirstMode() throws Exception {
             new EquivalentAddressGroup(backends1.get(0).addr, eagAttrsWithToken("token0001")),
             new EquivalentAddressGroup(backends1.get(1).addr, eagAttrsWithToken("token0002")));
 
-    // Initially IDLE
-    inOrder.verify(helper).updateBalancingState(eq(IDLE), pickerCaptor.capture());
+    // 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
+    // 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).containsExactly(new IdleSubchannelEntry(subchannel, syncContext));
+    assertThat(picker0.pickList).hasSize(1);
+    assertThat(picker0.pickList.get(0)).isInstanceOf(ChildLbPickerEntry.class);
 
-    // PICK_FIRST doesn't eagerly connect
-    verify(subchannel, never()).requestConnection();
-
-    // CONNECTING
-    deliverSubchannelState(subchannel, ConnectivityStateInfo.forNonError(CONNECTING));
-    inOrder.verify(helper).updateBalancingState(eq(CONNECTING), pickerCaptor.capture());
-    RoundRobinPicker picker1 = (RoundRobinPicker) pickerCaptor.getValue();
-    assertThat(picker1.dropList).containsExactly(null, null);
-    assertThat(picker1.pickList).containsExactly(BUFFER_ENTRY);
+    // Child pick_first eagerly calls requestConnection()
+    verify(subchannel).requestConnection();
 
     // TRANSIENT_FAILURE
     Status error = Status.UNAVAILABLE.withDescription("Simulated connection error");
     deliverSubchannelState(subchannel, ConnectivityStateInfo.forTransientFailure(error));
-    inOrder.verify(helper).updateBalancingState(eq(TRANSIENT_FAILURE), pickerCaptor.capture());
-    RoundRobinPicker picker2 = (RoundRobinPicker) pickerCaptor.getValue();
-    assertThat(picker2.dropList).containsExactly(null, null);
-    assertThat(picker2.pickList).containsExactly(new ErrorEntry(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).updateBalancingState(eq(READY), pickerCaptor.capture());
-    RoundRobinPicker picker3 = (RoundRobinPicker) pickerCaptor.getValue();
-    assertThat(picker3.dropList).containsExactly(null, null);
-    assertThat(picker3.pickList).containsExactly(
-        new BackendEntry(subchannel, new TokenAttachingTracerFactory(getLoadRecorder())));
-
+    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(
@@ -1764,37 +1971,40 @@ public void grpclbWorking_pickFirstMode() throws Exception {
         .updateBalancingState(any(ConnectivityState.class), any(SubchannelPicker.class));
     lbResponseObserver.onNext(buildLbResponse(backends2));
 
-    // new addresses will be updated to the existing subchannel
-    // createSubchannel() has ever been called only once
+    // 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).updateBalancingState(eq(READY), pickerCaptor.capture());
-    RoundRobinPicker picker4 = (RoundRobinPicker) pickerCaptor.getValue();
-    assertThat(picker4.dropList).containsExactly(
+    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);
-    assertThat(picker4.pickList).containsExactly(
-        new BackendEntry(subchannel, new TokenAttachingTracerFactory(getLoadRecorder())));
+    ChildLbPickerEntry updatedEntry = (ChildLbPickerEntry) picker3.pickList.get(0);
+    PickResult updatedResult =
+        updatedEntry.getChildPicker().pickSubchannel(mock(PickSubchannelArgs.class));
+    assertThat(updatedResult.getSubchannel()).isEqualTo(subchannel);
 
-    // Subchannel goes IDLE, but PICK_FIRST will not try to reconnect
+    // Subchannel goes IDLE, grpclb state should follow
     deliverSubchannelState(subchannel, ConnectivityStateInfo.forNonError(IDLE));
     inOrder.verify(helper).updateBalancingState(eq(IDLE), pickerCaptor.capture());
-    RoundRobinPicker picker5 = (RoundRobinPicker) pickerCaptor.getValue();
-    verify(subchannel, never()).requestConnection();
+    RoundRobinPicker picker4 = (RoundRobinPicker) pickerCaptor.getValue();
 
-    // ... until it's selected
+    // 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 = picker5.pickSubchannel(args);
-    assertThat(pick).isSameInstanceAs(PickResult.withNoResult());
-    verify(subchannel).requestConnection();
-
-    // ... or requested by application
-    balancer.requestConnection();
+    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())
@@ -1832,6 +2042,7 @@ public void grpclbWorking_pickFirstMode_lbSendsEmptyAddress() throws Exception {
     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())
@@ -1839,55 +2050,43 @@ public void grpclbWorking_pickFirstMode_lbSendsEmptyAddress() throws Exception {
             new EquivalentAddressGroup(backends1.get(0).addr, eagAttrsWithToken("token0001")),
             new EquivalentAddressGroup(backends1.get(1).addr, eagAttrsWithToken("token0002")));
 
-    // Initially IDLE
-    inOrder.verify(helper).updateBalancingState(eq(IDLE), pickerCaptor.capture());
+    // 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();
-
-    // Only one subchannel is created
+    // Verify subchannel creation by child LB
     assertThat(mockSubchannels).hasSize(1);
     Subchannel subchannel = mockSubchannels.poll();
     assertThat(picker0.dropList).containsExactly(null, null);
-    assertThat(picker0.pickList).containsExactly(new IdleSubchannelEntry(subchannel, syncContext));
-
-    // PICK_FIRST doesn't eagerly connect
-    verify(subchannel, never()).requestConnection();
-
-    // CONNECTING
-    deliverSubchannelState(subchannel, ConnectivityStateInfo.forNonError(CONNECTING));
-    inOrder.verify(helper).updateBalancingState(eq(CONNECTING), pickerCaptor.capture());
-    RoundRobinPicker picker1 = (RoundRobinPicker) pickerCaptor.getValue();
-    assertThat(picker1.dropList).containsExactly(null, null);
-    assertThat(picker1.pickList).containsExactly(BUFFER_ENTRY);
+    assertThat(picker0.pickList).hasSize(1);
+    assertThat(picker0.pickList.get(0)).isInstanceOf(ChildLbPickerEntry.class);
 
-    // TRANSIENT_FAILURE
-    Status error = Status.UNAVAILABLE.withDescription("Simulated connection error");
-    deliverSubchannelState(subchannel, ConnectivityStateInfo.forTransientFailure(error));
-    inOrder.verify(helper).updateBalancingState(eq(TRANSIENT_FAILURE), pickerCaptor.capture());
-    RoundRobinPicker picker2 = (RoundRobinPicker) pickerCaptor.getValue();
-    assertThat(picker2.dropList).containsExactly(null, null);
-    assertThat(picker2.pickList).containsExactly(new ErrorEntry(error));
+    // Child pick_first eagerly calls requestConnection()
+    verify(subchannel).requestConnection();
 
     // READY
     deliverSubchannelState(subchannel, 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(subchannel, new TokenAttachingTracerFactory(getLoadRecorder())));
-
+    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
+    // Empty addresses from LB - child LB is shutdown
     lbResponseObserver.onNext(buildLbResponse(Collections.<ServerEntry>emptyList()));
 
-    // new addresses will be updated to the existing subchannel
+    // 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();
 
-    inOrder.verify(helper).updateBalancingState(eq(TRANSIENT_FAILURE), pickerCaptor.capture());
+    // 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));
@@ -1904,18 +2103,22 @@ public void grpclbWorking_pickFirstMode_lbSendsEmptyAddress() throws Exception {
         .updateBalancingState(any(ConnectivityState.class), any(SubchannelPicker.class));
     lbResponseObserver.onNext(buildLbResponse(backends2));
 
-    // new addresses will be updated to the existing subchannel
-    inOrder.verify(helper, times(1)).createSubchannel(any(CreateSubchannelArgs.class));
-    inOrder.verify(helper).updateBalancingState(eq(IDLE), pickerCaptor.capture());
-    subchannel = mockSubchannels.poll();
+    // 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(subchannel, ConnectivityStateInfo.forNonError(CONNECTING));
-    deliverSubchannelState(subchannel, ConnectivityStateInfo.forNonError(READY));
-    inOrder.verify(helper).updateBalancingState(eq(READY), pickerCaptor.capture());
-    RoundRobinPicker picker4 = (RoundRobinPicker) pickerCaptor.getValue();
-    assertThat(picker4.pickList).containsExactly(
-        new BackendEntry(subchannel, new TokenAttachingTracerFactory(getLoadRecorder())));
+    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);
   }
 
   @Test
@@ -1947,16 +2150,23 @@ private void subtestShutdownWithoutSubchannel(GrpclbConfig grpclbConfig) {
   }
 
   @Test
-  public void pickFirstMode_fallback() throws Exception {
+  public void pickFirstMode_defaultTimeout_fallback() throws Exception {
+    pickFirstModeFallback(GrpclbState.FALLBACK_TIMEOUT_MS);
+  }
+
+  @Test
+  public void pickFirstMode_serviceConfigTimeout_fallback() throws Exception {
+    pickFirstModeFallback(12345);
+  }
+
+  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));
+        backendList, grpclbBalancerList, GrpclbConfig.create(Mode.PICK_FIRST, null, timeout));
 
     // Attempted to connect to balancer
     assertEquals(1, fakeOobChannels.size());
@@ -1965,9 +2175,9 @@ public void pickFirstMode_fallback() throws Exception {
     assertEquals(1, lbRequestObservers.size());
 
     // Fallback timer expires with no response
-    fakeClock.forwardTime(GrpclbState.FALLBACK_TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    fakeClock.forwardTime(timeout, TimeUnit.MILLISECONDS);
 
-    // Entering fallback mode
+    // Entering fallback mode - child LB is created for fallback backends
     inOrder.verify(helper).createSubchannel(createSubchannelArgsCaptor.capture());
     CreateSubchannelArgs createSubchannelArgs = createSubchannelArgsCaptor.getValue();
     assertThat(createSubchannelArgs.getAddresses())
@@ -1976,23 +2186,24 @@ public void pickFirstMode_fallback() throws Exception {
     assertThat(mockSubchannels).hasSize(1);
     Subchannel subchannel = mockSubchannels.poll();
 
-    // Initially IDLE
-    inOrder.verify(helper).updateBalancingState(eq(IDLE), pickerCaptor.capture());
+    // 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);
 
-    // READY
+    // Initial eager connection request
+    verify(subchannel).requestConnection();
+    // READY transition in fallback
     deliverSubchannelState(subchannel, ConnectivityStateInfo.forNonError(READY));
-    inOrder.verify(helper).updateBalancingState(eq(READY), pickerCaptor.capture());
+    inOrder.verify(helper, atLeast(1)).updateBalancingState(eq(READY), pickerCaptor.capture());
     RoundRobinPicker picker1 = (RoundRobinPicker) pickerCaptor.getValue();
     assertThat(picker1.dropList).containsExactly(null, null);
-    assertThat(picker1.pickList).containsExactly(
-        new BackendEntry(subchannel, new TokenAttachingTracerFactory(null)));
+    ChildLbPickerEntry readyEntry = (ChildLbPickerEntry) picker1.pickList.get(0);
+    assertThat(
+        readyEntry.getChildPicker().pickSubchannel(mock(PickSubchannelArgs.class)).getSubchannel())
+        .isEqualTo(subchannel);
 
-    assertThat(picker0.dropList).containsExactly(null, null);
-    assertThat(picker0.pickList).containsExactly(new IdleSubchannelEntry(subchannel, syncContext));
-
-
-    // Finally, an LB response, which brings us out of fallback
+    // 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"));
@@ -2001,20 +2212,42 @@ public void pickFirstMode_fallback() throws Exception {
     lbResponseObserver.onNext(buildInitialResponse());
     lbResponseObserver.onNext(buildLbResponse(backends1));
 
-    // new addresses will be updated to the existing subchannel
-    // createSubchannel() has ever been called only once
+    // 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).updateBalancingState(eq(READY), pickerCaptor.capture());
+    inOrder.verify(helper, atLeast(1)).updateBalancingState(eq(READY), pickerCaptor.capture());
     RoundRobinPicker picker2 = (RoundRobinPicker) pickerCaptor.getValue();
     assertThat(picker2.dropList).containsExactly(null, null);
-    assertThat(picker2.pickList).containsExactly(
-        new BackendEntry(subchannel, new TokenAttachingTracerFactory(getLoadRecorder())));
+
+    // 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())
@@ -2048,6 +2281,8 @@ public void switchMode() throws Exception {
     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());
@@ -2072,7 +2307,6 @@ public void switchMode() throws Exception {
         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)
@@ -2091,13 +2325,13 @@ public void switchMode() throws Exception {
             InitialLoadBalanceRequest.newBuilder().setName(SERVICE_AUTHORITY).build())
             .build()));
 
-    // Simulate receiving LB response
+    // 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
+    // PICK_FIRST Subchannel: child LB creates it
     inOrder.verify(helper).createSubchannel(createSubchannelArgsCaptor.capture());
     CreateSubchannelArgs createSubchannelArgs = createSubchannelArgsCaptor.getValue();
     assertThat(createSubchannelArgs.getAddresses())
@@ -2105,7 +2339,9 @@ public void switchMode() throws Exception {
             new EquivalentAddressGroup(backends1.get(0).addr, eagAttrsWithToken("token0001")),
             new EquivalentAddressGroup(backends1.get(1).addr, eagAttrsWithToken("token0002")));
 
-    inOrder.verify(helper).updateBalancingState(eq(IDLE), any(SubchannelPicker.class));
+    // Child pick_first eagerly connects, so initial state is CONNECTING (not IDLE)
+    inOrder.verify(helper, atLeast(1))
+        .updateBalancingState(eq(CONNECTING), any(SubchannelPicker.class));
   }
 
   private static Attributes eagAttrsWithToken(String token) {
@@ -2132,7 +2368,7 @@ public void switchMode_nullLbPolicy() throws Exception {
             InitialLoadBalanceRequest.newBuilder().setName(SERVICE_AUTHORITY).build())
             .build()));
 
-    // Simulate receiving LB response
+    // 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"));
@@ -2179,13 +2415,13 @@ public void switchMode_nullLbPolicy() throws Exception {
             InitialLoadBalanceRequest.newBuilder().setName(SERVICE_AUTHORITY).build())
             .build()));
 
-    // Simulate receiving LB response
+    // 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
+    // PICK_FIRST Subchannel: with delegation, child LB creates the subchannel
     inOrder.verify(helper).createSubchannel(createSubchannelArgsCaptor.capture());
     CreateSubchannelArgs createSubchannelArgs = createSubchannelArgsCaptor.getValue();
     assertThat(createSubchannelArgs.getAddresses())
@@ -2193,7 +2429,9 @@ public void switchMode_nullLbPolicy() throws Exception {
             new EquivalentAddressGroup(backends1.get(0).addr, eagAttrsWithToken("token0001")),
             new EquivalentAddressGroup(backends1.get(1).addr, eagAttrsWithToken("token0002")));
 
-    inOrder.verify(helper).updateBalancingState(eq(IDLE), any(SubchannelPicker.class));
+    // Child pick_first eagerly connects, so state is CONNECTING (not IDLE)
+    inOrder.verify(helper, atLeast(1))
+        .updateBalancingState(eq(CONNECTING), any(SubchannelPicker.class));
   }
 
   @Test
@@ -2206,7 +2444,7 @@ public void switchServiceName() throws Exception {
     deliverResolvedAddresses(
         Collections.<EquivalentAddressGroup>emptyList(),
         grpclbBalancerList,
-        GrpclbConfig.create(Mode.ROUND_ROBIN, serviceName));
+        GrpclbConfig.create(Mode.ROUND_ROBIN, serviceName, GrpclbState.FALLBACK_TIMEOUT_MS));
 
     assertEquals(1, fakeOobChannels.size());
     ManagedChannel oobChannel = fakeOobChannels.poll();
@@ -2248,7 +2486,7 @@ public void switchServiceName() throws Exception {
     deliverResolvedAddresses(
         Collections.<EquivalentAddressGroup>emptyList(),
         newGrpclbResolutionList,
-        GrpclbConfig.create(Mode.ROUND_ROBIN, serviceName));
+        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();
@@ -2276,13 +2514,8 @@ public void grpclbWorking_lbSendsFallbackMessage() {
 
     // Fallback timer is started as soon as the addresses are resolved.
     assertEquals(1, fakeClock.numPendingTasks(FALLBACK_MODE_TASK_FILTER));
-
-    List<SocketAddress> addrs = new ArrayList<>();
-    addrs.addAll(grpclbBalancerList.get(0).getAddresses());
-    addrs.addAll(grpclbBalancerList.get(1).getAddresses());
-    Attributes attr = grpclbBalancerList.get(0).getAttributes();
-    EquivalentAddressGroup oobChannelEag = new EquivalentAddressGroup(addrs, attr);
-    verify(helper).createOobChannel(eq(oobChannelEag), eq(lbAuthority(0)));
+    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());
@@ -2304,7 +2537,7 @@ public void grpclbWorking_lbSendsFallbackMessage() {
     logs.clear();
     lbResponseObserver.onNext(buildInitialResponse());
     assertThat(logs).containsExactly(
-        "DEBUG: [grpclb-<api.google.com>] Got an LB response: " + buildInitialResponse());
+        "INFO: [grpclb-<api.google.com>] Got an LB initial response: " + buildInitialResponse());
     logs.clear();
     lbResponseObserver.onNext(buildLbResponse(backends1));
 
@@ -2337,25 +2570,15 @@ public void grpclbWorking_lbSendsFallbackMessage() {
     assertThat(picker0.pickList).containsExactly(BUFFER_ENTRY);
     inOrder.verifyNoMoreInteractions();
 
-    assertThat(logs).containsExactly(
-            "DEBUG: [grpclb-<api.google.com>] Got an LB response: " + buildLbResponse(backends1),
-            "INFO: [grpclb-<api.google.com>] Using RR list="
-                + "[[[/127.0.0.1:2000]/{io.grpc.grpclb.lbProvidedBackend=true}](token0001),"
-                + " [[/127.0.0.1:2010]/{io.grpc.grpclb.lbProvidedBackend=true}](token0002)],"
-                + " drop=[null, null]",
-            "INFO: [grpclb-<api.google.com>] "
-                + "Update balancing state to CONNECTING: picks=[BUFFER_ENTRY], drops=[null, null]")
+    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());
-    assertThat(logs).containsExactly(
-        "INFO: [grpclb-<api.google.com>] Update balancing state to READY: picks="
-            + "[[[[[/127.0.0.1:2010]/{io.grpc.grpclb.lbProvidedBackend=true}]](token0002)]],"
-            + " drops=[null, null]");
-    logs.clear();
 
     RoundRobinPicker picker1 = (RoundRobinPicker) pickerCaptor.getValue();
 
@@ -2365,12 +2588,6 @@ public void grpclbWorking_lbSendsFallbackMessage() {
 
     deliverSubchannelState(subchannel1, ConnectivityStateInfo.forNonError(READY));
     inOrder.verify(helper).updateBalancingState(eq(READY), pickerCaptor.capture());
-    assertThat(logs).containsExactly(
-        "INFO: [grpclb-<api.google.com>] Update balancing state to READY: picks="
-            + "[[[[[/127.0.0.1:2000]/{io.grpc.grpclb.lbProvidedBackend=true}]](token0001)],"
-            + " [[[[/127.0.0.1:2010]/{io.grpc.grpclb.lbProvidedBackend=true}]](token0002)]],"
-            + " drops=[null, null]");
-    logs.clear();
 
     RoundRobinPicker picker2 = (RoundRobinPicker) pickerCaptor.getValue();
     assertThat(picker2.dropList).containsExactly(null, null);
@@ -2379,7 +2596,7 @@ public void grpclbWorking_lbSendsFallbackMessage() {
         new BackendEntry(subchannel2, getLoadRecorder(), "token0002"))
         .inOrder();
 
-    // enter fallback mode
+    // Balancer forces entering fallback mode
     lbResponseObserver.onNext(buildLbFallbackResponse());
 
     // existing subchannels must be returned immediately to gracefully shutdown.
@@ -2394,6 +2611,25 @@ public void grpclbWorking_lbSendsFallbackMessage() {
     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));
+    }
+
+    // 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");
@@ -2432,25 +2668,15 @@ public void grpclbWorking_lbSendsFallbackMessage() {
     assertThat(picker6.pickList).containsExactly(BUFFER_ENTRY);
     inOrder.verifyNoMoreInteractions();
 
-    assertThat(logs).containsExactly(
-            "DEBUG: [grpclb-<api.google.com>] Got an LB response: " + buildLbResponse(backends2),
-            "INFO: [grpclb-<api.google.com>] Using RR list="
-                + "[[[/127.0.0.1:8000]/{io.grpc.grpclb.lbProvidedBackend=true}](token1001),"
-                + " [[/127.0.0.1:8010]/{io.grpc.grpclb.lbProvidedBackend=true}](token1002)],"
-                + " drop=[null, null]",
-            "INFO: [grpclb-<api.google.com>] "
-                + "Update balancing state to CONNECTING: picks=[BUFFER_ENTRY], drops=[null, null]")
+    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());
-    assertThat(logs).containsExactly(
-        "INFO: [grpclb-<api.google.com>] Update balancing state to READY: picks="
-            + "[[[[[/127.0.0.1:8000]/{io.grpc.grpclb.lbProvidedBackend=true}]](token1001)]],"
-            + " drops=[null, null]");
-    logs.clear();
 
     RoundRobinPicker picker3 = (RoundRobinPicker) pickerCaptor.getValue();
     assertThat(picker3.dropList).containsExactly(null, null);
@@ -2459,12 +2685,6 @@ public void grpclbWorking_lbSendsFallbackMessage() {
 
     deliverSubchannelState(subchannel4, ConnectivityStateInfo.forNonError(READY));
     inOrder.verify(helper).updateBalancingState(eq(READY), pickerCaptor.capture());
-    assertThat(logs).containsExactly(
-        "INFO: [grpclb-<api.google.com>] Update balancing state to READY: picks="
-            + "[[[[[/127.0.0.1:8000]/{io.grpc.grpclb.lbProvidedBackend=true}]](token1001)],"
-            + " [[[[/127.0.0.1:8010]/{io.grpc.grpclb.lbProvidedBackend=true}]](token1002)]],"
-            + " drops=[null, null]");
-    logs.clear();
 
     RoundRobinPicker picker4 = (RoundRobinPicker) pickerCaptor.getValue();
     assertThat(picker4.dropList).containsExactly(null, null);
@@ -2474,6 +2694,39 @@ public void grpclbWorking_lbSendsFallbackMessage() {
         .inOrder();
   }
 
+  @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);
+    }
+  }
+
   private void deliverSubchannelState(
       final Subchannel subchannel, final ConnectivityStateInfo newState) {
     ((FakeSubchannel) subchannel).updateState(newState);
@@ -2503,7 +2756,7 @@ private void deliverResolvedAddresses(
     syncContext.execute(new Runnable() {
       @Override
       public void run() {
-        balancer.handleResolvedAddresses(
+        balancer.acceptResolvedAddresses(
             ResolvedAddresses.newBuilder()
                 .setAddresses(backendAddrs)
                 .setAttributes(attrs)
@@ -2585,6 +2838,18 @@ private static LoadBalanceResponse buildLbResponse(List<ServerEntry> servers) {
         .build();
   }
 
+  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 class ServerEntry {
     final InetSocketAddress addr;
     final String token;
@@ -2652,7 +2917,7 @@ public SynchronizationContext getSynchronizationContext() {
     }
 
     @Override
-    public ManagedChannel createOobChannel(EquivalentAddressGroup eag, String authority) {
+    public ManagedChannel createOobChannel(List<EquivalentAddressGroup> eag, String authority) {
       ManagedChannel channel =
           InProcessChannelBuilder
               .forName("fakeLb")
@@ -2664,6 +2929,11 @@ public ManagedChannel createOobChannel(EquivalentAddressGroup eag, String author
       return channel;
     }
 
+    @Override
+    public ManagedChannel createOobChannel(EquivalentAddressGroup eag, String authority) {
+      return createOobChannel(Collections.singletonList(eag), authority);
+    }
+
     @Override
     public Subchannel createSubchannel(CreateSubchannelArgs args) {
       FakeSubchannel subchannel =
@@ -2704,5 +2974,10 @@ public String getAuthority() {
     @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
index bf44a81a823..a90556a01b0 100644
--- a/grpclb/src/test/java/io/grpc/grpclb/GrpclbNameResolverTest.java
+++ b/grpclb/src/test/java/io/grpc/grpclb/GrpclbNameResolverTest.java
@@ -20,7 +20,6 @@
 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;
 
@@ -32,6 +31,7 @@
 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;
@@ -95,7 +95,6 @@ public void close(Executor instance) {}
   }
 
   @Captor private ArgumentCaptor<ResolutionResult> resultCaptor;
-  @Captor private ArgumentCaptor<Status> errorCaptor;
   @Mock private ServiceConfigParser serviceConfigParser;
   @Mock private NameResolver.Listener2 mockListener;
 
@@ -121,6 +120,13 @@ public void setUp() {
     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() {
@@ -144,9 +150,9 @@ public List<SrvRecord> resolveSrv(String host) throws Exception {
     resolver.start(mockListener);
     assertThat(fakeClock.runDueTasks()).isEqualTo(1);
 
-    verify(mockListener).onResult(resultCaptor.capture());
+    verify(mockListener).onResult2(resultCaptor.capture());
     ResolutionResult result = resultCaptor.getValue();
-    assertThat(result.getAddresses()).isEmpty();
+    assertThat(result.getAddressesOrError().getValue()).isEmpty();
     assertThat(result.getAttributes()).isEqualTo(Attributes.EMPTY);
     assertThat(result.getServiceConfig()).isNull();
   }
@@ -184,11 +190,11 @@ public ConfigOrError answer(InvocationOnMock invocation) {
 
     resolver.start(mockListener);
     assertThat(fakeClock.runDueTasks()).isEqualTo(1);
-    verify(mockListener).onResult(resultCaptor.capture());
+    verify(mockListener).onResult2(resultCaptor.capture());
     ResolutionResult result = resultCaptor.getValue();
     InetSocketAddress resolvedBackendAddr =
         (InetSocketAddress) Iterables.getOnlyElement(
-            Iterables.getOnlyElement(result.getAddresses()).getAddresses());
+            Iterables.getOnlyElement(result.getAddressesOrError().getValue()).getAddresses());
     assertThat(resolvedBackendAddr.getAddress()).isEqualTo(backendAddr);
     EquivalentAddressGroup resolvedBalancerAddr =
         Iterables.getOnlyElement(result.getAttributes().get(GrpclbConstants.ATTR_LB_ADDRS));
@@ -217,9 +223,9 @@ public void resolve_nullResourceResolver() throws Exception {
 
     resolver.start(mockListener);
     assertThat(fakeClock.runDueTasks()).isEqualTo(1);
-    verify(mockListener).onResult(resultCaptor.capture());
+    verify(mockListener).onResult2(resultCaptor.capture());
     ResolutionResult result = resultCaptor.getValue();
-    assertThat(result.getAddresses())
+    assertThat(result.getAddressesOrError().getValue())
         .containsExactly(
             new EquivalentAddressGroup(new InetSocketAddress(backendAddr, DEFAULT_PORT)));
     assertThat(result.getAttributes()).isEqualTo(Attributes.EMPTY);
@@ -237,8 +243,8 @@ public void resolve_nullResourceResolver_addressFailure() throws Exception {
 
     resolver.start(mockListener);
     assertThat(fakeClock.runDueTasks()).isEqualTo(1);
-    verify(mockListener).onError(errorCaptor.capture());
-    Status errorStatus = errorCaptor.getValue();
+    verify(mockListener).onResult2(resultCaptor.capture());
+    Status errorStatus = resultCaptor.getValue().getAddressesOrError().getStatus();
     assertThat(errorStatus.getCode()).isEqualTo(Code.UNAVAILABLE);
     assertThat(errorStatus.getCause()).hasMessageThat().contains("no addr");
   }
@@ -264,9 +270,9 @@ public void resolve_addressFailure_stillLookUpBalancersAndServiceConfig() throws
 
     resolver.start(mockListener);
     assertThat(fakeClock.runDueTasks()).isEqualTo(1);
-    verify(mockListener).onResult(resultCaptor.capture());
+    verify(mockListener).onResult2(resultCaptor.capture());
     ResolutionResult result = resultCaptor.getValue();
-    assertThat(result.getAddresses()).isEmpty();
+    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))
@@ -298,12 +304,12 @@ public void resolveAll_balancerLookupFails_stillLookUpServiceConfig() throws Exc
 
     resolver.start(mockListener);
     assertThat(fakeClock.runDueTasks()).isEqualTo(1);
-    verify(mockListener).onResult(resultCaptor.capture());
+    verify(mockListener).onResult2(resultCaptor.capture());
     ResolutionResult result = resultCaptor.getValue();
 
     InetSocketAddress resolvedBackendAddr =
         (InetSocketAddress) Iterables.getOnlyElement(
-            Iterables.getOnlyElement(result.getAddresses()).getAddresses());
+            Iterables.getOnlyElement(result.getAddressesOrError().getValue()).getAddresses());
     assertThat(resolvedBackendAddr.getAddress()).isEqualTo(backendAddr);
     assertThat(result.getAttributes().get(GrpclbConstants.ATTR_LB_ADDRS)).isNull();
     verify(mockAddressResolver).resolveAddress(hostName);
@@ -312,7 +318,7 @@ public void resolveAll_balancerLookupFails_stillLookUpServiceConfig() throws Exc
   }
 
   @Test
-  public void resolve_addressAndBalancersLookupFail_neverLookupServiceConfig() throws Exception {
+  public void resolve_addressAndBalancersLookupFail_stillLookupServiceConfig() throws Exception {
     AddressResolver mockAddressResolver = mock(AddressResolver.class);
     when(mockAddressResolver.resolveAddress(anyString()))
         .thenThrow(new UnknownHostException("I really tried"));
@@ -327,11 +333,11 @@ public void resolve_addressAndBalancersLookupFail_neverLookupServiceConfig() thr
 
     resolver.start(mockListener);
     assertThat(fakeClock.runDueTasks()).isEqualTo(1);
-    verify(mockListener).onError(errorCaptor.capture());
-    Status errorStatus = errorCaptor.getValue();
+    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).resolveTxt("_grpc_config." + hostName);
     verify(mockResourceResolver).resolveSrv("_grpclb._tcp." + hostName);
   }
-}
\ No newline at end of file
+}
diff --git a/grpclb/src/test/java/io/grpc/grpclb/SecretGrpclbNameResolverProviderTest.java b/grpclb/src/test/java/io/grpc/grpclb/SecretGrpclbNameResolverProviderTest.java
index 24b1c781f58..e9ed92a54d0 100644
--- a/grpclb/src/test/java/io/grpc/grpclb/SecretGrpclbNameResolverProviderTest.java
+++ b/grpclb/src/test/java/io/grpc/grpclb/SecretGrpclbNameResolverProviderTest.java
@@ -17,6 +17,8 @@
 package io.grpc.grpclb;
 
 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.fail;
 import static org.mockito.Mockito.mock;
 
@@ -24,15 +26,19 @@
 import io.grpc.NameResolver;
 import io.grpc.NameResolver.ServiceConfigParser;
 import io.grpc.SynchronizationContext;
+import io.grpc.Uri;
 import io.grpc.internal.DnsNameResolverProvider;
 import io.grpc.internal.GrpcUtil;
 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 SecretGrpclbNameResolverProvider}. */
-@RunWith(JUnit4.class)
+@RunWith(Parameterized.class)
 public class SecretGrpclbNameResolverProviderTest {
 
   private final SynchronizationContext syncContext = new SynchronizationContext(
@@ -53,6 +59,13 @@ public void uncaughtException(Thread t, Throwable e) {
   private SecretGrpclbNameResolverProvider.Provider provider =
       new SecretGrpclbNameResolverProvider.Provider();
 
+  @Parameters(name = "enableRfc3986UrisParam={0}")
+  public static Iterable<Object[]> data() {
+    return Arrays.asList(new Object[][] {{true}, {false}});
+  }
+
+  @Parameter public boolean enableRfc3986UrisParam;
+
   @Test
   public void isAvailable() {
     assertThat(provider.isAvailable()).isTrue();
@@ -66,43 +79,65 @@ public void priority_shouldBeHigherThanDefaultDnsNameResolver() {
   }
 
   @Test
-  public void newNameResolver() {
-    assertThat(provider.newNameResolver(URI.create("dns:///localhost:443"), args))
+  public void newNameResolverReturnsCorrectType() {
+    assertThat(newNameResolver("dns:///localhost:443", args))
         .isInstanceOf(GrpclbNameResolver.class);
-    assertThat(provider.newNameResolver(URI.create("notdns:///localhost:443"), args)).isNull();
+    assertThat(newNameResolver("notdns:///localhost:443", args)).isNull();
   }
 
   @Test
   public void invalidDnsName() throws Exception {
-    testInvalidUri(new URI("dns", null, "/[invalid]", null));
+    testInvalidUri("dns:/%5Binvalid%5D");
   }
 
   @Test
   public void validIpv6() throws Exception {
-    testValidUri(new URI("dns", null, "/[::1]", null));
+    testValidUri("dns:/%5B::1%5D");
   }
 
   @Test
   public void validDnsNameWithoutPort() throws Exception {
-    testValidUri(new URI("dns", null, "/foo.googleapis.com", null));
+    testValidUri("dns:/foo.googleapis.com");
   }
 
   @Test
   public void validDnsNameWithPort() throws Exception {
-    testValidUri(new URI("dns", null, "/foo.googleapis.com:456", null));
+    testValidUri("dns:/foo.googleapis.com:456");
+  }
+
+  @Test
+  public void newNameResolver_rejectsExtraPathSegments() {
+    assume().that(enableRfc3986UrisParam).isTrue();
+    IllegalArgumentException iae =
+        assertThrows(
+            IllegalArgumentException.class,
+            () -> newNameResolver("dns:///localhost:443/extras", args));
+    assertThat(iae).hasMessageThat().contains("expected 1 path segment in target");
   }
 
-  private void testInvalidUri(URI uri) {
+  @Test
+  public void newNameResolver_toleratesExtraPathSegments() {
+    assume().that(enableRfc3986UrisParam).isFalse();
+    newNameResolver("dns:///localhost:443/extras", args);
+  }
+
+  private void testInvalidUri(String uri) {
     try {
-      provider.newNameResolver(uri, args);
+      newNameResolver(uri, args);
       fail("Should have failed");
     } catch (IllegalArgumentException e) {
       // expected
     }
   }
 
-  private void testValidUri(URI uri) {
-    GrpclbNameResolver resolver = provider.newNameResolver(uri, args);
+  private void testValidUri(String uri) {
+    NameResolver resolver = newNameResolver(uri, args);
     assertThat(resolver).isNotNull();
   }
+
+  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/grpclb/src/test/java/io/grpc/grpclb/TokenAttachingTracerFactoryTest.java b/grpclb/src/test/java/io/grpc/grpclb/TokenAttachingTracerFactoryTest.java
index 34b0a8ea1aa..4787c8697cc 100644
--- a/grpclb/src/test/java/io/grpc/grpclb/TokenAttachingTracerFactoryTest.java
+++ b/grpclb/src/test/java/io/grpc/grpclb/TokenAttachingTracerFactoryTest.java
@@ -33,7 +33,18 @@
 /** Unit tests for {@link TokenAttachingTracerFactory}. */
 @RunWith(JUnit4.class)
 public class TokenAttachingTracerFactoryTest {
-  private static final ClientStreamTracer fakeTracer = new ClientStreamTracer() {};
+  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,
@@ -51,28 +62,25 @@ 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()
-        .setTransportAttrs(
-            Attributes.newBuilder().set(GrpcAttributes.ATTR_CLIENT_EAG_ATTRS, eagAttrs).build())
-        .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));
-    assertThat(tracer).isSameInstanceAs(fakeTracer);
+    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()
-        .setTransportAttrs(
-            Attributes.newBuilder()
-                .set(GrpcAttributes.ATTR_CLIENT_EAG_ATTRS, Attributes.EMPTY).build())
-        .build();
+    ClientStreamTracer.StreamInfo info = ClientStreamTracer.StreamInfo.newBuilder().build();
 
     Metadata headers = new Metadata();
     // Preexisting token should be removed
@@ -80,22 +88,25 @@ public void noToken() {
 
     ClientStreamTracer tracer = factory.newClientStreamTracer(info, headers);
     verify(delegate).newClientStreamTracer(same(info), same(headers));
-    assertThat(tracer).isSameInstanceAs(fakeTracer);
+    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()
-        .setTransportAttrs(
-            Attributes.newBuilder()
-                .set(GrpcAttributes.ATTR_CLIENT_EAG_ATTRS, Attributes.EMPTY).build())
-        .build();
+    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/core/src/main/java/io/grpc/inprocess/InProcessServerBuilder.java b/inprocess/src/main/java/io/grpc/inprocess/InProcessServerBuilder.java
similarity index 88%
rename from core/src/main/java/io/grpc/inprocess/InProcessServerBuilder.java
rename to inprocess/src/main/java/io/grpc/inprocess/InProcessServerBuilder.java
index 25291c28489..b2004426aae 100644
--- a/core/src/main/java/io/grpc/inprocess/InProcessServerBuilder.java
+++ b/inprocess/src/main/java/io/grpc/inprocess/InProcessServerBuilder.java
@@ -19,12 +19,14 @@
 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.MetricRecorder;
 import io.grpc.ServerBuilder;
 import io.grpc.ServerStreamTracer;
-import io.grpc.internal.AbstractServerImplBuilder;
 import io.grpc.internal.FixedObjectPool;
 import io.grpc.internal.GrpcUtil;
 import io.grpc.internal.InternalServer;
@@ -33,6 +35,7 @@
 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;
@@ -71,8 +74,7 @@
  * </pre>
  */
 @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1783")
-public final class InProcessServerBuilder extends
-    AbstractServerImplBuilder<InProcessServerBuilder> {
+public final class InProcessServerBuilder extends ForwardingServerBuilder<InProcessServerBuilder> {
   /**
    * Create a server builder that will bind with the given name.
    *
@@ -80,12 +82,22 @@ public final class InProcessServerBuilder extends
    * @return a new builder
    */
   public static InProcessServerBuilder forName(String name) {
-    return new InProcessServerBuilder(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");
   }
@@ -98,18 +110,19 @@ public static String generateName() {
   }
 
   private final ServerImplBuilder serverImplBuilder;
-  final String name;
+  final SocketAddress listenAddress;
   int maxInboundMetadataSize = Integer.MAX_VALUE;
   ObjectPool<ScheduledExecutorService> schedulerPool =
       SharedResourcePool.forResource(GrpcUtil.TIMER_SERVICE);
 
-  private InProcessServerBuilder(String name) {
-    this.name = Preconditions.checkNotNull(name, "name");
+  private InProcessServerBuilder(SocketAddress listenAddress) {
+    this.listenAddress = checkNotNull(listenAddress, "listenAddress");
 
     final class InProcessClientTransportServersBuilder implements ClientTransportServersBuilder {
       @Override
       public InternalServer buildClientTransportServers(
-          List<? extends ServerStreamTracer.Factory> streamTracerFactories) {
+          List<? extends ServerStreamTracer.Factory> streamTracerFactories,
+          MetricRecorder metricRecorder) {
         return buildTransportServers(streamTracerFactories);
       }
     }
diff --git a/core/src/main/java/io/grpc/inprocess/InProcessSocketAddress.java b/inprocess/src/main/java/io/grpc/inprocess/InProcessSocketAddress.java
similarity index 84%
rename from core/src/main/java/io/grpc/inprocess/InProcessSocketAddress.java
rename to inprocess/src/main/java/io/grpc/inprocess/InProcessSocketAddress.java
index e5f0515f1d0..98ecf7e1a5f 100644
--- a/core/src/main/java/io/grpc/inprocess/InProcessSocketAddress.java
+++ b/inprocess/src/main/java/io/grpc/inprocess/InProcessSocketAddress.java
@@ -29,7 +29,9 @@ public final class InProcessSocketAddress extends SocketAddress {
   private final String name;
 
   /**
-   * @param name - The name of the inprocess channel or server.
+   * 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) {
@@ -37,7 +39,7 @@ public InProcessSocketAddress(String name) {
   }
 
   /**
-   * Gets the name of the inprocess channel or server.
+   * Gets the name of the inprocess server.
    *
    * @since 1.0.0
    */
@@ -46,6 +48,8 @@ public String getName() {
   }
 
   /**
+   * Returns {@link #getName}.
+   *
    * @since 1.14.0
    */
   @Override
@@ -53,15 +57,14 @@ public String toString() {
     return name;
   }
 
-  /**
-   * @since 1.15.0
-   */
   @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
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/core/src/main/java/io/grpc/inprocess/InternalInProcessChannelBuilder.java b/inprocess/src/main/java/io/grpc/inprocess/InternalInProcessChannelBuilder.java
similarity index 100%
rename from core/src/main/java/io/grpc/inprocess/InternalInProcessChannelBuilder.java
rename to inprocess/src/main/java/io/grpc/inprocess/InternalInProcessChannelBuilder.java
diff --git a/core/src/main/java/io/grpc/inprocess/InternalInProcessServerBuilder.java b/inprocess/src/main/java/io/grpc/inprocess/InternalInProcessServerBuilder.java
similarity index 100%
rename from core/src/main/java/io/grpc/inprocess/InternalInProcessServerBuilder.java
rename to inprocess/src/main/java/io/grpc/inprocess/InternalInProcessServerBuilder.java
diff --git a/core/src/main/java/io/grpc/inprocess/package-info.java b/inprocess/src/main/java/io/grpc/inprocess/package-info.java
similarity index 100%
rename from core/src/main/java/io/grpc/inprocess/package-info.java
rename to inprocess/src/main/java/io/grpc/inprocess/package-info.java
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/core/src/test/java/io/grpc/inprocess/InProcessChannelBuilderTest.java b/inprocess/src/test/java/io/grpc/inprocess/InProcessChannelBuilderTest.java
similarity index 100%
rename from core/src/test/java/io/grpc/inprocess/InProcessChannelBuilderTest.java
rename to inprocess/src/test/java/io/grpc/inprocess/InProcessChannelBuilderTest.java
diff --git a/core/src/test/java/io/grpc/inprocess/InProcessClientTransportFactoryTest.java b/inprocess/src/test/java/io/grpc/inprocess/InProcessClientTransportFactoryTest.java
similarity index 93%
rename from core/src/test/java/io/grpc/inprocess/InProcessClientTransportFactoryTest.java
rename to inprocess/src/test/java/io/grpc/inprocess/InProcessClientTransportFactoryTest.java
index 4dcd4b86569..1629d741730 100644
--- a/core/src/test/java/io/grpc/inprocess/InProcessClientTransportFactoryTest.java
+++ b/inprocess/src/test/java/io/grpc/inprocess/InProcessClientTransportFactoryTest.java
@@ -16,8 +16,8 @@
 
 package io.grpc.inprocess;
 
+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/core/src/test/java/io/grpc/inprocess/InProcessServerBuilderTest.java b/inprocess/src/test/java/io/grpc/inprocess/InProcessServerBuilderTest.java
similarity index 100%
rename from core/src/test/java/io/grpc/inprocess/InProcessServerBuilderTest.java
rename to inprocess/src/test/java/io/grpc/inprocess/InProcessServerBuilderTest.java
diff --git a/core/src/test/java/io/grpc/inprocess/InProcessServerTest.java b/inprocess/src/test/java/io/grpc/inprocess/InProcessServerTest.java
similarity index 100%
rename from core/src/test/java/io/grpc/inprocess/InProcessServerTest.java
rename to inprocess/src/test/java/io/grpc/inprocess/InProcessServerTest.java
diff --git a/core/src/test/java/io/grpc/inprocess/InProcessSocketAddressTest.java b/inprocess/src/test/java/io/grpc/inprocess/InProcessSocketAddressTest.java
similarity index 100%
rename from core/src/test/java/io/grpc/inprocess/InProcessSocketAddressTest.java
rename to inprocess/src/test/java/io/grpc/inprocess/InProcessSocketAddressTest.java
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 01af6529324..5160759460c 100644
--- a/interop-testing/build.gradle
+++ b/interop-testing/build.gradle
@@ -1,37 +1,36 @@
 plugins {
     id "application"
-    id "java"
+    id "java-library"
     id "maven-publish"
 
     id "com.google.protobuf"
+    id "ru.vyarus.animalsniffer"
 }
 
 description = "gRPC: Integration Testing"
-startScripts.enabled = false
-
-configurations {
-    alpnagent
-}
-
-evaluationDependsOn(project(':grpc-context').path)
 
 dependencies {
     implementation project(path: ':grpc-alts', configuration: 'shadow'),
             project(':grpc-auth'),
             project(':grpc-census'),
-            project(':grpc-core'),
+            project(':grpc-opentelemetry'),
+            project(':grpc-gcp-csm-observability'),
             project(':grpc-netty'),
             project(':grpc-okhttp'),
-            project(':grpc-protobuf'),
             project(':grpc-services'),
-            project(':grpc-stub'),
             project(':grpc-testing'),
+            project(':grpc-protobuf-lite'),
             project(path: ':grpc-xds', configuration: 'shadow'),
-            libraries.junit,
-            libraries.truth
-    censusGrpcMetricDependency 'implementation'
-    googleOauth2Dependency 'implementation'
-    compileOnly libraries.javax_annotation
+            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.
@@ -39,61 +38,67 @@ dependencies {
     // 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,
-            project(':grpc-grpclb')
-    testImplementation project(':grpc-context').sourceSets.test.output,
-            libraries.mockito
-    alpnagent libraries.jetty_alpn_agent
+    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
+
+    signature (libraries.signature.java) {
+        artifact {
+            extension = "signature"
+        }
+    }
+    signature (libraries.signature.android) {
+        artifact {
+            extension = "signature"
+        }
+    }
 }
 
 configureProtoCompilation()
 
 import net.ltgt.gradle.errorprone.CheckSeverity
 
-compileJava {
+tasks.named("compileJava").configure {
     // This isn't a library; it can use beta APIs
     options.errorprone.check("BetaApi", CheckSeverity.OFF)
 }
 
-test {
-    // For the automated tests, use Jetty ALPN.
-    jvmArgs "-javaagent:" + configurations.alpnagent.asPath
-}
-
 // 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"
-    defaultJvmOpts = [
-        "-javaagent:JAVAAGENT_APP_HOME" + configurations.alpnagent.singleFile.name
-    ]
     outputDir = new File(project.buildDir, 'tmp/scripts/' + name)
     classpath = startScripts.classpath
-    doLast {
-        unixScript.text = unixScript.text.replace('JAVAAGENT_APP_HOME', '\$APP_HOME/lib/')
-        windowsScript.text = windowsScript.text.replace('JAVAAGENT_APP_HOME', '%APP_HOME%\\lib\\')
-    }
 }
 
-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/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/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/scripts/' + name)
     classpath = startScripts.classpath
@@ -103,15 +108,15 @@ task stresstest_client(type: CreateStartScripts) {
     ]
 }
 
-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/scripts/' + name)
     classpath = startScripts.classpath
 }
 
-task grpclb_long_lived_affinity_test_client(type: CreateStartScripts) {
-    mainClassName = "io.grpc.testing.integration.GrpclbLongLivedAffinityTestClient"
+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
@@ -120,8 +125,8 @@ task grpclb_long_lived_affinity_test_client(type: CreateStartScripts) {
     ]
 }
 
-task grpclb_fallback_test_client (type: CreateStartScripts) {
-    mainClassName = "io.grpc.testing.integration.GrpclbFallbackTestClient"
+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
@@ -130,35 +135,43 @@ task grpclb_fallback_test_client (type: CreateStartScripts) {
     ]
 }
 
-task xds_test_client(type: CreateStartScripts) {
-    mainClassName = "io.grpc.testing.integration.XdsTestClient"
+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
 }
 
-task xds_test_server(type: CreateStartScripts) {
-    mainClassName = "io.grpc.testing.integration.XdsTestServer"
+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
 }
 
-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)
-    fileMode = 0755
+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
 }
 
-applicationDistribution.into("lib") {
-    from(configurations.alpnagent)
+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 {
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
index 2d5a62b4da9..22c64d12f33 100644
--- 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
@@ -7,14 +7,12 @@
  * A service used to obtain stats for verifying LB behavior.
  * </pre>
  */
-@javax.annotation.Generated(
-    value = "by gRPC proto compiler",
-    comments = "Source: grpc/testing/test.proto")
+@io.grpc.stub.annotations.GrpcGenerated
 public final class LoadBalancerStatsServiceGrpc {
 
   private LoadBalancerStatsServiceGrpc() {}
 
-  public static final String SERVICE_NAME = "grpc.testing.LoadBalancerStatsService";
+  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,
@@ -93,6 +91,21 @@ public LoadBalancerStatsServiceStub newStub(io.grpc.Channel channel, io.grpc.Cal
     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
    */
@@ -128,14 +141,14 @@ public LoadBalancerStatsServiceFutureStub newStub(io.grpc.Channel channel, io.gr
    * A service used to obtain stats for verifying LB behavior.
    * </pre>
    */
-  public static abstract class LoadBalancerStatsServiceImplBase implements io.grpc.BindableService {
+  public interface AsyncService {
 
     /**
      * <pre>
      * Gets the backend distribution for RPCs sent by a test client.
      * </pre>
      */
-    public void getClientStats(io.grpc.testing.integration.Messages.LoadBalancerStatsRequest request,
+    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);
     }
@@ -145,37 +158,34 @@ public void getClientStats(io.grpc.testing.integration.Messages.LoadBalancerStat
      * Gets the accumulated stats for RPCs sent by a test client.
      * </pre>
      */
-    public void getClientAccumulatedStats(io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsRequest request,
+    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 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>(
-                  this, 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>(
-                  this, METHODID_GET_CLIENT_ACCUMULATED_STATS)))
-          .build();
+      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> {
+  public static final class LoadBalancerStatsServiceStub
+      extends io.grpc.stub.AbstractAsyncStub<LoadBalancerStatsServiceStub> {
     private LoadBalancerStatsServiceStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -211,11 +221,53 @@ public void getClientAccumulatedStats(io.grpc.testing.integration.Messages.LoadB
   }
 
   /**
+   * 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 LoadBalancerStatsServiceBlockingStub extends io.grpc.stub.AbstractBlockingStub<LoadBalancerStatsServiceBlockingStub> {
+  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);
@@ -249,11 +301,13 @@ public io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsResponse
   }
 
   /**
+   * 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> {
+  public static final class LoadBalancerStatsServiceFutureStub
+      extends io.grpc.stub.AbstractFutureStub<LoadBalancerStatsServiceFutureStub> {
     private LoadBalancerStatsServiceFutureStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -296,10 +350,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 LoadBalancerStatsServiceImplBase serviceImpl;
+    private final AsyncService serviceImpl;
     private final int methodId;
 
-    MethodHandlers(LoadBalancerStatsServiceImplBase serviceImpl, int methodId) {
+    MethodHandlers(AsyncService serviceImpl, int methodId) {
       this.serviceImpl = serviceImpl;
       this.methodId = methodId;
     }
@@ -332,6 +386,25 @@ public io.grpc.stub.StreamObserver<Req> invoke(
     }
   }
 
+  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() {}
@@ -355,9 +428,9 @@ private static final class LoadBalancerStatsServiceFileDescriptorSupplier
   private static final class LoadBalancerStatsServiceMethodDescriptorSupplier
       extends LoadBalancerStatsServiceBaseDescriptorSupplier
       implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
-    private final String methodName;
+    private final java.lang.String methodName;
 
-    LoadBalancerStatsServiceMethodDescriptorSupplier(String methodName) {
+    LoadBalancerStatsServiceMethodDescriptorSupplier(java.lang.String methodName) {
       this.methodName = methodName;
     }
 
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
index cbc13a2dfe3..980dee010f1 100644
--- 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
@@ -4,14 +4,12 @@
 
 /**
  */
-@javax.annotation.Generated(
-    value = "by gRPC proto compiler",
-    comments = "Source: grpc/testing/metrics.proto")
+@io.grpc.stub.annotations.GrpcGenerated
 public final class MetricsServiceGrpc {
 
   private MetricsServiceGrpc() {}
 
-  public static final String SERVICE_NAME = "grpc.testing.MetricsService";
+  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,
@@ -90,6 +88,21 @@ public MetricsServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions c
     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
    */
@@ -122,7 +135,7 @@ public MetricsServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOpt
 
   /**
    */
-  public static abstract class MetricsServiceImplBase implements io.grpc.BindableService {
+  public interface AsyncService {
 
     /**
      * <pre>
@@ -130,7 +143,7 @@ public static abstract class MetricsServiceImplBase implements io.grpc.BindableS
      * the service
      * </pre>
      */
-    public void getAllGauges(io.grpc.testing.integration.Metrics.EmptyMessage request,
+    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);
     }
@@ -140,34 +153,28 @@ public void getAllGauges(io.grpc.testing.integration.Metrics.EmptyMessage reques
      * Returns the value of one gauge
      * </pre>
      */
-    public void getGauge(io.grpc.testing.integration.Metrics.GaugeRequest request,
+    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 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>(
-                  this, 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>(
-                  this, METHODID_GET_GAUGE)))
-          .build();
+      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> {
+  public static final class MetricsServiceStub
+      extends io.grpc.stub.AbstractAsyncStub<MetricsServiceStub> {
     private MetricsServiceStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -204,8 +211,50 @@ public void getGauge(io.grpc.testing.integration.Metrics.GaugeRequest request,
   }
 
   /**
+   * 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> {
+  public static final class MetricsServiceBlockingStub
+      extends io.grpc.stub.AbstractBlockingStub<MetricsServiceBlockingStub> {
     private MetricsServiceBlockingStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -241,8 +290,10 @@ public io.grpc.testing.integration.Metrics.GaugeResponse getGauge(io.grpc.testin
   }
 
   /**
+   * 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> {
+  public static final class MetricsServiceFutureStub
+      extends io.grpc.stub.AbstractFutureStub<MetricsServiceFutureStub> {
     private MetricsServiceFutureStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -274,10 +325,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 MetricsServiceImplBase serviceImpl;
+    private final AsyncService serviceImpl;
     private final int methodId;
 
-    MethodHandlers(MetricsServiceImplBase serviceImpl, int methodId) {
+    MethodHandlers(AsyncService serviceImpl, int methodId) {
       this.serviceImpl = serviceImpl;
       this.methodId = methodId;
     }
@@ -310,6 +361,25 @@ public io.grpc.stub.StreamObserver<Req> invoke(
     }
   }
 
+  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() {}
@@ -333,9 +403,9 @@ private static final class MetricsServiceFileDescriptorSupplier
   private static final class MetricsServiceMethodDescriptorSupplier
       extends MetricsServiceBaseDescriptorSupplier
       implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
-    private final String methodName;
+    private final java.lang.String methodName;
 
-    MetricsServiceMethodDescriptorSupplier(String methodName) {
+    MetricsServiceMethodDescriptorSupplier(java.lang.String methodName) {
       this.methodName = methodName;
     }
 
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
index 5af70fdddae..05d46ce8e95 100644
--- 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
@@ -7,37 +7,35 @@
  * A service used to control reconnect server.
  * </pre>
  */
-@javax.annotation.Generated(
-    value = "by gRPC proto compiler",
-    comments = "Source: grpc/testing/test.proto")
+@io.grpc.stub.annotations.GrpcGenerated
 public final class ReconnectServiceGrpc {
 
   private ReconnectServiceGrpc() {}
 
-  public static final String SERVICE_NAME = "grpc.testing.ReconnectService";
+  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.EmptyProtos.Empty,
+  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.EmptyProtos.Empty.class,
+      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.EmptyProtos.Empty,
+  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.EmptyProtos.Empty, 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.EmptyProtos.Empty, io.grpc.testing.integration.EmptyProtos.Empty>newBuilder()
+              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.EmptyProtos.Empty.getDefaultInstance()))
+                  io.grpc.testing.integration.Messages.ReconnectParams.getDefaultInstance()))
               .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                   io.grpc.testing.integration.EmptyProtos.Empty.getDefaultInstance()))
               .setSchemaDescriptor(new ReconnectServiceMethodDescriptorSupplier("Start"))
@@ -93,6 +91,21 @@ public ReconnectServiceStub newStub(io.grpc.Channel channel, io.grpc.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
    */
@@ -128,48 +141,45 @@ public ReconnectServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallO
    * A service used to control reconnect server.
    * </pre>
    */
-  public static abstract class ReconnectServiceImplBase implements io.grpc.BindableService {
+  public interface AsyncService {
 
     /**
      */
-    public void start(io.grpc.testing.integration.EmptyProtos.Empty request,
+    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);
     }
 
     /**
      */
-    public void stop(io.grpc.testing.integration.EmptyProtos.Empty request,
+    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 io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
-          .addMethod(
-            getStartMethod(),
-            io.grpc.stub.ServerCalls.asyncUnaryCall(
-              new MethodHandlers<
-                io.grpc.testing.integration.EmptyProtos.Empty,
-                io.grpc.testing.integration.EmptyProtos.Empty>(
-                  this, METHODID_START)))
-          .addMethod(
-            getStopMethod(),
-            io.grpc.stub.ServerCalls.asyncUnaryCall(
-              new MethodHandlers<
-                io.grpc.testing.integration.EmptyProtos.Empty,
-                io.grpc.testing.integration.Messages.ReconnectInfo>(
-                  this, METHODID_STOP)))
-          .build();
+      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> {
+  public static final class ReconnectServiceStub
+      extends io.grpc.stub.AbstractAsyncStub<ReconnectServiceStub> {
     private ReconnectServiceStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -183,7 +193,7 @@ protected ReconnectServiceStub build(
 
     /**
      */
-    public void start(io.grpc.testing.integration.EmptyProtos.Empty request,
+    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);
@@ -199,11 +209,47 @@ public void stop(io.grpc.testing.integration.EmptyProtos.Empty request,
   }
 
   /**
+   * 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 ReconnectServiceBlockingStub extends io.grpc.stub.AbstractBlockingStub<ReconnectServiceBlockingStub> {
+  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);
@@ -217,7 +263,7 @@ protected ReconnectServiceBlockingStub build(
 
     /**
      */
-    public io.grpc.testing.integration.EmptyProtos.Empty start(io.grpc.testing.integration.EmptyProtos.Empty request) {
+    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);
     }
@@ -231,11 +277,13 @@ public io.grpc.testing.integration.Messages.ReconnectInfo stop(io.grpc.testing.i
   }
 
   /**
+   * 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> {
+  public static final class ReconnectServiceFutureStub
+      extends io.grpc.stub.AbstractFutureStub<ReconnectServiceFutureStub> {
     private ReconnectServiceFutureStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -250,7 +298,7 @@ protected ReconnectServiceFutureStub build(
     /**
      */
     public com.google.common.util.concurrent.ListenableFuture<io.grpc.testing.integration.EmptyProtos.Empty> start(
-        io.grpc.testing.integration.EmptyProtos.Empty request) {
+        io.grpc.testing.integration.Messages.ReconnectParams request) {
       return io.grpc.stub.ClientCalls.futureUnaryCall(
           getChannel().newCall(getStartMethod(), getCallOptions()), request);
     }
@@ -272,10 +320,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 ReconnectServiceImplBase serviceImpl;
+    private final AsyncService serviceImpl;
     private final int methodId;
 
-    MethodHandlers(ReconnectServiceImplBase serviceImpl, int methodId) {
+    MethodHandlers(AsyncService serviceImpl, int methodId) {
       this.serviceImpl = serviceImpl;
       this.methodId = methodId;
     }
@@ -285,7 +333,7 @@ private static final class MethodHandlers<Req, Resp> implements
     public void invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserver) {
       switch (methodId) {
         case METHODID_START:
-          serviceImpl.start((io.grpc.testing.integration.EmptyProtos.Empty) request,
+          serviceImpl.start((io.grpc.testing.integration.Messages.ReconnectParams) request,
               (io.grpc.stub.StreamObserver<io.grpc.testing.integration.EmptyProtos.Empty>) responseObserver);
           break;
         case METHODID_STOP:
@@ -308,6 +356,25 @@ public io.grpc.stub.StreamObserver<Req> invoke(
     }
   }
 
+  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() {}
@@ -331,9 +398,9 @@ private static final class ReconnectServiceFileDescriptorSupplier
   private static final class ReconnectServiceMethodDescriptorSupplier
       extends ReconnectServiceBaseDescriptorSupplier
       implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
-    private final String methodName;
+    private final java.lang.String methodName;
 
-    ReconnectServiceMethodDescriptorSupplier(String methodName) {
+    ReconnectServiceMethodDescriptorSupplier(java.lang.String methodName) {
       this.methodName = methodName;
     }
 
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
index b2289d19cd5..a881c85c150 100644
--- 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
@@ -8,14 +8,12 @@
  * performance with various types of payload.
  * </pre>
  */
-@javax.annotation.Generated(
-    value = "by gRPC proto compiler",
-    comments = "Source: grpc/testing/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.TestService";
 
   // Static method descriptors that strictly reflect the proto.
   private static volatile io.grpc.MethodDescriptor<io.grpc.testing.integration.EmptyProtos.Empty,
@@ -280,6 +278,21 @@ public TestServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions call
     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
    */
@@ -316,14 +329,14 @@ public TestServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOption
    * performance with various types of payload.
    * </pre>
    */
-  public static abstract class TestServiceImplBase implements io.grpc.BindableService {
+  public interface AsyncService {
 
     /**
      * <pre>
      * One empty request followed by one empty response.
      * </pre>
      */
-    public void emptyCall(io.grpc.testing.integration.EmptyProtos.Empty request,
+    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);
     }
@@ -333,7 +346,7 @@ public void emptyCall(io.grpc.testing.integration.EmptyProtos.Empty request,
      * One request followed by one response.
      * </pre>
      */
-    public void unaryCall(io.grpc.testing.integration.Messages.SimpleRequest request,
+    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);
     }
@@ -345,7 +358,7 @@ public void unaryCall(io.grpc.testing.integration.Messages.SimpleRequest request
      * satisfy subsequent requests.
      * </pre>
      */
-    public void cacheableUnaryCall(io.grpc.testing.integration.Messages.SimpleRequest request,
+    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);
     }
@@ -356,7 +369,7 @@ public void cacheableUnaryCall(io.grpc.testing.integration.Messages.SimpleReques
      * The server returns the payload with client desired type and sizes.
      * </pre>
      */
-    public void streamingOutputCall(io.grpc.testing.integration.Messages.StreamingOutputCallRequest request,
+    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);
     }
@@ -367,7 +380,7 @@ public void streamingOutputCall(io.grpc.testing.integration.Messages.StreamingOu
      * 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(
+    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);
     }
@@ -379,7 +392,7 @@ public io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.Streamin
      * demonstrates the idea of full duplexing.
      * </pre>
      */
-    public io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingOutputCallRequest> fullDuplexCall(
+    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);
     }
@@ -392,7 +405,7 @@ public io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.Streamin
      * first request.
      * </pre>
      */
-    public io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingOutputCallRequest> halfDuplexCall(
+    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);
     }
@@ -403,80 +416,36 @@ public io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.Streamin
      * to test the behavior when clients call unimplemented methods.
      * </pre>
      */
-    public void unimplementedCall(io.grpc.testing.integration.EmptyProtos.Empty request,
+    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 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>(
-                  this, METHODID_EMPTY_CALL)))
-          .addMethod(
-            getUnaryCallMethod(),
-            io.grpc.stub.ServerCalls.asyncUnaryCall(
-              new MethodHandlers<
-                io.grpc.testing.integration.Messages.SimpleRequest,
-                io.grpc.testing.integration.Messages.SimpleResponse>(
-                  this, METHODID_UNARY_CALL)))
-          .addMethod(
-            getCacheableUnaryCallMethod(),
-            io.grpc.stub.ServerCalls.asyncUnaryCall(
-              new MethodHandlers<
-                io.grpc.testing.integration.Messages.SimpleRequest,
-                io.grpc.testing.integration.Messages.SimpleResponse>(
-                  this, 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>(
-                  this, 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>(
-                  this, 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>(
-                  this, 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>(
-                  this, 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>(
-                  this, METHODID_UNIMPLEMENTED_CALL)))
-          .build();
+      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> {
+  public static final class TestServiceStub
+      extends io.grpc.stub.AbstractAsyncStub<TestServiceStub> {
     private TestServiceStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -588,12 +557,133 @@ public void unimplementedCall(io.grpc.testing.integration.EmptyProtos.Empty requ
   }
 
   /**
+   * 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> {
+  public static final class TestServiceBlockingStub
+      extends io.grpc.stub.AbstractBlockingStub<TestServiceBlockingStub> {
     private TestServiceBlockingStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -662,12 +752,14 @@ public io.grpc.testing.integration.EmptyProtos.Empty unimplementedCall(io.grpc.t
   }
 
   /**
+   * 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> {
+  public static final class TestServiceFutureStub
+      extends io.grpc.stub.AbstractFutureStub<TestServiceFutureStub> {
     private TestServiceFutureStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -741,10 +833,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 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;
     }
@@ -798,6 +890,67 @@ public io.grpc.stub.StreamObserver<Req> invoke(
     }
   }
 
+  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() {}
@@ -821,9 +974,9 @@ private static final class TestServiceFileDescriptorSupplier
   private static final class TestServiceMethodDescriptorSupplier
       extends TestServiceBaseDescriptorSupplier
       implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
-    private final String methodName;
+    private final java.lang.String methodName;
 
-    TestServiceMethodDescriptorSupplier(String methodName) {
+    TestServiceMethodDescriptorSupplier(java.lang.String methodName) {
       this.methodName = methodName;
     }
 
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
index a7c5058dc32..fdd8d5650ed 100644
--- 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
@@ -8,14 +8,12 @@
  * that case.
  * </pre>
  */
-@javax.annotation.Generated(
-    value = "by gRPC proto compiler",
-    comments = "Source: grpc/testing/test.proto")
+@io.grpc.stub.annotations.GrpcGenerated
 public final class UnimplementedServiceGrpc {
 
   private UnimplementedServiceGrpc() {}
 
-  public static final String SERVICE_NAME = "grpc.testing.UnimplementedService";
+  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,
@@ -63,6 +61,21 @@ public UnimplementedServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOpt
     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
    */
@@ -99,38 +112,43 @@ public UnimplementedServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.C
    * that case.
    * </pre>
    */
-  public static abstract class UnimplementedServiceImplBase implements io.grpc.BindableService {
+  public interface AsyncService {
 
     /**
      * <pre>
      * A call that no server should implement
      * </pre>
      */
-    public void unimplementedCall(io.grpc.testing.integration.EmptyProtos.Empty request,
+    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 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>(
-                  this, METHODID_UNIMPLEMENTED_CALL)))
-          .build();
+      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> {
+  public static final class UnimplementedServiceStub
+      extends io.grpc.stub.AbstractAsyncStub<UnimplementedServiceStub> {
     private UnimplementedServiceStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -155,12 +173,45 @@ public void unimplementedCall(io.grpc.testing.integration.EmptyProtos.Empty requ
   }
 
   /**
+   * 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> {
+  public static final class UnimplementedServiceBlockingStub
+      extends io.grpc.stub.AbstractBlockingStub<UnimplementedServiceBlockingStub> {
     private UnimplementedServiceBlockingStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -184,12 +235,14 @@ public io.grpc.testing.integration.EmptyProtos.Empty unimplementedCall(io.grpc.t
   }
 
   /**
+   * 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> {
+  public static final class UnimplementedServiceFutureStub
+      extends io.grpc.stub.AbstractFutureStub<UnimplementedServiceFutureStub> {
     private UnimplementedServiceFutureStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -220,10 +273,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 UnimplementedServiceImplBase serviceImpl;
+    private final AsyncService serviceImpl;
     private final int methodId;
 
-    MethodHandlers(UnimplementedServiceImplBase serviceImpl, int methodId) {
+    MethodHandlers(AsyncService serviceImpl, int methodId) {
       this.serviceImpl = serviceImpl;
       this.methodId = methodId;
     }
@@ -252,6 +305,18 @@ public io.grpc.stub.StreamObserver<Req> invoke(
     }
   }
 
+  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() {}
@@ -275,9 +340,9 @@ private static final class UnimplementedServiceFileDescriptorSupplier
   private static final class UnimplementedServiceMethodDescriptorSupplier
       extends UnimplementedServiceBaseDescriptorSupplier
       implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
-    private final String methodName;
+    private final java.lang.String methodName;
 
-    UnimplementedServiceMethodDescriptorSupplier(String methodName) {
+    UnimplementedServiceMethodDescriptorSupplier(java.lang.String methodName) {
       this.methodName = methodName;
     }
 
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
index 582f0841a80..6c019efefea 100644
--- 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
@@ -7,14 +7,12 @@
  * A service to dynamically update the configuration of an xDS test client.
  * </pre>
  */
-@javax.annotation.Generated(
-    value = "by gRPC proto compiler",
-    comments = "Source: grpc/testing/test.proto")
+@io.grpc.stub.annotations.GrpcGenerated
 public final class XdsUpdateClientConfigureServiceGrpc {
 
   private XdsUpdateClientConfigureServiceGrpc() {}
 
-  public static final String SERVICE_NAME = "grpc.testing.XdsUpdateClientConfigureService";
+  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,
@@ -62,6 +60,21 @@ public XdsUpdateClientConfigureServiceStub newStub(io.grpc.Channel channel, io.g
     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
    */
@@ -97,37 +110,41 @@ public XdsUpdateClientConfigureServiceFutureStub newStub(io.grpc.Channel channel
    * A service to dynamically update the configuration of an xDS test client.
    * </pre>
    */
-  public static abstract class XdsUpdateClientConfigureServiceImplBase implements io.grpc.BindableService {
+  public interface AsyncService {
 
     /**
      * <pre>
      * Update the tes client's configuration.
      * </pre>
      */
-    public void configure(io.grpc.testing.integration.Messages.ClientConfigureRequest request,
+    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 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>(
-                  this, METHODID_CONFIGURE)))
-          .build();
+      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> {
+  public static final class XdsUpdateClientConfigureServiceStub
+      extends io.grpc.stub.AbstractAsyncStub<XdsUpdateClientConfigureServiceStub> {
     private XdsUpdateClientConfigureServiceStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -152,11 +169,43 @@ public void configure(io.grpc.testing.integration.Messages.ClientConfigureReques
   }
 
   /**
+   * 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> {
+  public static final class XdsUpdateClientConfigureServiceBlockingStub
+      extends io.grpc.stub.AbstractBlockingStub<XdsUpdateClientConfigureServiceBlockingStub> {
     private XdsUpdateClientConfigureServiceBlockingStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -180,11 +229,13 @@ public io.grpc.testing.integration.Messages.ClientConfigureResponse configure(io
   }
 
   /**
+   * 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> {
+  public static final class XdsUpdateClientConfigureServiceFutureStub
+      extends io.grpc.stub.AbstractFutureStub<XdsUpdateClientConfigureServiceFutureStub> {
     private XdsUpdateClientConfigureServiceFutureStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -215,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 XdsUpdateClientConfigureServiceImplBase serviceImpl;
+    private final AsyncService serviceImpl;
     private final int methodId;
 
-    MethodHandlers(XdsUpdateClientConfigureServiceImplBase serviceImpl, int methodId) {
+    MethodHandlers(AsyncService serviceImpl, int methodId) {
       this.serviceImpl = serviceImpl;
       this.methodId = methodId;
     }
@@ -247,6 +298,18 @@ public io.grpc.stub.StreamObserver<Req> invoke(
     }
   }
 
+  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() {}
@@ -270,9 +333,9 @@ private static final class XdsUpdateClientConfigureServiceFileDescriptorSupplier
   private static final class XdsUpdateClientConfigureServiceMethodDescriptorSupplier
       extends XdsUpdateClientConfigureServiceBaseDescriptorSupplier
       implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
-    private final String methodName;
+    private final java.lang.String methodName;
 
-    XdsUpdateClientConfigureServiceMethodDescriptorSupplier(String methodName) {
+    XdsUpdateClientConfigureServiceMethodDescriptorSupplier(java.lang.String methodName) {
       this.methodName = methodName;
     }
 
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
index 6d1a67a52bd..5531033ae5c 100644
--- 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
@@ -7,14 +7,12 @@
  * A service to remotely control health status of an xDS test server.
  * </pre>
  */
-@javax.annotation.Generated(
-    value = "by gRPC proto compiler",
-    comments = "Source: grpc/testing/test.proto")
+@io.grpc.stub.annotations.GrpcGenerated
 public final class XdsUpdateHealthServiceGrpc {
 
   private XdsUpdateHealthServiceGrpc() {}
 
-  public static final String SERVICE_NAME = "grpc.testing.XdsUpdateHealthService";
+  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,
@@ -93,6 +91,21 @@ public XdsUpdateHealthServiceStub newStub(io.grpc.Channel channel, io.grpc.CallO
     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
    */
@@ -128,48 +141,45 @@ public XdsUpdateHealthServiceFutureStub newStub(io.grpc.Channel channel, io.grpc
    * A service to remotely control health status of an xDS test server.
    * </pre>
    */
-  public static abstract class XdsUpdateHealthServiceImplBase implements io.grpc.BindableService {
+  public interface AsyncService {
 
     /**
      */
-    public void setServing(io.grpc.testing.integration.EmptyProtos.Empty request,
+    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);
     }
 
     /**
      */
-    public void setNotServing(io.grpc.testing.integration.EmptyProtos.Empty request,
+    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 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>(
-                  this, METHODID_SET_SERVING)))
-          .addMethod(
-            getSetNotServingMethod(),
-            io.grpc.stub.ServerCalls.asyncUnaryCall(
-              new MethodHandlers<
-                io.grpc.testing.integration.EmptyProtos.Empty,
-                io.grpc.testing.integration.EmptyProtos.Empty>(
-                  this, METHODID_SET_NOT_SERVING)))
-          .build();
+      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> {
+  public static final class XdsUpdateHealthServiceStub
+      extends io.grpc.stub.AbstractAsyncStub<XdsUpdateHealthServiceStub> {
     private XdsUpdateHealthServiceStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -199,11 +209,47 @@ public void setNotServing(io.grpc.testing.integration.EmptyProtos.Empty request,
   }
 
   /**
+   * 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 XdsUpdateHealthServiceBlockingStub extends io.grpc.stub.AbstractBlockingStub<XdsUpdateHealthServiceBlockingStub> {
+  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);
@@ -231,11 +277,13 @@ public io.grpc.testing.integration.EmptyProtos.Empty setNotServing(io.grpc.testi
   }
 
   /**
+   * 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> {
+  public static final class XdsUpdateHealthServiceFutureStub
+      extends io.grpc.stub.AbstractFutureStub<XdsUpdateHealthServiceFutureStub> {
     private XdsUpdateHealthServiceFutureStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -272,10 +320,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 XdsUpdateHealthServiceImplBase serviceImpl;
+    private final AsyncService serviceImpl;
     private final int methodId;
 
-    MethodHandlers(XdsUpdateHealthServiceImplBase serviceImpl, int methodId) {
+    MethodHandlers(AsyncService serviceImpl, int methodId) {
       this.serviceImpl = serviceImpl;
       this.methodId = methodId;
     }
@@ -308,6 +356,25 @@ public io.grpc.stub.StreamObserver<Req> invoke(
     }
   }
 
+  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() {}
@@ -331,9 +398,9 @@ private static final class XdsUpdateHealthServiceFileDescriptorSupplier
   private static final class XdsUpdateHealthServiceMethodDescriptorSupplier
       extends XdsUpdateHealthServiceBaseDescriptorSupplier
       implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
-    private final String methodName;
+    private final java.lang.String methodName;
 
-    XdsUpdateHealthServiceMethodDescriptorSupplier(String methodName) {
+    XdsUpdateHealthServiceMethodDescriptorSupplier(java.lang.String methodName) {
       this.methodName = methodName;
     }
 
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 758f99d5353..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
@@ -21,18 +21,12 @@
 import static io.grpc.stub.ClientCalls.blockingServerStreamingCall;
 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 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;
@@ -40,11 +34,11 @@
 import com.google.common.util.concurrent.SettableFuture;
 import com.google.protobuf.ByteString;
 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.ClientInterceptors;
 import io.grpc.ClientStreamTracer;
 import io.grpc.Context;
 import io.grpc.Grpc;
@@ -61,7 +55,6 @@
 import io.grpc.ServerStreamTracer;
 import io.grpc.Status;
 import io.grpc.StatusRuntimeException;
-import io.grpc.auth.MoreCallCredentials;
 import io.grpc.census.InternalCensusStatsAccessor;
 import io.grpc.census.internal.DeprecatedCensusConstants;
 import io.grpc.internal.GrpcUtil;
@@ -76,7 +69,6 @@
 import io.grpc.internal.testing.TestServerStreamTracer;
 import io.grpc.internal.testing.TestStreamTracer;
 import io.grpc.stub.ClientCallStreamObserver;
-import io.grpc.stub.ClientCalls;
 import io.grpc.stub.MetadataUtils;
 import io.grpc.stub.StreamObserver;
 import io.grpc.testing.TestUtils;
@@ -92,12 +84,14 @@
 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 io.opencensus.trace.unsafe.ContextUtils;
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
@@ -111,6 +105,7 @@
 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;
@@ -137,7 +132,7 @@
 /**
  * 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());
@@ -152,6 +147,15 @@ public abstract class AbstractInteropTest {
    * 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 =
@@ -199,7 +203,7 @@ public Context filterContext(Context context) {
    * Constructor for tests.
    */
   protected AbstractInteropTest() {
-    TestRule timeout = Timeout.seconds(60);
+    TestRule timeout = Timeout.seconds(90);
     try {
       timeout = new DisableOnDebug(timeout);
     } catch (Throwable t) {
@@ -223,11 +227,8 @@ public ServerStreamTracer newServerStreamTracer(String fullMethodName, Metadata
 
   protected static final Empty EMPTY = Empty.getDefaultInstance();
 
-  private void startServer() {
-    maybeStartHandshakerServer();
-    ServerBuilder<?> builder = getServerBuilder();
+  private void configBuilder(@Nullable ServerBuilder<?> builder) {
     if (builder == null) {
-      server = null;
       return;
     }
     testServiceExecutor = Executors.newScheduledThreadPool(2);
@@ -245,6 +246,14 @@ private void startServer() {
                 new TestServiceImpl(testServiceExecutor),
                 allInterceptors))
         .addStreamTracerFactory(serverStreamTracerFactory);
+  }
+
+  protected void startServer(@Nullable ServerBuilder<?> builder) {
+    maybeStartHandshakerServer();
+    if (builder == null) {
+      server = null;
+      return;
+    }
 
     try {
       server = builder.build().start();
@@ -287,6 +296,11 @@ final SocketAddress getListenAddress() {
 
   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() {
@@ -312,12 +326,19 @@ public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
    */
   @Before
   public void setUp() {
-    startServer();
+    ServerBuilder<?> serverBuilder = getServerBuilder();
+    configBuilder(serverBuilder);
+    startServer(serverBuilder);
     channel = createChannel();
 
-    blockingStub =
-        TestServiceGrpc.newBlockingStub(channel).withInterceptors(tracerSetupInterceptor);
-    asyncStub = TestServiceGrpc.newStub(channel).withInterceptors(tracerSetupInterceptor);
+    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) {
@@ -375,7 +396,9 @@ protected final ClientInterceptor createCensusStatsClientInterceptor() {
             .getClientInterceptor(
                 tagger, tagContextBinarySerializer, clientStatsRecorder,
                 GrpcUtil.STOPWATCH_SUPPLIER,
-                true, true, true, false /* real-time metrics */);
+                true, true, true,
+                /* recordRealTimeMetrics= */ false,
+                /* recordRetryMetrics= */ true);
   }
 
   protected final ServerStreamTracer.Factory createCustomCensusTracerFactory() {
@@ -411,47 +434,6 @@ public void emptyUnaryWithRetriableStream() throws Exception {
     assertEquals(EMPTY, TestServiceGrpc.newBlockingStub(channel).emptyCall(EMPTY));
   }
 
-  /** 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.
-  }
-
   @Test
   public void largeUnary() throws Exception {
     assumeEnoughMemory();
@@ -501,7 +483,7 @@ public void clientCompressedUnary(boolean probe) throws Exception {
         blockingStub.unaryCall(expectCompressedRequest);
         fail("expected INVALID_ARGUMENT");
       } catch (StatusRuntimeException e) {
-        assertEquals(Status.INVALID_ARGUMENT.getCode(), e.getStatus().getCode());
+        assertCodeEquals(Status.Code.INVALID_ARGUMENT, e.getStatus());
       }
       assertStatsTrace("grpc.testing.TestService/UnaryCall", Status.Code.INVALID_ARGUMENT);
     }
@@ -563,26 +545,6 @@ public void serverCompressedUnary() throws Exception {
         Collections.singleton(goldenResponse));
   }
 
-  /**
-   * 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());
-    }
-  }
-
   @Test
   public void serverStreaming() throws Exception {
     final StreamingOutputCallRequest request = StreamingOutputCallRequest.newBuilder()
@@ -690,7 +652,7 @@ public void clientCompressedStreaming(boolean probe) throws Exception {
       responseObserver.awaitCompletion(operationTimeoutMillis(), TimeUnit.MILLISECONDS);
       Throwable e = responseObserver.getError();
       assertNotNull("expected INVALID_ARGUMENT", e);
-      assertEquals(Status.INVALID_ARGUMENT.getCode(), Status.fromThrowable(e).getCode());
+      assertCodeEquals(Status.Code.INVALID_ARGUMENT, Status.fromThrowable(e));
     }
 
     // Start a new stream
@@ -839,8 +801,7 @@ 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()) {
       MetricsRecord clientStartRecord = clientStatsRecorder.pollRecord(5, TimeUnit.SECONDS);
@@ -877,8 +838,7 @@ public void cancelAfterFirstResponse() throws Exception {
     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()));
 
     assertStatsTrace("grpc.testing.TestService/FullDuplexCall", Status.Code.CANCELLED);
   }
@@ -909,7 +869,7 @@ 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);
       int length = response.getPayload().getBody().size();
@@ -943,7 +903,7 @@ public void halfDuplexCallShouldSucceed() 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);
       int length = response.getPayload().getBody().size();
@@ -1042,42 +1002,38 @@ public void veryLargeResponse() throws Exception {
 
   @Test
   public void exchangeMetadataUnaryCall() throws Exception {
-    TestServiceGrpc.TestServiceBlockingStub stub = blockingStub;
-
     // 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(Util.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<>();
     AtomicReference<Metadata> headersCapture = new AtomicReference<>();
-    stub = MetadataUtils.captureMetadata(stub, headersCapture, trailersCapture);
+    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(Util.METADATA_KEY));
-    Assert.assertEquals(contextValue, trailersCapture.get().get(Util.METADATA_KEY));
+    Assert.assertEquals(metadataValue, headersCapture.get().get(Util.METADATA_KEY));
+    Assert.assertEquals(metadataValue, trailersCapture.get().get(Util.METADATA_KEY));
   }
 
   @Test
   public void exchangeMetadataStreamingCall() throws Exception {
-    TestServiceGrpc.TestServiceStub stub = asyncStub;
-
     // 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(Util.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<>();
     AtomicReference<Metadata> headersCapture = new AtomicReference<>();
-    stub = MetadataUtils.captureMetadata(stub, headersCapture, trailersCapture);
+    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 =
@@ -1099,11 +1055,12 @@ public void exchangeMetadataStreamingCall() throws Exception {
     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(Util.METADATA_KEY));
-    Assert.assertEquals(contextValue, trailersCapture.get().get(Util.METADATA_KEY));
+    Assert.assertEquals(metadataValue, headersCapture.get().get(Util.METADATA_KEY));
+    Assert.assertEquals(metadataValue, trailersCapture.get().get(Util.METADATA_KEY));
   }
 
   @Test
@@ -1148,12 +1105,12 @@ public void deadlineExceeded() throws Exception {
       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("deadline exceeded after .*s. \\[.*\\]", desc)
+          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."));
@@ -1179,6 +1136,7 @@ public void deadlineExceeded() throws Exception {
   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);
@@ -1193,9 +1151,7 @@ public void deadlineExceededServerStreaming() throws Exception {
         .withDeadlineAfter(30, TimeUnit.MILLISECONDS)
         .streamingOutputCall(request, recorder);
     recorder.awaitCompletion();
-    assertEquals(Status.DEADLINE_EXCEEDED.getCode(),
-        Status.fromThrowable(recorder.getError()).getCode());
-    assertStatsTrace("grpc.testing.TestService/EmptyCall", Status.Code.OK);
+    assertCodeEquals(Status.Code.DEADLINE_EXCEEDED, Status.fromThrowable(recorder.getError()));
     if (metricsExpected()) {
       // Stream may not have been created when deadline is exceeded, thus we don't check tracer
       // stats.
@@ -1220,9 +1176,9 @@ public void deadlineInPast() throws Exception {
           .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 deadline exceeded");
+          .startsWith("ClientCall started after CallOptions deadline was exceeded");
     }
 
     // CensusStreamTracerModule record final status in the interceptor, thus is guaranteed to be
@@ -1235,21 +1191,28 @@ public void deadlineInPast() throws Exception {
       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 {
       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 deadline exceeded");
+          .startsWith("ClientCall started after CallOptions deadline was exceeded");
     }
-    assertStatsTrace("grpc.testing.TestService/EmptyCall", Status.Code.OK);
     if (metricsExpected()) {
       MetricsRecord clientStartRecord = clientStatsRecorder.pollRecord(5, TimeUnit.SECONDS);
       checkStartTags(clientStartRecord, "grpc.testing.TestService/EmptyCall", true);
@@ -1257,6 +1220,7 @@ public void deadlineInPast() throws Exception {
       checkEndTags(
           clientEndRecord, "grpc.testing.TestService/EmptyCall",
           Status.DEADLINE_EXCEEDED.getCode(), true);
+      assertZeroRetryRecorded();
     }
   }
 
@@ -1311,8 +1275,7 @@ public void maxInboundSize_tooBig() {
       stub.streamingOutputCall(request).next();
       fail();
     } catch (StatusRuntimeException ex) {
-      Status s = ex.getStatus();
-      assertWithMessage(s.toString()).that(s.getCode()).isEqualTo(Status.Code.RESOURCE_EXHAUSTED);
+      assertCodeEquals(Status.Code.RESOURCE_EXHAUSTED, ex.getStatus());
       assertThat(Throwables.getStackTraceAsString(ex)).contains("exceeds maximum");
     }
   }
@@ -1367,8 +1330,7 @@ public void maxOutboundSize_tooBig() {
       stub.streamingOutputCall(request).next();
       fail();
     } catch (StatusRuntimeException ex) {
-      Status s = ex.getStatus();
-      assertWithMessage(s.toString()).that(s.getCode()).isEqualTo(Status.Code.CANCELLED);
+      assertCodeEquals(Status.Code.CANCELLED, ex.getStatus());
       assertThat(Throwables.getStackTraceAsString(ex)).contains("message too large");
     }
   }
@@ -1484,11 +1446,11 @@ 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 = this.blockingStub;
-    blockingStub = MetadataUtils.attachHeaders(blockingStub, metadata);
     AtomicReference<Metadata> headersCapture = new AtomicReference<>();
     AtomicReference<Metadata> trailersCapture = new AtomicReference<>();
-    blockingStub = MetadataUtils.captureMetadata(blockingStub, headersCapture, trailersCapture);
+    TestServiceGrpc.TestServiceBlockingStub blockingStub = this.blockingStub.withInterceptors(
+        MetadataUtils.newAttachHeadersInterceptor(metadata),
+        MetadataUtils.newCaptureMetadataInterceptor(headersCapture, trailersCapture));
     SimpleResponse response = blockingStub.unaryCall(request);
 
     assertResponse(goldenResponse, response);
@@ -1503,11 +1465,11 @@ public void customMetadata() throws Exception {
     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 = asyncStub;
-    stub = MetadataUtils.attachHeaders(stub, metadata);
     headersCapture = new AtomicReference<>();
     trailersCapture = new AtomicReference<>();
-    stub = MetadataUtils.captureMetadata(stub, headersCapture, trailersCapture);
+    TestServiceGrpc.TestServiceStub stub = asyncStub.withInterceptors(
+        MetadataUtils.newAttachHeadersInterceptor(metadata),
+        MetadataUtils.newCaptureMetadataInterceptor(headersCapture, trailersCapture));
 
     StreamRecorder<Messages.StreamingOutputCallResponse> recorder = StreamRecorder.create();
     StreamObserver<Messages.StreamingOutputCallRequest> requestStream =
@@ -1526,6 +1488,7 @@ public void customMetadata() throws Exception {
         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);
@@ -1540,7 +1503,7 @@ public void censusContextsPropagated() {
                 .emptyBuilder()
                 .putLocal(StatsTestUtils.EXTRA_TAG, TagValue.create("extra value"))
                 .build());
-    ctx = ContextUtils.withValue(ctx, clientParentSpan);
+    ctx = io.opencensus.trace.unsafe.ContextUtils.withValue(ctx, clientParentSpan);
     Context origCtx = ctx.attach();
     try {
       blockingStub.unaryCall(SimpleRequest.getDefaultInstance());
@@ -1560,7 +1523,7 @@ public void censusContextsPropagated() {
       }
       assertTrue("tag not found", tagFound);
 
-      Span span = ContextUtils.getValue(serverCtx);
+      Span span = io.opencensus.trace.unsafe.ContextUtils.getValue(serverCtx);
       assertNotNull(span);
       SpanContext spanContext = span.getContext();
       assertEquals(clientParentSpan.getContext().getTraceId(), spanContext.getTraceId());
@@ -1589,7 +1552,7 @@ 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());
     }
     assertStatsTrace("grpc.testing.TestService/UnaryCall", Status.Code.UNKNOWN);
@@ -1605,7 +1568,7 @@ public void statusCodeAndMessage() throws Exception {
         .isTrue();
     assertThat(responseObserver.getError()).isNotNull();
     Status status = Status.fromThrowable(responseObserver.getError());
-    assertEquals(Status.UNKNOWN.getCode(), status.getCode());
+    assertCodeEquals(Status.Code.UNKNOWN, status);
     assertEquals(errorMessage, status.getDescription());
     assertStatsTrace("grpc.testing.TestService/FullDuplexCall", Status.Code.UNKNOWN);
   }
@@ -1625,7 +1588,7 @@ public void specialStatusMessage() 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());
     }
     assertStatsTrace("grpc.testing.TestService/UnaryCall", Status.Code.UNKNOWN);
@@ -1638,7 +1601,7 @@ public void unimplementedMethod() {
       blockingStub.unimplementedCall(Empty.getDefaultInstance());
       fail();
     } catch (StatusRuntimeException e) {
-      assertEquals(Status.UNIMPLEMENTED.getCode(), e.getStatus().getCode());
+      assertCodeEquals(Status.Code.UNIMPLEMENTED, e.getStatus());
     }
 
     assertClientStatsTrace("grpc.testing.TestService/UnimplementedCall",
@@ -1654,7 +1617,7 @@ public void unimplementedService() {
       stub.unimplementedCall(Empty.getDefaultInstance());
       fail();
     } catch (StatusRuntimeException e) {
-      assertEquals(Status.UNIMPLEMENTED.getCode(), e.getStatus().getCode());
+      assertCodeEquals(Status.Code.UNIMPLEMENTED, e.getStatus());
     }
 
     assertStatsTrace("grpc.testing.UnimplementedService/UnimplementedCall",
@@ -1662,7 +1625,6 @@ public void unimplementedService() {
   }
 
   /** Start a fullDuplexCall which the server will not respond, and verify the deadline expires. */
-  @SuppressWarnings("MissingFail")
   @Test
   public void timeoutOnSleepingServer() throws Exception {
     TestServiceGrpc.TestServiceStub stub =
@@ -1672,20 +1634,15 @@ public void timeoutOnSleepingServer() throws Exception {
     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());
 
     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()) {
       // CensusStreamTracerModule record final status in the interceptor, thus is guaranteed to be
@@ -1711,169 +1668,13 @@ public void getServerAddressAndLocalAddressFromClient() {
     assertNotNull(obtainLocalClientAddr());
   }
 
-  /** 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);
-  }
-
-  protected static void assertSuccess(StreamRecorder<?> recorder) {
+  private static void assertSuccess(StreamRecorder<?> recorder) {
     if (recorder.getError() != null) {
       throw new AssertionError(recorder.getError());
     }
   }
 
-  /** Helper for getting remote address from {@link io.grpc.ServerCall#getAttributes()} */
+  /** Helper for getting remote address from {@link io.grpc.ServerCall#getAttributes()}. */
   protected SocketAddress obtainRemoteClientAddr() {
     TestServiceGrpc.TestServiceBlockingStub stub =
         blockingStub.withDeadlineAfter(5, TimeUnit.SECONDS);
@@ -1883,7 +1684,7 @@ protected SocketAddress obtainRemoteClientAddr() {
     return serverCallCapture.get().getAttributes().get(Grpc.TRANSPORT_ATTR_REMOTE_ADDR);
   }
 
-  /** Helper for getting remote address from {@link io.grpc.ClientCall#getAttributes()} */
+  /** Helper for getting remote address from {@link io.grpc.ClientCall#getAttributes()}. */
   protected SocketAddress obtainRemoteServerAddr() {
     TestServiceGrpc.TestServiceBlockingStub stub = blockingStub
         .withInterceptors(recordClientCallInterceptor(clientCallCapture))
@@ -1894,7 +1695,7 @@ protected SocketAddress obtainRemoteServerAddr() {
     return clientCallCapture.get().getAttributes().get(Grpc.TRANSPORT_ATTR_REMOTE_ADDR);
   }
 
-  /** Helper for getting local address from {@link io.grpc.ServerCall#getAttributes()} */
+  /** Helper for getting local address from {@link io.grpc.ServerCall#getAttributes()}. */
   protected SocketAddress obtainLocalServerAddr() {
     TestServiceGrpc.TestServiceBlockingStub stub =
         blockingStub.withDeadlineAfter(5, TimeUnit.SECONDS);
@@ -1904,7 +1705,7 @@ protected SocketAddress obtainLocalServerAddr() {
     return serverCallCapture.get().getAttributes().get(Grpc.TRANSPORT_ATTR_LOCAL_ADDR);
   }
 
-  /** Helper for getting local address from {@link io.grpc.ClientCall#getAttributes()} */
+  /** Helper for getting local address from {@link io.grpc.ClientCall#getAttributes()}. */
   protected SocketAddress obtainLocalClientAddr() {
     TestServiceGrpc.TestServiceBlockingStub stub = blockingStub
         .withInterceptors(recordClientCallInterceptor(clientCallCapture))
@@ -1915,10 +1716,10 @@ protected SocketAddress obtainLocalClientAddr() {
     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 =
-        blockingStub.withDeadlineAfter(5, TimeUnit.SECONDS);
+        blockingStub.withDeadlineAfter(10, TimeUnit.SECONDS);
 
     stub.unaryCall(SimpleRequest.getDefaultInstance());
 
@@ -1935,11 +1736,11 @@ protected void assertX500SubjectDn(String tlsInfo) {
     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;
   }
 
   /**
@@ -1974,6 +1775,13 @@ 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 assertClientStatsTrace(String method, Status.Code code,
       Collection<? extends MessageLite> requests, Collection<? extends MessageLite> responses) {
     // Tracer-based stats
@@ -2003,6 +1811,7 @@ private void assertClientStatsTrace(String method, Status.Code code,
       if (requests != null && responses != null) {
         checkCensus(clientEndRecord, false, requests, responses);
       }
+      assertZeroRetryRecorded();
     }
   }
 
@@ -2096,9 +1905,10 @@ private void checkTracers(
     long uncompressedSentSize = 0;
     int seqNo = 0;
     for (MessageLite msg : sentMessages) {
-      assertThat(tracer.nextOutboundEvent()).isEqualTo(String.format("outboundMessage(%d)", seqNo));
+      assertThat(tracer.nextOutboundEvent())
+          .isEqualTo(String.format(Locale.US, "outboundMessage(%d)", seqNo));
       assertThat(tracer.nextOutboundEvent()).matches(
-          String.format("outboundMessageSent\\(%d, -?[0-9]+, -?[0-9]+\\)", seqNo));
+          String.format(Locale.US, "outboundMessageSent\\(%d, -?[0-9]+, -?[0-9]+\\)", seqNo));
       seqNo++;
       uncompressedSentSize += msg.getSerializedSize();
     }
@@ -2106,9 +1916,10 @@ private void checkTracers(
     long uncompressedReceivedSize = 0;
     seqNo = 0;
     for (MessageLite msg : receivedMessages) {
-      assertThat(tracer.nextInboundEvent()).isEqualTo(String.format("inboundMessage(%d)", seqNo));
+      assertThat(tracer.nextInboundEvent())
+          .isEqualTo(String.format(Locale.US, "inboundMessage(%d)", seqNo));
       assertThat(tracer.nextInboundEvent()).matches(
-          String.format("inboundMessageRead\\(%d, -?[0-9]+, -?[0-9]+\\)", seqNo));
+          String.format(Locale.US, "inboundMessageRead\\(%d, -?[0-9]+, -?[0-9]+\\)", seqNo));
       uncompressedReceivedSize += msg.getSerializedSize();
       seqNo++;
     }
@@ -2135,10 +1946,10 @@ private void checkCensus(MetricsRecord record, boolean isServer,
     if (isServer) {
       assertEquals(
           requests.size(),
-          record.getMetricAsLongOrFail(DeprecatedCensusConstants.RPC_SERVER_REQUEST_COUNT));
+          record.getMetricAsLongOrFail(RpcMeasureConstants.GRPC_SERVER_RECEIVED_MESSAGES_PER_RPC));
       assertEquals(
           responses.size(),
-          record.getMetricAsLongOrFail(DeprecatedCensusConstants.RPC_SERVER_RESPONSE_COUNT));
+          record.getMetricAsLongOrFail(RpcMeasureConstants.GRPC_SERVER_SENT_MESSAGES_PER_RPC));
       assertEquals(
           uncompressedRequestsSize,
           record.getMetricAsLongOrFail(
@@ -2147,18 +1958,18 @@ private void checkCensus(MetricsRecord record, boolean isServer,
           uncompressedResponsesSize,
           record.getMetricAsLongOrFail(
               DeprecatedCensusConstants.RPC_SERVER_UNCOMPRESSED_RESPONSE_BYTES));
-      assertNotNull(record.getMetric(DeprecatedCensusConstants.RPC_SERVER_SERVER_LATENCY));
+      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(DeprecatedCensusConstants.RPC_SERVER_REQUEST_BYTES));
-      assertNotNull(record.getMetric(DeprecatedCensusConstants.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(
           requests.size(),
-          record.getMetricAsLongOrFail(DeprecatedCensusConstants.RPC_CLIENT_REQUEST_COUNT));
+          record.getMetricAsLongOrFail(RpcMeasureConstants.GRPC_CLIENT_SENT_MESSAGES_PER_RPC));
       assertEquals(
           responses.size(),
-          record.getMetricAsLongOrFail(DeprecatedCensusConstants.RPC_CLIENT_RESPONSE_COUNT));
+          record.getMetricAsLongOrFail(RpcMeasureConstants.GRPC_CLIENT_RECEIVED_MESSAGES_PER_RPC));
       assertEquals(
           uncompressedRequestsSize,
           record.getMetricAsLongOrFail(
@@ -2167,11 +1978,11 @@ private void checkCensus(MetricsRecord record, boolean isServer,
           uncompressedResponsesSize,
           record.getMetricAsLongOrFail(
               DeprecatedCensusConstants.RPC_CLIENT_UNCOMPRESSED_RESPONSE_BYTES));
-      assertNotNull(record.getMetric(DeprecatedCensusConstants.RPC_CLIENT_ROUNDTRIP_LATENCY));
+      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(DeprecatedCensusConstants.RPC_CLIENT_REQUEST_BYTES));
-      assertNotNull(record.getMetric(DeprecatedCensusConstants.RPC_CLIENT_RESPONSE_BYTES));
+      assertNotNull(record.getMetric(RpcMeasureConstants.GRPC_CLIENT_SENT_BYTES_PER_RPC));
+      assertNotNull(record.getMetric(RpcMeasureConstants.GRPC_CLIENT_RECEIVED_BYTES_PER_RPC));
     }
   }
 
@@ -2198,7 +2009,7 @@ private void assertResponse(
     }
   }
 
-  private void assertResponse(SimpleResponse expected, SimpleResponse actual) {
+  public void assertResponse(SimpleResponse expected, SimpleResponse actual) {
     assertPayload(expected.getPayload(), actual.getPayload());
     assertEquals(expected.getUsername(), actual.getUsername());
     assertEquals(expected.getOauthScope(), actual.getOauthScope());
@@ -2213,6 +2024,10 @@ private void assertPayload(Payload expected, Payload actual) {
     }
   }
 
+  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()}
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
index e98f4c31d2a..8ce83f73e6d 100644
--- a/interop-testing/src/main/java/io/grpc/testing/integration/GrpclbFallbackTestClient.java
+++ b/interop-testing/src/main/java/io/grpc/testing/integration/GrpclbFallbackTestClient.java
@@ -16,7 +16,7 @@
 
 package io.grpc.testing.integration;
 
-import static com.google.common.base.Charsets.UTF_8;
+import static java.nio.charset.StandardCharsets.UTF_8;
 import static org.junit.Assert.assertEquals;
 
 import com.google.common.io.CharStreams;
@@ -69,11 +69,13 @@ public void run() {
     System.exit(0);
   }
 
-  private String unrouteLbAndBackendAddrsCmd = "exit 1";
-  private String blackholeLbAndBackendAddrsCmd = "exit 1";
+  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;
@@ -102,12 +104,16 @@ private void parseArgs(String[] args) {
         serverUri = value;
       } else if ("test_case".equals(key)) {
         testCase = value;
-      } else if ("unroute_lb_and_backend_addrs_cmd".equals(key)) {
-        unrouteLbAndBackendAddrsCmd = value;
-      } else if ("blackhole_lb_and_backend_addrs_cmd".equals(key)) {
-        blackholeLbAndBackendAddrsCmd = 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;
@@ -123,20 +129,25 @@ private void parseArgs(String[] args) {
           + c.serverUri
           + "\n  --custom_credentials_type             Name of Credentials to use. "
           + "Default: " + c.customCredentialsType
-          + "\n  --unroute_lb_and_backend_addrs_cmd    Shell command used to make "
-          + "LB and backend addresses unroutable. Default: "
-          + c.unrouteLbAndBackendAddrsCmd
-          + "\n  --blackhole_lb_and_backend_addrs_cmd  Shell command used to make "
-          + "LB and backend addresses black holed. Default: "
-          + c.blackholeLbAndBackendAddrsCmd
+          + "\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      fast_fallback_before_startup : fallback before LB connection"
-          + "\n      fast_fallback_after_startup : fallback after startup due to "
-          + "LB/backend addresses becoming unroutable"
-          + "\n      slow_fallback_before_startup : fallback before LB connection "
-          + "due to LB/backend addresses being blackholed"
-          + "\n      slow_fallback_after_startup : fallback after startup due to "
-          + "LB/backend addresses becoming blackholed"
+          + "\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);
@@ -172,9 +183,14 @@ private void tearDown() {
     }
   }
 
-  private static void runShellCmd(String cmd) throws Exception {
+  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);
-    ProcessBuilder pb = new ProcessBuilder("bash", "-c", 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: "
@@ -185,14 +201,15 @@ private static void runShellCmd(String cmd) throws Exception {
     assertEquals(0, exitCode);
   }
 
-  private GrpclbRouteType doRpcAndGetPath(Deadline deadline) {
+  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 = blockingStub
+      SimpleResponse response = stub
           .withDeadline(deadline)
           .unaryCall(request);
       result = response.getGrpclbRouteType();
@@ -211,10 +228,10 @@ private GrpclbRouteType doRpcAndGetPath(Deadline deadline) {
 
   private void waitForFallbackAndDoRpcs(Deadline fallbackDeadline) throws Exception {
     int fallbackRetryCount = 0;
-    boolean fellBack = false;
+    boolean fallBack = false;
     while (!fallbackDeadline.isExpired()) {
       GrpclbRouteType grpclbRouteType = doRpcAndGetPath(
-          Deadline.after(1, TimeUnit.SECONDS));
+          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");
@@ -222,68 +239,70 @@ private void waitForFallbackAndDoRpcs(Deadline fallbackDeadline) throws Exceptio
       if (grpclbRouteType == GrpclbRouteType.GRPCLB_ROUTE_TYPE_FALLBACK) {
         logger.info("Made one successful RPC to a fallback. Now expect the "
             + "same for the rest.");
-        fellBack = true;
+        fallBack = true;
         break;
       } else {
         logger.info("Retryable RPC failure on iteration: " + fallbackRetryCount);
       }
       fallbackRetryCount++;
     }
-    if (!fellBack) {
+    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(Deadline.after(20, TimeUnit.SECONDS)));
+          doRpcAndGetPath(blockingStub, Deadline.after(20, TimeUnit.SECONDS)));
       Thread.sleep(1000);
     }
   }
 
-  private void runFastFallbackBeforeStartup() throws Exception {
-    runShellCmd(unrouteLbAndBackendAddrsCmd);
-    final Deadline fallbackDeadline = Deadline.after(5, TimeUnit.SECONDS);
+  private void runFallbackBeforeStartup() throws Exception {
+    runShellCmd(induceFallbackCmd);
+    final Deadline fallbackDeadline = Deadline.after(
+        fallbackDeadlineSeconds, TimeUnit.SECONDS);
     initStub();
     waitForFallbackAndDoRpcs(fallbackDeadline);
   }
 
-  private void runSlowFallbackBeforeStartup() throws Exception {
-    runShellCmd(blackholeLbAndBackendAddrsCmd);
-    final Deadline fallbackDeadline = Deadline.after(20, TimeUnit.SECONDS);
-    initStub();
-    waitForFallbackAndDoRpcs(fallbackDeadline);
-  }
-
-  private void runFastFallbackAfterStartup() throws Exception {
+  private void runFallbackAfterStartup() throws Exception {
     initStub();
     assertEquals(
         GrpclbRouteType.GRPCLB_ROUTE_TYPE_BACKEND,
-        doRpcAndGetPath(Deadline.after(20, TimeUnit.SECONDS)));
-    runShellCmd(unrouteLbAndBackendAddrsCmd);
-    final Deadline fallbackDeadline = Deadline.after(40, TimeUnit.SECONDS);
+        doRpcAndGetPath(blockingStub, Deadline.after(20, TimeUnit.SECONDS)));
+    runShellCmd(induceFallbackCmd);
+    final Deadline fallbackDeadline = Deadline.after(
+        fallbackDeadlineSeconds, TimeUnit.SECONDS);
     waitForFallbackAndDoRpcs(fallbackDeadline);
   }
 
-  private void runSlowFallbackAfterStartup() throws Exception {
-    initStub();
-    assertEquals(
-        GrpclbRouteType.GRPCLB_ROUTE_TYPE_BACKEND,
-        doRpcAndGetPath(Deadline.after(20, TimeUnit.SECONDS)));
-    runShellCmd(blackholeLbAndBackendAddrsCmd);
-    final Deadline fallbackDeadline = Deadline.after(40, 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("fast_fallback_before_startup")) {
-      runFastFallbackBeforeStartup();
-    } else if (testCase.equals("slow_fallback_before_startup")) {
-      runSlowFallbackBeforeStartup();
-    } else if (testCase.equals("fast_fallback_after_startup")) {
-      runFastFallbackAfterStartup();
-    } else if (testCase.equals("slow_fallback_after_startup")) {
-      runSlowFallbackAfterStartup();
+    if (testCase.equals("fallback_before_startup")) {
+      runFallbackBeforeStartup();
+    } else if (testCase.equals("fallback_after_startup")) {
+      runFallbackAfterStartup();
     } else {
       throw new RuntimeException("invalid testcase: " + testCase);
     }
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 fbe9e3fa28f..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
@@ -23,18 +23,16 @@
 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.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;
@@ -272,7 +270,7 @@ private void maxStreams() throws Exception {
       threadpool = MoreExecutors.listeningDecorator(newFixedThreadPool(numThreads));
       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);
@@ -314,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
@@ -355,15 +351,8 @@ 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() {
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 b064ee74243..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
@@ -17,6 +17,7 @@
 package io.grpc.testing.integration;
 
 import com.google.common.base.Preconditions;
+import java.util.Locale;
 
 /**
  * Enum of HTTP/2 interop test cases.
@@ -49,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 a89e8788abe..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
@@ -25,6 +25,7 @@
 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
@@ -79,12 +80,12 @@ private void runTest() throws Exception {
             .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..f1410142bff
--- /dev/null
+++ b/interop-testing/src/main/java/io/grpc/testing/integration/RpcBehaviorLoadBalancerProvider.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.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;
+    }
+
+    @Deprecated
+    @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 6669d2700d6..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
@@ -32,30 +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.internal.testing.TestUtils;
-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.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;
 
@@ -86,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 {
@@ -103,14 +109,17 @@ public void run() {
   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<>();
+  private final AtomicLong totalCallCount = new AtomicLong(0);
 
   private volatile boolean shutdown;
 
@@ -121,6 +130,7 @@ public void run() {
       new ArrayList<>();
   private final List<ManagedChannel> channels = new ArrayList<>();
   private ListeningExecutorService threadpool;
+  private ScheduledExecutorService metricsLoggingThreadpool;
 
   @VisibleForTesting
   void parseArgs(String[] args) {
@@ -153,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)) {
@@ -163,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;
@@ -193,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);
     }
@@ -214,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.");
@@ -231,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);
 
@@ -272,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);
     }
@@ -284,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
@@ -295,19 +341,9 @@ private List<InetSocketAddress> parseServerAddresses(String addressesStr) {
     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;
@@ -340,19 +376,47 @@ 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();
     }
-    return NettyChannelBuilder.forAddress(address)
-        .negotiationType(useTls ? NegotiationType.TLS : NegotiationType.PLAINTEXT)
-        .sslContext(sslContext)
-        .build();
+    ManagedChannelBuilder<?> builder;
+    if (address.getPort() == 0) {
+      builder = Grpc.newChannelBuilder(address.getHostString(), channelCredentials);
+    } else {
+      builder = Grpc.newChannelBuilderForAddress(address.getHostString(), address.getPort(),
+          channelCredentials);
+    }
+
+    if (serverHostOverride != null) {
+      builder.overrideAuthority(serverHostOverride);
+    }
+    return builder.build();
+  }
+
+  private long getTotalCallCount() {
+    return totalCallCount.get();
   }
 
   private static String serverAddressesToString(List<InetSocketAddress> addresses) {
@@ -372,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(": ")
@@ -410,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();
@@ -426,6 +494,7 @@ public void run() {
         }
 
         testCasesSinceLastMetricsCollection++;
+        totalCallCount.incrementAndGet();
 
         double durationSecs = computeDurationSecs(lastMetricsCollectionTime);
         if (durationSecs >= METRICS_COLLECTION_INTERVAL_SECS) {
@@ -639,6 +708,11 @@ boolean useTestCa() {
     return useTestCa;
   }
 
+  @VisibleForTesting
+  String customCredentialsType() {
+    return customCredentialsType;
+  }
+
   @VisibleForTesting
   List<TestCaseWeightPair> testCaseWeightPairs() {
     return testCaseWeightPairs;
@@ -663,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 2d1648e157a..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
@@ -17,6 +17,7 @@
 package io.grpc.testing.integration;
 
 import com.google.common.base.Preconditions;
+import java.util.Locale;
 
 /**
  * Enum of interop test cases.
@@ -54,7 +55,11 @@ public enum TestCases {
   CANCEL_AFTER_FIRST_RESPONSE("cancel on first 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");
+  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 e070b1e764b..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
@@ -16,30 +16,68 @@
 
 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.internal.testing.TestUtils;
+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.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.io.InputStream;
 import java.nio.charset.Charset;
+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;
 
 /**
@@ -50,14 +88,19 @@ 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 {
-    // Let Netty or OkHttp use Conscrypt if it is available.
-    TestUtils.installConscryptIfAvailable();
     final TestServiceClient client = new TestServiceClient();
     client.parseArgs(args);
+    customBackendMetricsLoadBalancerProvider = new CustomBackendMetricsLoadBalancerProvider();
+    LoadBalancerRegistry.getDefaultRegistry().register(customBackendMetricsLoadBalancerProvider);
     client.setUp();
 
     try {
@@ -65,13 +108,13 @@ public static void main(String[] args) throws Exception {
     } 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;
@@ -81,13 +124,24 @@ public static void main(String[] args) throws Exception {
   private String defaultServiceAccount;
   private String serviceAccountKeyFile;
   private String oauthScope;
-  private boolean fullStreamDecompression;
   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();
 
   @VisibleForTesting
-  void parseArgs(String[] args) {
+  void parseArgs(String[] args) throws Exception {
     boolean usage = false;
     for (String arg : args) {
       if (!arg.startsWith("--")) {
@@ -115,6 +169,8 @@ 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)) {
@@ -139,10 +195,30 @@ void parseArgs(String[] args) {
         serviceAccountKeyFile = value;
       } else if ("oauth_scope".equals(key)) {
         oauthScope = value;
-      } else if ("full_stream_decompression".equals(key)) {
-        fullStreamDecompression = Boolean.parseBoolean(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;
@@ -164,6 +240,8 @@ 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
@@ -184,8 +262,44 @@ 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  --full_stream_decompression Enable full-stream decompression. Default "
-            + c.fullStreamDecompression
+          + "\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);
     }
@@ -199,6 +313,10 @@ void setUp() {
   private synchronized void tearDown() {
     try {
       tester.tearDown();
+      if (customBackendMetricsLoadBalancerProvider != null) {
+        LoadBalancerRegistry.getDefaultRegistry()
+            .deregister(customBackendMetricsLoadBalancerProvider);
+      }
     } catch (RuntimeException ex) {
       throw ex;
     } catch (Exception ex) {
@@ -209,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) {
@@ -278,8 +398,19 @@ private void runTest(TestCases testCase) throws Exception {
         break;
 
       case COMPUTE_ENGINE_CHANNEL_CREDENTIALS: {
-        ManagedChannel channel = Grpc.newChannelBuilderForAddress(
-            serverHost, serverPort, ComputeEngineChannelCredentials.create()).build();
+        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);
@@ -319,8 +450,19 @@ private void runTest(TestCases testCase) throws Exception {
       }
 
       case GOOGLE_DEFAULT_CREDENTIALS: {
-        ManagedChannel channel = Grpc.newChannelBuilderForAddress(
-            serverHost, serverPort, GoogleDefaultChannelCredentials.create()).build();
+        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);
@@ -380,11 +522,79 @@ private void runTest(TestCases testCase) throws Exception {
         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 ManagedChannelBuilder<?> createChannelBuilder() {
@@ -417,7 +627,7 @@ protected ManagedChannelBuilder<?> createChannelBuilder() {
         } else {
           try {
             channelCredentials = TlsChannelCredentials.newBuilder()
-                .trustManager(TestUtils.loadCert("ca.pem"))
+                .trustManager(TlsTesting.loadCert("ca.pem"))
                 .build();
           } catch (Exception ex) {
             throw new RuntimeException(ex);
@@ -435,44 +645,391 @@ protected ManagedChannelBuilder<?> createChannelBuilder() {
           channelCredentials = InsecureChannelCredentials.create();
         }
       }
+      ClientInterceptor addMdInterceptor = maybeCreateAdditionalMetadataInterceptor(
+          additionalMetadata);
       if (useGeneric) {
-        ManagedChannelBuilder<?> channelBuilder =
-            Grpc.newChannelBuilderForAddress(serverHost, serverPort, channelCredentials);
+        ManagedChannelBuilder<?> channelBuilder;
+        if (serverPort == 0) {
+          channelBuilder = Grpc.newChannelBuilder(serverHost, channelCredentials);
+        } else {
+          channelBuilder =
+              Grpc.newChannelBuilderForAddress(serverHost, serverPort, channelCredentials);
+        }
         if (serverHostOverride != null) {
           channelBuilder.overrideAuthority(serverHostOverride);
         }
+        if (serviceConfig != null) {
+          channelBuilder.disableServiceConfigLookUp();
+          channelBuilder.defaultServiceConfig(serviceConfig);
+        }
+        if (addMdInterceptor != null) {
+          channelBuilder.intercept(addMdInterceptor);
+        }
         return channelBuilder;
       }
       if (!useOkHttp) {
-        NettyChannelBuilder nettyBuilder =
-            NettyChannelBuilder.forAddress(serverHost, serverPort, channelCredentials)
-                .flowControlWindow(AbstractInteropTest.TEST_FLOW_CONTROL_WINDOW);
+        NettyChannelBuilder nettyBuilder;
+        if (serverPort == 0) {
+          nettyBuilder = NettyChannelBuilder.forTarget(serverHost, channelCredentials);
+        } else {
+          nettyBuilder = NettyChannelBuilder.forAddress(serverHost, serverPort, channelCredentials);
+        }
+        nettyBuilder.flowControlWindow(AbstractInteropTest.TEST_FLOW_CONTROL_WINDOW);
         if (serverHostOverride != null) {
           nettyBuilder.overrideAuthority(serverHostOverride);
         }
-        if (fullStreamDecompression) {
-          nettyBuilder.enableFullStreamDecompression();
-        }
         // 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 nettyBuilder.intercept(createCensusStatsClientInterceptor());
       }
 
-      OkHttpChannelBuilder okBuilder =
-          OkHttpChannelBuilder.forAddress(serverHost, serverPort, channelCredentials);
+      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));
       }
-      if (fullStreamDecompression) {
-        okBuilder.enableFullStreamDecompression();
-      }
       // 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() {
       // Exact message size doesn't match when testing with Go servers:
@@ -492,12 +1049,17 @@ protected ServerBuilder<?> getHandshakerServerBuilder() {
         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 5fe7248b2bd..4742675416b 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
@@ -18,6 +18,7 @@
 
 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 io.grpc.ForwardingServerCall.SimpleForwardingServerCall;
 import io.grpc.Metadata;
@@ -25,7 +26,10 @@
 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.Payload;
@@ -36,34 +40,48 @@
 import io.grpc.testing.integration.Messages.StreamingInputCallResponse;
 import io.grpc.testing.integration.Messages.StreamingOutputCallRequest;
 import io.grpc.testing.integration.Messages.StreamingOutputCallResponse;
+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.HashSet;
+import java.util.HashMap;
 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 {
+public class TestServiceImpl implements io.grpc.BindableService, AsyncService {
   private final Random random = new Random();
 
   private final ScheduledExecutorService executor;
   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.metricRecorder = metricRecorder;
+  }
+
+  public TestServiceImpl(ScheduledExecutorService executor) {
+    this(executor, MetricRecorder.newInstance());
+  }
+
+  @Override
+  public final io.grpc.ServerServiceDefinition bindService() {
+    return TestServiceGrpc.bindService(this);
   }
 
   @Override
@@ -112,10 +130,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.
@@ -165,8 +207,25 @@ 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();
           dispatcher.onError(Status.fromCodeValue(request.getResponseStatus().getCode())
@@ -179,6 +238,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();
@@ -187,6 +250,10 @@ public void onCompleted() {
 
       @Override
       public void onError(Throwable cause) {
+        if (oobTestLocked) {
+          lock.release();
+          oobTestLocked = false;
+        }
         dispatcher.onError(cause);
       }
     };
@@ -351,12 +418,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;
         }
       }
     }
@@ -443,27 +509,30 @@ public static List<ServerInterceptor> interceptors() {
   }
 
   /**
-   * Echo the request headers from a client into response headers and trailers. Useful for
+   * Echo a request header from a client into response headers and trailers. Useful for
    * testing end-to-end metadata propagation.
    */
-  private static ServerInterceptor echoRequestHeadersInterceptor(final Metadata.Key<?>... keys) {
-    final Set<Metadata.Key<?>> keySet = new HashSet<>(Arrays.asList(keys));
+  private static <T> ServerInterceptor echoRequestHeadersInterceptor(final Metadata.Key<T> key) {
     return new ServerInterceptor() {
       @Override
       public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(
           ServerCall<ReqT, RespT> call,
-          final Metadata requestHeaders,
+          Metadata requestHeaders,
           ServerCallHandler<ReqT, RespT> next) {
+        if (!requestHeaders.containsKey(key)) {
+          return next.startCall(call, requestHeaders);
+        }
+        T value = requestHeaders.get(key);
         return next.startCall(new SimpleForwardingServerCall<ReqT, RespT>(call) {
               @Override
               public void sendHeaders(Metadata responseHeaders) {
-                responseHeaders.merge(requestHeaders, keySet);
+                responseHeaders.put(key, value);
                 super.sendHeaders(responseHeaders);
               }
 
               @Override
               public void close(Status status, Metadata trailers) {
-                trailers.merge(requestHeaders, keySet);
+                trailers.put(key, value);
                 super.close(status, trailers);
               }
             }, requestHeaders);
@@ -472,52 +541,48 @@ public void close(Status status, Metadata trailers) {
   }
 
   /**
-   * Echoes request headers with the specified key(s) from a client into response headers only.
+   * Echoes request headers with the specified key from a client into response headers only.
    */
-  private static ServerInterceptor echoRequestMetadataInHeaders(final Metadata.Key<?>... keys) {
-    final Set<Metadata.Key<?>> keySet = new HashSet<>(Arrays.asList(keys));
+  private static <T> ServerInterceptor echoRequestMetadataInHeaders(final Metadata.Key<T> key) {
     return new ServerInterceptor() {
       @Override
       public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(
           ServerCall<ReqT, RespT> call,
           final Metadata requestHeaders,
           ServerCallHandler<ReqT, RespT> next) {
+        if (!requestHeaders.containsKey(key)) {
+          return next.startCall(call, requestHeaders);
+        }
+        T value = requestHeaders.get(key);
         return next.startCall(new SimpleForwardingServerCall<ReqT, RespT>(call) {
           @Override
           public void sendHeaders(Metadata responseHeaders) {
-            responseHeaders.merge(requestHeaders, keySet);
+            responseHeaders.put(key, value);
             super.sendHeaders(responseHeaders);
           }
-
-          @Override
-          public void close(Status status, Metadata trailers) {
-            super.close(status, trailers);
-          }
         }, requestHeaders);
       }
     };
   }
 
   /**
-   * Echoes request headers with the specified key(s) from a client into response trailers only.
+   * Echoes request headers with the specified key from a client into response trailers only.
    */
-  private static ServerInterceptor echoRequestMetadataInTrailers(final Metadata.Key<?>... keys) {
-    final Set<Metadata.Key<?>> keySet = new HashSet<>(Arrays.asList(keys));
+  private static <T> ServerInterceptor echoRequestMetadataInTrailers(final Metadata.Key<T> key) {
     return new ServerInterceptor() {
       @Override
       public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(
           ServerCall<ReqT, RespT> call,
           final Metadata requestHeaders,
           ServerCallHandler<ReqT, RespT> next) {
+        if (!requestHeaders.containsKey(key)) {
+          return next.startCall(call, requestHeaders);
+        }
+        T value = requestHeaders.get(key);
         return next.startCall(new SimpleForwardingServerCall<ReqT, RespT>(call) {
-          @Override
-          public void sendHeaders(Metadata responseHeaders) {
-            super.sendHeaders(responseHeaders);
-          }
-
           @Override
           public void close(Status status, Metadata trailers) {
-            trailers.merge(requestHeaders, keySet);
+            trailers.put(key, value);
             super.close(status, trailers);
           }
         }, requestHeaders);
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 19946ec4a7d..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
@@ -18,14 +18,24 @@
 
 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.TlsServerCredentials;
 import io.grpc.alts.AltsServerCredentials;
-import io.grpc.internal.testing.TestUtils;
+import io.grpc.netty.NettyServerBuilder;
+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;
@@ -34,8 +44,6 @@
 public class TestServiceServer {
   /** The main application allowing this server to be launched from the command line. */
   public static void main(String[] args) throws Exception {
-    // Let Netty use Conscrypt if it is available.
-    TestUtils.installConscryptIfAvailable();
     final TestServiceServer server = new TestServiceServer();
     server.parseArgs(args);
     if (server.useTls) {
@@ -71,6 +79,7 @@ public void run() {
   private ScheduledExecutorService executor;
   private Server server;
   private int localHandshakerPort = -1;
+  private Util.AddressType addressType = Util.AddressType.IPV4_IPV6;
 
   @VisibleForTesting
   void parseArgs(String[] args) {
@@ -101,6 +110,8 @@ void parseArgs(String[] args) {
         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");
@@ -128,11 +139,14 @@ void parseArgs(String[] args) {
               + "\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();
@@ -147,15 +161,53 @@ void start() throws Exception {
       }
     } else if (useTls) {
       serverCreds = TlsServerCredentials.create(
-          TestUtils.loadCert("server1.pem"), TestUtils.loadCert("server1.key"));
+          TlsTesting.loadCert("server1.pem"), TlsTesting.loadCert("server1.key"));
     } else {
       serverCreds = InsecureServerCredentials.create();
     }
-    server = Grpc.newServerBuilderForPort(port, serverCreds)
+    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), TestServiceImpl.interceptors()))
+                new TestServiceImpl(executor, metricRecorder), TestServiceImpl.interceptors()))
+        .addService(orcaOobService)
+        .intercept(OrcaMetricReportingServerInterceptor.create(metricRecorder))
         .build()
         .start();
   }
@@ -180,4 +232,5 @@ private void blockUntilShutdown() throws InterruptedException {
       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 d75661132a9..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
@@ -16,9 +16,17 @@
 
 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.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;
 
@@ -27,10 +35,10 @@
  */
 public class Util {
 
-  public static final Metadata.Key<Messages.SimpleContext> METADATA_KEY =
+  public static final Metadata.Key<StringValue> METADATA_KEY =
       Metadata.Key.of(
-          "grpc.testing.SimpleContext" + Metadata.BINARY_HEADER_SUFFIX,
-          ProtoLiteUtils.metadataMarshaller(Messages.SimpleContext.getDefaultInstance()));
+          "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
@@ -65,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
index 10d40cc7e60..89519041a79 100644
--- a/interop-testing/src/main/java/io/grpc/testing/integration/XdsTestClient.java
+++ b/interop-testing/src/main/java/io/grpc/testing/integration/XdsTestClient.java
@@ -19,6 +19,7 @@
 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;
@@ -26,6 +27,8 @@
 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;
@@ -34,14 +37,16 @@
 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.netty.NettyServerBuilder;
+import io.grpc.gcp.csm.observability.CsmObservability;
 import io.grpc.protobuf.services.ProtoReflectionService;
-import io.grpc.services.ChannelzService;
+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;
@@ -51,9 +56,11 @@
 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;
@@ -71,6 +78,7 @@
 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 {
@@ -80,7 +88,6 @@ public final class XdsTestClient {
   private final Object lock = new Object();
   private final List<ManagedChannel> channels = new ArrayList<>();
   private final StatsAccumulator statsAccumulator = new StatsAccumulator();
-  private static final int CHANNELZ_MAX_PAGE_SIZE = 100;
 
   private int numChannels = 1;
   private boolean printResponse = false;
@@ -89,10 +96,14 @@ public final class XdsTestClient {
   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.
@@ -152,6 +163,12 @@ private void parseArgs(String[] args) {
         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)) {
@@ -195,6 +212,10 @@ private void parseArgs(String[] args) {
               + 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);
@@ -241,13 +262,29 @@ private static RpcType parseRpc(String 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 =
-        NettyServerBuilder.forPort(statsPort)
+        Grpc.newServerBuilderForPort(statsPort, InsecureServerCredentials.create())
             .addService(new XdsStatsImpl())
             .addService(new ConfigureUpdateServiceImpl())
-            .addService(ProtoReflectionService.newInstance())
-            .addService(ChannelzService.newInstance(CHANNELZ_MAX_PAGE_SIZE))
+            .addService(oldReflectionService)
+            .addService(ProtoReflectionServiceV1.newInstance())
+            .addServices(AdminInterface.getStandardServices())
             .build();
     try {
       statsServer.start();
@@ -258,10 +295,14 @@ private void run() {
                     secureMode
                         ? XdsChannelCredentials.create(InsecureChannelCredentials.create())
                         : InsecureChannelCredentials.create())
+                .enableRetry()
                 .build());
       }
       exec = MoreExecutors.listeningDecorator(Executors.newSingleThreadScheduledExecutor());
-      runQps();
+      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);
@@ -281,10 +322,13 @@ private void stop() throws InterruptedException {
     if (exec != null) {
       exec.shutdownNow();
     }
+    if (csmObservability != null) {
+      csmObservability.close();
+    }
   }
 
 
-  private void runQps() throws InterruptedException, ExecutionException {
+  private void runQps(Payload requestPayload) throws InterruptedException, ExecutionException {
     final SettableFuture<Void> failure = SettableFuture.create();
     final class PeriodicRpc implements Runnable {
 
@@ -357,7 +401,11 @@ public void onError(Throwable t) {
                 public void onNext(EmptyProtos.Empty response) {}
               });
         } else if (config.rpcType == RpcType.UNARY_CALL) {
-          SimpleRequest request = SimpleRequest.newBuilder().setFillServerId(true).build();
+          SimpleRequest request = SimpleRequest.newBuilder()
+              .setFillServerId(true)
+              .setPayload(requestPayload)
+              .setResponseSize(responseSize)
+              .build();
           stub.unaryCall(
               request,
               new StreamObserver<SimpleResponse>() {
@@ -369,7 +417,7 @@ public void onCompleted() {
                 @Override
                 public void onError(Throwable t) {
                   if (printResponse) {
-                    logger.log(Level.WARNING, "Rpc failed: {0}", t);
+                    logger.log(Level.WARNING, "Rpc failed", t);
                   }
                   handleRpcError(requestId, config.rpcType, Status.fromThrowable(t),
                       savedWatchers);
@@ -449,7 +497,10 @@ public void configure(ClientConfigureRequest request,
         StreamObserver<ClientConfigureResponse> responseObserver) {
       EnumMap<RpcType, Metadata> newMetadata = new EnumMap<>(RpcType.class);
       for (ClientConfigureRequest.Metadata metadata : request.getMetadataList()) {
-        Metadata md = new Metadata();
+        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);
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
index 47a4376d983..88f1bf468b6 100644
--- a/interop-testing/src/main/java/io/grpc/testing/integration/XdsTestServer.java
+++ b/interop-testing/src/main/java/io/grpc/testing/integration/XdsTestServer.java
@@ -16,33 +16,48 @@
 
 package io.grpc.testing.integration;
 
-import io.grpc.Context;
-import io.grpc.Contexts;
+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.StatusRuntimeException;
+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.services.ChannelzService;
-import io.grpc.services.HealthStatusManager;
+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 {
@@ -50,22 +65,33 @@ public final class XdsTestServer {
       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 Context.Key<String> CALL_BEHAVIOR_KEY =
-      Context.key("rpc-behavior");
+  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 int CHANNELZ_MAX_PAGE_SIZE = 100;
+  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.
@@ -92,7 +118,7 @@ public void run() {
     server.blockUntilShutdown();
   }
 
-  private void parseArgs(String[] args) {
+  void parseArgs(String[] args) {
     boolean usage = false;
     for (String arg : args) {
       if (!arg.startsWith("--")) {
@@ -118,8 +144,12 @@ private void parseArgs(String[] args) {
         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;
@@ -151,14 +181,33 @@ private void parseArgs(String[] args) {
               + " 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);
+              + s.serverId
+              + "\n  --address_type=STRING  type of IP address to bind to (IPV4|IPV6|IPV4_IPV6)."
+              + "\n                      Default: "
+              + s.addressType);
       System.exit(1);
     }
   }
 
-  private void start() throws Exception {
+  @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) {
@@ -166,41 +215,79 @@ private void start() throws Exception {
       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()
-              .start();
-      maintenanceServer =
-          NettyServerBuilder.forPort(maintenancePort)
-              .addService(new XdsUpdateHealthServiceImpl(health))
-              .addService(health.getHealthService())
-              .addService(ProtoReflectionService.newInstance())
-              .addService(ChannelzService.newInstance(CHANNELZ_MAX_PAGE_SIZE))
-              .build()
-              .start();
+              .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 =
-          NettyServerBuilder.forPort(port)
+          serverBuilder
               .addService(
                   ServerInterceptors.intercept(
                       new TestServiceImpl(serverId, host), new TestInfoInterceptor(host)))
               .addService(new XdsUpdateHealthServiceImpl(health))
               .addService(health.getHealthService())
-              .addService(ProtoReflectionService.newInstance())
-              .addService(ChannelzService.newInstance(CHANNELZ_MAX_PAGE_SIZE))
-              .build()
-              .start();
+              .addService(oldReflectionService)
+              .addService(ProtoReflectionServiceV1.newInstance())
+              .addServices(AdminInterface.getStandardServices())
+              .build();
+      server.start();
       maintenanceServer = null;
     }
     health.setStatus("", ServingStatus.SERVING);
   }
 
-  private void stop() throws Exception {
+  void stop() throws Exception {
     server.shutdownNow();
     if (maintenanceServer != null) {
       maintenanceServer.shutdownNow();
@@ -211,6 +298,9 @@ private void stop() throws Exception {
     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 {
@@ -235,18 +325,19 @@ private TestServiceImpl(String serverId, String host) {
     public void emptyCall(
         EmptyProtos.Empty req, StreamObserver<EmptyProtos.Empty> responseObserver) {
       responseObserver.onNext(EmptyProtos.Empty.getDefaultInstance());
-      if (!CALL_BEHAVIOR_KEEP_OPEN_VALUE.equals(CALL_BEHAVIOR_KEY.get())) {
-        responseObserver.onCompleted();
-      }
+      responseObserver.onCompleted();
     }
 
     @Override
     public void unaryCall(SimpleRequest req, StreamObserver<SimpleResponse> responseObserver) {
-      responseObserver.onNext(
-          SimpleResponse.newBuilder().setServerId(serverId).setHostname(host).build());
-      if (!CALL_BEHAVIOR_KEEP_OPEN_VALUE.equals(CALL_BEHAVIOR_KEY.get())) {
-        responseObserver.onCompleted();
-      }
+      responseObserver.onNext(SimpleResponse.newBuilder()
+          .setServerId(serverId)
+          .setHostname(host)
+          .setPayload(Payload.newBuilder()
+            .setBody(ByteString.copyFrom(new byte[req.getResponseSize()]))
+            .build())
+          .build());
+      responseObserver.onCompleted();
     }
   }
 
@@ -287,22 +378,7 @@ public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(
         ServerCall<ReqT, RespT> call,
         final Metadata requestHeaders,
         ServerCallHandler<ReqT, RespT> next) {
-      String callBehavior = requestHeaders.get(CALL_BEHAVIOR_MD_KEY);
-      Context newContext = Context.current().withValue(CALL_BEHAVIOR_KEY, callBehavior);
-      if (callBehavior != null && callBehavior.startsWith(CALL_BEHAVIOR_SLEEP_VALUE)) {
-        try {
-          int timeout = Integer.parseInt(
-              callBehavior.substring(CALL_BEHAVIOR_SLEEP_VALUE.length()));
-          Thread.sleep(timeout * 1000);
-        } catch (NumberFormatException e) {
-          throw new StatusRuntimeException(
-              Status.INVALID_ARGUMENT.withDescription(
-                  String.format("Invalid format for rpc-behavior header (%s)", callBehavior)));
-        } catch (InterruptedException e) {
-          throw new StatusRuntimeException(
-              Status.ABORTED.withDescription("execution of server interrupted"));
-        }
-      }
+      List<String> callBehaviors = getCallBehaviors(requestHeaders);
       ServerCall<ReqT, RespT> newCall = new SimpleForwardingServerCall<ReqT, RespT>(call) {
         @Override
         public void sendHeaders(Metadata responseHeaders) {
@@ -310,7 +386,114 @@ public void sendHeaders(Metadata responseHeaders) {
           super.sendHeaders(responseHeaders);
         }
       };
-      return Contexts.interceptCall(newContext, newCall, requestHeaders, next);
+      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
index bd626abe522..43779012dc4 100644
--- a/interop-testing/src/main/proto/grpc/testing/empty.proto
+++ b/interop-testing/src/main/proto/grpc/testing/empty.proto
@@ -1,4 +1,5 @@
-// Copyright 2015 The gRPC Authors
+
+// 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.
@@ -11,7 +12,8 @@
 // WITHOUT 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";
+
+syntax = "proto3";
 
 package grpc.testing;
 
diff --git a/interop-testing/src/main/proto/grpc/testing/messages.proto b/interop-testing/src/main/proto/grpc/testing/messages.proto
index 9ac53cd89e1..fbcb6b4ce9b 100644
--- a/interop-testing/src/main/proto/grpc/testing/messages.proto
+++ b/interop-testing/src/main/proto/grpc/testing/messages.proto
@@ -1,4 +1,5 @@
-// Copyright 2015 The gRPC Authors
+
+// 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.
@@ -20,16 +21,24 @@ package grpc.testing;
 
 option java_package = "io.grpc.testing.integration";
 
-// TODO(jihuncho): Use well-known types once all languages are synced.
+// 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 {
-  reserved 1;
-
+  // The type of data in body.
+  PayloadType type = 1;
   // Primary contents of payload.
   bytes body = 2;
 }
@@ -58,7 +67,9 @@ enum GrpclbRouteType {
 
 // Unary request.
 message SimpleRequest {
-  reserved 1;
+  // 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;
@@ -89,6 +100,9 @@ message SimpleRequest {
 
   // 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.
@@ -106,14 +120,11 @@ message SimpleResponse {
   string server_id = 4;
   // gRPCLB Path.
   GrpclbRouteType grpclb_route_type = 5;
+
   // Server hostname.
   string hostname = 6;
 }
 
-message SimpleContext {
-  string value = 1;
-}
-
 // Client-streaming request.
 message StreamingInputCallRequest {
   // Optional input payload sent along with the request.
@@ -152,7 +163,11 @@ message ResponseParameters {
 
 // Server-streaming request.
 message StreamingOutputCallRequest {
-  reserved 1;
+  // 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;
@@ -162,6 +177,9 @@ message StreamingOutputCallRequest {
 
   // 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.
@@ -258,3 +276,13 @@ message ClientConfigureRequest {
 
 // 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/test.proto b/interop-testing/src/main/proto/grpc/testing/test.proto
index f8b0927cc98..efe83b88261 100644
--- a/interop-testing/src/main/proto/grpc/testing/test.proto
+++ b/interop-testing/src/main/proto/grpc/testing/test.proto
@@ -1,4 +1,5 @@
-// Copyright 2015 The gRPC Authors
+
+// 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.
@@ -11,8 +12,10 @@
 // WITHOUT 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";
@@ -73,7 +76,7 @@ service UnimplementedService {
 
 // A service used to control reconnect server.
 service ReconnectService {
-  rpc Start(grpc.testing.Empty) returns (grpc.testing.Empty);
+  rpc Start(grpc.testing.ReconnectParams) returns (grpc.testing.Empty);
   rpc Stop(grpc.testing.Empty) returns (grpc.testing.ReconnectInfo);
 }
 
@@ -81,11 +84,11 @@ service ReconnectService {
 service LoadBalancerStatsService {
   // Gets the backend distribution for RPCs sent by a test client.
   rpc GetClientStats(LoadBalancerStatsRequest)
-    returns (LoadBalancerStatsResponse) {}
+      returns (LoadBalancerStatsResponse) {}
 
   // Gets the accumulated stats for RPCs sent by a test client.
   rpc GetClientAccumulatedStats(LoadBalancerAccumulatedStatsRequest)
-    returns (LoadBalancerAccumulatedStatsResponse) {}
+      returns (LoadBalancerAccumulatedStatsResponse) {}
 }
 
 // A service to remotely control health status of an xDS test server.
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
index 6d082d40421..36ca3d3fd0a 100644
--- a/interop-testing/src/test/java/io/grpc/ChannelAndServerBuilderTest.java
+++ b/interop-testing/src/test/java/io/grpc/ChannelAndServerBuilderTest.java
@@ -19,6 +19,7 @@
 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;
@@ -46,17 +47,28 @@ public class ChannelAndServerBuilderTest {
   public Class<?> builderClass;
 
   /**
-   * Javadoc.
+   * 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();
-    Collection<ClassInfo> classInfos =
+    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();
@@ -64,10 +76,11 @@ public static Collection<Object[]> params() throws Exception {
         continue;
       }
       Class<?> clazz = Class.forName(className, false /*initialize*/, loader);
-      if (ServerBuilder.class.isAssignableFrom(clazz) && clazz != ServerBuilder.class) {
-        classes.add(new Object[]{clazz});
-      } else if (ManagedChannelBuilder.class.isAssignableFrom(clazz)
-          && clazz != ManagedChannelBuilder.class) {
+      if (ignoreClasses.contains(clazz)) {
+        continue;
+      }
+      if (ServerBuilder.class.isAssignableFrom(clazz)
+          || ManagedChannelBuilder.class.isAssignableFrom(clazz)) {
         classes.add(new Object[]{clazz});
       }
     }
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 ab576d0c078..82e6f3e83a5 100644
--- a/interop-testing/src/test/java/io/grpc/stub/StubConfigTest.java
+++ b/interop-testing/src/test/java/io/grpc/stub/StubConfigTest.java
@@ -30,23 +30,26 @@
 import io.grpc.ClientCall;
 import io.grpc.Deadline;
 import io.grpc.MethodDescriptor;
-import io.grpc.internal.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.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;
@@ -58,7 +61,6 @@ public class StubConfigTest {
    * Sets up mocks.
    */
   @Before public void setUp() {
-    MockitoAnnotations.initMocks(this);
     ClientCall<SimpleRequest, SimpleResponse> call =
         new NoopClientCall<>();
     when(channel.newCall(
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 81ac60571a2..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
@@ -52,17 +52,20 @@
 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;
@@ -77,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();
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 208eb40c438..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
@@ -24,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;
@@ -53,8 +55,6 @@
 import io.grpc.testing.integration.TestServiceGrpc.TestServiceBlockingStub;
 import io.grpc.testing.integration.TransportCompressionTest.Fzip;
 import java.nio.charset.Charset;
-import java.util.ArrayList;
-import java.util.Collection;
 import java.util.List;
 import java.util.concurrent.Executors;
 import java.util.concurrent.ScheduledExecutorService;
@@ -146,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<>(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
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 b566a8c888f..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
@@ -16,8 +16,10 @@
 
 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;
@@ -27,12 +29,13 @@
 import io.grpc.TlsServerCredentials;
 import io.grpc.internal.testing.TestUtils;
 import io.grpc.stub.StreamObserver;
+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 java.io.File;
 import java.io.IOException;
-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;
@@ -40,9 +43,7 @@
 import java.util.concurrent.TimeUnit;
 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;
 
@@ -58,28 +59,29 @@
 @RunWith(JUnit4.class)
 public class ConcurrencyTest {
 
-  @Rule public final Timeout globalTimeout = Timeout.seconds(60);
-  
   /**
-   * 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
@@ -87,19 +89,19 @@ 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
@@ -117,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;
@@ -168,27 +173,24 @@ public void tearDown() {
   @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 IOException {
-    File serverCertChainFile = TestUtils.loadCert("server1.pem");
-    File serverPrivateKeyFile = TestUtils.loadCert("server1.key");
-    File serverTrustedCaCerts = TestUtils.loadCert("ca.pem");
-
     ServerCredentials serverCreds = TlsServerCredentials.newBuilder()
-        .keyManager(serverCertChainFile, serverPrivateKeyFile)
-        .trustManager(serverTrustedCaCerts)
+        .keyManager(TlsTesting.loadCert("server1.pem"), TlsTesting.loadCert("server1.key"))
+        .trustManager(TlsTesting.loadCert("ca.pem"))
         .clientAuth(TlsServerCredentials.ClientAuth.REQUIRE)
         .build();
 
@@ -199,13 +201,9 @@ private Server newServer() throws IOException {
   }
 
   private ManagedChannel newClientChannel() throws IOException {
-    File clientCertChainFile = TestUtils.loadCert("client.pem");
-    File clientPrivateKeyFile = TestUtils.loadCert("client.key");
-    File clientTrustedCaCerts = TestUtils.loadCert("ca.pem");
-
     ChannelCredentials channelCreds = TlsChannelCredentials.newBuilder()
-        .keyManager(clientCertChainFile, clientPrivateKeyFile)
-        .trustManager(clientTrustedCaCerts)
+        .keyManager(TlsTesting.loadCert("client.pem"), TlsTesting.loadCert("client.key"))
+        .trustManager(TlsTesting.loadCert("ca.pem"))
         .build();
 
     return Grpc.newChannelBuilder("localhost:" + server.getPort(), channelCreds)
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 778e8bdf97c..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
@@ -57,7 +57,7 @@ protected NettyChannelBuilder createChannelBuilder() {
     NettyChannelBuilder builder = NettyChannelBuilder
         .forAddress(new LocalAddress("in-process-1"))
         .negotiationType(NegotiationType.PLAINTEXT)
-        .channelType(LocalChannel.class)
+        .channelType(LocalChannel.class, LocalAddress.class)
         .eventLoopGroup(eventLoopGroup)
         .flowControlWindow(AbstractInteropTest.TEST_FLOW_CONTROL_WINDOW)
         .maxInboundMessageSize(AbstractInteropTest.MAX_MESSAGE_SIZE);
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 af4d6edabda..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
@@ -16,9 +16,6 @@
 
 package io.grpc.testing.integration;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotEquals;
-
 import io.grpc.ChannelCredentials;
 import io.grpc.ServerBuilder;
 import io.grpc.ServerCredentials;
@@ -29,8 +26,8 @@
 import io.grpc.netty.InternalNettyServerBuilder;
 import io.grpc.netty.NettyChannelBuilder;
 import io.grpc.netty.NettyServerBuilder;
+import io.grpc.testing.TlsTesting;
 import java.io.IOException;
-import java.net.InetAddress;
 import java.net.InetSocketAddress;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -47,8 +44,8 @@ protected ServerBuilder<?> getServerBuilder() {
     // Starts the server with HTTPS.
     try {
       ServerCredentials serverCreds = TlsServerCredentials.newBuilder()
-          .keyManager(TestUtils.loadCert("server1.pem"), TestUtils.loadCert("server1.key"))
-          .trustManager(TestUtils.loadCert("ca.pem"))
+          .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)
@@ -66,8 +63,8 @@ protected ServerBuilder<?> getServerBuilder() {
   protected NettyChannelBuilder createChannelBuilder() {
     try {
       ChannelCredentials channelCreds = TlsChannelCredentials.newBuilder()
-          .keyManager(TestUtils.loadCert("client.pem"), TestUtils.loadCert("client.key"))
-          .trustManager(TestUtils.loadCert("ca.pem"))
+          .keyManager(TlsTesting.loadCert("client.pem"), TlsTesting.loadCert("client.key"))
+          .trustManager(TlsTesting.loadCert("ca.pem"))
           .build();
       NettyChannelBuilder builder = NettyChannelBuilder
           .forAddress("localhost", ((InetSocketAddress) getListenAddress()).getPort(), channelCreds)
@@ -82,21 +79,6 @@ protected NettyChannelBuilder createChannelBuilder() {
     }
   }
 
-  @Test
-  public void remoteAddr() {
-    InetSocketAddress isa = (InetSocketAddress) obtainRemoteClientAddr();
-    assertEquals(InetAddress.getLoopbackAddress(), isa.getAddress());
-    // 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();
-    assertEquals(InetAddress.getLoopbackAddress(), isa.getAddress());
-    assertEquals(((InetSocketAddress) getListenAddress()).getPort(), isa.getPort());
-  }
-
   @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 7cce836fa97..00000000000
--- a/interop-testing/src/test/java/io/grpc/testing/integration/Http2OkHttpTest.java
+++ /dev/null
@@ -1,218 +0,0 @@
-/*
- * 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.testing.integration;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
-
-import com.google.common.base.Throwables;
-import com.squareup.okhttp.ConnectionSpec;
-import io.grpc.ChannelCredentials;
-import io.grpc.ManagedChannel;
-import io.grpc.ServerBuilder;
-import io.grpc.ServerCredentials;
-import io.grpc.TlsChannelCredentials;
-import io.grpc.TlsServerCredentials;
-import io.grpc.internal.GrpcUtil;
-import io.grpc.internal.testing.StreamRecorder;
-import io.grpc.internal.testing.TestUtils;
-import io.grpc.netty.InternalNettyServerBuilder;
-import io.grpc.netty.NettyServerBuilder;
-import io.grpc.okhttp.InternalOkHttpChannelBuilder;
-import io.grpc.okhttp.OkHttpChannelBuilder;
-import io.grpc.okhttp.internal.Platform;
-import io.grpc.stub.StreamObserver;
-import io.grpc.testing.integration.EmptyProtos.Empty;
-import java.io.IOException;
-import java.net.InetSocketAddress;
-import javax.net.ssl.HostnameVerifier;
-import javax.net.ssl.SSLPeerUnverifiedException;
-import javax.net.ssl.SSLSession;
-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 {
-
-  private static final String BAD_HOSTNAME = "I.am.a.bad.hostname";
-
-  @BeforeClass
-  public static void loadConscrypt() throws Exception {
-    // Load conscrypt if it is available. Either Conscrypt or Jetty ALPN needs to be available for
-    // OkHttp to negotiate.
-    TestUtils.installConscryptIfAvailable();
-  }
-
-  @Override
-  protected ServerBuilder<?> getServerBuilder() {
-    // Starts the server with HTTPS.
-    try {
-      ServerCredentials serverCreds = TlsServerCredentials.create(
-          TestUtils.loadCert("server1.pem"), TestUtils.loadCert("server1.key"));
-      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);
-    }
-  }
-
-  @Override
-  protected OkHttpChannelBuilder createChannelBuilder() {
-    int port = ((InetSocketAddress) getListenAddress()).getPort();
-    ChannelCredentials channelCreds;
-    try {
-      channelCreds = TlsChannelCredentials.newBuilder()
-          .trustManager(TestUtils.loadCert("ca.pem"))
-          .build();
-    } catch (IOException ex) {
-      throw new RuntimeException(ex);
-    }
-    OkHttpChannelBuilder builder = OkHttpChannelBuilder.forAddress("localhost", port, channelCreds)
-        .maxInboundMessageSize(AbstractInteropTest.MAX_MESSAGE_SIZE)
-        .overrideAuthority(GrpcUtil.authorityFromHostAndPort(
-            TestUtils.TEST_SERVER_HOST, port));
-    // Disable the default census stats interceptor, use testing interceptor instead.
-    InternalOkHttpChannelBuilder.setStatsEnabled(builder, false);
-    return builder.intercept(createCensusStatsClientInterceptor());
-  }
-
-  private OkHttpChannelBuilder createChannelBuilderPreCredentialsApi() {
-    int port = ((InetSocketAddress) getListenAddress()).getPort();
-    OkHttpChannelBuilder builder = OkHttpChannelBuilder.forAddress("localhost", port)
-        .maxInboundMessageSize(AbstractInteropTest.MAX_MESSAGE_SIZE)
-        .connectionSpec(new ConnectionSpec.Builder(ConnectionSpec.MODERN_TLS)
-            .build())
-        .overrideAuthority(GrpcUtil.authorityFromHostAndPort(
-            TestUtils.TEST_SERVER_HOST, port));
-    try {
-      builder.sslSocketFactory(TestUtils.newSslSocketFactoryForCa(Platform.get().getProvider(),
-          TestUtils.loadCert("ca.pem")));
-    } catch (Exception e) {
-      throw new RuntimeException(e);
-    }
-    // Disable the default census stats interceptor, use testing interceptor instead.
-    InternalOkHttpChannelBuilder.setStatsEnabled(builder, false);
-    return builder.intercept(createCensusStatsClientInterceptor());
-  }
-
-  @Test
-  public void receivedDataForFinishedStream() throws Exception {
-    Messages.ResponseParameters.Builder responseParameters =
-        Messages.ResponseParameters.newBuilder()
-        .setSize(1);
-    Messages.StreamingOutputCallRequest.Builder requestBuilder =
-        Messages.StreamingOutputCallRequest.newBuilder();
-    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
-  public void wrongHostNameFailHostnameVerification() throws Exception {
-    int port = ((InetSocketAddress) getListenAddress()).getPort();
-    ManagedChannel channel = createChannelBuilderPreCredentialsApi()
-        .overrideAuthority(GrpcUtil.authorityFromHostAndPort(
-            BAD_HOSTNAME, port))
-        .build();
-    TestServiceGrpc.TestServiceBlockingStub blockingStub =
-        TestServiceGrpc.newBlockingStub(channel);
-
-    Throwable actualThrown = null;
-    try {
-      blockingStub.emptyCall(Empty.getDefaultInstance());
-    } catch (Throwable t) {
-      actualThrown = t;
-    }
-    assertNotNull("The rpc should have been failed due to hostname verification", actualThrown);
-    Throwable cause = Throwables.getRootCause(actualThrown);
-    assertTrue(
-        "Failed by unexpected exception: " + cause, cause instanceof SSLPeerUnverifiedException);
-    channel.shutdown();
-  }
-
-  @Test
-  public void hostnameVerifierWithBadHostname() throws Exception {
-    int port = ((InetSocketAddress) getListenAddress()).getPort();
-    ManagedChannel channel = createChannelBuilderPreCredentialsApi()
-        .overrideAuthority(GrpcUtil.authorityFromHostAndPort(
-            BAD_HOSTNAME, port))
-        .hostnameVerifier(new HostnameVerifier() {
-          @Override
-          public boolean verify(String hostname, SSLSession session) {
-            return true;
-          }
-        })
-        .build();
-    TestServiceGrpc.TestServiceBlockingStub blockingStub =
-        TestServiceGrpc.newBlockingStub(channel);
-
-    blockingStub.emptyCall(Empty.getDefaultInstance());
-
-    channel.shutdown();
-  }
-
-  @Test
-  public void hostnameVerifierWithCorrectHostname() throws Exception {
-    int port = ((InetSocketAddress) getListenAddress()).getPort();
-    ManagedChannel channel = createChannelBuilderPreCredentialsApi()
-        .overrideAuthority(GrpcUtil.authorityFromHostAndPort(
-            TestUtils.TEST_SERVER_HOST, port))
-        .hostnameVerifier(new HostnameVerifier() {
-          @Override
-          public boolean verify(String hostname, SSLSession session) {
-            return false;
-          }
-        })
-        .build();
-    TestServiceGrpc.TestServiceBlockingStub blockingStub =
-        TestServiceGrpc.newBlockingStub(channel);
-
-    Throwable actualThrown = null;
-    try {
-      blockingStub.emptyCall(Empty.getDefaultInstance());
-    } catch (Throwable t) {
-      actualThrown = t;
-    }
-    assertNotNull("The rpc should have been failed due to hostname verification", actualThrown);
-    Throwable cause = Throwables.getRootCause(actualThrown);
-    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/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 bf373dd5ba3..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
@@ -249,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 4d7c8bdbca7..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
@@ -39,17 +39,13 @@
 import io.netty.channel.ChannelHandler;
 import io.netty.handler.codec.http2.Http2Stream;
 import io.netty.util.AsciiString;
-import io.netty.util.concurrent.DefaultThreadFactory;
 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.Ignore;
 import org.junit.Test;
@@ -80,16 +76,6 @@ public class NettyFlowControlTest {
   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));
-
-
-  @AfterClass
-  public static void shutDownTests() {
-    executor.shutdown();
-  }
-
   @Before
   public void initTest() {
     startServer(REGULAR_WINDOW);
@@ -161,10 +147,11 @@ private void doTest(int bandwidth, int latency) throws InterruptedException {
     // 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));
 
-    // 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);
   }
@@ -203,16 +190,14 @@ private void startServer(int serverFlowControlWindow) {
   private static class TestStreamObserver implements StreamObserver<StreamingOutputCallResponse> {
 
     final AtomicReference<GrpcHttp2ConnectionHandler> grpcHandlerRef;
-    final long startRequestNanos;
-    long endRequestNanos;
     final CountDownLatch latch = new CountDownLatch(1);
     final long expectedWindow;
     int lastWindow;
+    boolean wasCompleted;
 
     public TestStreamObserver(
         AtomicReference<GrpcHttp2ConnectionHandler> grpcHandlerRef, long window) {
       this.grpcHandlerRef = grpcHandlerRef;
-      startRequestNanos = System.nanoTime();
       expectedWindow = window;
     }
 
@@ -220,9 +205,18 @@ public TestStreamObserver(
     public void onNext(StreamingOutputCallResponse value) {
       GrpcHttp2ConnectionHandler grpcHandler = grpcHandlerRef.get();
       Http2Stream connectionStream = grpcHandler.connection().connectionStream();
-      lastWindow = grpcHandler.decoder().flowController().initialWindowSize(connectionStream);
-      if (lastWindow >= expectedWindow) {
-        onCompleted();
+      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;
+        }
       }
     }
 
@@ -237,10 +231,6 @@ 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;
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 c336ee9aea8..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
@@ -62,7 +62,6 @@ public void shutdownTest() throws IOException {
   }
 
   @Test
-  @org.junit.Ignore // flaky. latency commonly too high
   public void smallLatency() throws Exception {
     server = new Server();
     int serverPort = server.init();
@@ -93,7 +92,7 @@ public void smallLatency() throws Exception {
     }
     Collections.sort(rtts);
     long rtt = rtts.get(0);
-    assertEquals(latency, rtt, .5 * latency);
+    assertEquals(latency, (double) rtt, .5 * latency);
   }
 
   @Test
@@ -126,7 +125,7 @@ public void bigLatency() throws Exception {
     }
     Collections.sort(rtts);
     long rtt = rtts.get(0);
-    assertEquals(latency, rtt, .5 * latency);
+    assertEquals(latency, (double) rtt, .5 * latency);
   }
 
   @Test
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..4a43af67ac8
--- /dev/null
+++ b/interop-testing/src/test/java/io/grpc/testing/integration/RpcBehaviorLoadBalancerProviderTest.java
@@ -0,0 +1,137 @@
+/*
+ * 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");
+  }
+
+  @Deprecated
+  @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 c1f193b7993..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
@@ -19,6 +19,7 @@
 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;
@@ -32,8 +33,6 @@
 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;
@@ -45,13 +44,13 @@
 public class StressTestClientTest {
 
   @Rule
-  public final Timeout globalTimeout = Timeout.seconds(5);
+  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));
@@ -67,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
@@ -81,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),
@@ -101,29 +104,23 @@ public void allCommandlineSwitchesAreSupported() {
     assertEquals(10, client.channelsPerServer());
     assertEquals(5, client.stubsPerChannel());
     assertEquals(9090, client.metricsPort());
-  }
-
-  @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());
+    assertEquals("google_default_credentials", client.customCredentialsType());
+    assertEquals(60, client.metricsLogRateSecs());
   }
 
   @Test
   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();
@@ -142,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 4e511c1cfe5..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
@@ -65,7 +65,9 @@ public void testCaseNamesShouldMapToEnums() {
       "unimplemented_service",
       "cancel_after_begin",
       "cancel_after_first_response",
-      "timeout_on_sleeping_server"
+      "timeout_on_sleeping_server",
+      "orca_per_rpc",
+      "orca_oob"
     };
 
     // additional test cases
@@ -73,7 +75,9 @@ public void testCaseNamesShouldMapToEnums() {
       "client_compressed_unary_noprobe",
       "client_compressed_streaming_noprobe",
       "very_large_request",
-      "pick_first_unary"
+      "pick_first_unary",
+      "channel_soak",
+      "rpc_soak"
     };
 
     assertEquals(testCases.length + additionalTestCases.length, TestCases.values().length);
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
index 97e8501f70a..b9ed63d5a52 100644
--- a/interop-testing/src/test/java/io/grpc/testing/integration/TestServiceClientTest.java
+++ b/interop-testing/src/test/java/io/grpc/testing/integration/TestServiceClientTest.java
@@ -25,7 +25,7 @@
 public class TestServiceClientTest {
 
   @Test
-  public void emptyArgumentListShouldNotThrowException() {
+  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/TrafficControlProxy.java b/interop-testing/src/test/java/io/grpc/testing/integration/TrafficControlProxy.java
index 19f22cb03f1..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
@@ -51,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));
 
   /**
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/xds/third_party/istio/LICENSE b/istio-interop-testing/third_party/istio/LICENSE
similarity index 100%
rename from xds/third_party/istio/LICENSE
rename to istio-interop-testing/third_party/istio/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
index cd385998d27..e6afc028883 100644
--- a/java_grpc_library.bzl
+++ b/java_grpc_library.bzl
@@ -1,9 +1,12 @@
 """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 = [
-        "host_javabase",
         "java_toolchain",
+        "java_plugins",
         "plugin",
         "plugin_arg",
         "protoc",
@@ -14,11 +17,11 @@ _JavaRpcToolchainInfo = provider(
 def _java_rpc_toolchain_impl(ctx):
     return [
         _JavaRpcToolchainInfo(
-            host_javabase = ctx.attr._host_javabase,
             java_toolchain = ctx.attr._java_toolchain,
-            plugin = ctx.executable.plugin,
+            java_plugins = ctx.attr.java_plugins,
+            plugin = ctx.attr.plugin,
             plugin_arg = ctx.attr.plugin_arg,
-            protoc = ctx.executable._protoc,
+            protoc = ctx.attr._protoc,
             runtime = ctx.attr.runtime,
         ),
         platform_common.ToolchainInfo(),  # Magic for b/78647825
@@ -32,22 +35,22 @@ java_rpc_toolchain = rule(
             providers = [JavaInfo],
         ),
         "plugin": attr.label(
-            cfg = "host",
+            cfg = "exec",
             executable = True,
         ),
         "plugin_arg": attr.string(),
         "_protoc": attr.label(
-            cfg = "host",
+            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"),
         ),
-        "_host_javabase": attr.label(
-            cfg = "host",
-            default = Label("@bazel_tools//tools/jdk:current_java_runtime"),
-        ),
     },
     provides = [
         _JavaRpcToolchainInfo,
@@ -89,16 +92,18 @@ def _java_rpc_library_impl(ctx):
     srcjar = ctx.actions.declare_file("%s-proto-gensrc.jar" % ctx.label.name)
 
     args = ctx.actions.args()
-    args.add(toolchain.plugin, format = "--plugin=protoc-gen-rpc-plugin=%s")
+    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.host_configuration.host_path_separator)
+    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([toolchain.plugin] + srcs, transitive = [descriptor_set_in]),
+        inputs = depset(srcs, transitive = [descriptor_set_in, toolchain.plugin[DefaultInfo].files]),
         outputs = [srcjar],
-        executable = toolchain.protoc,
+        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])
@@ -106,10 +111,10 @@ def _java_rpc_library_impl(ctx):
     java_info = java_common.compile(
         ctx,
         java_toolchain = toolchain.java_toolchain[java_common.JavaToolchainInfo],
-        host_javabase = toolchain.host_javabase[java_common.JavaRuntimeInfo],
         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],
@@ -133,6 +138,34 @@ _java_grpc_library = rule(
             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",
@@ -159,6 +192,7 @@ _java_lite_grpc_library = rule(
             default = Label("//compiler:java_lite_grpc_library_toolchain"),
         ),
     },
+    toolchains = ["@bazel_tools//tools/jdk:toolchain_type"],
     fragments = ["java"],
     outputs = {
         "jar": "lib%{name}.jar",
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
index 668abc3ca30..8253d1f5bff 100644
--- a/netty/BUILD.bazel
+++ b/netty/BUILD.bazel
@@ -1,3 +1,6 @@
+load("@rules_java//java:defs.bzl", "java_library")
+load("@rules_jvm_external//:defs.bzl", "artifact")
+
 java_library(
     name = "netty",
     srcs = glob([
@@ -10,29 +13,31 @@ java_library(
     deps = [
         "//api",
         "//core:internal",
-        "@com_google_code_findbugs_jsr305//jar",
-        "@com_google_errorprone_error_prone_annotations//jar",
-        "@com_google_guava_guava//jar",
-        "@com_google_j2objc_j2objc_annotations//jar",
-        "@io_netty_netty_buffer//jar",
-        "@io_netty_netty_codec//jar",
-        "@io_netty_netty_codec_http//jar",
-        "@io_netty_netty_codec_http2//jar",
-        "@io_netty_netty_codec_socks//jar",
-        "@io_netty_netty_common//jar",
-        "@io_netty_netty_handler//jar",
-        "@io_netty_netty_handler_proxy//jar",
-        "@io_netty_netty_resolver//jar",
-        "@io_netty_netty_transport//jar",
-        "@io_perfmark_perfmark_api//jar",
+        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. Purposefully does not export any
-# symbols, as it 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.
+# 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"],
diff --git a/netty/build.gradle b/netty/build.gradle
index 20b35eb36d1..cb97ae10b55 100644
--- a/netty/build.gradle
+++ b/netty/build.gradle
@@ -3,64 +3,103 @@ plugins {
     id "maven-publish"
 
     id "me.champeau.gradle.japicmp"
-    id "me.champeau.gradle.jmh"
+    id "me.champeau.jmh"
     id "ru.vyarus.animalsniffer"
 }
 
 description = "gRPC: Netty"
 
-configurations {
-    alpnagent
+tasks.named("jar").configure {
+    manifest {
+        attributes('Automatic-Module-Name': 'io.grpc.netty')
+    }
 }
 
-evaluationDependsOn(project(':grpc-core').path)
-
 dependencies {
-    api project(':grpc-core'),
-            libraries.netty
-    implementation libraries.netty_proxy_handler
-    guavaDependency 'implementation'
-    perfmarkDependency 'implementation'
+    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.
-    testImplementation project(':grpc-core').sourceSets.test.output,
-            project(':grpc-api').sourceSets.test.output,
+    testImplementation testFixtures(project(':grpc-core')),
+            testFixtures(project(':grpc-api')),
             project(':grpc-testing'),
-            project(':grpc-testing-proto')
-    testRuntimeOnly libraries.netty_tcnative,
+            project(':grpc-testing-proto'),
             libraries.conscrypt,
-            libraries.netty_epoll
-    signature "org.codehaus.mojo.signature:java17:1.0@signature"
-    alpnagent libraries.jetty_alpn_agent
+            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"
+        }
+    }
 }
 
 import net.ltgt.gradle.errorprone.CheckSeverity
 
-[compileJava, compileTestJava].each() {
-    // Netty retuns a lot of futures that we mostly don't care about.
-    it.options.errorprone.check("FutureReturnValueIgnored", CheckSeverity.OFF)
+[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)
 }
 
-javadoc {
-    options.links 'http://netty.io/4.1/api/'
+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'
 }
 
-project.sourceSets {
-    main { java { srcDir "${projectDir}/third_party/netty/java" } }
-}
-
-test {
-    // Allow testing Jetty ALPN in TlsTest
-    jvmArgs "-javaagent:" + configurations.alpnagent.asPath
-}
-
-jmh {
+tasks.named("jmh").configure {
     // Workaround
     // https://github.com/melix/jmh-gradle-plugin/issues/97#issuecomment-316664026
     includeTests = true
 }
 
-checkstyleMain {
+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
index bb23cfdf489..0a93907bd2f 100644
--- a/netty/shaded/BUILD.bazel
+++ b/netty/shaded/BUILD.bazel
@@ -1,10 +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",
-        "@io_netty_netty_tcnative_boringssl_static//jar",
-        "@io_netty_netty_transport_native_epoll_linux_x86_64//jar",
+        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
index 37c5428b158..27816f9380b 100644
--- a/netty/shaded/build.gradle
+++ b/netty/shaded/build.gradle
@@ -1,36 +1,97 @@
+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.github.johnrengelman.shadow"
+    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_epoll
+    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-core')
+    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"
+        }
+    }
 }
 
-jar {
-    // Must use a different classifier to avoid conflicting with shadowJar
-    classifier = 'original'
+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')
+    }
 }
 
-shadowJar {
-    classifier = null
+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
@@ -38,38 +99,88 @@ shadowJar {
     // 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) {
-            // Ideally swap to project.shadow.component(it) when it isn't broken for project deps
-            artifact shadowJar
+            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 {
-                def dependencies = asNode().appendNode('dependencies')
-                project.configurations.shadow.allDependencies.each { dep ->
-                    def dependencyNode = dependencies.appendNode('dependency')
-                    dependencyNode.appendNode('groupId', dep.group)
-                    dependencyNode.appendNode('artifactId', dep.name)
-                    def version = (dep.name == 'grpc-core') ? '[' + dep.version + ']' : dep.version
-                    dependencyNode.appendNode('version', version)
-                    dependencyNode.appendNode('scope', 'compile')
+                asNode().dependencies.'*'.findAll() { dep ->
+                    dep.artifactId.text() == 'grpc-core'
+                }.each() { core ->
+                    core.scope*.value = "compile"
                 }
             }
         }
     }
 }
 
-task testShadow(type: Test) {
+tasks.register("testShadow", Test) {
     testClassesDirs = sourceSets.testShadow.output.classesDirs
     classpath = sourceSets.testShadow.runtimeClasspath
 }
-compileTestShadowJava.options.compilerArgs = compileTestJava.options.compilerArgs
-compileTestShadowJava.options.encoding = compileTestJava.options.encoding
+tasks.named("compileTestShadowJava").configure {
+    options.compilerArgs = compileTestJava.options.compilerArgs
+    options.encoding = compileTestJava.options.encoding
+}
 
-test.dependsOn testShadow
+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
index e4a84986976..89803998925 100644
--- a/netty/shaded/src/testShadow/java/io/grpc/netty/shaded/ShadingTest.java
+++ b/netty/shaded/src/testShadow/java/io/grpc/netty/shaded/ShadingTest.java
@@ -26,7 +26,6 @@
 import io.grpc.Server;
 import io.grpc.ServerCredentials;
 import io.grpc.TlsServerCredentials;
-import io.grpc.internal.testing.TestUtils;
 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;
@@ -34,11 +33,16 @@
 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;
@@ -69,6 +73,21 @@ 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()))
@@ -93,13 +112,13 @@ public void basic() throws Exception {
   @Test
   public void tcnative() throws Exception {
     ServerCredentials serverCreds = TlsServerCredentials.create(
-        TestUtils.loadCert("server1.pem"), TestUtils.loadCert("server1.key"));
+        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(TestUtils.loadCert("ca.pem")).build());
+            .trustManager(TlsTesting.loadCert("ca.pem")).build());
     channel = Grpc.newChannelBuilder("localhost:" + server.getPort(), creds)
         .overrideAuthority("foo.test.google.fr")
         .build();
diff --git a/netty/src/jmh/java/io/grpc/netty/InboundHeadersBenchmark.java b/netty/src/jmh/java/io/grpc/netty/InboundHeadersBenchmark.java
index aef75a1a26c..504f4ec27d7 100644
--- a/netty/src/jmh/java/io/grpc/netty/InboundHeadersBenchmark.java
+++ b/netty/src/jmh/java/io/grpc/netty/InboundHeadersBenchmark.java
@@ -147,39 +147,39 @@ private static void clientHandler(Blackhole bh, Http2Headers headers) {
     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);
-//  }
+  ///**
+  // * 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
index 92129967181..96844016c5c 100644
--- a/netty/src/jmh/java/io/grpc/netty/MethodDescriptorBenchmark.java
+++ b/netty/src/jmh/java/io/grpc/netty/MethodDescriptorBenchmark.java
@@ -38,16 +38,16 @@ 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 InputStream stream(Void value) {
+          return new ByteArrayInputStream(new byte[]{});
+        }
 
-    @Override
-    public Void parse(InputStream stream) {
-      return null;
-    }
-  };
+        @Override
+        public Void parse(InputStream stream) {
+          return null;
+        }
+      };
 
   MethodDescriptor<Void, Void> method = MethodDescriptor.<Void, Void>newBuilder()
       .setType(MethodDescriptor.MethodType.UNARY)
diff --git a/netty/src/main/java/io/grpc/netty/AbstractHttp2Headers.java b/netty/src/main/java/io/grpc/netty/AbstractHttp2Headers.java
index 7e3c7144952..00395acda53 100644
--- a/netty/src/main/java/io/grpc/netty/AbstractHttp2Headers.java
+++ b/netty/src/main/java/io/grpc/netty/AbstractHttp2Headers.java
@@ -37,7 +37,7 @@ public int size() {
 
   @Override
   public boolean isEmpty() {
-    throw new UnsupportedOperationException();
+    return size() == 0;
   }
 
   @Override
diff --git a/netty/src/main/java/io/grpc/netty/AbstractNettyHandler.java b/netty/src/main/java/io/grpc/netty/AbstractNettyHandler.java
index 4ab88f9efcb..c4ec5913cde 100644
--- a/netty/src/main/java/io/grpc/netty/AbstractNettyHandler.java
+++ b/netty/src/main/java/io/grpc/netty/AbstractNettyHandler.java
@@ -16,10 +16,13 @@
 
 package io.grpc.netty;
 
+import static com.google.common.base.Preconditions.checkNotNull;
 import static io.netty.handler.codec.http2.Http2CodecUtil.getEmbeddedHttp2Exception;
 
 import com.google.common.annotations.VisibleForTesting;
 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;
@@ -39,33 +42,43 @@ abstract class AbstractNettyHandler extends GrpcHttp2ConnectionHandler {
 
   private final int initialConnectionWindow;
   private final FlowControlPinger flowControlPing;
-
+  protected final int maxHeaderListSize;
+  protected final int softLimitHeaderListSize;
   private boolean autoTuneFlowControlOn;
   private ChannelHandlerContext ctx;
   private boolean initialWindowSent = false;
+  private final Ticker ticker;
 
   private static final long BDP_MEASUREMENT_PING = 1234;
+  protected static final int MIN_ALLOCATED_CHUNK = 16 * 1024;
 
   AbstractNettyHandler(
       ChannelPromise channelUnused,
       Http2ConnectionDecoder decoder,
       Http2ConnectionEncoder encoder,
       Http2Settings initialSettings,
+      ChannelLogger negotiationLogger,
       boolean autoFlowControl,
-      PingLimiter pingLimiter) {
-    super(channelUnused, decoder, encoder, initialSettings);
+      PingLimiter pingLimiter,
+      Ticker ticker,
+      int maxHeaderListSize,
+      int softLimitHeaderListSize) {
+    super(channelUnused, decoder, encoder, initialSettings, negotiationLogger);
 
     // 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
@@ -129,14 +142,17 @@ 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 FlowControlPinger(PingLimiter pingLimiter) {
       Preconditions.checkNotNull(pingLimiter, "pingLimiter");
@@ -155,10 +171,24 @@ public void onDataRead(int dataLength, int paddingLength) {
       if (!autoTuneFlowControlOn) {
         return;
       }
-      if (!isPinging() && pingLimiter.isPingAllowed()) {
+
+      // 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,25 +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() {
@@ -198,7 +235,7 @@ private void setPinging(boolean pingOut) {
 
     private void sendPing(ChannelHandlerContext ctx) {
       setDataSizeSincePing(0);
-      lastPingTime = System.nanoTime();
+      lastPingTime = ticker.read();
       encoder().writePing(ctx, false, BDP_MEASUREMENT_PING, ctx.newPromise());
       pingCount++;
     }
@@ -227,16 +264,18 @@ private void setDataSizeSincePing(int dataSize) {
       dataSizeSincePing = dataSize;
     }
 
+    // Only used in testing
     @VisibleForTesting
     void setDataSizeAndSincePing(int dataSize) {
       setDataSizeSincePing(dataSize);
-      lastPingTime = System.nanoTime() - TimeUnit.SECONDS.toNanos(1);
+      pingFrequencyMultiplier = 1;
+      lastPingTime = ticker.read() ;
     }
   }
 
   /** Controls whether PINGs like those for BDP are permitted to be sent at the current time. */
   public interface PingLimiter {
-    public boolean isPingAllowed();
+    boolean isPingAllowed();
   }
 
   private static final class AllowPingLimiter implements PingLimiter {
diff --git a/netty/src/main/java/io/grpc/netty/CancelServerStreamCommand.java b/netty/src/main/java/io/grpc/netty/CancelServerStreamCommand.java
index d9f5d96e06e..a3b29457670 100644
--- a/netty/src/main/java/io/grpc/netty/CancelServerStreamCommand.java
+++ b/netty/src/main/java/io/grpc/netty/CancelServerStreamCommand.java
@@ -27,10 +27,23 @@
 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() {
@@ -41,6 +54,10 @@ Status reason() {
     return reason;
   }
 
+  boolean wantsHeaders() {
+    return peerNotify == PeerNotify.BEST_EFFORT_STATUS;
+  }
+
   @Override
   public boolean equals(Object o) {
     if (this == o) {
@@ -52,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
@@ -66,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 1111904086a..01e7bc3ed12 100644
--- a/netty/src/main/java/io/grpc/netty/ClientTransportLifecycleManager.java
+++ b/netty/src/main/java/io/grpc/netty/ClientTransportLifecycleManager.java
@@ -17,7 +17,9 @@
 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. */
@@ -29,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;
@@ -48,23 +56,22 @@ public void notifyReady() {
    * 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) {
+  public void notifyGracefulShutdown(Status s, DisconnectError disconnectError) {
     if (transportShutdown) {
       return;
     }
     transportShutdown = true;
-    listener.transportShutdown(s);
+    listener.transportShutdown(s, disconnectError);
   }
 
   /** Returns {@code true} if was the first shutdown. */
   @CanIgnoreReturnValue
-  public boolean notifyShutdown(Status s) {
-    notifyGracefulShutdown(s);
+  public boolean notifyShutdown(Status s, DisconnectError disconnectError) {
+    notifyGracefulShutdown(s, disconnectError);
     if (shutdownStatus != null) {
       return false;
     }
     shutdownStatus = s;
-    shutdownThrowable = s.asException();
     return true;
   }
 
@@ -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/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 65cac8d1eaf..ee5227484fb 100644
--- a/netty/src/main/java/io/grpc/netty/GrpcHttp2ConnectionHandler.java
+++ b/netty/src/main/java/io/grpc/netty/GrpcHttp2ConnectionHandler.java
@@ -16,7 +16,10 @@
 
 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;
@@ -31,17 +34,20 @@
  */
 @Internal
 public abstract class GrpcHttp2ConnectionHandler extends Http2ConnectionHandler {
-
   @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;
   }
 
   /**
@@ -52,6 +58,7 @@ protected GrpcHttp2ConnectionHandler(
    * @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);
   }
@@ -69,6 +76,14 @@ 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
diff --git a/netty/src/main/java/io/grpc/netty/GrpcHttp2HeadersUtils.java b/netty/src/main/java/io/grpc/netty/GrpcHttp2HeadersUtils.java
index 8f46c2c13dd..96c4310ae3d 100644
--- a/netty/src/main/java/io/grpc/netty/GrpcHttp2HeadersUtils.java
+++ b/netty/src/main/java/io/grpc/netty/GrpcHttp2HeadersUtils.java
@@ -31,22 +31,27 @@
 
 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 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}.
@@ -143,6 +148,11 @@ protected CharSequence get(AsciiString name) {
       return null;
     }
 
+    @Override
+    public boolean contains(CharSequence name) {
+      return get(name) != null;
+    }
+
     @Override
     public CharSequence status() {
       return get(Http2Headers.PseudoHeaderName.STATUS.value());
@@ -160,6 +170,44 @@ public List<CharSequence> getAll(CharSequence csName) {
       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
@@ -243,6 +291,11 @@ 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) {
@@ -251,14 +304,22 @@ protected static void appendNameAndValue(StringBuilder builder, CharSequence nam
       builder.append(name).append(": ").append(value);
     }
 
-    protected final String namesAndValuesToString() {
-      StringBuilder builder = new StringBuilder();
-      boolean prependSeparator = false;
+    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];
-        appendNameAndValue(builder, name, value, prependSeparator);
+        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();
@@ -295,7 +356,12 @@ public Http2Headers add(CharSequence csName, CharSequence csValue) {
       AsciiString name = validateName(requireAsciiString(csName));
       AsciiString value = requireAsciiString(csValue);
       if (isPseudoHeader(name)) {
-        addPseudoHeader(name, value);
+        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)) {
@@ -308,17 +374,30 @@ public Http2Headers add(CharSequence csName, CharSequence csValue) {
     @Override
     public CharSequence get(CharSequence csName) {
       AsciiString name = requireAsciiString(csName);
-      checkArgument(!isPseudoHeader(name), "Use direct accessor methods for pseudo headers.");
+      if (isPseudoHeader(name)) {
+        return getPseudoHeader(name);
+      }
       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);
+    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)) {
@@ -330,6 +409,7 @@ private void addPseudoHeader(CharSequence csName, CharSequence csValue) {
       } else {
         PlatformDependent.throwException(
             connectionError(PROTOCOL_ERROR, "Illegal pseudo-header '%s' in request.", name));
+        throw new AssertionError(); // Make flow control obvious to javac
       }
     }
 
@@ -353,15 +433,16 @@ 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.");
+        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);
@@ -369,6 +450,25 @@ public List<CharSequence> getAll(CharSequence csName) {
       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.
      */
diff --git a/netty/src/main/java/io/grpc/netty/GrpcHttp2OutboundHeaders.java b/netty/src/main/java/io/grpc/netty/GrpcHttp2OutboundHeaders.java
index 0489e135813..aabcd4fbaaa 100644
--- a/netty/src/main/java/io/grpc/netty/GrpcHttp2OutboundHeaders.java
+++ b/netty/src/main/java/io/grpc/netty/GrpcHttp2OutboundHeaders.java
@@ -66,6 +66,16 @@ private GrpcHttp2OutboundHeaders(AsciiString[] preHeaders, byte[][] serializedMe
     this.preHeaders = preHeaders;
   }
 
+  @Override
+  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() {
diff --git a/netty/src/main/java/io/grpc/netty/GrpcSslContexts.java b/netty/src/main/java/io/grpc/netty/GrpcSslContexts.java
index 245a915f4ec..f1f2c8aed71 100644
--- a/netty/src/main/java/io/grpc/netty/GrpcSslContexts.java
+++ b/netty/src/main/java/io/grpc/netty/GrpcSslContexts.java
@@ -83,6 +83,8 @@ private GrpcSslContexts() {}
 
   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 an SslContextBuilder with ciphers and APN appropriate for gRPC.
@@ -153,8 +155,7 @@ public static SslContextBuilder configure(SslContextBuilder builder) {
   @CanIgnoreReturnValue
   public static SslContextBuilder configure(SslContextBuilder builder, SslProvider provider) {
     switch (provider) {
-      case JDK:
-      {
+      case JDK: {
         Provider jdkProvider = findJdkProvider();
         if (jdkProvider == null) {
           throw new IllegalArgumentException(
@@ -162,8 +163,7 @@ public static SslContextBuilder configure(SslContextBuilder builder, SslProvider
         }
         return configure(builder, jdkProvider);
       }
-      case OPENSSL:
-      {
+      case OPENSSL: {
         ApplicationProtocolConfig apc;
         if (OpenSsl.isAlpnSupported()) {
           apc = NPN_AND_ALPN;
@@ -199,7 +199,9 @@ public static SslContextBuilder configure(SslContextBuilder builder, Provider jd
         throw new IllegalArgumentException(
             jdkProvider.getName() + " selected, but Java 9+ and Jetty NPN/ALPN unavailable");
       }
-    } else if (IBM_PROVIDER_NAME.equals(jdkProvider.getName())) {
+    } 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 {
@@ -254,7 +256,9 @@ private static Provider findJdkProvider() {
             || JettyTlsUtil.isJava9AlpnAvailable()) {
           return provider;
         }
-      } else if (IBM_PROVIDER_NAME.equals(provider.getName())) {
+      } 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;
         }
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 363e0c8ef53..1848b475d59 100644
--- a/netty/src/main/java/io/grpc/netty/InternalNettyChannelBuilder.java
+++ b/netty/src/main/java/io/grpc/netty/InternalNettyChannelBuilder.java
@@ -16,11 +16,14 @@
 
 package io.grpc.netty;
 
+import com.google.common.annotations.VisibleForTesting;
 import io.grpc.Internal;
 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
@@ -88,13 +91,17 @@ public static void setStatsRecordRealTimeMetrics(NettyChannelBuilder builder, bo
     builder.setStatsRecordRealTimeMetrics(value);
   }
 
+  public static void setStatsRecordRetryMetrics(NettyChannelBuilder builder, boolean value) {
+    builder.setStatsRecordRetryMetrics(value);
+  }
+
   /**
    * 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 static void useNioTransport(NettyChannelBuilder builder) {
-    builder.channelType(NioSocketChannel.class);
+    builder.channelType(NioSocketChannel.class, InetSocketAddress.class);
     builder
         .eventLoopGroupPool(SharedResourcePool.forResource(Utils.NIO_WORKER_EVENT_LOOP_GROUP));
   }
@@ -103,5 +110,11 @@ public static ClientTransportFactory buildTransportFactory(NettyChannelBuilder b
     return builder.buildTransportFactory();
   }
 
+  @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/InternalNettyServerBuilder.java b/netty/src/main/java/io/grpc/netty/InternalNettyServerBuilder.java
index 876c55ebfc8..1a0809feebe 100644
--- a/netty/src/main/java/io/grpc/netty/InternalNettyServerBuilder.java
+++ b/netty/src/main/java/io/grpc/netty/InternalNettyServerBuilder.java
@@ -18,11 +18,8 @@
 
 import io.grpc.Attributes;
 import io.grpc.Internal;
-import io.grpc.ServerStreamTracer;
 import io.grpc.internal.SharedResourcePool;
-import io.grpc.internal.TransportTracer;
 import io.netty.channel.socket.nio.NioServerSocketChannel;
-import java.util.List;
 
 /**
  * Internal {@link NettyServerBuilder} accessor.  This is intended for usage internal to
@@ -30,16 +27,6 @@
  */
 @Internal
 public final class InternalNettyServerBuilder {
-  public static NettyServer buildTransportServers(NettyServerBuilder builder,
-      List<? extends ServerStreamTracer.Factory> streamTracerFactories) {
-    return builder.buildTransportServers(streamTracerFactories);
-  }
-
-  public static void setTransportTracerFactory(NettyServerBuilder builder,
-      TransportTracer.Factory transportTracerFactory) {
-    builder.setTransportTracerFactory(transportTracerFactory);
-  }
-
   public static void setStatsEnabled(NettyServerBuilder builder, boolean value) {
     builder.setStatsEnabled(value);
   }
diff --git a/netty/src/main/java/io/grpc/netty/InternalProtocolNegotiators.java b/netty/src/main/java/io/grpc/netty/InternalProtocolNegotiators.java
index 99e98da417d..35dc1bbc2e8 100644
--- a/netty/src/main/java/io/grpc/netty/InternalProtocolNegotiators.java
+++ b/netty/src/main/java/io/grpc/netty/InternalProtocolNegotiators.java
@@ -16,14 +16,17 @@
 
 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.channel.ChannelHandlerContext;
 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}.
@@ -32,20 +35,19 @@ public final class InternalProtocolNegotiators {
 
   private InternalProtocolNegotiators() {}
 
-  /**
-   * Returns the channel logger for the given channel context, or a Noop Logger if absent.
-   */
-  public static ChannelLogger negotiationLogger(ChannelHandlerContext ctx) {
-    return ProtocolNegotiators.negotiationLogger(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.
+   * @param executorPool a dedicated {@link Executor} pool for time-consuming TLS tasks
    */
-  public static InternalProtocolNegotiator.ProtocolNegotiator tls(SslContext sslContext) {
-    final io.grpc.netty.ProtocolNegotiator negotiator = ProtocolNegotiators.tls(sslContext);
+  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
@@ -63,10 +65,21 @@ 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
@@ -146,8 +159,9 @@ public void close() {
   /**
    * Internal version of {@link WaitUntilActiveHandler}.
    */
-  public static ChannelHandler waitUntilActiveHandler(ChannelHandler next) {
-    return new WaitUntilActiveHandler(next);
+  public static ChannelHandler waitUntilActiveHandler(ChannelHandler next,
+      ChannelLogger negotiationLogger) {
+    return new WaitUntilActiveHandler(next, negotiationLogger);
   }
 
   /**
@@ -158,19 +172,22 @@ public static ChannelHandler grpcNegotiationHandler(GrpcHttp2ConnectionHandler n
   }
 
   public static ChannelHandler clientTlsHandler(
-      ChannelHandler next, SslContext sslContext, String authority) {
-    return new ClientTlsHandler(next, sslContext, authority, null);
+      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) {
-      super(next, negotiatorName);
+    protected ProtocolNegotiationHandler(ChannelHandler next, String negotiatorName,
+        ChannelLogger negotiationLogger) {
+      super(next, negotiatorName, negotiationLogger);
     }
 
-    protected ProtocolNegotiationHandler(ChannelHandler next) {
-      super(next);
+    protected ProtocolNegotiationHandler(ChannelHandler next, ChannelLogger negotiationLogger) {
+      super(next, negotiationLogger);
     }
   }
 }
diff --git a/netty/src/main/java/io/grpc/netty/JettyTlsUtil.java b/netty/src/main/java/io/grpc/netty/JettyTlsUtil.java
index 392aaf8d3e7..2f5e3db1387 100644
--- a/netty/src/main/java/io/grpc/netty/JettyTlsUtil.java
+++ b/netty/src/main/java/io/grpc/netty/JettyTlsUtil.java
@@ -17,8 +17,6 @@
 package io.grpc.netty;
 
 import java.lang.reflect.Method;
-import java.security.AccessController;
-import java.security.PrivilegedExceptionAction;
 import javax.net.ssl.SSLContext;
 import javax.net.ssl.SSLEngine;
 
@@ -34,6 +32,7 @@ private JettyTlsUtil() {
 
   private static class Java9AlpnUnavailabilityCauseHolder {
 
+    @SuppressWarnings("StaticAssignmentOfThrowable")
     static final Throwable cause = checkAlpnAvailability();
 
     static Throwable checkAlpnAvailability() {
@@ -41,13 +40,7 @@ static Throwable checkAlpnAvailability() {
         SSLContext context = SSLContext.getInstance("TLS");
         context.init(null, null, null);
         SSLEngine engine = context.createSSLEngine();
-        Method getApplicationProtocol =
-            AccessController.doPrivileged(new PrivilegedExceptionAction<Method>() {
-              @Override
-              public Method run() throws Exception {
-                return SSLEngine.class.getMethod("getApplicationProtocol");
-              }
-            });
+        Method getApplicationProtocol = SSLEngine.class.getMethod("getApplicationProtocol");
         getApplicationProtocol.invoke(engine);
         return null;
       } catch (Throwable t) {
@@ -56,9 +49,8 @@ public Method run() throws Exception {
     }
   }
 
-  /**
-   * Indicates whether or not the Jetty ALPN jar is installed in the boot classloader.
-   */
+  /** 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);
@@ -78,9 +70,8 @@ static synchronized Throwable getJettyAlpnUnavailabilityCause() {
     return jettyAlpnUnavailabilityCause;
   }
 
-  /**
-   * Indicates whether or not the Jetty NPN jar is installed in the boot classloader.
-   */
+  /** 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);
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 bb203e2906a..e64f1065681 100644
--- a/netty/src/main/java/io/grpc/netty/NettyChannelBuilder.java
+++ b/netty/src/main/java/io/grpc/netty/NettyChannelBuilder.java
@@ -23,17 +23,21 @@
 import static io.grpc.internal.GrpcUtil.KEEPALIVE_TIME_NANOS_DISABLED;
 
 import com.google.common.annotations.VisibleForTesting;
+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.ForwardingChannelBuilder2;
 import io.grpc.HttpConnectProxiedSocketAddress;
 import io.grpc.Internal;
 import io.grpc.ManagedChannelBuilder;
-import io.grpc.internal.AbstractManagedChannelImplBuilder;
 import io.grpc.internal.AtomicBackoff;
 import io.grpc.internal.ClientTransportFactory;
 import io.grpc.internal.ConnectionClientTransport;
@@ -56,12 +60,13 @@
 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;
 
@@ -69,9 +74,8 @@
  * 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> {
+@CheckReturnValue
+public final class NettyChannelBuilder extends ForwardingChannelBuilder2<NettyChannelBuilder> {
 
   // 1MiB.
   public static final int DEFAULT_FLOW_CONTROL_WINDOW = 1024 * 1024;
@@ -99,8 +103,9 @@ public final class NettyChannelBuilder extends
   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 maxInboundMessageSize = GrpcUtil.DEFAULT_MAX_MESSAGE_SIZE;
   private int maxHeaderListSize = GrpcUtil.DEFAULT_MAX_HEADER_LIST_SIZE;
+  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;
@@ -115,6 +120,8 @@ public final class NettyChannelBuilder extends
    */
   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
@@ -122,15 +129,29 @@ public final class NettyChannelBuilder extends
    * 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 forTarget(GrpcUtil.authorityFromHostAndPort(host, port));
   }
@@ -138,7 +159,6 @@ public static NettyChannelBuilder forAddress(String host, int port) {
   /**
    * Creates a new builder with the given host and port.
    */
-  @CheckReturnValue
   public static NettyChannelBuilder forAddress(String host, int port, ChannelCredentials creds) {
     return forTarget(GrpcUtil.authorityFromHostAndPort(host, port), creds);
   }
@@ -147,7 +167,6 @@ public static NettyChannelBuilder forAddress(String host, int port, ChannelCrede
    * 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);
   }
@@ -156,7 +175,6 @@ public static NettyChannelBuilder forTarget(String target) {
    * 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, ChannelCredentials creds) {
     FromChannelCredentialsResult result = ProtocolNegotiators.from(creds);
     if (result.error != null) {
@@ -179,7 +197,6 @@ public int getDefaultPort() {
     }
   }
 
-  @CheckReturnValue
   NettyChannelBuilder(String target) {
     managedChannelImplBuilder = new ManagedChannelImplBuilder(target,
         new NettyChannelTransportFactoryBuilder(),
@@ -198,7 +215,6 @@ public int getDefaultPort() {
     this.freezeProtocolNegotiatorFactory = true;
   }
 
-  @CheckReturnValue
   NettyChannelBuilder(SocketAddress address) {
     managedChannelImplBuilder = new ManagedChannelImplBuilder(address,
         getAuthorityFromAddress(address),
@@ -207,13 +223,24 @@ public int getDefaultPort() {
     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;
@@ -237,9 +264,25 @@ private static String getAuthorityFromAddress(SocketAddress address) {
    * {@link NioSocketChannel} must use {@link io.netty.channel.nio.NioEventLoopGroup}, otherwise
    * your application won't start.
    */
+  @CanIgnoreReturnValue
   public NettyChannelBuilder channelType(Class<? extends Channel> 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));
+    return channelFactory(new ReflectiveChannelFactory<>(channelType),
+        transportSocketType);
   }
 
   /**
@@ -255,8 +298,24 @@ public NettyChannelBuilder channelType(Class<? extends Channel> channelType) {
    * {@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;
   }
 
@@ -264,6 +323,7 @@ public NettyChannelBuilder channelFactory(ChannelFactory<? extends Channel> chan
    * 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;
@@ -274,6 +334,7 @@ public <T> NettyChannelBuilder withOption(ChannelOption<T> option, T value) {
    *
    * <p>Default: <code>TLS</code>
    */
+  @CanIgnoreReturnValue
   public NettyChannelBuilder negotiationType(NegotiationType type) {
     checkState(!freezeProtocolNegotiatorFactory,
                "Cannot change security when using ChannelCredentials");
@@ -298,6 +359,7 @@ public NettyChannelBuilder negotiationType(NegotiationType type) {
    * <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) {
     if (eventLoopGroup != null) {
       return eventLoopGroupPool(new FixedObjectPool<>(eventLoopGroup));
@@ -305,6 +367,7 @@ public NettyChannelBuilder eventLoopGroup(@Nullable EventLoopGroup eventLoopGrou
     return eventLoopGroupPool(DEFAULT_EVENT_LOOP_GROUP_POOL);
   }
 
+  @CanIgnoreReturnValue
   NettyChannelBuilder eventLoopGroupPool(ObjectPool<? extends EventLoopGroup> eventLoopGroupPool) {
     this.eventLoopGroupPool = checkNotNull(eventLoopGroupPool, "eventLoopGroupPool");
     return this;
@@ -314,6 +377,7 @@ NettyChannelBuilder eventLoopGroupPool(ObjectPool<? extends EventLoopGroup> even
    * 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");
@@ -336,6 +400,7 @@ public NettyChannelBuilder sslContext(SslContext sslContext) {
    * 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;
@@ -349,6 +414,7 @@ public NettyChannelBuilder initialFlowControlWindow(int initialFlowControlWindow
    * 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;
@@ -364,7 +430,9 @@ public NettyChannelBuilder flowControlWindow(int flowControlWindow) {
    *
    * @deprecated Use {@link #maxInboundMetadataSize} instead
    */
+  @CanIgnoreReturnValue
   @Deprecated
+  @InlineMe(replacement = "this.maxInboundMetadataSize(maxHeaderListSize)")
   public NettyChannelBuilder maxHeaderListSize(int maxHeaderListSize) {
     return maxInboundMetadataSize(maxHeaderListSize);
   }
@@ -380,16 +448,52 @@ public NettyChannelBuilder maxHeaderListSize(int maxHeaderListSize) {
    * @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 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 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}.
    */
+  @CanIgnoreReturnValue
   @Override
   public NettyChannelBuilder usePlaintext() {
     negotiationType(NegotiationType.PLAINTEXT);
@@ -399,6 +503,7 @@ public NettyChannelBuilder usePlaintext() {
   /**
    * Equivalent to using {@link #negotiationType(NegotiationType)} with {@code TLS}.
    */
+  @CanIgnoreReturnValue
   @Override
   public NettyChannelBuilder useTransportSecurity() {
     negotiationType(NegotiationType.TLS);
@@ -410,6 +515,7 @@ public NettyChannelBuilder useTransportSecurity() {
    *
    * @since 1.3.0
    */
+  @CanIgnoreReturnValue
   @Override
   public NettyChannelBuilder keepAliveTime(long keepAliveTime, TimeUnit timeUnit) {
     checkArgument(keepAliveTime > 0L, "keepalive time must be positive");
@@ -427,6 +533,7 @@ public NettyChannelBuilder keepAliveTime(long keepAliveTime, TimeUnit timeUnit)
    *
    * @since 1.3.0
    */
+  @CanIgnoreReturnValue
   @Override
   public NettyChannelBuilder keepAliveTimeout(long keepAliveTimeout, TimeUnit timeUnit) {
     checkArgument(keepAliveTimeout > 0L, "keepalive timeout must be positive");
@@ -440,6 +547,7 @@ public NettyChannelBuilder keepAliveTimeout(long keepAliveTimeout, TimeUnit time
    *
    * @since 1.3.0
    */
+  @CanIgnoreReturnValue
   @Override
   public NettyChannelBuilder keepAliveWithoutCalls(boolean enable) {
     keepAliveWithoutCalls = enable;
@@ -450,6 +558,7 @@ public NettyChannelBuilder keepAliveWithoutCalls(boolean enable) {
   /**
    * 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;
@@ -486,6 +595,7 @@ public SocketAddress createSocketAddress(
    * 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");
@@ -493,16 +603,27 @@ public NettyChannelBuilder maxInboundMessageSize(int max) {
     return this;
   }
 
-  @CheckReturnValue
   ClientTransportFactory buildTransportFactory() {
     assertEventLoopAndChannelType();
 
     ProtocolNegotiator negotiator = protocolNegotiatorFactory.newNegotiator();
     return new NettyTransportFactory(
-        negotiator, channelFactory, channelOptions,
-        eventLoopGroupPool, autoFlowControl, flowControlWindow, maxInboundMessageSize,
-        maxHeaderListSize, keepAliveTimeNanos, keepAliveTimeoutNanos, keepAliveWithoutCalls,
-        transportTracerFactory, localSocketPicker, useGetForSafeMethods);
+        negotiator,
+        channelFactory,
+        channelOptions,
+        eventLoopGroupPool,
+        autoFlowControl,
+        flowControlWindow,
+        maxInboundMessageSize,
+        maxHeaderListSize,
+        softLimitHeaderListSize,
+        keepAliveTimeNanos,
+        keepAliveTimeoutNanos,
+        keepAliveWithoutCalls,
+        transportTracerFactory,
+        localSocketPicker,
+        useGetForSafeMethods,
+        transportSocketType);
   }
 
   @VisibleForTesting
@@ -516,13 +637,11 @@ void assertEventLoopAndChannelType() {
         "Both EventLoopGroup and ChannelType should be provided or neither should be");
   }
 
-  @CheckReturnValue
   int getDefaultPort() {
     return protocolNegotiatorFactory.getDefaultPort();
   }
 
   @VisibleForTesting
-  @CheckReturnValue
   static ProtocolNegotiator createProtocolNegotiatorByType(
       NegotiationType negotiationType,
       SslContext sslContext,
@@ -533,17 +652,19 @@ static ProtocolNegotiator createProtocolNegotiatorByType(
       case PLAINTEXT_UPGRADE:
         return ProtocolNegotiators.plaintextUpgrade();
       case TLS:
-        return ProtocolNegotiators.tls(sslContext, executorPool);
+        return ProtocolNegotiators.tls(sslContext, executorPool, Optional.absent(), null, null);
       default:
         throw new IllegalArgumentException("Unsupported negotiationType: " + negotiationType);
     }
   }
 
+  @CanIgnoreReturnValue
   NettyChannelBuilder disableCheckAuthority() {
     this.managedChannelImplBuilder.disableCheckAuthority();
     return this;
   }
 
+  @CanIgnoreReturnValue
   NettyChannelBuilder enableCheckAuthority() {
     this.managedChannelImplBuilder.enableCheckAuthority();
     return this;
@@ -576,12 +697,21 @@ void setStatsRecordRealTimeMetrics(boolean value) {
     this.managedChannelImplBuilder.setStatsRecordRealTimeMetrics(value);
   }
 
+  void setStatsRecordRetryMetrics(boolean value) {
+    this.managedChannelImplBuilder.setStatsRecordRetryMetrics(value);
+  }
+
+  @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;
@@ -617,7 +747,6 @@ public int getDefaultPort() {
   /**
    * Creates Netty transports. Exposed for internal use, as it should be private.
    */
-  @CheckReturnValue
   private static final class NettyTransportFactory implements ClientTransportFactory {
     private final ProtocolNegotiator protocolNegotiator;
     private final ChannelFactory<? extends Channel> channelFactory;
@@ -628,6 +757,7 @@ private static final class NettyTransportFactory implements ClientTransportFacto
     private final int flowControlWindow;
     private final int maxMessageSize;
     private final int maxHeaderListSize;
+    private final int softLimitHeaderListSize;
     private final long keepAliveTimeNanos;
     private final AtomicBackoff keepAliveBackoff;
     private final long keepAliveTimeoutNanos;
@@ -637,15 +767,25 @@ private static final class NettyTransportFactory implements ClientTransportFacto
     private final boolean useGetForSafeMethods;
 
     private boolean closed;
+    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,
-        long keepAliveTimeNanos, long keepAliveTimeoutNanos, boolean keepAliveWithoutCalls,
-        TransportTracer.Factory transportTracerFactory, LocalSocketPicker localSocketPicker,
-        boolean useGetForSafeMethods) {
+        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);
@@ -655,6 +795,7 @@ private static final class NettyTransportFactory implements ClientTransportFacto
       this.flowControlWindow = flowControlWindow;
       this.maxMessageSize = maxMessageSize;
       this.maxHeaderListSize = maxHeaderListSize;
+      this.softLimitHeaderListSize = softLimitHeaderListSize;
       this.keepAliveTimeNanos = keepAliveTimeNanos;
       this.keepAliveBackoff = new AtomicBackoff("keepalive time nanos", keepAliveTimeNanos);
       this.keepAliveTimeoutNanos = keepAliveTimeoutNanos;
@@ -663,6 +804,7 @@ private static final class NettyTransportFactory implements ClientTransportFacto
       this.localSocketPicker =
           localSocketPicker != null ? localSocketPicker : new LocalSocketPicker();
       this.useGetForSafeMethods = useGetForSafeMethods;
+      this.transportSocketType = transportSocketType;
     }
 
     @Override
@@ -676,6 +818,7 @@ public ConnectionClientTransport newClientTransport(
         serverAddress = proxiedAddr.getTargetAddress();
         localNegotiator = ProtocolNegotiators.httpProxy(
             proxiedAddr.getProxyAddress(),
+            proxiedAddr.getHeaders(),
             proxiedAddr.getUsername(),
             proxiedAddr.getPassword(),
             protocolNegotiator);
@@ -690,13 +833,31 @@ public void run() {
       };
 
       // TODO(carl-mastrangelo): Pass channelLogger in.
-      NettyClientTransport transport = new NettyClientTransport(
-          serverAddress, channelFactory, channelOptions, group,
-          localNegotiator, autoFlowControl, flowControlWindow,
-          maxMessageSize, maxHeaderListSize, keepAliveTimeNanosState.get(), keepAliveTimeoutNanos,
-          keepAliveWithoutCalls, options.getAuthority(), options.getUserAgent(),
-          tooManyPingsRunnable, transportTracerFactory.create(), options.getEagAttributes(),
-          localSocketPicker, channelLogger, useGetForSafeMethods);
+      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,
+              options.getMetricRecorder(),
+              Ticker.systemTicker());
       return transport;
     }
 
@@ -712,11 +873,24 @@ public SwapChannelCredentialsResult swapChannelCredentials(ChannelCredentials ch
       if (result.error != null) {
         return null;
       }
-      ClientTransportFactory factory = new NettyTransportFactory(
-          result.negotiator.newNegotiator(), channelFactory, channelOptions, groupPool,
-          autoFlowControl, flowControlWindow, maxMessageSize, maxHeaderListSize, keepAliveTimeNanos,
-          keepAliveTimeoutNanos, keepAliveWithoutCalls, transportTracerFactory,  localSocketPicker,
-          useGetForSafeMethods);
+      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);
     }
 
@@ -730,5 +904,11 @@ public void close() {
       protocolNegotiator.close();
       groupPool.returnObject(group);
     }
+
+    @Override
+    public Collection<Class<? extends SocketAddress>> getSupportedSocketAddressTypes() {
+      return transportSocketType == null ? null
+          : Collections.singleton(transportSocketType);
+    }
   }
 }
diff --git a/netty/src/main/java/io/grpc/netty/NettyChannelProvider.java b/netty/src/main/java/io/grpc/netty/NettyChannelProvider.java
index bf3df4fa6aa..1b22a95a44b 100644
--- a/netty/src/main/java/io/grpc/netty/NettyChannelProvider.java
+++ b/netty/src/main/java/io/grpc/netty/NettyChannelProvider.java
@@ -19,6 +19,8 @@
 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
@@ -52,4 +54,9 @@ public NewChannelBuilderResult newChannelBuilder(String target, ChannelCredentia
     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 3a31498f0f8..14a1d7535ad 100644
--- a/netty/src/main/java/io/grpc/netty/NettyClientHandler.java
+++ b/netty/src/main/java/io/grpc/netty/NettyClientHandler.java
@@ -24,18 +24,25 @@
 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.MetricRecorder;
 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.internal.SimpleDisconnectError;
 import io.grpc.internal.TransportTracer;
 import io.grpc.netty.GrpcHttp2HeadersUtils.GrpcHttp2ClientHeadersDecoder;
 import io.netty.buffer.ByteBuf;
@@ -52,6 +59,7 @@
 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;
@@ -61,24 +69,27 @@
 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.Http2FlowController;
 import io.netty.handler.codec.http2.Http2FrameAdapter;
 import io.netty.handler.codec.http2.Http2FrameLogger;
 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.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.WeightedFairQueueByteDistributor;
+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;
@@ -90,6 +101,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
@@ -111,6 +124,7 @@ class NettyClientHandler extends AbstractNettyHandler {
   private final Supplier<Stopwatch> stopwatchFactory;
   private final TransportTracer transportTracer;
   private final Attributes eagAttributes;
+  private final TcpMetrics tcpMetrics;
   private final String authority;
   private final InUseStateAggregator<Http2Stream> inUseState =
       new InUseStateAggregator<Http2Stream>() {
@@ -124,6 +138,13 @@ 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;
@@ -138,18 +159,24 @@ static NettyClientHandler newHandler(
       boolean autoFlowControl,
       int flowControlWindow,
       int maxHeaderListSize,
+      int softLimitHeaderListSize,
       Supplier<Stopwatch> stopwatchFactory,
       Runnable tooManyPingsRunnable,
       TransportTracer transportTracer,
       Attributes eagAttributes,
-      String authority) {
+      String authority,
+      ChannelLogger negotiationLogger,
+      Ticker ticker,
+      MetricRecorder metricRecorder) {
     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);
-    WeightedFairQueueByteDistributor dist = new WeightedFairQueueByteDistributor(connection);
-    dist.allocationQuantum(16 * 1024); // Make benchmarks fast again.
+    UniformStreamByteDistributor dist = new UniformStreamByteDistributor(connection);
+    dist.minAllocationChunk(MIN_ALLOCATED_CHUNK); // Increased for benchmarks performance.
     DefaultHttp2RemoteFlowController controller =
         new DefaultHttp2RemoteFlowController(connection, dist);
     connection.remote().flowController(controller);
@@ -163,11 +190,15 @@ static NettyClientHandler newHandler(
         autoFlowControl,
         flowControlWindow,
         maxHeaderListSize,
+        softLimitHeaderListSize,
         stopwatchFactory,
         tooManyPingsRunnable,
         transportTracer,
         eagAttributes,
-        authority);
+        authority,
+        negotiationLogger,
+        ticker,
+        metricRecorder);
   }
 
   @VisibleForTesting
@@ -180,16 +211,22 @@ static NettyClientHandler newHandler(
       boolean autoFlowControl,
       int flowControlWindow,
       int maxHeaderListSize,
+      int softLimitHeaderListSize,
       Supplier<Stopwatch> stopwatchFactory,
       Runnable tooManyPingsRunnable,
       TransportTracer transportTracer,
       Attributes eagAttributes,
-      String authority) {
+      String authority,
+      ChannelLogger negotiationLogger,
+      Ticker ticker,
+      MetricRecorder metricRecorder) {
     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.checkArgument(softLimitHeaderListSize > 0,
+        "softLimitHeaderListSize must be positive");
     Preconditions.checkNotNull(stopwatchFactory, "stopwatchFactory");
     Preconditions.checkNotNull(tooManyPingsRunnable, "tooManyPingsRunnable");
     Preconditions.checkNotNull(eagAttributes, "eagAttributes");
@@ -213,17 +250,7 @@ static NettyClientHandler newHandler(
     Http2ConnectionDecoder decoder = new DefaultHttp2ConnectionDecoder(connection, encoder,
         frameReader);
 
-    transportTracer.setFlowControlWindowReader(new TransportTracer.FlowControlReader() {
-      final Http2FlowController local = connection.local().flowController();
-      final Http2FlowController remote = connection.remote().flowController();
-
-      @Override
-      public TransportTracer.FlowControlWindows read() {
-        return new TransportTracer.FlowControlWindows(
-            local.windowSize(connection.connectionStream()),
-            remote.windowSize(connection.connectionStream()));
-      }
-    });
+    transportTracer.setFlowControlWindowReader(new Utils.FlowControlReader(connection));
 
     Http2Settings settings = new Http2Settings();
     settings.pushEnabled(false);
@@ -235,6 +262,7 @@ public TransportTracer.FlowControlWindows read() {
         decoder,
         encoder,
         settings,
+        negotiationLogger,
         lifecycleManager,
         keepAliveManager,
         stopwatchFactory,
@@ -243,13 +271,18 @@ public TransportTracer.FlowControlWindows read() {
         eagAttributes,
         authority,
         autoFlowControl,
-        pingCounter);
+        pingCounter,
+        ticker,
+        maxHeaderListSize,
+        softLimitHeaderListSize,
+        metricRecorder);
   }
 
   private NettyClientHandler(
       Http2ConnectionDecoder decoder,
       Http2ConnectionEncoder encoder,
       Http2Settings settings,
+      ChannelLogger negotiationLogger,
       ClientTransportLifecycleManager lifecycleManager,
       KeepAliveManager keepAliveManager,
       Supplier<Stopwatch> stopwatchFactory,
@@ -258,8 +291,22 @@ private NettyClientHandler(
       Attributes eagAttributes,
       String authority,
       boolean autoFlowControl,
-      PingLimiter pingLimiter) {
-    super(/* channelUnused= */ null, decoder, encoder, settings, autoFlowControl, pingLimiter);
+      PingLimiter pingLimiter,
+      Ticker ticker,
+      int maxHeaderListSize,
+      int softLimitHeaderListSize,
+      MetricRecorder metricRecorder) {
+    super(
+        /* channelUnused= */ null,
+        decoder,
+        encoder,
+        settings,
+        negotiationLogger,
+        autoFlowControl,
+        pingLimiter,
+        ticker,
+        maxHeaderListSize,
+        softLimitHeaderListSize);
     this.lifecycleManager = lifecycleManager;
     this.keepAliveManager = keepAliveManager;
     this.stopwatchFactory = stopwatchFactory;
@@ -268,6 +315,7 @@ private NettyClientHandler(
     this.authority = authority;
     this.attributes = Attributes.newBuilder()
         .set(GrpcAttributes.ATTR_CLIENT_EAG_ATTRS, eagAttributes).build();
+    this.tcpMetrics = new TcpMetrics(metricRecorder);
 
     // Set the frame listener on the decoder.
     decoder().frameListener(new FrameListener());
@@ -373,6 +421,28 @@ private void onHeadersRead(int streamId, Http2Headers headers, boolean endStream
     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);
     }
 
@@ -416,10 +486,12 @@ private void onRstStreamRead(int streamId, long errorCode) {
 
   @Override
   public void close(ChannelHandlerContext ctx, ChannelPromise promise) throws Exception {
+    tcpMetrics.recordTcpInfo(ctx.channel());
     logger.fine("Network channel being closed by the application.");
     if (ctx.channel().isActive()) { // Ignore notification that the socket was closed
       lifecycleManager.notifyShutdown(
-          Status.UNAVAILABLE.withDescription("Transport closed for unknown reason"));
+          Status.UNAVAILABLE.withDescription("Transport closed for unknown reason"),
+          SimpleDisconnectError.UNKNOWN);
     }
     super.close(ctx, promise);
   }
@@ -427,12 +499,19 @@ public void close(ChannelHandlerContext ctx, ChannelPromise promise) throws Exce
   /**
    * Handler for the Channel shutting down.
    */
+  @Override
+  public void channelActive(ChannelHandlerContext ctx) throws Exception {
+    tcpMetrics.channelActive(ctx.channel());
+    super.channelActive(ctx);
+  }
+
   @Override
   public void channelInactive(ChannelHandlerContext ctx) throws Exception {
     try {
       logger.fine("Network channel is closed");
+      tcpMetrics.channelInactive(ctx.channel());
       Status status = Status.UNAVAILABLE.withDescription("Network closed for unknown reason");
-      lifecycleManager.notifyShutdown(status);
+      lifecycleManager.notifyShutdown(status, SimpleDisconnectError.UNKNOWN);
       final Status streamStatus;
       if (channelInactiveReason != null) {
         streamStatus = channelInactiveReason;
@@ -440,7 +519,7 @@ public void channelInactive(ChannelHandlerContext ctx) throws Exception {
         streamStatus = lifecycleManager.getShutdownStatus();
       }
       try {
-        cancelPing(lifecycleManager.getShutdownThrowable());
+        cancelPing(lifecycleManager.getShutdownStatus());
         // Report status to the application layer for any open streams
         connection().forEachActiveStream(new Http2StreamVisitor() {
           @Override
@@ -453,7 +532,7 @@ public boolean visit(Http2Stream stream) throws Http2Exception {
           }
         });
       } finally {
-        lifecycleManager.notifyTerminated(status);
+        lifecycleManager.notifyTerminated(status, SimpleDisconnectError.UNKNOWN);
       }
     } finally {
       // Close any open streams
@@ -501,7 +580,8 @@ InternalChannelz.Security getSecurityInfo() {
   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, outbound, cause, http2Ex);
   }
@@ -534,16 +614,67 @@ protected boolean isGracefulShutdownComplete() {
    */
   private void createStream(CreateStreamCommand command, ChannelPromise promise)
           throws Exception {
-    if (lifecycleManager.getShutdownThrowable() != null) {
+    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.REFUSED, true, new Metadata());
-      promise.setFailure(lifecycleManager.getShutdownThrowable());
+          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.
     int streamId;
     try {
@@ -557,38 +688,44 @@ private void createStream(CreateStreamCommand command, ChannelPromise promise)
       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()
-        && streamId > connection().local().lastStreamKnownByPeer()) {
-      // This should only be reachable during onGoAwayReceived, as otherwise
-      // getShutdownThrowable() != null
-      command.stream().setNonExistent();
+    if (connection().goAwayReceived()) {
       Status s = abruptGoAwayStatus;
+      int maxActiveStreams = connection().local().maxActiveStreams();
+      int lastStreamId = connection().local().lastStreamKnownByPeer();
       if (s == null) {
-        // Should be impossible, but handle psuedo-gracefully
+        // 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;
       }
-      command.stream().transportReportStatus(s, RpcProgress.REFUSED, true, new Metadata());
-      promise.setFailure(s.asRuntimeException());
-      return;
     }
 
     NettyClientStream.TransportState stream = command.stream();
     Http2Headers headers = command.headers();
     stream.setId(streamId);
 
-    PerfMark.startTask("NettyClientHandler.createStream", stream.tag());
-    PerfMark.linkIn(command.getLink());
-    try {
+    try (TaskCloseable ignore = PerfMark.traceTask("NettyClientHandler.createStream")) {
+      PerfMark.linkIn(command.getLink());
+      PerfMark.attachTag(stream.tag());
       createStreamTraced(
           streamId, stream, headers, command.isGet(), command.shouldBeCountedForInUse(), promise);
-    } finally {
-      PerfMark.stopTask("NettyClientHandler.createStream", stream.tag());
     }
   }
 
@@ -622,30 +759,54 @@ public void operationComplete(ChannelFuture future) throws Exception {
 
                 // 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());
               }
-              // 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();
+              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());
-                stream.transportReportStatus(status, RpcProgress.REFUSED, true, new Metadata());
-                promise.setFailure(status.asRuntimeException());
-              } else {
-                promise.setFailure(cause);
+                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);
+    }
   }
 
   /**
@@ -654,9 +815,9 @@ public void operationComplete(ChannelFuture future) throws Exception {
   private void cancelStream(ChannelHandlerContext ctx, CancelClientStreamCommand cmd,
       ChannelPromise promise) {
     NettyClientStream.TransportState stream = cmd.stream();
-    PerfMark.startTask("NettyClientHandler.cancelStream", stream.tag());
-    PerfMark.linkIn(cmd.getLink());
-    try {
+    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());
@@ -666,8 +827,6 @@ private void cancelStream(ChannelHandlerContext ctx, CancelClientStreamCommand c
       } else {
         promise.setSuccess();
       }
-    } finally {
-      PerfMark.stopTask("NettyClientHandler.cancelStream", stream.tag());
     }
   }
 
@@ -676,25 +835,20 @@ private void cancelStream(ChannelHandlerContext ctx, CancelClientStreamCommand c
    */
   private void sendGrpcFrame(ChannelHandlerContext ctx, SendGrpcFrameCommand cmd,
       ChannelPromise promise) {
-    PerfMark.startTask("NettyClientHandler.sendGrpcFrame", cmd.stream().tag());
-    PerfMark.linkIn(cmd.getLink());
-    try {
+    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);
-    } finally {
-      PerfMark.stopTask("NettyClientHandler.sendGrpcFrame", cmd.stream().tag());
     }
   }
 
   private void sendPingFrame(ChannelHandlerContext ctx, SendPingCommand msg,
       ChannelPromise promise) {
-    PerfMark.startTask("NettyClientHandler.sendPingFrame");
-    PerfMark.linkIn(msg.getLink());
-    try {
+    try (TaskCloseable ignore = PerfMark.traceTask("NettyClientHandler.sendPingFrame")) {
+      PerfMark.linkIn(msg.getLink());
       sendPingFrameTraced(ctx, msg, promise);
-    } finally {
-      PerfMark.stopTask("NettyClientHandler.sendPingFrame");
     }
   }
 
@@ -738,19 +892,21 @@ private void sendPingFrameTraced(ChannelHandlerContext ctx, SendPingCommand msg,
       public void operationComplete(ChannelFuture future) throws Exception {
         if (future.isSuccess()) {
           transportTracer.reportKeepAliveSent();
-        } else {
-          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;
+          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;
         }
       }
     });
@@ -758,7 +914,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);
@@ -772,17 +928,15 @@ private void forcefulClose(final ChannelHandlerContext ctx, final ForcefulCloseC
       public boolean visit(Http2Stream stream) throws Http2Exception {
         NettyClientStream.TransportState clientStream = clientStream(stream);
         Tag tag = clientStream != null ? clientStream.tag() : PerfMark.createTag();
-        PerfMark.startTask("NettyClientHandler.forcefulClose", tag);
-        PerfMark.linkIn(msg.getLink());
-        try {
+        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;
-        } finally {
-          PerfMark.stopTask("NettyClientHandler.forcefulClose", tag);
         }
       }
     });
@@ -796,17 +950,20 @@ public boolean visit(Http2Stream stream) throws Http2Exception {
   private void goingAway(long errorCode, byte[] debugData) {
     Status finalStatus = statusFromH2Error(
         Status.Code.UNAVAILABLE, "GOAWAY shut down transport", errorCode, debugData);
-    lifecycleManager.notifyGracefulShutdown(finalStatus);
+    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 is if there is a protocol error, and if
+    // 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
@@ -816,7 +973,7 @@ private void goingAway(long errorCode, byte[] debugData) {
     // 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)) {
+    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(
@@ -833,11 +990,12 @@ public boolean visit(Http2Stream stream) throws Http2Exception {
             if (clientStream != null) {
               // RpcProgress _should_ be REFUSED, but are being conservative. See comment for
               // abruptGoAwayStatusConservative. This does reduce our ability to perform transparent
-              // retries, but our main goal of transporent retries is to resolve the local race. We
-              // still hope/expect servers to use the graceful double-GOAWAY when closing
-              // connections.
+              // retries, but only if something else caused a connection failure.
+              RpcProgress progress = mayBeHittingNettyBug
+                  ? RpcProgress.PROCESSED
+                  : RpcProgress.REFUSED;
               clientStream.transportReportStatus(
-                  abruptGoAwayStatusConservative, RpcProgress.PROCESSED, false, new Metadata());
+                  abruptGoAwayStatusConservative, progress, false, new Metadata());
             }
             stream.close();
           }
@@ -849,9 +1007,9 @@ 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;
     }
   }
@@ -859,7 +1017,7 @@ private void cancelPing(Throwable t) {
   /** 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((int) errorCode);
+    Status status = GrpcUtil.Http2Error.statusForCode(errorCode);
     if (statusCode == null) {
       statusCode = status.getCode();
     }
@@ -905,6 +1063,7 @@ private class FrameListener extends Http2FrameAdapter {
     public void onSettingsRead(ChannelHandlerContext ctx, Http2Settings settings) {
       if (firstSettings) {
         firstSettings = false;
+        attributes = lifecycleManager.filterAttributes(attributes);
         lifecycleManager.notifyReady();
       }
     }
@@ -939,17 +1098,16 @@ public void onPingAckRead(ChannelHandlerContext ctx, long ackPayload) throws Htt
       Http2Ping p = ping;
       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) {
         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");
diff --git a/netty/src/main/java/io/grpc/netty/NettyClientStream.java b/netty/src/main/java/io/grpc/netty/NettyClientStream.java
index 3e044a39649..2939eed2e37 100644
--- a/netty/src/main/java/io/grpc/netty/NettyClientStream.java
+++ b/netty/src/main/java/io/grpc/netty/NettyClientStream.java
@@ -31,6 +31,7 @@
 import io.grpc.MethodDescriptor;
 import io.grpc.Status;
 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;
@@ -45,6 +46,7 @@
 import io.netty.util.AsciiString;
 import io.perfmark.PerfMark;
 import io.perfmark.Tag;
+import io.perfmark.TaskCloseable;
 import javax.annotation.Nullable;
 
 /**
@@ -116,11 +118,9 @@ private class Sink implements AbstractClientStream.Sink {
 
     @Override
     public void writeHeaders(Metadata headers, byte[] requestPayload) {
-      PerfMark.startTask("NettyClientStream$Sink.writeHeaders");
-      try {
+      try (TaskCloseable ignore =
+               PerfMark.traceTask("NettyClientStream$Sink.writeHeaders")) {
         writeHeadersInternal(headers, requestPayload);
-      } finally {
-        PerfMark.stopTask("NettyClientStream$Sink.writeHeaders");
       }
     }
 
@@ -152,12 +152,18 @@ public void operationComplete(ChannelFuture future) throws Exception {
             // 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 execeptionCaught because NettyClientHandler does not propagate it).
+            // receive the exceptionCaught because NettyClientHandler does not propagate it).
             Status s = transportState().handler.getLifecycleManager().getShutdownStatus();
             if (s == null) {
               s = transportState().statusFromFailedFuture(future);
             }
-            transportState().transportReportStatus(s, true, new Metadata());
+            if (transportState().isNonExistent()) {
+              transportState().transportReportStatus(
+                  s, RpcProgress.MISCARRIED, true, new Metadata());
+            } else {
+              transportState().transportReportStatus(
+                  s, RpcProgress.PROCESSED, true, new Metadata());
+            }
           }
         }
       };
@@ -176,20 +182,10 @@ private void writeFrameInternal(
       if (numBytes > 0) {
         // Add the bytes to outbound flow control.
         onSendingBytes(numBytes);
+        ChannelFutureListener failureListener =
+            future -> transportState().onWriteFrameData(future, numMessages, numBytes);
         writeQueue.enqueue(new SendGrpcFrameCommand(transportState(), bytebuf, endOfStream), flush)
-            .addListener(new ChannelFutureListener() {
-              @Override
-              public void operationComplete(ChannelFuture future) throws Exception {
-                // 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() && transportState().http2Stream() != null) {
-                  // Remove the bytes from outbound flow control, optionally notifying
-                  // the client that they can send more bytes.
-                  transportState().onSentBytes(numBytes);
-                  NettyClientStream.this.getTransportTracer().reportMessageSent(numMessages);
-                }
-              }
-            });
+            .addListener(failureListener);
       } else {
         // The frame is empty and will not impact outbound flow control. Just send it.
         writeQueue.enqueue(
@@ -200,26 +196,20 @@ public void operationComplete(ChannelFuture future) throws Exception {
     @Override
     public void writeFrame(
         WritableBuffer frame, boolean endOfStream, boolean flush, int numMessages) {
-      PerfMark.startTask("NettyClientStream$Sink.writeFrame");
-      try {
+      try (TaskCloseable ignore = PerfMark.traceTask("NettyClientStream$Sink.writeFrame")) {
         writeFrameInternal(frame, endOfStream, flush, numMessages);
-      } finally {
-        PerfMark.stopTask("NettyClientStream$Sink.writeFrame");
       }
     }
 
     @Override
     public void cancel(Status status) {
-      PerfMark.startTask("NettyClientStream$Sink.cancel");
-      try {
+      try (TaskCloseable ignore = PerfMark.traceTask("NettyClientStream$Sink.cancel")) {
         writeQueue.enqueue(new CancelClientStreamCommand(transportState(), status), true);
-      } finally {
-        PerfMark.stopTask("NettyClientStream$Sink.cancel");
       }
     }
   }
 
-  /** 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;
@@ -237,8 +227,9 @@ protected TransportState(
         int maxMessageSize,
         StatsTraceContext statsTraceCtx,
         TransportTracer transportTracer,
-        String methodName) {
-      super(maxMessageSize, statsTraceCtx, 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");
@@ -268,7 +259,7 @@ void setNonExistent() {
     }
 
     boolean isNonExistent() {
-      return this.id == NON_EXISTENT_ID;
+      return this.id == NON_EXISTENT_ID || this.id == 0;
     }
 
     /**
@@ -306,6 +297,29 @@ protected void http2ProcessingFailed(Status status, boolean stopDelivery, Metada
       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()) {
diff --git a/netty/src/main/java/io/grpc/netty/NettyClientTransport.java b/netty/src/main/java/io/grpc/netty/NettyClientTransport.java
index 5802bfe6164..6585df42df3 100644
--- a/netty/src/main/java/io/grpc/netty/NettyClientTransport.java
+++ b/netty/src/main/java/io/grpc/netty/NettyClientTransport.java
@@ -23,23 +23,28 @@
 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.MetricRecorder;
 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.KeepAliveManager.ClientKeepAlivePinger;
+import io.grpc.internal.SimpleDisconnectError;
 import io.grpc.internal.StatsTraceContext;
 import io.grpc.internal.TransportTracer;
 import io.grpc.netty.NettyChannelBuilder.LocalSocketPicker;
@@ -54,7 +59,6 @@
 import io.netty.channel.EventLoopGroup;
 import io.netty.handler.codec.http2.StreamBufferingEncoder.Http2ChannelClosedException;
 import io.netty.util.AsciiString;
-import io.netty.util.AttributeKey;
 import io.netty.util.concurrent.Future;
 import io.netty.util.concurrent.GenericFutureListener;
 import java.net.SocketAddress;
@@ -67,21 +71,8 @@
 /**
  * A Netty-based {@link ConnectionClientTransport} implementation.
  */
-class NettyClientTransport implements ConnectionClientTransport {
-
-  /**
-   * Get the existing {@link ChannelLogger} key in case a separate, isolated class loader has
-   * already created {@link LOGGER_KEY}.
-   */
-  private static final AttributeKey<ChannelLogger> getOrCreateChannelLogger() {
-    AttributeKey<ChannelLogger> key = AttributeKey.valueOf("channelLogger");
-    if (key == null) {
-      key = AttributeKey.newInstance("channelLogger");
-    }
-    return key;
-  }
-
-  static final AttributeKey<ChannelLogger> LOGGER_KEY = getOrCreateChannelLogger();
+class NettyClientTransport implements ConnectionClientTransport,
+    ClientKeepAlivePinger.TransportWithDisconnectReason {
 
   private final InternalLogId logId;
   private final Map<ChannelOption<?>, ?> channelOptions;
@@ -96,6 +87,7 @@ private static final AttributeKey<ChannelLogger> getOrCreateChannelLogger() {
   private final int flowControlWindow;
   private final int maxMessageSize;
   private final int maxHeaderListSize;
+  private final int softLimitHeaderListSize;
   private KeepAliveManager keepAliveManager;
   private final long keepAliveTimeNanos;
   private final long keepAliveTimeoutNanos;
@@ -116,17 +108,35 @@ private static final AttributeKey<ChannelLogger> getOrCreateChannelLogger() {
   private final LocalSocketPicker localSocketPicker;
   private final ChannelLogger channelLogger;
   private final boolean useGetForSafeMethods;
+  private final Ticker ticker;
+  private final MetricRecorder metricRecorder;
+
 
   NettyClientTransport(
-      SocketAddress address, ChannelFactory<? extends Channel> channelFactory,
-      Map<ChannelOption<?>, ?> channelOptions, EventLoopGroup group,
-      ProtocolNegotiator negotiator, boolean autoFlowControl, int flowControlWindow,
-      int maxMessageSize, int maxHeaderListSize,
-      long keepAliveTimeNanos, long keepAliveTimeoutNanos,
-      boolean keepAliveWithoutCalls, String authority, @Nullable String userAgent,
-      Runnable tooManyPingsRunnable, TransportTracer transportTracer, Attributes eagAttributes,
-      LocalSocketPicker localSocketPicker, ChannelLogger channelLogger,
-      boolean useGetForSafeMethods) {
+      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,
+      MetricRecorder metricRecorder,
+      Ticker ticker) {
+
     this.negotiator = Preconditions.checkNotNull(negotiator, "negotiator");
     this.negotiationScheme = this.negotiator.scheme();
     this.remoteAddress = Preconditions.checkNotNull(address, "address");
@@ -137,6 +147,7 @@ private static final AttributeKey<ChannelLogger> getOrCreateChannelLogger() {
     this.flowControlWindow = flowControlWindow;
     this.maxMessageSize = maxMessageSize;
     this.maxHeaderListSize = maxHeaderListSize;
+    this.softLimitHeaderListSize = softLimitHeaderListSize;
     this.keepAliveTimeNanos = keepAliveTimeNanos;
     this.keepAliveTimeoutNanos = keepAliveTimeoutNanos;
     this.keepAliveWithoutCalls = keepAliveWithoutCalls;
@@ -151,6 +162,8 @@ private static final AttributeKey<ChannelLogger> getOrCreateChannelLogger() {
     this.logId = InternalLogId.allocate(getClass(), remoteAddress.toString());
     this.channelLogger = Preconditions.checkNotNull(channelLogger, "channelLogger");
     this.useGetForSafeMethods = useGetForSafeMethods;
+    this.metricRecorder = metricRecorder;
+    this.ticker = Preconditions.checkNotNull(ticker, "ticker");
   }
 
   @Override
@@ -159,7 +172,7 @@ public void ping(final PingCallback callback, final Executor executor) {
       executor.execute(new Runnable() {
         @Override
         public void run() {
-          callback.onFailure(statusExplainingWhyTheChannelIsNull.asException());
+          callback.onFailure(statusExplainingWhyTheChannelIsNull);
         }
       });
       return;
@@ -171,7 +184,7 @@ public void run() {
       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);
         }
       }
     };
@@ -182,14 +195,15 @@ public void operationComplete(ChannelFuture future) throws Exception {
 
   @Override
   public ClientStream newStream(
-      MethodDescriptor<?, ?> method, Metadata headers, CallOptions callOptions) {
+      MethodDescriptor<?, ?> method, Metadata headers, CallOptions callOptions,
+      ClientStreamTracer[] tracers) {
     Preconditions.checkNotNull(method, "method");
     Preconditions.checkNotNull(headers, "headers");
     if (channel == null) {
-      return new FailingClientStream(statusExplainingWhyTheChannelIsNull);
+      return new FailingClientStream(statusExplainingWhyTheChannelIsNull, tracers);
     }
     StatsTraceContext statsTraceCtx =
-        StatsTraceContext.newClientContext(callOptions, getAttributes(), headers);
+        StatsTraceContext.newClientContext(tracers, getAttributes(), headers);
     return new NettyClientStream(
         new NettyClientStream.TransportState(
             handler,
@@ -197,7 +211,8 @@ public ClientStream newStream(
             maxMessageSize,
             statsTraceCtx,
             transportTracer,
-            method.getFullMethodName()) {
+            method.getFullMethodName(),
+            callOptions) {
           @Override
           protected Status statusFromFailedFuture(ChannelFuture f) {
             return NettyClientTransport.this.statusFromFailedFuture(f);
@@ -223,38 +238,34 @@ public Runnable start(Listener transportListener) {
     EventLoop eventLoop = group.next();
     if (keepAliveTimeNanos != KEEPALIVE_TIME_NANOS_DISABLED) {
       keepAliveManager = new KeepAliveManager(
-          new ClientKeepAlivePinger(this), eventLoop, keepAliveTimeNanos, keepAliveTimeoutNanos,
-          keepAliveWithoutCalls);
+          new ClientKeepAlivePinger(this), eventLoop, keepAliveTimeNanos,
+          keepAliveTimeoutNanos, keepAliveWithoutCalls);
     }
 
     handler = NettyClientHandler.newHandler(
-        lifecycleManager,
-        keepAliveManager,
-        autoFlowControl,
-        flowControlWindow,
-        maxHeaderListSize,
-        GrpcUtil.STOPWATCH_SUPPLIER,
-        tooManyPingsRunnable,
-        transportTracer,
-        eagAttributes,
-        authorityString);
+            lifecycleManager,
+            keepAliveManager,
+            autoFlowControl,
+            flowControlWindow,
+            maxHeaderListSize,
+            softLimitHeaderListSize,
+            GrpcUtil.STOPWATCH_SUPPLIER,
+            tooManyPingsRunnable,
+            transportTracer,
+            eagAttributes,
+            authorityString,
+            channelLogger,
+            ticker,
+            metricRecorder);
 
     ChannelHandler negotiationHandler = negotiator.newHandler(handler);
 
     Bootstrap b = new Bootstrap();
     b.option(ALLOCATOR, Utils.getByteBufAllocator(false));
-    b.attr(LOGGER_KEY, channelLogger);
     b.group(eventLoop);
     b.channelFactory(channelFactory);
     // For non-socket based channel, the option will be ignored.
     b.option(SO_KEEPALIVE, true);
-    // For non-epoll based channel, the option will be ignored.
-    if (keepAliveTimeNanos != KEEPALIVE_TIME_NANOS_DISABLED) {
-      ChannelOption<Integer> tcpUserTimeout = Utils.maybeGetTcpUserTimeoutOption();
-      if (tcpUserTimeout != null) {
-        b.option(tcpUserTimeout, (int) TimeUnit.NANOSECONDS.toMillis(keepAliveTimeoutNanos));
-      }
-    }
     for (Map.Entry<ChannelOption<?>, ?> entry : channelOptions.entrySet()) {
       // Every entry in the map is obtained from
       // NettyChannelBuilder#withOption(ChannelOption<T> option, T value)
@@ -264,7 +275,7 @@ public Runnable start(Listener transportListener) {
 
     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.
@@ -288,11 +299,26 @@ public void run() {
           // 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);
+          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
@@ -306,7 +332,8 @@ 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);
         }
       }
     });
@@ -340,12 +367,17 @@ public void shutdown(Status reason) {
 
   @Override
   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 Runnable() {
         @Override
         public void run() {
-          lifecycleManager.notifyShutdown(reason);
+          lifecycleManager.notifyShutdown(reason, disconnectError);
           channel.write(new ForcefulCloseCommand(reason));
         }
       }, true);
diff --git a/netty/src/main/java/io/grpc/netty/NettyReadableBuffer.java b/netty/src/main/java/io/grpc/netty/NettyReadableBuffer.java
index 37caccb0eb3..af5ec8d8bad 100644
--- a/netty/src/main/java/io/grpc/netty/NettyReadableBuffer.java
+++ b/netty/src/main/java/io/grpc/netty/NettyReadableBuffer.java
@@ -60,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 {
@@ -94,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 4c16ac50a26..2bb6b2c5921 100644
--- a/netty/src/main/java/io/grpc/netty/NettyServer.java
+++ b/netty/src/main/java/io/grpc/netty/NettyServer.java
@@ -31,6 +31,7 @@
 import io.grpc.InternalInstrumented;
 import io.grpc.InternalLogId;
 import io.grpc.InternalWithLogId;
+import io.grpc.MetricRecorder;
 import io.grpc.ServerStreamTracer;
 import io.grpc.internal.InternalServer;
 import io.grpc.internal.ObjectPool;
@@ -92,6 +93,8 @@ class NettyServer implements InternalServer, InternalWithLogId {
   private final int flowControlWindow;
   private final int maxMessageSize;
   private final int maxHeaderListSize;
+  private final int softLimitHeaderListSize;
+  private MetricRecorder metricRecorder;
   private final long keepAliveTimeInNanos;
   private final long keepAliveTimeoutInNanos;
   private final long maxConnectionIdleInNanos;
@@ -99,6 +102,8 @@ class NettyServer implements InternalServer, InternalWithLogId {
   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();
@@ -121,14 +126,22 @@ class NettyServer implements InternalServer, InternalWithLogId {
       ProtocolNegotiator protocolNegotiator,
       List<? extends ServerStreamTracer.Factory> streamTracerFactories,
       TransportTracer.Factory transportTracerFactory,
-      int maxStreamsPerConnection, boolean autoFlowControl, int flowControlWindow,
-      int maxMessageSize, int maxHeaderListSize,
-      long keepAliveTimeInNanos, long keepAliveTimeoutInNanos,
+      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,
-      Attributes eagAttributes, InternalChannelz channelz) {
+      int maxRstCount, long maxRstPeriodNanos,
+      Attributes eagAttributes, InternalChannelz channelz,
+      MetricRecorder metricRecorder) {
     this.addresses = checkNotNull(addresses, "addresses");
+    this.metricRecorder = metricRecorder;
     this.channelFactory = checkNotNull(channelFactory, "channelFactory");
     checkNotNull(channelOptions, "channelOptions");
     this.channelOptions = new HashMap<ChannelOption<?>, Object>(channelOptions);
@@ -149,6 +162,7 @@ class NettyServer implements InternalServer, InternalWithLogId {
     this.flowControlWindow = flowControlWindow;
     this.maxMessageSize = maxMessageSize;
     this.maxHeaderListSize = maxHeaderListSize;
+    this.softLimitHeaderListSize = softLimitHeaderListSize;
     this.keepAliveTimeInNanos = keepAliveTimeInNanos;
     this.keepAliveTimeoutInNanos = keepAliveTimeoutInNanos;
     this.maxConnectionIdleInNanos = maxConnectionIdleInNanos;
@@ -156,12 +170,15 @@ class NettyServer implements InternalServer, InternalWithLogId {
     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 SocketAddress getListenSocketAddress() {
     Iterator<Channel> it = channelGroup.iterator();
@@ -238,26 +255,30 @@ public void initChannel(Channel ch) {
               (long) ((.9D + Math.random() * .2D) * maxConnectionAgeInNanos);
         }
 
-        NettyServerTransport transport =
-            new NettyServerTransport(
-                ch,
-                channelDone,
-                protocolNegotiator,
-                streamTracerFactories,
-                transportTracerFactory.create(),
-                maxStreamsPerConnection,
-                autoFlowControl,
-                flowControlWindow,
-                maxMessageSize,
-                maxHeaderListSize,
-                keepAliveTimeInNanos,
-                keepAliveTimeoutInNanos,
-                maxConnectionIdleInNanos,
-                maxConnectionAgeInNanos,
-                maxConnectionAgeGraceInNanos,
-                permitKeepAliveWithoutCalls,
-                permitKeepAliveTimeInNanos,
-                eagAttributes);
+            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,
+                    metricRecorder);
         ServerTransportListener transportListener;
         // This is to order callbacks on the listener, not to guard access to channel.
         synchronized (NettyServer.this) {
@@ -272,9 +293,7 @@ public void initChannel(Channel ch) {
           transportListener = listener.transportCreated(transport);
         }
 
-        /**
-         * Releases the event loop if the channel is "done", possibly due to the channel closing.
-         */
+        /* Releases the event loop if the channel is "done", possibly due to the channel closing. */
         final class LoopReleaser implements ChannelFutureListener {
           private boolean done;
 
diff --git a/netty/src/main/java/io/grpc/netty/NettyServerBuilder.java b/netty/src/main/java/io/grpc/netty/NettyServerBuilder.java
index 9b67cd21f19..4ef14b0e933 100644
--- a/netty/src/main/java/io/grpc/netty/NettyServerBuilder.java
+++ b/netty/src/main/java/io/grpc/netty/NettyServerBuilder.java
@@ -22,17 +22,21 @@
 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.DEFAULT_SERVER_PERMIT_KEEPALIVE_TIME_NANOS;
 import static io.grpc.internal.GrpcUtil.SERVER_KEEPALIVE_TIME_NANOS_DISABLED;
 
 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.MetricRecorder;
 import io.grpc.ServerBuilder;
 import io.grpc.ServerCredentials;
 import io.grpc.ServerStreamTracer;
-import io.grpc.internal.AbstractServerImplBuilder;
 import io.grpc.internal.FixedObjectPool;
 import io.grpc.internal.GrpcUtil;
 import io.grpc.internal.InternalServer;
@@ -58,15 +62,14 @@
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.TimeUnit;
-import javax.annotation.CheckReturnValue;
 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> {
+@CheckReturnValue
+public final class NettyServerBuilder extends ForwardingServerBuilder<NettyServerBuilder> {
 
   // 1MiB
   public static final int DEFAULT_FLOW_CONTROL_WINDOW = 1024 * 1024;
@@ -74,9 +77,8 @@ public final class NettyServerBuilder extends AbstractServerImplBuilder<NettySer
   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_KEEPALIVE_TIME_NANO = TimeUnit.MILLISECONDS.toNanos(1L);
-  private static final long MIN_KEEPALIVE_TIMEOUT_NANO = TimeUnit.MICROSECONDS.toNanos(499L);
   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);
@@ -105,13 +107,16 @@ public final class NettyServerBuilder extends AbstractServerImplBuilder<NettySer
   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 long permitKeepAliveTimeInNanos = DEFAULT_SERVER_PERMIT_KEEPALIVE_TIME_NANOS;
+  private int maxRstCount;
+  private long maxRstPeriodNanos;
   private Attributes eagAttributes = Attributes.EMPTY;
 
   /**
@@ -120,7 +125,6 @@ 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 forAddress(new InetSocketAddress(port));
   }
@@ -131,7 +135,6 @@ public static NettyServerBuilder forPort(int port) {
    * @param port the port on which the server is to be bound.
    * @return the server builder.
    */
-  @CheckReturnValue
   public static NettyServerBuilder forPort(int port, ServerCredentials creds) {
     return forAddress(new InetSocketAddress(port), creds);
   }
@@ -142,7 +145,6 @@ public static NettyServerBuilder forPort(int port, ServerCredentials creds) {
    * @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);
   }
@@ -153,7 +155,6 @@ public static NettyServerBuilder forAddress(SocketAddress address) {
    * @param address the socket address on which the server is to be bound.
    * @return the server builder
    */
-  @CheckReturnValue
   public static NettyServerBuilder forAddress(SocketAddress address, ServerCredentials creds) {
     ProtocolNegotiators.FromServerCredentialsResult result = ProtocolNegotiators.from(creds);
     if (result.error != null) {
@@ -165,12 +166,12 @@ public static NettyServerBuilder forAddress(SocketAddress address, ServerCredent
   private final class NettyClientTransportServersBuilder implements ClientTransportServersBuilder {
     @Override
     public InternalServer buildClientTransportServers(
-        List<? extends ServerStreamTracer.Factory> streamTracerFactories) {
-      return buildTransportServers(streamTracerFactories);
+        List<? extends ServerStreamTracer.Factory> streamTracerFactories,
+        MetricRecorder metricRecorder) {
+      return buildTransportServers(streamTracerFactories, metricRecorder);
     }
   }
 
-  @CheckReturnValue
   private NettyServerBuilder(SocketAddress address) {
     serverImplBuilder = new ServerImplBuilder(new NettyClientTransportServersBuilder());
     this.listenAddresses.add(address);
@@ -178,9 +179,7 @@ private NettyServerBuilder(SocketAddress address) {
     this.freezeProtocolNegotiatorFactory = false;
   }
 
-  @CheckReturnValue
-  NettyServerBuilder(
-      SocketAddress address, ProtocolNegotiator.ServerFactory negotiatorFactory) {
+  NettyServerBuilder(SocketAddress address, ProtocolNegotiator.ServerFactory negotiatorFactory) {
     serverImplBuilder = new ServerImplBuilder(new NettyClientTransportServersBuilder());
     this.listenAddresses.add(address);
     this.protocolNegotiatorFactory = checkNotNull(negotiatorFactory, "negotiatorFactory");
@@ -198,6 +197,7 @@ protected ServerBuilder<?> delegate() {
    * 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;
@@ -218,6 +218,7 @@ public NettyServerBuilder addListenAddress(SocketAddress listenAddress) {
    * 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) {
     checkNotNull(channelType, "channelType");
     return channelFactory(new ReflectiveChannelFactory<>(channelType));
@@ -237,6 +238,7 @@ public NettyServerBuilder channelType(Class<? extends ServerChannel> channelType
    * 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;
@@ -248,6 +250,7 @@ public NettyServerBuilder channelFactory(ChannelFactory<? extends ServerChannel>
    *
    * @since 1.30.0
    */
+  @CanIgnoreReturnValue
   public <T> NettyServerBuilder withOption(ChannelOption<T> option, T value) {
     this.channelOptions.put(option, value);
     return this;
@@ -259,6 +262,7 @@ public <T> NettyServerBuilder withOption(ChannelOption<T> option, T value) {
    *
    * @since 1.9.0
    */
+  @CanIgnoreReturnValue
   public <T> NettyServerBuilder withChildOption(ChannelOption<T> option, T value) {
     this.childChannelOptions.put(option, value);
     return this;
@@ -287,6 +291,7 @@ public <T> NettyServerBuilder withChildOption(ChannelOption<T> option, T value)
    * 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) {
     if (group != null) {
       return bossEventLoopGroupPool(new FixedObjectPool<>(group));
@@ -294,6 +299,7 @@ public NettyServerBuilder bossEventLoopGroup(EventLoopGroup group) {
     return bossEventLoopGroupPool(DEFAULT_BOSS_EVENT_LOOP_GROUP_POOL);
   }
 
+  @CanIgnoreReturnValue
   NettyServerBuilder bossEventLoopGroupPool(
       ObjectPool<? extends EventLoopGroup> bossEventLoopGroupPool) {
     this.bossEventLoopGroupPool = checkNotNull(bossEventLoopGroupPool, "bossEventLoopGroupPool");
@@ -323,6 +329,7 @@ NettyServerBuilder bossEventLoopGroupPool(
    * 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) {
     if (group != null) {
       return workerEventLoopGroupPool(new FixedObjectPool<>(group));
@@ -330,6 +337,7 @@ public NettyServerBuilder workerEventLoopGroup(EventLoopGroup group) {
     return workerEventLoopGroupPool(DEFAULT_WORKER_EVENT_LOOP_GROUP_POOL);
   }
 
+  @CanIgnoreReturnValue
   NettyServerBuilder workerEventLoopGroupPool(
       ObjectPool<? extends EventLoopGroup> workerEventLoopGroupPool) {
     this.workerEventLoopGroupPool =
@@ -348,6 +356,7 @@ void setForceHeapBuffer(boolean 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");
@@ -366,6 +375,7 @@ public NettyServerBuilder sslContext(SslContext sslContext) {
    * Sets the {@link ProtocolNegotiator} to be used. Overrides the value specified in {@link
    * #sslContext(SslContext)}.
    */
+  @CanIgnoreReturnValue
   @Internal
   public final NettyServerBuilder protocolNegotiator(ProtocolNegotiator protocolNegotiator) {
     checkState(!freezeProtocolNegotiatorFactory,
@@ -394,6 +404,7 @@ void setStatsRecordRealTimeMetrics(boolean 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;
@@ -406,6 +417,7 @@ public NettyServerBuilder maxConcurrentCallsPerConnection(int maxCalls) {
    * 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;
@@ -419,6 +431,7 @@ public NettyServerBuilder initialFlowControlWindow(int initialFlowControlWindow)
    * 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: %s",
         flowControlWindow);
@@ -436,12 +449,15 @@ public NettyServerBuilder flowControlWindow(int flowControlWindow) {
    * @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) {
     return maxInboundMessageSize(maxMessageSize);
   }
 
   /** {@inheritDoc} */
+  @CanIgnoreReturnValue
   @Override
   public NettyServerBuilder maxInboundMessageSize(int bytes) {
     checkArgument(bytes >= 0, "bytes must be non-negative: %s", bytes);
@@ -457,7 +473,9 @@ public NettyServerBuilder maxInboundMessageSize(int bytes) {
    *
    * @deprecated Use {@link #maxInboundMetadataSize} instead
    */
+  @CanIgnoreReturnValue
   @Deprecated
+  @InlineMe(replacement = "this.maxInboundMetadataSize(maxHeaderListSize)")
   public NettyServerBuilder maxHeaderListSize(int maxHeaderListSize) {
     return maxInboundMetadataSize(maxHeaderListSize);
   }
@@ -473,10 +491,44 @@ public NettyServerBuilder maxHeaderListSize(int maxHeaderListSize) {
    * @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;
   }
 
@@ -487,6 +539,8 @@ public NettyServerBuilder maxInboundMetadataSize(int bytes) {
    *
    * @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);
@@ -495,10 +549,6 @@ public NettyServerBuilder keepAliveTime(long keepAliveTime, TimeUnit timeUnit) {
       // Bump keepalive time to infinite. This disables keep alive.
       keepAliveTimeInNanos = SERVER_KEEPALIVE_TIME_NANOS_DISABLED;
     }
-    if (keepAliveTimeInNanos < MIN_KEEPALIVE_TIME_NANO) {
-      // Bump keepalive time.
-      keepAliveTimeInNanos = MIN_KEEPALIVE_TIME_NANO;
-    }
     return this;
   }
 
@@ -508,16 +558,14 @@ public NettyServerBuilder keepAliveTime(long keepAliveTime, TimeUnit timeUnit) {
    *
    * @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);
-    if (keepAliveTimeoutInNanos < MIN_KEEPALIVE_TIMEOUT_NANO) {
-      // Bump keepalive timeout.
-      keepAliveTimeoutInNanos = MIN_KEEPALIVE_TIMEOUT_NANO;
-    }
     return this;
   }
 
@@ -530,6 +578,8 @@ public NettyServerBuilder keepAliveTimeout(long keepAliveTimeout, TimeUnit timeU
    *
    * @since 1.4.0
    */
+  @CanIgnoreReturnValue
+  @Override
   public NettyServerBuilder maxConnectionIdle(long maxConnectionIdle, TimeUnit timeUnit) {
     checkArgument(maxConnectionIdle > 0L, "max connection idle must be positive: %s",
         maxConnectionIdle);
@@ -551,6 +601,8 @@ public NettyServerBuilder maxConnectionIdle(long maxConnectionIdle, TimeUnit tim
    *
    * @since 1.3.0
    */
+  @CanIgnoreReturnValue
+  @Override
   public NettyServerBuilder maxConnectionAge(long maxConnectionAge, TimeUnit timeUnit) {
     checkArgument(maxConnectionAge > 0L, "max connection age must be positive: %s",
         maxConnectionAge);
@@ -573,6 +625,8 @@ public NettyServerBuilder maxConnectionAge(long maxConnectionAge, TimeUnit timeU
    * @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);
@@ -597,6 +651,8 @@ public NettyServerBuilder maxConnectionAgeGrace(long maxConnectionAgeGrace, Time
    * @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);
@@ -611,33 +667,83 @@ public NettyServerBuilder permitKeepAliveTime(long keepAliveTime, TimeUnit timeU
    * @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");
   }
 
-  @CheckReturnValue
+  @VisibleForTesting
   NettyServer buildTransportServers(
-      List<? extends ServerStreamTracer.Factory> streamTracerFactories) {
+      List<? extends ServerStreamTracer.Factory> streamTracerFactories,
+      MetricRecorder metricRecorder) {
     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,
-        keepAliveTimeInNanos, keepAliveTimeoutInNanos,
-        maxConnectionIdleInNanos, maxConnectionAgeInNanos,
-        maxConnectionAgeGraceInNanos, permitKeepAliveWithoutCalls, permitKeepAliveTimeInNanos,
-        eagAttributes, this.serverImplBuilder.getChannelz());
+        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(),
+        metricRecorder);
   }
 
   @VisibleForTesting
@@ -654,12 +760,13 @@ void assertEventLoopsAndChannelType() {
             + "neither should be");
   }
 
-  NettyServerBuilder setTransportTracerFactory(
-      TransportTracer.Factory transportTracerFactory) {
+  @CanIgnoreReturnValue
+  NettyServerBuilder setTransportTracerFactory(TransportTracer.Factory transportTracerFactory) {
     this.transportTracerFactory = transportTracerFactory;
     return this;
   }
 
+  @CanIgnoreReturnValue
   @Override
   public NettyServerBuilder useTransportSecurity(File certChain, File privateKey) {
     checkState(!freezeProtocolNegotiatorFactory,
@@ -675,6 +782,7 @@ public NettyServerBuilder useTransportSecurity(File certChain, File privateKey)
     return this;
   }
 
+  @CanIgnoreReturnValue
   @Override
   public NettyServerBuilder useTransportSecurity(InputStream certChain, InputStream privateKey) {
     checkState(!freezeProtocolNegotiatorFactory,
diff --git a/netty/src/main/java/io/grpc/netty/NettyServerHandler.java b/netty/src/main/java/io/grpc/netty/NettyServerHandler.java
index 697534bb694..79715ca2996 100644
--- a/netty/src/main/java/io/grpc/netty/NettyServerHandler.java
+++ b/netty/src/main/java/io/grpc/netty/NettyServerHandler.java
@@ -26,31 +26,43 @@
 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.MetricRecorder;
 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.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;
@@ -58,8 +70,10 @@
 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;
@@ -67,24 +81,27 @@
 import io.netty.handler.codec.http2.Http2Error;
 import io.netty.handler.codec.http2.Http2Exception;
 import io.netty.handler.codec.http2.Http2Exception.StreamException;
-import io.netty.handler.codec.http2.Http2FlowController;
 import io.netty.handler.codec.http2.Http2FrameAdapter;
 import io.netty.handler.codec.http2.Http2FrameLogger;
 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.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.WeightedFairQueueByteDistributor;
+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;
@@ -104,14 +121,19 @@ class NettyServerHandler extends AbstractNettyHandler {
   @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 TcpMetrics tcpMetrics;
   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;
@@ -143,6 +165,7 @@ static NettyServerHandler newHandler(
       boolean autoFlowControl,
       int flowControlWindow,
       int maxHeaderListSize,
+      int softLimitHeaderListSize,
       int maxMessageSize,
       long keepAliveTimeInNanos,
       long keepAliveTimeoutInNanos,
@@ -151,15 +174,20 @@ static NettyServerHandler newHandler(
       long maxConnectionAgeGraceInNanos,
       boolean permitKeepAliveWithoutCalls,
       long permitKeepAliveTimeInNanos,
-      Attributes eagAttributes) {
+      int maxRstCount,
+      long maxRstPeriodNanos,
+      Attributes eagAttributes,
+      MetricRecorder metricRecorder) {
     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);
+        new Http2OutboundFrameLogger(new DefaultHttp2FrameWriter(encoder), frameLogger);
     return newHandler(
         channelUnused,
         frameReader,
@@ -171,6 +199,7 @@ static NettyServerHandler newHandler(
         autoFlowControl,
         flowControlWindow,
         maxHeaderListSize,
+        softLimitHeaderListSize,
         maxMessageSize,
         keepAliveTimeInNanos,
         keepAliveTimeoutInNanos,
@@ -179,7 +208,11 @@ static NettyServerHandler newHandler(
         maxConnectionAgeGraceInNanos,
         permitKeepAliveWithoutCalls,
         permitKeepAliveTimeInNanos,
-        eagAttributes);
+        maxRstCount,
+        maxRstPeriodNanos,
+        eagAttributes,
+        Ticker.systemTicker(),
+        metricRecorder);
   }
 
   static NettyServerHandler newHandler(
@@ -193,6 +226,7 @@ static NettyServerHandler newHandler(
       boolean autoFlowControl,
       int flowControlWindow,
       int maxHeaderListSize,
+      int softLimitHeaderListSize,
       int maxMessageSize,
       long keepAliveTimeInNanos,
       long keepAliveTimeoutInNanos,
@@ -201,24 +235,37 @@ static NettyServerHandler newHandler(
       long maxConnectionAgeGraceInNanos,
       boolean permitKeepAliveWithoutCalls,
       long permitKeepAliveTimeInNanos,
-      Attributes eagAttributes) {
+      int maxRstCount,
+      long maxRstPeriodNanos,
+      Attributes eagAttributes,
+      Ticker ticker,
+      MetricRecorder metricRecorder) {
     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);
-    WeightedFairQueueByteDistributor dist = new WeightedFairQueueByteDistributor(connection);
-    dist.allocationQuantum(16 * 1024); // Make benchmarks fast again.
+    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));
@@ -226,6 +273,7 @@ static NettyServerHandler newHandler(
     Http2ConnectionEncoder encoder =
         new DefaultHttp2ConnectionEncoder(connection, frameWriter);
     encoder = new Http2ControlFrameLimitEncoder(encoder, 10000);
+    encoder = new Http2RstCounterEncoder(encoder, rstStreamCounter);
     Http2ConnectionDecoder decoder = new DefaultHttp2ConnectionDecoder(connection, encoder,
         frameReader);
 
@@ -242,12 +290,17 @@ static NettyServerHandler newHandler(
         transportTracer,
         decoder, encoder, settings,
         maxMessageSize,
-        keepAliveTimeInNanos, keepAliveTimeoutInNanos,
+        maxHeaderListSize,
+        softLimitHeaderListSize,
+        keepAliveTimeInNanos,
+        keepAliveTimeoutInNanos,
         maxConnectionIdleInNanos,
         maxConnectionAgeInNanos, maxConnectionAgeGraceInNanos,
         keepAliveEnforcer,
         autoFlowControl,
-        eagAttributes);
+        rstStreamCounter,
+        eagAttributes, ticker,
+        metricRecorder);
   }
 
   private NettyServerHandler(
@@ -260,6 +313,8 @@ private NettyServerHandler(
       Http2ConnectionEncoder encoder,
       Http2Settings settings,
       int maxMessageSize,
+      int maxHeaderListSize,
+      int softLimitHeaderListSize,
       long keepAliveTimeInNanos,
       long keepAliveTimeoutInNanos,
       long maxConnectionIdleInNanos,
@@ -267,23 +322,27 @@ private NettyServerHandler(
       long maxConnectionAgeGraceInNanos,
       final KeepAliveEnforcer keepAliveEnforcer,
       boolean autoFlowControl,
-      Attributes eagAttributes) {
-    super(channelUnused, decoder, encoder, settings, autoFlowControl, null);
+      RstStreamCounter rstStreamCounter,
+      Attributes eagAttributes,
+      Ticker ticker,
+      MetricRecorder metricRecorder) {
+    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) {
-        @Override
-        void close(ChannelHandlerContext ctx) {
-          if (gracefulShutdown == null) {
-            gracefulShutdown = new GracefulShutdown("max_idle", null);
-            gracefulShutdown.start(ctx);
-            ctx.flush();
-          }
-        }
-      };
+      maxConnectionIdleManager = new MaxConnectionIdleManager(maxConnectionIdleInNanos);
     }
 
     connection.addListener(new Http2ConnectionAdapter() {
@@ -310,19 +369,20 @@ public void onStreamClosed(Http2Stream stream) {
 
     checkArgument(maxMessageSize >= 0, "maxMessageSize must be non-negative: %s", maxMessageSize);
     this.maxMessageSize = maxMessageSize;
+    this.tcpMetrics = new TcpMetrics(metricRecorder);
     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());
   }
@@ -354,7 +414,16 @@ public void run() {
     }
 
     if (maxConnectionIdleManager != null) {
-      maxConnectionIdleManager.start(ctx);
+      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) {
@@ -363,23 +432,8 @@ public void run() {
       keepAliveManager.onTransportStarted();
     }
 
-
-    if (transportTracer != null) {
-      assert encoder().connection().equals(decoder().connection());
-      final Http2Connection connection = encoder().connection();
-      transportTracer.setFlowControlWindowReader(new TransportTracer.FlowControlReader() {
-        private final Http2FlowController local = connection.local().flowController();
-        private final Http2FlowController remote = connection.remote().flowController();
-
-        @Override
-        public TransportTracer.FlowControlWindows read() {
-          assert ctx.executor().inEventLoop();
-          return new TransportTracer.FlowControlWindows(
-              local.windowSize(connection.connectionStream()),
-              remote.windowSize(connection.connectionStream()));
-        }
-      });
-    }
+    assert encoder().connection().equals(decoder().connection());
+    transportTracer.setFlowControlWindowReader(new Utils.FlowControlReader(encoder().connection()));
 
     super.handlerAdded(ctx);
   }
@@ -387,6 +441,26 @@ public TransportTracer.FlowControlWindows read() {
   private void onHeadersRead(ChannelHandlerContext ctx, int streamId, Http2Headers headers)
       throws Http2Exception {
     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();
@@ -420,8 +494,20 @@ private void onHeadersRead(ChannelHandlerContext ctx, int streamId, Http2Headers
       }
 
       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()));
+            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;
       }
 
@@ -449,21 +535,18 @@ private void onHeadersRead(ChannelHandlerContext ctx, int streamId, Http2Headers
           transportTracer,
           method);
 
-      PerfMark.startTask("NettyServerHandler.onHeadersRead", state.tag());
-      try {
+      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,
-            transportTracer);
+            statsTraceCtx);
         transportListener.streamCreated(stream, method, metadata);
         state.onStreamAllocated();
         http2Stream.setProperty(streamKey, state);
-      } finally {
-        PerfMark.stopTask("NettyServerHandler.onHeadersRead", state.tag());
       }
     } catch (Exception e) {
       logger.log(Level.WARNING, "Exception in onHeadersRead()", e);
@@ -489,11 +572,12 @@ private void onDataRead(int streamId, ByteBuf data, int padding, boolean endOfSt
     flowControlPing().onDataRead(data.readableBytes(), padding);
     try {
       NettyServerStream.TransportState stream = serverStream(requireHttp2Stream(streamId));
-      PerfMark.startTask("NettyServerHandler.onDataRead", stream.tag());
-      try {
+      if (stream == null) {
+        return;
+      }
+      try (TaskCloseable ignore = PerfMark.traceTask("NettyServerHandler.onDataRead")) {
+        PerfMark.attachTag(stream.tag());
         stream.inboundDataReceived(data, endOfStream);
-      } finally {
-        PerfMark.stopTask("NettyServerHandler.onDataRead", stream.tag());
       }
     } catch (Throwable e) {
       logger.log(Level.WARNING, "Exception in onDataRead()", e);
@@ -503,15 +587,18 @@ private void onDataRead(int streamId, ByteBuf data, int padding, boolean endOfSt
   }
 
   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) {
-        PerfMark.startTask("NettyServerHandler.onRstStreamRead", stream.tag());
-        try {
+        try (TaskCloseable ignore = PerfMark.traceTask("NettyServerHandler.onRstStreamRead")) {
+          PerfMark.attachTag(stream.tag());
           stream.transportReportStatus(
               Status.CANCELLED.withDescription("RST_STREAM received for code " + errorCode));
-        } finally {
-          PerfMark.stopTask("NettyServerHandler.onRstStreamRead", stream.tag());
         }
       }
     } catch (Throwable e) {
@@ -540,16 +627,14 @@ protected void onStreamError(ChannelHandlerContext ctx, boolean outbound, Throwa
     }
     logger.log(level, "Stream Error", cause);
     Tag tag = serverStream != null ? serverStream.tag() : PerfMark.createTag();
-    PerfMark.startTask("NettyServerHandler.onStreamError", tag);
-    try {
+    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);
-    } finally {
-      PerfMark.stopTask("NettyServerHandler.onStreamError", tag);
     }
   }
 
@@ -584,9 +669,16 @@ void setKeepAliveManagerForTest(KeepAliveManager keepAliveManager) {
   /**
    * Handler for the Channel shutting down.
    */
+  @Override
+  public void channelActive(ChannelHandlerContext ctx) throws Exception {
+    tcpMetrics.channelActive(ctx.channel());
+    super.channelActive(ctx);
+  }
+
   @Override
   public void channelInactive(ChannelHandlerContext ctx) throws Exception {
     try {
+      tcpMetrics.channelInactive(ctx.channel());
       if (keepAliveManager != null) {
         keepAliveManager.onTransportTermination();
       }
@@ -618,9 +710,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 {
@@ -630,6 +720,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 {
@@ -643,11 +735,8 @@ public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise)
 
   @Override
   public void close(ChannelHandlerContext ctx, ChannelPromise promise) throws Exception {
-    if (gracefulShutdown == null) {
-      gracefulShutdown = new GracefulShutdown("app_requested", null);
-      gracefulShutdown.start(ctx);
-      ctx.flush();
-    }
+    gracefulClose(ctx, new GracefulServerCloseCommand("app_requested"), promise);
+    ctx.flush();
   }
 
   /**
@@ -661,31 +750,46 @@ 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 {
-    PerfMark.startTask("NettyServerHandler.sendGrpcFrame", cmd.stream().tag());
-    PerfMark.linkIn(cmd.getLink());
-    try {
+  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, cmd.stream().id());
+        closeStreamWhenDone(promise, stream);
       }
       // Call the base class to write the HTTP/2 DATA frame.
-      encoder().writeData(ctx, cmd.stream().id(), cmd.content(), 0, cmd.endStream(), promise);
-    } finally {
-      PerfMark.stopTask("NettyServerHandler.sendGrpcFrame", cmd.stream().tag());
+      encoder().writeData(ctx, streamId, cmd.content(), 0, cmd.endStream(), promise);
     }
   }
 
@@ -694,38 +798,75 @@ private void sendGrpcFrame(ChannelHandlerContext ctx, SendGrpcFrameCommand cmd,
    */
   private void sendResponseHeaders(ChannelHandlerContext ctx, SendResponseHeadersCommand cmd,
       ChannelPromise promise) throws Http2Exception {
-    PerfMark.startTask("NettyServerHandler.sendResponseHeaders", cmd.stream().tag());
-    PerfMark.linkIn(cmd.getLink());
-    try {
-      // TODO(carl-mastrangelo): remove this check once https://github.com/netty/netty/issues/6296
-      // is fixed.
+    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) {
-        resetStream(ctx, streamId, Http2Error.CANCEL.code(), promise);
+        streamGone(streamId, promise);
         return;
       }
       if (cmd.endOfStream()) {
-        closeStreamWhenDone(promise, streamId);
+        closeStreamWhenDone(promise, stream);
       }
       encoder().writeHeaders(ctx, streamId, cmd.headers(), 0, cmd.endOfStream(), promise);
-    } finally {
-      PerfMark.stopTask("NettyServerHandler.sendResponseHeaders", cmd.stream().tag());
     }
   }
 
   private void cancelStream(ChannelHandlerContext ctx, CancelServerStreamCommand cmd,
       ChannelPromise promise) {
-    PerfMark.startTask("NettyServerHandler.cancelStream", cmd.stream().tag());
-    PerfMark.linkIn(cmd.getLink());
-    try {
+    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());
-      // Terminate the stream.
-      encoder().writeRstStream(ctx, cmd.stream().id(), Http2Error.CANCEL.code(), promise);
-    } finally {
-      PerfMark.stopTask("NettyServerHandler.cancelStream", cmd.stream().tag());
+
+      // 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,
@@ -736,13 +877,11 @@ private void forcefulClose(final ChannelHandlerContext ctx, final ForcefulCloseC
       public boolean visit(Http2Stream stream) throws Http2Exception {
         NettyServerStream.TransportState serverStream = serverStream(stream);
         if (serverStream != null) {
-          PerfMark.startTask("NettyServerHandler.forcefulClose", serverStream.tag());
-          PerfMark.linkIn(msg.getLink());
-          try {
+          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());
-          } finally {
-            PerfMark.stopTask("NettyServerHandler.forcefulClose", serverStream.tag());
           }
         }
         stream.close();
@@ -753,6 +892,12 @@ public boolean visit(Http2Stream stream) throws Http2Exception {
 
   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);
@@ -760,10 +905,11 @@ private void respondWithHttpError(
 
     Http2Headers headers = new DefaultHttp2Headers(true, serialized.length / 2)
         .status("" + code)
-        .set(CONTENT_TYPE_HEADER, "text/plain; encoding=utf-8");
+        .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());
@@ -826,6 +972,9 @@ public void onHeadersRead(ChannelHandlerContext ctx,
         keepAliveManager.onDataReceived();
       }
       NettyServerHandler.this.onHeadersRead(ctx, streamId, headers);
+      if (endStream) {
+        NettyServerHandler.this.onDataRead(streamId, Unpooled.EMPTY_BUFFER, 0, endStream);
+      }
     }
 
     @Override
@@ -862,10 +1011,8 @@ public void onPingAckRead(ChannelHandlerContext ctx, long data) throws Http2Exce
       }
       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
@@ -891,16 +1038,14 @@ public void ping() {
       ChannelFuture pingFuture = encoder().writePing(
           ctx, false /* isAck */, KEEPALIVE_PING, ctx.newPromise());
       ctx.flush();
-      if (transportTracer != null) {
-        pingFuture.addListener(new ChannelFutureListener() {
-          @Override
-          public void operationComplete(ChannelFuture future) throws Exception {
-            if (future.isSuccess()) {
-              transportTracer.reportKeepAliveSent();
-            }
+      pingFuture.addListener(new ChannelFutureListener() {
+        @Override
+        public void operationComplete(ChannelFuture future) throws Exception {
+          if (future.isSuccess()) {
+            transportTracer.reportKeepAliveSent();
           }
-        });
-      }
+        }
+      });
     }
 
     @Override
@@ -1045,4 +1190,104 @@ public ChannelFuture writeHeaders(ChannelHandlerContext ctx, int streamId, Http2
           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/NettyServerStream.java b/netty/src/main/java/io/grpc/netty/NettyServerStream.java
index 7452b0ff5bf..836f39ddf19 100644
--- a/netty/src/main/java/io/grpc/netty/NettyServerStream.java
+++ b/netty/src/main/java/io/grpc/netty/NettyServerStream.java
@@ -36,6 +36,7 @@
 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;
 
@@ -51,7 +52,6 @@ class NettyServerStream extends AbstractServerStream {
   private final WriteQueue writeQueue;
   private final Attributes attributes;
   private final String authority;
-  private final TransportTracer transportTracer;
   private final int streamId;
 
   public NettyServerStream(
@@ -59,14 +59,12 @@ public NettyServerStream(
       TransportState state,
       Attributes transportAttrs,
       String authority,
-      StatsTraceContext statsTraceCtx,
-      TransportTracer transportTracer) {
+      StatsTraceContext statsTraceCtx) {
     super(new NettyWritableBufferAllocator(channel.alloc()), statsTraceCtx);
     this.state = checkNotNull(state, "transportState");
     this.writeQueue = state.handler.getWriteQueue();
     this.attributes = checkNotNull(transportAttrs);
     this.authority = authority;
-    this.transportTracer = checkNotNull(transportTracer, "transportTracer");
     // Read the id early to avoid reading transportState later.
     this.streamId = transportState().id();
   }
@@ -93,78 +91,51 @@ public String getAuthority() {
 
   private class Sink implements AbstractServerStream.Sink {
     @Override
-    public void writeHeaders(Metadata headers) {
-      PerfMark.startTask("NettyServerStream$Sink.writeHeaders");
-      try {
-        writeQueue.enqueue(
-            SendResponseHeadersCommand.createHeaders(
-                transportState(),
-                Utils.convertServerHeaders(headers)),
-            true);
-      } finally {
-        PerfMark.stopTask("NettyServerStream$Sink.writeHeaders");
+    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);
       }
     }
 
-    private void writeFrameInternal(WritableBuffer frame, boolean flush, final int numMessages) {
-      Preconditions.checkArgument(numMessages >= 0);
-      if (frame == null) {
-        writeQueue.scheduleFlush();
-        return;
-      }
-      ByteBuf bytebuf = ((NettyWritableBuffer) frame).bytebuf().touch();
-      final int numBytes = bytebuf.readableBytes();
-      // Add the bytes to outbound flow control.
-      onSendingBytes(numBytes);
-      writeQueue.enqueue(new SendGrpcFrameCommand(transportState(), bytebuf, false), flush)
-          .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);
-              if (future.isSuccess()) {
-                transportTracer.reportMessageSent(numMessages);
-              }
-            }
-          });
-    }
-
     @Override
     public void writeFrame(WritableBuffer frame, boolean flush, final int numMessages) {
-      PerfMark.startTask("NettyServerStream$Sink.writeFrame");
-      try {
-        writeFrameInternal(frame, flush, numMessages);
-      } finally {
-        PerfMark.stopTask("NettyServerStream$Sink.writeFrame");
+      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);
       }
     }
 
     @Override
     public void writeTrailers(Metadata trailers, boolean headersSent, Status status) {
-      PerfMark.startTask("NettyServerStream$Sink.writeTrailers");
-      try {
+      try (TaskCloseable ignore = PerfMark.traceTask("NettyServerStream$Sink.writeTrailers")) {
         Http2Headers http2Trailers = Utils.convertTrailers(trailers, headersSent);
-        writeQueue.enqueue(
-            SendResponseHeadersCommand.createTrailers(transportState(), http2Trailers, status),
-            true);
-      } finally {
-        PerfMark.stopTask("NettyServerStream$Sink.writeTrailers");
+        SendResponseHeadersCommand trailersCommand =
+            SendResponseHeadersCommand.createTrailers(transportState(), http2Trailers, status);
+        writeQueue.enqueue(trailersCommand, true)
+            .addListener((ChannelFutureListener) transportState()::handleWriteFutureFailures);
       }
     }
 
     @Override
     public void cancel(Status status) {
-      PerfMark.startTask("NettyServerStream$Sink.cancel");
-      try {
-        writeQueue.enqueue(new CancelServerStreamCommand(transportState(), status), true);
-      } finally {
-        PerfMark.startTask("NettyServerStream$Sink.cancel");
+      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;
@@ -196,12 +167,11 @@ public void runOnTransportThread(final Runnable r) {
         eventLoop.execute(new Runnable() {
           @Override
           public void run() {
-            PerfMark.startTask("NettyServerStream$TransportState.runOnTransportThread", tag);
-            PerfMark.linkIn(link);
-            try {
+            try (TaskCloseable ignore =
+                     PerfMark.traceTask("NettyServerStream$TransportState.runOnTransportThread")) {
+              PerfMark.attachTag(tag);
+              PerfMark.linkIn(link);
               r.run();
-            } finally {
-              PerfMark.stopTask("NettyServerStream$TransportState.runOnTransportThread", tag);
             }
           }
         });
@@ -219,7 +189,40 @@ 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) {
diff --git a/netty/src/main/java/io/grpc/netty/NettyServerTransport.java b/netty/src/main/java/io/grpc/netty/NettyServerTransport.java
index 46ddeb27c93..c0e52b75876 100644
--- a/netty/src/main/java/io/grpc/netty/NettyServerTransport.java
+++ b/netty/src/main/java/io/grpc/netty/NettyServerTransport.java
@@ -25,6 +25,7 @@
 import io.grpc.Attributes;
 import io.grpc.InternalChannelz.SocketStats;
 import io.grpc.InternalLogId;
+import io.grpc.MetricRecorder;
 import io.grpc.ServerStreamTracer;
 import io.grpc.Status;
 import io.grpc.internal.ServerTransport;
@@ -70,6 +71,7 @@ class NettyServerTransport implements ServerTransport {
   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;
@@ -77,7 +79,10 @@ class NettyServerTransport implements ServerTransport {
   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 MetricRecorder metricRecorder;
   private final List<? extends ServerStreamTracer.Factory> streamTracerFactories;
   private final TransportTracer transportTracer;
 
@@ -92,6 +97,7 @@ class NettyServerTransport implements ServerTransport {
       int flowControlWindow,
       int maxMessageSize,
       int maxHeaderListSize,
+      int softLimitHeaderListSize,
       long keepAliveTimeInNanos,
       long keepAliveTimeoutInNanos,
       long maxConnectionIdleInNanos,
@@ -99,7 +105,10 @@ class NettyServerTransport implements ServerTransport {
       long maxConnectionAgeGraceInNanos,
       boolean permitKeepAliveWithoutCalls,
       long permitKeepAliveTimeInNanos,
-      Attributes eagAttributes) {
+      int maxRstCount,
+      long maxRstPeriodNanos,
+      Attributes eagAttributes,
+      MetricRecorder metricRecorder) {
     this.channel = Preconditions.checkNotNull(channel, "channel");
     this.channelUnused = channelUnused;
     this.protocolNegotiator = Preconditions.checkNotNull(protocolNegotiator, "protocolNegotiator");
@@ -111,6 +120,7 @@ class NettyServerTransport implements ServerTransport {
     this.flowControlWindow = flowControlWindow;
     this.maxMessageSize = maxMessageSize;
     this.maxHeaderListSize = maxHeaderListSize;
+    this.softLimitHeaderListSize = softLimitHeaderListSize;
     this.keepAliveTimeInNanos = keepAliveTimeInNanos;
     this.keepAliveTimeoutInNanos = keepAliveTimeoutInNanos;
     this.maxConnectionIdleInNanos = maxConnectionIdleInNanos;
@@ -118,7 +128,10 @@ class NettyServerTransport implements ServerTransport {
     this.maxConnectionAgeGraceInNanos = maxConnectionAgeGraceInNanos;
     this.permitKeepAliveWithoutCalls = permitKeepAliveWithoutCalls;
     this.permitKeepAliveTimeInNanos = permitKeepAliveTimeInNanos;
+    this.maxRstCount = maxRstCount;
+    this.maxRstPeriodNanos = maxRstPeriodNanos;
     this.eagAttributes = Preconditions.checkNotNull(eagAttributes, "eagAttributes");
+    this.metricRecorder = metricRecorder;
     SocketAddress remote = channel.remoteAddress();
     this.logId = InternalLogId.allocate(getClass(), remote != null ? remote.toString() : null);
   }
@@ -269,6 +282,7 @@ private NettyServerHandler createHandler(
         autoFlowControl,
         flowControlWindow,
         maxHeaderListSize,
+        softLimitHeaderListSize,
         maxMessageSize,
         keepAliveTimeInNanos,
         keepAliveTimeoutInNanos,
@@ -277,6 +291,9 @@ private NettyServerHandler createHandler(
         maxConnectionAgeGraceInNanos,
         permitKeepAliveWithoutCalls,
         permitKeepAliveTimeInNanos,
-        eagAttributes);
+        maxRstCount,
+        maxRstPeriodNanos,
+        eagAttributes,
+        metricRecorder);
   }
 }
diff --git a/netty/src/main/java/io/grpc/netty/NettySslContextChannelCredentials.java b/netty/src/main/java/io/grpc/netty/NettySslContextChannelCredentials.java
index ede511b68f6..3d3fdc67e8e 100644
--- a/netty/src/main/java/io/grpc/netty/NettySslContextChannelCredentials.java
+++ b/netty/src/main/java/io/grpc/netty/NettySslContextChannelCredentials.java
@@ -34,6 +34,6 @@ 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));
+    return NettyChannelCredentials.create(ProtocolNegotiators.tlsClientFactory(sslContext, null));
   }
 }
diff --git a/netty/src/main/java/io/grpc/netty/NettyWritableBufferAllocator.java b/netty/src/main/java/io/grpc/netty/NettyWritableBufferAllocator.java
index 9e93ee1155c..40b84717160 100644
--- a/netty/src/main/java/io/grpc/netty/NettyWritableBufferAllocator.java
+++ b/netty/src/main/java/io/grpc/netty/NettyWritableBufferAllocator.java
@@ -33,9 +33,6 @@
  */
 class NettyWritableBufferAllocator implements WritableBufferAllocator {
 
-  // Use 4k as our minimum buffer size.
-  private static final int MIN_BUFFER = 4 * 1024;
-
   // Set the maximum buffer size to 1MB.
   private static final int MAX_BUFFER = 1024 * 1024;
 
@@ -47,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
index 16da79e1af8..8103a2dc79f 100644
--- a/netty/src/main/java/io/grpc/netty/ProtocolNegotiationEvent.java
+++ b/netty/src/main/java/io/grpc/netty/ProtocolNegotiationEvent.java
@@ -20,10 +20,10 @@
 
 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.CheckReturnValue;
 import javax.annotation.Nullable;
 
 /**
diff --git a/netty/src/main/java/io/grpc/netty/ProtocolNegotiator.java b/netty/src/main/java/io/grpc/netty/ProtocolNegotiator.java
index 8a2c6f104b2..4332fdf2919 100644
--- a/netty/src/main/java/io/grpc/netty/ProtocolNegotiator.java
+++ b/netty/src/main/java/io/grpc/netty/ProtocolNegotiator.java
@@ -63,4 +63,5 @@ interface ServerFactory {
      */
     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 ce30b2402b6..8faf3d0fae8 100644
--- a/netty/src/main/java/io/grpc/netty/ProtocolNegotiators.java
+++ b/netty/src/main/java/io/grpc/netty/ProtocolNegotiators.java
@@ -16,10 +16,10 @@
 
 package io.grpc.netty;
 
-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.Optional;
 import com.google.common.base.Preconditions;
 import com.google.errorprone.annotations.ForOverride;
 import io.grpc.Attributes;
@@ -41,18 +41,22 @@
 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.ChannelHandlerContext;
 import io.netty.channel.ChannelInboundHandlerAdapter;
+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;
@@ -66,14 +70,16 @@
 import io.netty.handler.ssl.SslHandshakeCompletionEvent;
 import io.netty.handler.ssl.SslProvider;
 import io.netty.util.AsciiString;
-import io.netty.util.Attribute;
-import io.netty.util.AttributeMap;
 import java.io.ByteArrayInputStream;
 import java.net.SocketAddress;
 import java.net.URI;
 import java.nio.channels.ClosedChannelException;
+import java.security.GeneralSecurityException;
+import java.security.KeyStore;
 import java.util.Arrays;
 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;
@@ -83,6 +89,10 @@
 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.
@@ -96,7 +106,6 @@ final class ProtocolNegotiators {
       EnumSet.of(
           TlsServerCredentials.Feature.MTLS, TlsServerCredentials.Feature.CUSTOM_MANAGERS);
 
-
   private ProtocolNegotiators() {
   }
 
@@ -118,14 +127,25 @@ public static FromChannelCredentialsResult from(ChannelCredentials creds) {
             new ByteArrayInputStream(tlsCreds.getPrivateKey()),
             tlsCreds.getPrivateKeyPassword());
       }
-      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
       try {
-        return FromChannelCredentialsResult.negotiator(tlsClientFactory(builder.build()));
-      } catch (SSLException ex) {
+        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());
@@ -162,41 +182,6 @@ public static FromChannelCredentialsResult from(ChannelCredentials creds) {
     }
   }
 
-  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 FromServerCredentialsResult from(ServerCredentials creds) {
     if (creds instanceof TlsServerCredentials) {
       TlsServerCredentials tlsCreds = (TlsServerCredentials) creds;
@@ -275,45 +260,57 @@ public static FromServerCredentialsResult from(ServerCredentials creds) {
     }
   }
 
-  public static final class FromServerCredentialsResult {
-    public final ProtocolNegotiator.ServerFactory negotiator;
+  public static final class FromChannelCredentialsResult {
+    public final ProtocolNegotiator.ClientFactory negotiator;
+    public final CallCredentials callCredentials;
     public final String error;
 
-    private FromServerCredentialsResult(ProtocolNegotiator.ServerFactory negotiator, String error) {
+    private FromChannelCredentialsResult(ProtocolNegotiator.ClientFactory negotiator,
+        CallCredentials creds, String error) {
       this.negotiator = negotiator;
+      this.callCredentials = creds;
       this.error = error;
     }
 
-    public static FromServerCredentialsResult error(String error) {
-      return new FromServerCredentialsResult(null, Preconditions.checkNotNull(error, "error"));
+    public static FromChannelCredentialsResult error(String error) {
+      return new FromChannelCredentialsResult(
+          null, null, Preconditions.checkNotNull(error, "error"));
     }
 
-    public static FromServerCredentialsResult negotiator(ProtocolNegotiator.ServerFactory factory) {
-      return new FromServerCredentialsResult(Preconditions.checkNotNull(factory, "factory"), null);
+    public static FromChannelCredentialsResult negotiator(
+        ProtocolNegotiator.ClientFactory factory) {
+      return new FromChannelCredentialsResult(
+          Preconditions.checkNotNull(factory, "factory"), null, null);
     }
-  }
 
-  static ChannelLogger negotiationLogger(ChannelHandlerContext ctx) {
-    return negotiationLogger(ctx.channel());
+    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);
+    }
   }
 
-  private static ChannelLogger negotiationLogger(AttributeMap attributeMap) {
-    Attribute<ChannelLogger> attr = attributeMap.attr(NettyClientTransport.LOGGER_KEY);
-    final ChannelLogger channelLogger = attr.get();
-    if (channelLogger != null) {
-      return  channelLogger;
-    }
-    // This is only for tests where there may not be a valid logger.
-    final class NoopChannelLogger extends ChannelLogger {
+  public static final class FromServerCredentialsResult {
+    public final ProtocolNegotiator.ServerFactory negotiator;
+    public final String error;
 
-      @Override
-      public void log(ChannelLogLevel level, String message) {}
+    private FromServerCredentialsResult(ProtocolNegotiator.ServerFactory negotiator, String error) {
+      this.negotiator = negotiator;
+      this.error = error;
+    }
 
-      @Override
-      public void log(ChannelLogLevel level, String messageFormat, Object... args) {}
+    public static FromServerCredentialsResult error(String error) {
+      return new FromServerCredentialsResult(null, Preconditions.checkNotNull(error, "error"));
     }
 
-    return new NoopChannelLogger();
+    public static FromServerCredentialsResult negotiator(ProtocolNegotiator.ServerFactory factory) {
+      return new FromServerCredentialsResult(Preconditions.checkNotNull(factory, "factory"), null);
+    }
   }
 
   public static ProtocolNegotiator.ServerFactory fixedServerFactory(
@@ -400,7 +397,7 @@ public static ProtocolNegotiator serverTls(final SslContext sslContext,
       public ChannelHandler newHandler(GrpcHttp2ConnectionHandler handler) {
         ChannelHandler gnh = new GrpcNegotiationHandler(handler);
         ChannelHandler sth = new ServerTlsHandler(gnh, sslContext, executorPool);
-        return new WaitUntilActiveHandler(sth);
+        return new WaitUntilActiveHandler(sth, handler.getNegotiationLogger());
       }
 
       @Override
@@ -434,8 +431,8 @@ static final class ServerTlsHandler extends ChannelInboundHandlerAdapter {
     ServerTlsHandler(ChannelHandler next,
         SslContext sslContext,
         final ObjectPool<? extends Executor> executorPool) {
-      this.sslContext = checkNotNull(sslContext, "sslContext");
-      this.next = checkNotNull(next, "next");
+      this.sslContext = Preconditions.checkNotNull(sslContext, "sslContext");
+      this.next = Preconditions.checkNotNull(next, "next");
       if (executorPool != null) {
         this.executor = executorPool.getObject();
       }
@@ -490,17 +487,21 @@ private void fireProtocolNegotiationEvent(ChannelHandlerContext ctx, SSLSession
    * 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) {
-    checkNotNull(negotiator, "negotiator");
-    checkNotNull(proxyAddress, "proxyAddress");
+    Preconditions.checkNotNull(negotiator, "negotiator");
+    Preconditions.checkNotNull(proxyAddress, "proxyAddress");
     final AsciiString scheme = negotiator.scheme();
     class ProxyNegotiator implements ProtocolNegotiator {
       @Override
       public ChannelHandler newHandler(GrpcHttp2ConnectionHandler http2Handler) {
         ChannelHandler protocolNegotiationHandler = negotiator.newHandler(http2Handler);
+        ChannelLogger negotiationLogger = http2Handler.getNegotiationLogger();
+        HttpHeaders httpHeaders = toHttpHeaders(headers);
         return new ProxyProtocolNegotiationHandler(
-            proxyAddress, proxyUsername, proxyPassword, protocolNegotiationHandler);
+            proxyAddress, httpHeaders, proxyUsername, proxyPassword, protocolNegotiationHandler,
+            negotiationLogger);
       }
 
       @Override
@@ -519,6 +520,22 @@ public void close() {
     return new ProxyNegotiator();
   }
 
+  /**
+   * Converts generic Map of headers to Netty's HttpHeaders.
+   * Returns null if the map is null or empty.
+   */
+  @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
@@ -527,16 +544,20 @@ public void close() {
   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) {
-      super(next);
-      this.address = checkNotNull(address, "address");
+        ChannelHandler next,
+        ChannelLogger negotiationLogger) {
+      super(next, negotiationLogger);
+      this.address = Preconditions.checkNotNull(address, "address");
+      this.httpHeaders = httpHeaders;
       this.userName = userName;
       this.password = password;
     }
@@ -545,9 +566,9 @@ public ProxyProtocolNegotiationHandler(
     protected void protocolNegotiationEventTriggered(ChannelHandlerContext ctx) {
       HttpProxyHandler nettyProxyHandler;
       if (userName == null || password == null) {
-        nettyProxyHandler = new HttpProxyHandler(address);
+        nettyProxyHandler = new HttpProxyHandler(address, httpHeaders);
       } else {
-        nettyProxyHandler = new HttpProxyHandler(address, userName, password);
+        nettyProxyHandler = new HttpProxyHandler(address, userName, password, httpHeaders);
       }
       ctx.pipeline().addBefore(ctx.name(), /* name= */ null, nettyProxyHandler);
     }
@@ -565,16 +586,23 @@ protected void userEventTriggered0(ChannelHandlerContext ctx, Object evt) throws
   static final class ClientTlsProtocolNegotiator implements ProtocolNegotiator {
 
     public ClientTlsProtocolNegotiator(SslContext sslContext,
-        ObjectPool<? extends Executor> executorPool) {
-      this.sslContext = checkNotNull(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
@@ -585,9 +613,19 @@ public AsciiString scheme() {
     @Override
     public ChannelHandler newHandler(GrpcHttp2ConnectionHandler grpcHandler) {
       ChannelHandler gnh = new GrpcNegotiationHandler(grpcHandler);
-      ChannelHandler cth = new ClientTlsHandler(gnh, sslContext, grpcHandler.getAuthority(),
-          this.executor);
-      return new WaitUntilActiveHandler(cth);
+      ChannelLogger negotiationLogger = grpcHandler.getNegotiationLogger();
+      String authority;
+      if ("".equals(sni)) {
+        authority = null;
+      } else if (sni != null) {
+        authority = sni;
+      } else {
+        authority = grpcHandler.getAuthority();
+      }
+      ChannelHandler cth = new ClientTlsHandler(gnh, sslContext,
+          authority, this.executor, negotiationLogger, handshakeCompleteRunnable, this,
+          x509ExtendedTrustManager);
+      return new WaitUntilActiveHandler(cth, negotiationLogger);
     }
 
     @Override
@@ -596,6 +634,11 @@ public void close() {
         this.executorPool.returnObject(this.executor);
       }
     }
+
+    @VisibleForTesting
+    boolean hasX509ExtendedTrustManager() {
+      return x509ExtendedTrustManager != null;
+    }
   }
 
   static final class ClientTlsHandler extends ProtocolNegotiationHandler {
@@ -604,20 +647,38 @@ static final class ClientTlsHandler extends ProtocolNegotiationHandler {
     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) {
-      super(next);
-      this.sslContext = checkNotNull(sslContext, "sslContext");
-      HostPort hostPort = parseAuthority(authority);
-      this.host = hostPort.host;
-      this.port = hostPort.port;
+        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
+    @IgnoreJRERequirement
     protected void handlerAdded0(ChannelHandlerContext ctx) {
-      SSLEngine sslEngine = sslContext.newEngine(ctx.alloc(), host, port);
+      if (host != null) {
+        sslEngine = sslContext.newEngine(ctx.alloc(), host, port);
+      } else {
+        sslEngine = sslContext.newEngine(ctx.alloc());
+      }
       SSLParameters sslParams = sslEngine.getSSLParameters();
       sslParams.setEndpointIdentificationAlgorithm("HTTPS");
       sslEngine.setSSLParameters(sslParams);
@@ -657,6 +718,9 @@ protected void userEventTriggered0(ChannelHandlerContext ctx, Object evt) throws
           }
           ctx.fireExceptionCaught(t);
         }
+        if (handshakeCompleteRunnable.isPresent()) {
+          handshakeCompleteRunnable.get().run();
+        }
       } else {
         super.userEventTriggered0(ctx, evt);
       }
@@ -668,8 +732,13 @@ private void propagateTlsComplete(ChannelHandlerContext ctx, SSLSession session)
       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);
     }
   }
@@ -701,11 +770,14 @@ static HostPort parseAuthority(String authority) {
    * 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) {
-    return new ClientTlsProtocolNegotiator(sslContext, executorPool);
+      ObjectPool<? extends Executor> executorPool, Optional<Runnable> handshakeCompleteRunnable,
+      X509TrustManager x509ExtendedTrustManager, String sni) {
+    return new ClientTlsProtocolNegotiator(sslContext, executorPool, handshakeCompleteRunnable,
+        x509ExtendedTrustManager, sni);
   }
 
   /**
@@ -713,25 +785,30 @@ public static ProtocolNegotiator tls(SslContext sslContext,
    * 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) {
-    return tls(sslContext, null);
+  public static ProtocolNegotiator tls(SslContext sslContext,
+      X509TrustManager x509ExtendedTrustManager) {
+    return tls(sslContext, null, Optional.absent(), x509ExtendedTrustManager, null);
   }
 
-  public static ProtocolNegotiator.ClientFactory tlsClientFactory(SslContext sslContext) {
-    return new TlsProtocolNegotiatorClientFactory(sslContext);
+  public static ProtocolNegotiator.ClientFactory tlsClientFactory(SslContext sslContext,
+      X509TrustManager x509ExtendedTrustManager) {
+    return new TlsProtocolNegotiatorClientFactory(sslContext, x509ExtendedTrustManager);
   }
 
   @VisibleForTesting
   static final class TlsProtocolNegotiatorClientFactory
       implements ProtocolNegotiator.ClientFactory {
     private final SslContext sslContext;
+    private final X509TrustManager x509ExtendedTrustManager;
 
-    public TlsProtocolNegotiatorClientFactory(SslContext sslContext) {
+    public TlsProtocolNegotiatorClientFactory(SslContext sslContext,
+                                              X509TrustManager x509ExtendedTrustManager) {
       this.sslContext = Preconditions.checkNotNull(sslContext, "sslContext");
+      this.x509ExtendedTrustManager = x509ExtendedTrustManager;
     }
 
     @Override public ProtocolNegotiator newNegotiator() {
-      return tls(sslContext);
+      return tls(sslContext, x509ExtendedTrustManager);
     }
 
     @Override public int getDefaultPort() {
@@ -784,7 +861,9 @@ public AsciiString scheme() {
     public ChannelHandler newHandler(GrpcHttp2ConnectionHandler grpcHandler) {
       ChannelHandler upgradeHandler =
           new Http2UpgradeAndGrpcHandler(grpcHandler.getAuthority(), grpcHandler);
-      return new WaitUntilActiveHandler(upgradeHandler);
+      ChannelHandler plaintextHandler =
+          new PlaintextHandler(upgradeHandler, grpcHandler.getNegotiationLogger());
+      return new WaitUntilActiveHandler(plaintextHandler, grpcHandler.getNegotiationLogger());
     }
 
     @Override
@@ -800,17 +879,19 @@ static final class Http2UpgradeAndGrpcHandler extends ChannelInboundHandlerAdapt
 
     private final String authority;
     private final GrpcHttp2ConnectionHandler next;
+    private final ChannelLogger negotiationLogger;
 
     private ProtocolNegotiationEvent pne;
 
     Http2UpgradeAndGrpcHandler(String authority, GrpcHttp2ConnectionHandler next) {
-      this.authority = checkNotNull(authority, "authority");
-      this.next = checkNotNull(next, "next");
+      this.authority = Preconditions.checkNotNull(authority, "authority");
+      this.next = Preconditions.checkNotNull(next, "next");
+      this.negotiationLogger = next.getNegotiationLogger();
     }
 
     @Override
     public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
-      negotiationLogger(ctx).log(ChannelLogLevel.INFO, "Http2Upgrade started");
+      negotiationLogger.log(ChannelLogLevel.INFO, "Http2Upgrade started");
       HttpClientCodec httpClientCodec = new HttpClientCodec();
       ctx.pipeline().addBefore(ctx.name(), null, httpClientCodec);
 
@@ -836,7 +917,7 @@ public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exc
         pne = (ProtocolNegotiationEvent) evt;
       } else if (evt == HttpClientUpgradeHandler.UpgradeEvent.UPGRADE_SUCCESSFUL) {
         checkState(pne != null, "negotiation not yet complete");
-        negotiationLogger(ctx).log(ChannelLogLevel.INFO, "Http2Upgrade finished");
+        negotiationLogger.log(ChannelLogLevel.INFO, "Http2Upgrade finished");
         ctx.pipeline().remove(ctx.name());
         next.handleProtocolNegotiationCompleted(pne.getAttributes(), pne.getSecurity());
       } else if (evt == HttpClientUpgradeHandler.UpgradeEvent.UPGRADE_REJECTED) {
@@ -848,9 +929,9 @@ public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exc
   }
 
   /**
-   * 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 PlaintextProtocolNegotiator();
@@ -928,7 +1009,7 @@ static final class GrpcNegotiationHandler extends ChannelInboundHandlerAdapter {
     private final GrpcHttp2ConnectionHandler next;
 
     public GrpcNegotiationHandler(GrpcHttp2ConnectionHandler next) {
-      this.next = checkNotNull(next, "next");
+      this.next = Preconditions.checkNotNull(next, "next");
     }
 
     @Override
@@ -979,7 +1060,10 @@ static final class PlaintextProtocolNegotiator implements ProtocolNegotiator {
     @Override
     public ChannelHandler newHandler(GrpcHttp2ConnectionHandler grpcHandler) {
       ChannelHandler grpcNegotiationHandler = new GrpcNegotiationHandler(grpcHandler);
-      ChannelHandler activeHandler = new WaitUntilActiveHandler(grpcNegotiationHandler);
+      ChannelHandler plaintextHandler =
+          new PlaintextHandler(grpcNegotiationHandler, grpcHandler.getNegotiationLogger());
+      ChannelHandler activeHandler = new WaitUntilActiveHandler(plaintextHandler,
+          grpcHandler.getNegotiationLogger());
       return activeHandler;
     }
 
@@ -992,6 +1076,22 @@ public AsciiString scheme() {
     }
   }
 
+  static final class PlaintextHandler extends ProtocolNegotiationHandler {
+    PlaintextHandler(ChannelHandler next, ChannelLogger negotiationLogger) {
+      super(next, negotiationLogger);
+    }
+
+    @Override
+    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);
+    }
+  }
+
   /**
    * 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
@@ -1001,8 +1101,8 @@ static final class WaitUntilActiveHandler extends ProtocolNegotiationHandler {
 
     boolean protocolNegotiationEventReceived;
 
-    WaitUntilActiveHandler(ChannelHandler next) {
-      super(next);
+    WaitUntilActiveHandler(ChannelHandler next, ChannelLogger negotiationLogger) {
+      super(next, negotiationLogger);
     }
 
     @Override
@@ -1045,20 +1145,24 @@ 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) {
-      this.next = checkNotNull(next, "next");
+    protected ProtocolNegotiationHandler(ChannelHandler next, String negotiatorName,
+        ChannelLogger negotiationLogger) {
+      this.next = Preconditions.checkNotNull(next, "next");
       this.negotiatorName = negotiatorName;
+      this.negotiationLogger = Preconditions.checkNotNull(negotiationLogger, "negotiationLogger");
     }
 
-    protected ProtocolNegotiationHandler(ChannelHandler next) {
-      this.next = checkNotNull(next, "next");
+    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 final void handlerAdded(ChannelHandlerContext ctx) throws Exception {
-      negotiationLogger(ctx).log(ChannelLogLevel.DEBUG, "{0} started", negotiatorName);
+      negotiationLogger.log(ChannelLogLevel.DEBUG, "{0} started", negotiatorName);
       handlerAdded0(ctx);
     }
 
@@ -1094,14 +1198,52 @@ protected final ProtocolNegotiationEvent getProtocolNegotiationEvent() {
 
     protected final void replaceProtocolNegotiationEvent(ProtocolNegotiationEvent pne) {
       checkState(this.pne != null, "previous protocol negotiation event hasn't triggered");
-      this.pne = checkNotNull(pne);
+      this.pne = Preconditions.checkNotNull(pne);
     }
 
     protected final void fireProtocolNegotiationEvent(ChannelHandlerContext ctx) {
       checkState(pne != null, "previous protocol negotiation event hasn't triggered");
-      negotiationLogger(ctx).log(ChannelLogLevel.INFO, "{0} completed", negotiatorName);
+      negotiationLogger.log(ChannelLogLevel.INFO, "{0} completed", negotiatorName);
       ctx.pipeline().replace(ctx.name(), /* newName= */ null, next);
       ctx.fireUserEventTriggered(pne);
     }
   }
+
+  static final class SslEngineWrapper extends NoopSslEngine {
+    private final SSLEngine sslEngine;
+    private final String peerHost;
+
+    SslEngineWrapper(SSLEngine sslEngine, String peerHost) {
+      this.sslEngine = sslEngine;
+      this.peerHost = peerHost;
+    }
+
+    @Override
+    public String getPeerHost() {
+      return peerHost;
+    }
+
+    @Override
+    public SSLSession getHandshakeSession() {
+      return new FakeSslSession(peerHost);
+    }
+
+    @Override
+    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 4624dc87835..9c2507e3686 100644
--- a/netty/src/main/java/io/grpc/netty/SendGrpcFrameCommand.java
+++ b/netty/src/main/java/io/grpc/netty/SendGrpcFrameCommand.java
@@ -55,37 +55,8 @@ boolean endStream() {
   }
 
   @Override
-  public ByteBufHolder copy() {
-    return new SendGrpcFrameCommand(stream, content().copy(), endStream);
-  }
-
-  @Override
-  public ByteBufHolder duplicate() {
-    return new SendGrpcFrameCommand(stream, content().duplicate(), endStream);
-  }
-
-  @Override
-  public SendGrpcFrameCommand retain() {
-    super.retain();
-    return this;
-  }
-
-  @Override
-  public SendGrpcFrameCommand retain(int increment) {
-    super.retain(increment);
-    return this;
-  }
-
-  @Override
-  public SendGrpcFrameCommand touch() {
-    super.touch();
-    return this;
-  }
-
-  @Override
-  public SendGrpcFrameCommand touch(Object hint) {
-    super.touch(hint);
-    return this;
+  public ByteBufHolder replace(ByteBuf content) {
+    return new SendGrpcFrameCommand(stream, content, endStream);
   }
 
   @Override
diff --git a/netty/src/main/java/io/grpc/netty/TcpMetrics.java b/netty/src/main/java/io/grpc/netty/TcpMetrics.java
new file mode 100644
index 00000000000..c5809a5677e
--- /dev/null
+++ b/netty/src/main/java/io/grpc/netty/TcpMetrics.java
@@ -0,0 +1,227 @@
+/*
+ * 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.netty;
+
+import com.google.common.annotations.VisibleForTesting;
+import io.grpc.InternalTcpMetrics;
+import io.grpc.MetricRecorder;
+import io.netty.channel.Channel;
+import io.netty.util.concurrent.ScheduledFuture;
+import java.lang.reflect.Method;
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.ThreadLocalRandom;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * Utility for collecting TCP metrics from Netty channels.
+ */
+final class TcpMetrics {
+  private static final Logger log = Logger.getLogger(TcpMetrics.class.getName());
+
+  static EpollInfo epollInfo = loadEpollInfo();
+
+  static final class EpollInfo {
+    final Class<?> channelClass;
+    final java.lang.reflect.Constructor<?> infoConstructor;
+    final Method tcpInfo;
+    final Method totalRetrans;
+    final Method retransmits;
+    final Method rtt;
+
+    EpollInfo(
+        Class<?> channelClass,
+        java.lang.reflect.Constructor<?> infoConstructor,
+        Method tcpInfo,
+        Method totalRetrans,
+        Method retransmits,
+        Method rtt) {
+      this.channelClass = channelClass;
+      this.infoConstructor = infoConstructor;
+      this.tcpInfo = tcpInfo;
+      this.totalRetrans = totalRetrans;
+      this.retransmits = retransmits;
+      this.rtt = rtt;
+    }
+  }
+
+  static EpollInfo loadEpollInfo() {
+    boolean epollAvailable = false;
+    try {
+      Class<?> epollClass = Class.forName("io.netty.channel.epoll.Epoll");
+      Method isAvailableMethod = epollClass.getDeclaredMethod("isAvailable");
+      epollAvailable = (Boolean) isAvailableMethod.invoke(null);
+      if (epollAvailable) {
+        Class<?> channelClass = Class.forName("io.netty.channel.epoll.EpollSocketChannel");
+        Class<?> infoClass = Class.forName("io.netty.channel.epoll.EpollTcpInfo");
+        return new EpollInfo(
+            channelClass,
+            infoClass.getDeclaredConstructor(),
+            channelClass.getMethod("tcpInfo", infoClass),
+            infoClass.getMethod("totalRetrans"),
+            infoClass.getMethod("retrans"),
+            infoClass.getMethod("rtt"));
+      }
+    } catch (ReflectiveOperationException e) {
+      log.log(Level.FINE, "Failed to initialize Epoll tcp_info reflection", e);
+    } finally {
+      log.log(Level.INFO, "Epoll available during static init of TcpMetrics:"
+          + "{0}", epollAvailable);
+    }
+    return null;
+  }
+
+  private static final long RECORD_INTERVAL_MILLIS = TimeUnit.MINUTES.toMillis(5);
+  private final MetricRecorder metricRecorder;
+  private final Object tcpInfo;
+  private long lastTotalRetrans = 0;
+  private ScheduledFuture<?> reportTimer;
+
+  TcpMetrics(MetricRecorder metricRecorder) {
+    this.metricRecorder = metricRecorder;
+
+    Object tcpInfo = null;
+    if (epollInfo != null) {
+      try {
+        tcpInfo = epollInfo.infoConstructor.newInstance();
+      } catch (ReflectiveOperationException e) {
+        log.log(Level.FINE, "Failed to instantiate EpollTcpInfo", e);
+      }
+    }
+    this.tcpInfo = tcpInfo;
+  }
+
+  void channelActive(Channel channel) {
+    List<String> labelValues = getLabelValues(channel);
+    metricRecorder.addLongCounter(InternalTcpMetrics.CONNECTIONS_CREATED_INSTRUMENT, 1,
+        Collections.emptyList(), labelValues);
+    metricRecorder.addLongUpDownCounter(InternalTcpMetrics.CONNECTION_COUNT_INSTRUMENT, 1,
+        Collections.emptyList(), labelValues);
+    scheduleNextReport(channel, true);
+  }
+
+  private void scheduleNextReport(final Channel channel, boolean isInitial) {
+    if (epollInfo == null || !epollInfo.channelClass.isInstance(channel) || !channel.isActive()) {
+      return;
+    }
+
+    // Initial report has a larger jitter range to spread out initial connections.
+    // Subsequent reports have a smaller jitter range to avoid drift.
+    double jitter = isInitial
+        ? 0.1 + ThreadLocalRandom.current().nextDouble() // 10% to 110%
+        : 0.9 + ThreadLocalRandom.current().nextDouble() * 0.2; // 90% to 110%
+    long rearmingDelay = (long) (RECORD_INTERVAL_MILLIS * jitter);
+
+    reportTimer = channel.eventLoop().schedule(() -> {
+      if (channel.isActive()) {
+        recordTcpInfo(channel, false);
+        scheduleNextReport(channel, false); // Re-arm
+      }
+    }, rearmingDelay, TimeUnit.MILLISECONDS);
+  }
+
+  void channelInactive(Channel channel) {
+    if (reportTimer != null) {
+      reportTimer.cancel(false);
+    }
+    List<String> labelValues = getLabelValues(channel);
+    metricRecorder.addLongUpDownCounter(InternalTcpMetrics.CONNECTION_COUNT_INSTRUMENT, -1,
+        Collections.emptyList(), labelValues);
+    // Final collection on close
+    if (epollInfo != null && epollInfo.channelClass.isInstance(channel)) {
+      recordTcpInfo(channel, true);
+    }
+  }
+
+  void recordTcpInfo(Channel channel) {
+    recordTcpInfo(channel, false);
+  }
+
+  private void recordTcpInfo(Channel channel, boolean isClose) {
+    if (epollInfo == null || !epollInfo.channelClass.isInstance(channel)) {
+      return;
+    }
+    List<String> labelValues = getLabelValues(channel);
+    long totalRetrans;
+    long retransmits;
+    long rtt;
+    try {
+      epollInfo.tcpInfo.invoke(channel, tcpInfo);
+      totalRetrans = (Long) epollInfo.totalRetrans.invoke(tcpInfo);
+      retransmits = (Long) epollInfo.retransmits.invoke(tcpInfo);
+      rtt = (Long) epollInfo.rtt.invoke(tcpInfo);
+    } catch (ReflectiveOperationException e) {
+      log.log(Level.FINE, "Error computing TCP metrics", e);
+      return;
+    }
+
+    long deltaTotal = totalRetrans - lastTotalRetrans;
+    if (deltaTotal > 0) {
+      metricRecorder.addLongCounter(InternalTcpMetrics.PACKETS_RETRANSMITTED_INSTRUMENT,
+          deltaTotal, Collections.emptyList(), labelValues);
+      lastTotalRetrans = totalRetrans;
+    }
+    if (isClose && retransmits > 0) {
+      metricRecorder.addLongCounter(InternalTcpMetrics.RECURRING_RETRANSMITS_INSTRUMENT,
+          retransmits, Collections.emptyList(), labelValues);
+    }
+    metricRecorder.recordDoubleHistogram(InternalTcpMetrics.MIN_RTT_INSTRUMENT,
+        rtt / 1000000.0, // Convert microseconds to seconds
+        Collections.emptyList(), labelValues);
+  }
+
+  @VisibleForTesting
+  ScheduledFuture<?> getReportTimer() {
+    return reportTimer;
+  }
+
+  private static List<String> getLabelValues(Channel channel) {
+    String localAddress = "";
+    String localPort = "";
+    String peerAddress = "";
+    String peerPort = "";
+
+    SocketAddress local = channel.localAddress();
+    if (local instanceof InetSocketAddress) {
+      InetSocketAddress inetLocal = (InetSocketAddress) local;
+      if (inetLocal.getAddress() != null) {
+        localAddress = inetLocal.getAddress().getHostAddress();
+      } else if (inetLocal.getHostString() != null) {
+        localAddress = inetLocal.getHostString();
+      }
+      localPort = String.valueOf(inetLocal.getPort());
+    }
+
+    SocketAddress remote = channel.remoteAddress();
+    if (remote instanceof InetSocketAddress) {
+      InetSocketAddress inetRemote = (InetSocketAddress) remote;
+      if (inetRemote.getAddress() != null) {
+        peerAddress = inetRemote.getAddress().getHostAddress();
+      } else if (inetRemote.getHostString() != null) {
+        peerAddress = inetRemote.getHostString();
+      }
+      peerPort = String.valueOf(inetRemote.getPort());
+    }
+
+    return Arrays.asList(localAddress, localPort, peerAddress, peerPort);
+  }
+}
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..3477a458933
--- /dev/null
+++ b/netty/src/main/java/io/grpc/netty/UdsNameResolver.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.netty;
+
+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.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;
+
+  /**
+   * Constructs a new instance of UdsNameResolver.
+   *
+   * @param authority authority of the 'unix:' URI to resolve, or null if target has no authority
+   * @param targetPath path of the 'unix:' URI to resolve
+   */
+  UdsNameResolver(String authority, String targetPath, Args args) {
+    // UDS is inherently local. According to https://github.com/grpc/grpc/blob/master/doc/naming.md,
+    // this is expressed in the target URI either by using a blank authority, like "unix:///sock",
+    // or by omitting authority completely, e.g. "unix:/sock".
+    // TODO(jdcormie): Allow the explicit authority string "localhost"?
+    checkArgument(isNullOrEmpty(authority), "authority not supported: %s", authority);
+    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..baf18e3d7de
--- /dev/null
+++ b/netty/src/main/java/io/grpc/netty/UdsNameResolverProvider.java
@@ -0,0 +1,88 @@
+/*
+ * 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.grpc.Uri;
+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 NameResolver newNameResolver(Uri targetUri, NameResolver.Args args) {
+    if (SCHEME.equals(targetUri.getScheme())) {
+      return new UdsNameResolver(targetUri.getAuthority(), targetUri.getPath(), args);
+    } else {
+      return null;
+    }
+  }
+
+  @Override
+  public UdsNameResolver newNameResolver(URI targetUri, NameResolver.Args args) {
+    if (SCHEME.equals(targetUri.getScheme())) {
+      // TODO(jdcormie): java.net.URI has a bug where getAuthority() returns null for both the
+      // undefined and zero-length authority. Doesn't matter for now because UdsNameResolver doesn't
+      // distinguish these cases.
+      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) {
+      // TODO(jdcormie): This incorrectly includes '?' and any characters that follow. In the
+      // hierarchical case ('unix:///path'), java.net.URI parses these into a query component that's
+      // distinct from the path. But in the present "opaque" case ('unix:/path'), what may look like
+      // a query is considered part of the SSP.
+      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/Utils.java b/netty/src/main/java/io/grpc/netty/Utils.java
index 082ce63dd54..386df20ba0b 100644
--- a/netty/src/main/java/io/grpc/netty/Utils.java
+++ b/netty/src/main/java/io/grpc/netty/Utils.java
@@ -23,19 +23,23 @@
 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.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;
@@ -47,8 +51,11 @@
 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;
@@ -56,12 +63,12 @@
 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.CheckReturnValue;
 import javax.annotation.Nullable;
 import javax.net.ssl.SSLException;
 
@@ -85,6 +92,9 @@ class Utils {
       = 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;
 
@@ -100,6 +110,7 @@ private static final class ByteBufAllocatorPreferHeapHolder {
 
   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;
 
   @Nullable
   private static final Constructor<? extends EventLoopGroup> EPOLL_EVENT_LOOP_GROUP_CONSTRUCTOR;
@@ -108,16 +119,18 @@ private static final class ByteBufAllocatorPreferHeapHolder {
     // 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);
+      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;
@@ -127,13 +140,18 @@ private static final class ByteBufAllocatorPreferHeapHolder {
   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,
-          String.format(
-              "Using custom allocator: forceHeapBuffer=%s, defaultPreferDirect=%s",
-              forceHeapBuffer,
-              defaultPreferDirect));
+          "Using custom allocator: forceHeapBuffer={0}, defaultPreferDirect={1}",
+          new Object[] { forceHeapBuffer, defaultPreferDirect });
       if (forceHeapBuffer || !defaultPreferDirect) {
         return ByteBufAllocatorPreferHeapHolder.allocator;
       } else {
@@ -180,6 +198,61 @@ 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
@@ -257,9 +330,16 @@ 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.
+      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
@@ -322,6 +402,17 @@ private static Class<? extends Channel> epollChannelType() {
     }
   }
 
+  // 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 {
@@ -441,6 +532,28 @@ 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();
diff --git a/netty/src/main/java/io/grpc/netty/WriteBufferingAndExceptionHandler.java b/netty/src/main/java/io/grpc/netty/WriteBufferingAndExceptionHandler.java
index 9521fc93889..2799dfccb61 100644
--- a/netty/src/main/java/io/grpc/netty/WriteBufferingAndExceptionHandler.java
+++ b/netty/src/main/java/io/grpc/netty/WriteBufferingAndExceptionHandler.java
@@ -124,6 +124,8 @@ public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise)
       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();
@@ -182,7 +184,7 @@ public void channelRead(ChannelHandlerContext ctx, Object msg) {
    */
   @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"
diff --git a/netty/src/main/java/io/grpc/netty/WriteQueue.java b/netty/src/main/java/io/grpc/netty/WriteQueue.java
index f80e3fcaa5b..a96b7defac8 100644
--- a/netty/src/main/java/io/grpc/netty/WriteQueue.java
+++ b/netty/src/main/java/io/grpc/netty/WriteQueue.java
@@ -24,6 +24,7 @@
 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;
@@ -119,8 +120,7 @@ void drainNow() {
    * called in the event loop
    */
   private void flush() {
-    PerfMark.startTask("WriteQueue.periodicFlush");
-    try {
+    try (TaskCloseable ignore = PerfMark.traceTask("WriteQueue.periodicFlush")) {
       QueuedCommand cmd;
       int i = 0;
       boolean flushedOnce = false;
@@ -131,26 +131,19 @@ private void flush() {
           // 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.
-          PerfMark.startTask("WriteQueue.flush0");
-          try {
+          try (TaskCloseable ignore2 = PerfMark.traceTask("WriteQueue.flush0")) {
             channel.flush();
-          } finally {
-            PerfMark.stopTask("WriteQueue.flush0");
           }
           flushedOnce = true;
         }
       }
       // Must flush at least once, even if there were no writes.
       if (i != 0 || !flushedOnce) {
-        PerfMark.startTask("WriteQueue.flush1");
-        try {
+        try (TaskCloseable ignore2 = PerfMark.traceTask("WriteQueue.flush1")) {
           channel.flush();
-        } finally {
-          PerfMark.stopTask("WriteQueue.flush1");
         }
       }
     } finally {
-      PerfMark.stopTask("WriteQueue.periodicFlush");
       // Mark the write as done, if the queue is non-empty after marking trigger a new write.
       scheduled.set(false);
       if (!queue.isEmpty()) {
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 54595b38573..d1d7b87cf51 100644
--- a/netty/src/main/java/io/grpc/netty/package-info.java
+++ b/netty/src/main/java/io/grpc/netty/package-info.java
@@ -18,5 +18,5 @@
  * 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/AdvancedTlsTest.java b/netty/src/test/java/io/grpc/netty/AdvancedTlsTest.java
new file mode 100644
index 00000000000..66591cda153
--- /dev/null
+++ b/netty/src/test/java/io/grpc/netty/AdvancedTlsTest.java
@@ -0,0 +1,522 @@
+/*
+ * 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() throws Exception {
+    AdvancedTlsX509KeyManager km = new AdvancedTlsX509KeyManager();
+    km.updateIdentityCredentials(serverCert0, serverKey0);
+    assertArrayEquals(new String[] {"key-1"}, km.getClientAliases("", null));
+    assertEquals("key-1", km.chooseClientAlias(new String[] {"key-1"}, null, null));
+    assertArrayEquals(new String[] {"key-1"}, km.getServerAliases("", null));
+    assertEquals("key-1", km.chooseServerAlias("key-1", 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/GrpcHttp2HeadersUtilsTest.java b/netty/src/test/java/io/grpc/netty/GrpcHttp2HeadersUtilsTest.java
index 9336035f897..653b44a9d2d 100644
--- a/netty/src/test/java/io/grpc/netty/GrpcHttp2HeadersUtilsTest.java
+++ b/netty/src/test/java/io/grpc/netty/GrpcHttp2HeadersUtilsTest.java
@@ -16,13 +16,13 @@
 
 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.hamcrest.CoreMatchers.containsString;
-import static org.hamcrest.MatcherAssert.assertThat;
 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;
@@ -42,6 +42,8 @@
 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;
@@ -131,7 +133,131 @@ public void decode_emptyHeaders() throws Http2Exception {
 
     Http2Headers decodedHeaders = decoder.decodeHeaders(3 /* randomly chosen */, encodedHeaders);
     assertEquals(0, decodedHeaders.size());
-    assertThat(decodedHeaders.toString(), containsString("[]"));
+    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
@@ -156,8 +282,101 @@ public void dupBinHeadersWithComma() {
         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, containsString(key.toString()));
-    assertThat(str, containsString(value.toString()));
+    assertThat(str).contains(key.toString());
+    assertThat(str).contains(value.toString());
   }
 }
diff --git a/netty/src/test/java/io/grpc/netty/MaxConnectionIdleManagerTest.java b/netty/src/test/java/io/grpc/netty/MaxConnectionIdleManagerTest.java
deleted file mode 100644
index d2ae98980d0..00000000000
--- a/netty/src/test/java/io/grpc/netty/MaxConnectionIdleManagerTest.java
+++ /dev/null
@@ -1,113 +0,0 @@
-/*
- * 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 org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.spy;
-import static org.mockito.Mockito.verify;
-
-import io.grpc.internal.FakeClock;
-import io.grpc.netty.MaxConnectionIdleManager.Ticker;
-import io.netty.channel.ChannelHandlerContext;
-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 MaxConnectionIdleManager}. */
-@RunWith(JUnit4.class)
-public class MaxConnectionIdleManagerTest {
-  private final FakeClock fakeClock = new FakeClock();
-  private final Ticker ticker = new Ticker() {
-    @Override
-    public long nanoTime() {
-      return fakeClock.getTicker().read();
-    }
-  };
-
-  @Mock
-  private ChannelHandlerContext ctx;
-
-  @Before
-  public void setUp() {
-    MockitoAnnotations.initMocks(this);
-  }
-
-  @Test
-  public void maxIdleReached() {
-    MaxConnectionIdleManager maxConnectionIdleManager =
-        spy(new TestMaxConnectionIdleManager(123L, ticker));
-
-    maxConnectionIdleManager.start(ctx, fakeClock.getScheduledExecutorService());
-    maxConnectionIdleManager.onTransportIdle();
-    fakeClock.forwardNanos(123L);
-
-    verify(maxConnectionIdleManager).close(eq(ctx));
-  }
-
-  @Test
-  public void maxIdleNotReachedAndReached() {
-    MaxConnectionIdleManager maxConnectionIdleManager =
-        spy(new TestMaxConnectionIdleManager(123L, ticker));
-
-    maxConnectionIdleManager.start(ctx, 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(maxConnectionIdleManager, never()).close(any(ChannelHandlerContext.class));
-
-    // max idle reached
-    maxConnectionIdleManager.onTransportIdle();
-    fakeClock.forwardNanos(123L);
-
-    verify(maxConnectionIdleManager).close(eq(ctx));
-  }
-
-  @Test
-  public void shutdownThenMaxIdleReached() {
-    MaxConnectionIdleManager maxConnectionIdleManager =
-        spy(new TestMaxConnectionIdleManager(123L, ticker));
-
-    maxConnectionIdleManager.start(ctx, fakeClock.getScheduledExecutorService());
-    maxConnectionIdleManager.onTransportIdle();
-    maxConnectionIdleManager.onTransportTermination();
-    fakeClock.forwardNanos(123L);
-
-    verify(maxConnectionIdleManager, never()).close(any(ChannelHandlerContext.class));
-  }
-
-  private static class TestMaxConnectionIdleManager extends MaxConnectionIdleManager {
-    TestMaxConnectionIdleManager(long maxConnectionIdleInNanos, Ticker ticker) {
-      super(maxConnectionIdleInNanos, ticker);
-    }
-
-    @Override
-    void close(ChannelHandlerContext ctx) {
-    }
-  }
-}
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 b255923abc7..95d54d13b82 100644
--- a/netty/src/test/java/io/grpc/netty/NettyChannelBuilderTest.java
+++ b/netty/src/test/java/io/grpc/netty/NettyChannelBuilderTest.java
@@ -19,10 +19,12 @@
 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.ChannelCredentials;
+import io.grpc.InsecureChannelCredentials;
 import io.grpc.ManagedChannel;
 import io.grpc.internal.ClientTransportFactory;
 import io.grpc.internal.ClientTransportFactory.SwapChannelCredentialsResult;
@@ -31,23 +33,20 @@
 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 {
 
-  @SuppressWarnings("deprecation") // https://github.com/grpc/grpc-java/issues/7467
-  @Rule public final ExpectedException thrown = ExpectedException.none();
   private final SslContext noSslContext = null;
 
   private void shutdown(ManagedChannel mc) throws Exception {
@@ -79,9 +78,14 @@ public void overrideAuthorityIsReadableForTarget() throws Exception {
     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(new SocketAddress(){});
+    NettyChannelBuilder builder = NettyChannelBuilder.forAddress(
+        getTestSocketAddress());
     overrideAuthorityIsReadableHelper(builder, "override:5678");
   }
 
@@ -98,17 +102,16 @@ private void overrideAuthorityIsReadableHelper(NettyChannelBuilder builder,
 
   @Test
   public void failOverrideInvalidAuthority() {
-    NettyChannelBuilder builder = new NettyChannelBuilder(new SocketAddress(){});
+    NettyChannelBuilder builder = new NettyChannelBuilder(getTestSocketAddress());
 
-    thrown.expect(IllegalArgumentException.class);
-    thrown.expectMessage("Invalid authority:");
-
-    builder.overrideAuthority("[invalidauthority");
+    IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
+        () -> builder.overrideAuthority("[invalidauthority"));
+    assertThat(e).hasMessageThat().isEqualTo("Invalid authority: [invalidauthority");
   }
 
   @Test
   public void disableCheckAuthorityAllowsInvalidAuthority() {
-    NettyChannelBuilder builder = new NettyChannelBuilder(new SocketAddress(){})
+    NettyChannelBuilder builder = new NettyChannelBuilder(getTestSocketAddress())
         .disableCheckAuthority();
 
     Object unused = builder.overrideAuthority("[invalidauthority")
@@ -118,39 +121,60 @@ public void disableCheckAuthorityAllowsInvalidAuthority() {
 
   @Test
   public void enableCheckAuthorityFailOverrideInvalidAuthority() {
-    NettyChannelBuilder builder = new NettyChannelBuilder(new SocketAddress(){})
+    NettyChannelBuilder builder = new NettyChannelBuilder(getTestSocketAddress())
         .disableCheckAuthority()
         .enableCheckAuthority();
-
-    thrown.expect(IllegalArgumentException.class);
-    thrown.expectMessage("Invalid authority:");
-    builder.overrideAuthority("[invalidauthority");
+    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");
-
-    Object unused =
-        NettyChannelBuilder.forAddress(new InetSocketAddress("invalid_authority", 1234));
+    @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() {
     SslContext sslContext = mock(SslContext.class);
-    NettyChannelBuilder builder = new NettyChannelBuilder(new SocketAddress(){});
+    NettyChannelBuilder builder = new NettyChannelBuilder(getTestSocketAddress());
 
-    thrown.expect(IllegalArgumentException.class);
-    thrown.expectMessage("Server SSL context can not be used for client channel");
+    IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
+        () -> builder.sslContext(sslContext));
+    assertThat(e).hasMessageThat()
+        .isEqualTo("Server SSL context can not be used for client channel");
+  }
 
-    builder.sslContext(sslContext);
+  @Test
+  public void failNegotiationTypeWithChannelCredentials_target() {
+    NettyChannelBuilder builder = NettyChannelBuilder.forTarget(
+        "fakeTarget", InsecureChannelCredentials.create());
+
+    IllegalStateException e = assertThrows(IllegalStateException.class,
+        () -> builder.negotiationType(NegotiationType.TLS));
+    assertThat(e).hasMessageThat()
+        .isEqualTo("Cannot change security when using ChannelCredentials");
+  }
+
+  @Test
+  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
@@ -175,10 +199,9 @@ public void createProtocolNegotiatorByType_plaintextUpgrade() {
 
   @Test
   public void createProtocolNegotiatorByType_tlsWithNoContext() {
-    thrown.expect(NullPointerException.class);
-    NettyChannelBuilder.createProtocolNegotiatorByType(
-        NegotiationType.TLS,
-        noSslContext, null);
+    assertThrows(NullPointerException.class,
+        () -> NettyChannelBuilder.createProtocolNegotiatorByType(
+            NegotiationType.TLS, noSslContext, null));
   }
 
   @Test
@@ -215,38 +238,40 @@ public void createProtocolNegotiatorByType_tlsWithAuthorityFallback() throws SSL
   public void negativeKeepAliveTime() {
     NettyChannelBuilder builder = NettyChannelBuilder.forTarget("fakeTarget");
 
-    thrown.expect(IllegalArgumentException.class);
-    thrown.expectMessage("keepalive time must be positive");
-    builder.keepAliveTime(-1L, TimeUnit.HOURS);
+    IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
+        () -> builder.keepAliveTime(-1L, TimeUnit.HOURS));
+    assertThat(e).hasMessageThat().isEqualTo("keepalive time must be positive");
   }
 
   @Test
   public void negativeKeepAliveTimeout() {
     NettyChannelBuilder builder = NettyChannelBuilder.forTarget("fakeTarget");
 
-    thrown.expect(IllegalArgumentException.class);
-    thrown.expectMessage("keepalive timeout must be positive");
-    builder.keepAliveTimeout(-1L, TimeUnit.HOURS);
+    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));
-    thrown.expect(IllegalStateException.class);
-    thrown.expectMessage("Both EventLoopGroup and ChannelType should be provided");
 
-    builder.assertEventLoopAndChannelType();
+    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);
-    thrown.expect(IllegalStateException.class);
-    thrown.expectMessage("Both EventLoopGroup and ChannelType should be provided");
+    builder.channelType(LocalChannel.class, LocalAddress.class);
 
-    builder.assertEventLoopAndChannelType();
+    IllegalStateException e = assertThrows(IllegalStateException.class,
+        builder::assertEventLoopAndChannelType);
+    assertThat(e).hasMessageThat()
+        .isEqualTo("Both EventLoopGroup and ChannelType should be provided or neither should be");
   }
 
   @Test
@@ -258,10 +283,11 @@ public Channel newChannel() {
         return null;
       }
     });
-    thrown.expect(IllegalStateException.class);
-    thrown.expectMessage("Both EventLoopGroup and ChannelType should be provided");
 
-    builder.assertEventLoopAndChannelType();
+    IllegalStateException e = assertThrows(IllegalStateException.class,
+        builder::assertEventLoopAndChannelType);
+    assertThat(e).hasMessageThat()
+        .isEqualTo("Both EventLoopGroup and ChannelType should be provided or neither should be");
   }
 
   @Test
@@ -275,7 +301,7 @@ public void assertEventLoopAndChannelType_usingDefault() {
   public void assertEventLoopAndChannelType_bothProvided() {
     NettyChannelBuilder builder = NettyChannelBuilder.forTarget("fakeTarget");
     builder.eventLoopGroup(mock(EventLoopGroup.class));
-    builder.channelType(LocalChannel.class);
+    builder.channelType(LocalChannel.class, LocalAddress.class);
 
     builder.assertEventLoopAndChannelType();
   }
diff --git a/netty/src/test/java/io/grpc/netty/NettyClientHandlerTest.java b/netty/src/test/java/io/grpc/netty/NettyClientHandlerTest.java
index b708d20931a..9f6be9a2f3e 100644
--- a/netty/src/test/java/io/grpc/netty/NettyClientHandlerTest.java
+++ b/netty/src/test/java/io/grpc/netty/NettyClientHandlerTest.java
@@ -16,8 +16,8 @@
 
 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;
@@ -28,13 +28,14 @@
 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 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.junit.Assert.fail;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.ArgumentMatchers.same;
@@ -46,6 +47,7 @@
 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;
@@ -53,20 +55,25 @@
 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.MetricRecorder;
 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.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;
@@ -85,10 +92,12 @@
 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;
@@ -103,8 +112,9 @@
 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;
 
 /**
@@ -117,7 +127,8 @@ public class NettyClientHandlerTest extends NettyHandlerTestBase<NettyClientHand
   private Http2Headers grpcHeaders;
   private long nanoTime; // backs a ticker, for testing ping round-trip time measurement
   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",
@@ -129,25 +140,44 @@ public class NettyClientHandlerTest extends NettyHandlerTestBase<NettyClientHand
 
   @Rule
   public TestName testNameRule = new TestName();
+  @Rule
+  public final MockitoRule mocks = MockitoJUnit.rule();
   @Mock
   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
@@ -161,9 +191,13 @@ public Void answer(InvocationOnMock invocation) throws Throwable {
               return null;
             }
           })
-      .when(streamListener)
-      .messagesAvailable(ArgumentMatchers.<StreamListener.MessageProducer>any());
-
+        .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.
@@ -191,6 +225,37 @@ public Void answer(InvocationOnMock invocation) throws Throwable {
     // 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
@@ -200,19 +265,19 @@ public void cancelBufferedStreamShouldChangeClientStreamStatus() throws Exceptio
     // Create a new stream with id 3.
     ChannelFuture createFuture = enqueue(
         newCreateStreamCommand(grpcHeaders, streamTransportState));
-    assertEquals(3, streamTransportState.id());
+    assertEquals(STREAM_ID, streamTransportState.id());
     // Cancel the stream.
     cancelStream(Status.CANCELLED);
 
-    assertTrue(createFuture.isSuccess());
+    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
@@ -220,7 +285,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
@@ -232,7 +297,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));
   }
 
@@ -247,7 +312,7 @@ public void cancelWhileBufferedShouldSucceed() throws Exception {
     ChannelFuture cancelFuture = cancelStream(Status.CANCELLED);
     assertTrue(cancelFuture.isSuccess());
     assertTrue(createFuture.isDone());
-    assertTrue(createFuture.isSuccess());
+    assertFalse(createFuture.isSuccess());
   }
 
   /**
@@ -261,7 +326,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);
@@ -274,7 +339,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);
@@ -286,11 +351,12 @@ public void sendFrameShouldSucceed() throws Exception {
     createStream();
 
     // Send a frame and verify that it was written.
+    ByteBuf content = content();
     ChannelFuture future
-        = enqueue(new SendGrpcFrameCommand(streamTransportState, content(), true));
+        = 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);
@@ -312,7 +378,7 @@ 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());
@@ -322,7 +388,7 @@ public void inboundShouldForwardToStream() throws Exception {
     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);
     InputStream message = streamListenerMessageQueue.poll();
     assertArrayEquals(ByteBufUtil.getBytes(content()), ByteStreams.toByteArray(message));
@@ -331,9 +397,18 @@ public void inboundShouldForwardToStream() throws Exception {
   }
 
   @Test
-  public void receivedGoAwayShouldRefuseLaterStreamId() throws Exception {
+  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));
@@ -344,8 +419,6 @@ public void receivedGoAwayShouldRefuseLaterStreamId() throws Exception {
   public void receivedGoAwayShouldNotAffectEarlyStreamId() throws Exception {
     ChannelFuture future = enqueue(newCreateStreamCommand(grpcHeaders, streamTransportState));
     channelRead(goAwayFrame(streamId));
-    verify(streamListener, never())
-        .closed(any(Status.class), any(Metadata.class));
     verify(streamListener, never())
         .closed(any(Status.class), any(RpcProgress.class), any(Metadata.class));
     assertTrue(future.isDone());
@@ -357,8 +430,6 @@ public void receivedGoAwayShouldNotAffectRacingQueuedStreamId() throws Exception
     ChannelFuture future = writeQueue().enqueue(
         newCreateStreamCommand(grpcHeaders, streamTransportState), true);
     channelRead(goAwayFrame(streamId));
-    verify(streamListener, never())
-        .closed(any(Status.class), any(Metadata.class));
     verify(streamListener, never())
         .closed(any(Status.class), any(RpcProgress.class), any(Metadata.class));
     assertTrue(future.isDone());
@@ -373,16 +444,68 @@ public void receivedAbruptGoAwayShouldFailRacingQueuedStreamid() throws Exceptio
     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(REFUSED),
+    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));
@@ -434,6 +557,20 @@ public void receivedGoAwayShouldFailBufferedStreams() throws Exception {
         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.
@@ -528,7 +665,7 @@ public void close() throws SecurityException {
   public void cancelStreamShouldCreateAndThenFailBufferedStream() throws Exception {
     receiveMaxConcurrentStreams(0);
     enqueue(newCreateStreamCommand(grpcHeaders, streamTransportState));
-    assertEquals(3, streamTransportState.id());
+    assertEquals(STREAM_ID, streamTransportState.id());
     cancelStream(Status.CANCELLED);
     verify(streamListener).closed(eq(Status.CANCELLED), same(PROCESSED), any(Metadata.class));
   }
@@ -575,7 +712,7 @@ public void connectionWindowShouldBeOverridden() throws Exception {
   public void createIncrementsIdsForActualAndBufferdStreams() throws Exception {
     receiveMaxConcurrentStreams(2);
     enqueue(newCreateStreamCommand(grpcHeaders, streamTransportState));
-    assertEquals(3, streamTransportState.id());
+    assertEquals(STREAM_ID, streamTransportState.id());
 
     streamTransportState = new TransportStateImpl(
         handler(),
@@ -629,7 +766,7 @@ public void exhaustedStreamsShouldFail() throws Exception {
   public void nonExistentStream() throws Exception {
     Status status = Status.INTERNAL.withDescription("zz");
 
-    lifecycleManager.notifyShutdown(status);
+    lifecycleManager.notifyShutdown(status, SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
     // Stream creation can race with the transport shutting down, with the create command already
     // enqueued.
     ChannelFuture future1 = createStream();
@@ -695,9 +832,7 @@ 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);
   }
@@ -714,7 +849,7 @@ public void oustandingUserPingShouldNotInteractWithDataPing() throws Exception {
     ArgumentCaptor<Long> captor = ArgumentCaptor.forClass(long.class);
     verifyWrite().writePing(eq(ctx()), eq(false), captor.capture(), any(ChannelPromise.class));
     long payload = captor.getValue();
-    channelRead(grpcDataFrame(3, false, contentAsArray()));
+    channelRead(grpcDataFrame(STREAM_ID, false, contentAsArray()));
     long pingData = handler().flowControlPing().payload();
     channelRead(pingFrame(true, pingData));
 
@@ -737,18 +872,18 @@ public void bdpPingAvoidsTooManyPingsOnSpecialServers() throws Exception {
 
     Http2Headers headers = new DefaultHttp2Headers().status(STATUS_OK)
         .set(CONTENT_TYPE_HEADER, CONTENT_TYPE_GRPC);
-    channelRead(headersFrame(3, headers));
-    channelRead(dataFrame(3, false, content()));
+    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(3, false, content()));
-    verifyWrite(times(2)).writePing(eq(ctx()), eq(false), eq(1234L), any(ChannelPromise.class));
+    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(3, false, content()));
+    channelRead(dataFrame(STREAM_ID, false, content()));
     // No ping was sent
-    verifyWrite(times(2)).writePing(eq(ctx()), eq(false), eq(1234L), any(ChannelPromise.class));
+    verifyWrite(times(1)).writePing(eq(ctx()), eq(false), eq(1234L), any(ChannelPromise.class));
   }
 
   @Test
@@ -768,26 +903,26 @@ public void bdpPingAllowedAfterSendingData() throws Exception {
 
     Http2Headers headers = new DefaultHttp2Headers().status(STATUS_OK)
         .set(CONTENT_TYPE_HEADER, CONTENT_TYPE_GRPC);
-    channelRead(headersFrame(3, headers));
-    channelRead(dataFrame(3, false, content()));
+    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(3, false, content()));
-    verifyWrite(times(2)).writePing(eq(ctx()), eq(false), eq(1234L), any(ChannelPromise.class));
+    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(3, false, content()));
+    channelRead(dataFrame(STREAM_ID, false, content()));
     // No ping was sent
-    verifyWrite(times(2)).writePing(eq(ctx()), eq(false), eq(1234L), any(ChannelPromise.class));
+    verifyWrite(times(1)).writePing(eq(ctx()), eq(false), eq(1234L), any(ChannelPromise.class));
 
     channelRead(windowUpdate(0, 2024));
-    channelRead(windowUpdate(3, 2024));
+    channelRead(windowUpdate(STREAM_ID, 2024));
     assertTrue(future.isDone());
     assertTrue(future.isSuccess());
     // But now one is sent
-    channelRead(dataFrame(3, false, content()));
-    verifyWrite(times(3)).writePing(eq(ctx()), eq(false), eq(1234L), any(ChannelPromise.class));
+    channelRead(dataFrame(STREAM_ID, false, content()));
+    verifyWrite(times(1)).writePing(eq(ctx()), eq(false), eq(1234L), any(ChannelPromise.class));
   }
 
   @Override
@@ -810,6 +945,159 @@ 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();
@@ -817,7 +1105,7 @@ protected void makeStream() throws Exception {
     // both client- and server-side.
     Http2Headers headers = new DefaultHttp2Headers().status(STATUS_OK)
         .set(CONTENT_TYPE_HEADER, CONTENT_TYPE_GRPC);
-    ByteBuf headersFrame = headersFrame(3, headers);
+    ByteBuf headersFrame = headersFrame(STREAM_ID, headers);
     channelRead(headersFrame);
   }
 
@@ -871,11 +1159,15 @@ public Stopwatch get() {
         false,
         flowControlWindow,
         maxHeaderListSize,
+        softLimitHeaderListSize,
         stopwatchSupplier,
         tooManyPingsRunnable,
         transportTracer,
         Attributes.EMPTY,
-        "someauthority");
+        "someauthority",
+        null,
+        fakeClock().getTicker(),
+        new MetricRecorder() {});
   }
 
   @Override
@@ -896,7 +1188,7 @@ private static CreateStreamCommand newCreateStreamCommand(
   private static class PingCallbackImpl implements ClientTransport.PingCallback {
     int invocationCount;
     long roundTripTime;
-    Throwable failureCause;
+    Status failureCause;
 
     @Override
     public void onSuccess(long roundTripTimeNanos) {
@@ -905,7 +1197,7 @@ public void onSuccess(long roundTripTimeNanos) {
     }
 
     @Override
-    public void onFailure(Throwable cause) {
+    public void onFailure(Status cause) {
       invocationCount++;
       this.failureCause = cause;
     }
@@ -923,7 +1215,8 @@ public TransportStateImpl(
           maxMessageSize,
           StatsTraceContext.NOOP,
           transportTracer,
-          "methodName");
+          "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 66cb37be532..4dd24c3fd4d 100644
--- a/netty/src/test/java/io/grpc/netty/NettyClientStreamTest.java
+++ b/netty/src/test/java/io/grpc/netty/NettyClientStreamTest.java
@@ -23,6 +23,8 @@
 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;
@@ -34,6 +36,7 @@
 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;
@@ -43,6 +46,7 @@
 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;
@@ -50,6 +54,7 @@
 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;
@@ -61,6 +66,7 @@
 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;
@@ -74,6 +80,7 @@
 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;
@@ -123,8 +130,8 @@ public Void answer(InvocationOnMock invocation) throws Throwable {
               return null;
             }
           })
-      .when(listener)
-      .messagesAvailable(ArgumentMatchers.<StreamListener.MessageProducer>any());
+        .when(listener)
+        .messagesAvailable(ArgumentMatchers.<StreamListener.MessageProducer>any());
   }
 
   @Override
@@ -204,6 +211,52 @@ public void writeMessageShouldSendRequestUnknownLength() throws Exception {
         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);
@@ -304,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
@@ -553,6 +607,7 @@ private Http2Headers grpcResponseTrailers(Status status) {
   }
 
   private class TransportStateImpl extends NettyClientStream.TransportState {
+    @SuppressWarnings("DirectInvocationOnMock")
     public TransportStateImpl(NettyClientHandler handler, int maxMessageSize) {
       super(
           handler,
@@ -560,7 +615,8 @@ public TransportStateImpl(NettyClientHandler handler, int maxMessageSize) {
           maxMessageSize,
           StatsTraceContext.NOOP,
           transportTracer,
-          "methodName");
+          "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 d512271d0ae..621afd98281 100644
--- a/netty/src/test/java/io/grpc/netty/NettyClientTransportFactoryTest.java
+++ b/netty/src/test/java/io/grpc/netty/NettyClientTransportFactoryTest.java
@@ -16,8 +16,8 @@
 
 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 fe3e604b9e6..7023acc947c 100644
--- a/netty/src/test/java/io/grpc/netty/NettyClientTransportTest.java
+++ b/netty/src/test/java/io/grpc/netty/NettyClientTransportTest.java
@@ -16,7 +16,6 @@
 
 package io.grpc.netty;
 
-import static com.google.common.base.Charsets.UTF_8;
 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;
@@ -27,7 +26,9 @@
 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;
@@ -35,24 +36,36 @@
 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.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.MetricRecorder;
 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;
@@ -66,6 +79,9 @@
 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;
@@ -73,6 +89,8 @@
 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;
@@ -83,14 +101,19 @@
 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;
@@ -100,24 +123,39 @@
 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;
 
@@ -141,7 +179,7 @@ public class NettyClientTransportTest {
 
   @Before
   public void setup() {
-    MockitoAnnotations.initMocks(this);
+    when(clientTransportListener.filterTransport(any())).thenAnswer(i -> i.getArguments()[0]);
   }
 
   @After
@@ -172,6 +210,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();
@@ -184,18 +223,37 @@ public void addDefaultUserAgent() throws Exception {
   }
 
   @Test
-  public void setSoLingerChannelOption() throws IOException {
+  public void setSoLingerChannelOption() throws IOException, GeneralSecurityException {
     startServer();
     Map<ChannelOption<?>, Object> channelOptions = new HashMap<>();
     // set SO_LINGER option
     int soLinger = 123;
     channelOptions.put(ChannelOption.SO_LINGER, soLinger);
     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, KEEPALIVE_TIME_NANOS_DISABLED, 1L, false, authority,
-        null /* user agent */, tooManyPingsRunnable, new TransportTracer(), Attributes.EMPTY,
-        new SocketPicker(), new FakeChannelLogger(), false);
+        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,
+        new MetricRecorder() {
+        },
+        Ticker.systemTicker());
     transports.add(transport);
     callMeMaybe(transport.start(clientTransportListener));
 
@@ -211,6 +269,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();
 
@@ -228,6 +287,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.
@@ -254,6 +314,7 @@ 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<>(transports.size());
@@ -283,6 +344,7 @@ public void run() {
             failureStatus.asRuntimeException());
       }
     });
+    verify(clientTransportListener, timeout(5000)).transportTerminated();
 
     Rpc rpc = new Rpc(transport).halfClose();
     try {
@@ -297,27 +359,26 @@ public void run() {
 
   @Test
   public void tlsNegotiationFailurePropagatesToStatus() throws Exception {
-    File serverCert = TestUtils.loadCert("server1.pem");
-    File serverKey = TestUtils.loadCert("server1.key");
+    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)
-        .ciphers(TestUtils.preferredTestCiphers(), SupportedCipherSuiteFilter.INSTANCE)
         .clientAuth(ClientAuth.REQUIRE)
         .build();
     negotiator = ProtocolNegotiators.serverTls(sslContext);
     startServer();
 
-    File caCert = TestUtils.loadCert("ca.pem");
-    File clientCert = TestUtils.loadCert("client.pem");
-    File clientKey = TestUtils.loadCert("client.key");
+    InputStream caCert = TlsTesting.loadCert("ca.pem");
+    InputStream clientCert = TlsTesting.loadCert("client.pem");
+    InputStream clientKey = TlsTesting.loadCert("client.key");
     SslContext clientContext = GrpcSslContexts.forClient()
         .trustManager(caCert)
-        .ciphers(TestUtils.preferredTestCiphers(), SupportedCipherSuiteFilter.INSTANCE)
         .keyManager(clientCert, clientKey)
         .build();
-    ProtocolNegotiator negotiator = ProtocolNegotiators.tls(clientContext);
+    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 {
@@ -347,6 +408,7 @@ public void channelExceptionDuringNegotiatonPropagatesToStatus() throws Exceptio
     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 {
@@ -378,6 +440,7 @@ public void run() {
         }
       }
     });
+    verify(clientTransportListener, timeout(5000)).transportTerminated();
 
     Rpc rpc = new Rpc(transport).halfClose();
     try {
@@ -397,6 +460,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.
@@ -442,12 +506,30 @@ 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, KEEPALIVE_TIME_NANOS_DISABLED, 1, false, authority,
-        null, tooManyPingsRunnable, new TransportTracer(), Attributes.EMPTY, new SocketPicker(),
-        new FakeChannelLogger(), false);
+        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,
+        new MetricRecorder() {
+        },
+        Ticker.systemTicker());
     transports.add(transport);
 
     // Should not throw
@@ -473,8 +555,8 @@ public void onSuccess(long roundTripTimeNanos) {
       }
 
       @Override
-      public void onFailure(Throwable cause) {
-        pingResult.setException(cause);
+      public void onFailure(Status cause) {
+        pingResult.setException(cause.asException());
       }
     };
     transport.ping(pingCallback, clock.getScheduledExecutorService());
@@ -508,15 +590,20 @@ public void channelFactoryShouldSetSocketOptionKeepAlive() throws Exception {
   @Test
   public void channelFactoryShouldNNotSetSocketOptionKeepAlive() 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<>(LocalChannel.class), group);
+    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));
+      callMeMaybe(transport.start(clientTransportListener));
 
-    assertThat(transport.channel().config().getOption(ChannelOption.SO_KEEPALIVE))
-        .isNull();
+      assertThat(transport.channel().config().getOption(ChannelOption.SO_KEEPALIVE))
+          .isNull();
+    } finally {
+      group.shutdownGracefully(0, 10, TimeUnit.SECONDS);
+    }
   }
 
   @Test
@@ -526,6 +613,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.
@@ -541,12 +629,93 @@ public void maxHeaderListSizeShouldBeEnforcedOnClient() throws Exception {
     }
   }
 
+  @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.
@@ -591,6 +760,7 @@ 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();
 
@@ -609,6 +779,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();
 
@@ -621,6 +792,7 @@ 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();
 
@@ -691,10 +863,9 @@ public void tlsNegotiationServerExecutorShouldSucceed() throws Exception {
     assertEquals(false, serverExecutorPool.isInUse());
     assertEquals(false, clientExecutorPool.isInUse());
 
-    File serverCert = TestUtils.loadCert("server1.pem");
-    File serverKey = TestUtils.loadCert("server1.key");
+    InputStream serverCert = TlsTesting.loadCert("server1.pem");
+    InputStream serverKey = TlsTesting.loadCert("server1.key");
     SslContext sslContext = GrpcSslContexts.forServer(serverCert, serverKey)
-        .ciphers(TestUtils.preferredTestCiphers(), SupportedCipherSuiteFilter.INSTANCE)
         .clientAuth(ClientAuth.NONE)
         .build();
     negotiator = ProtocolNegotiators.serverTls(sslContext, serverExecutorPool);
@@ -702,19 +873,20 @@ public void tlsNegotiationServerExecutorShouldSucceed() throws Exception {
     // after starting the server, the Executor in the server pool should be used
     assertEquals(true, serverExecutorPool.isInUse());
 
-    File caCert = TestUtils.loadCert("ca.pem");
-    File clientCert = TestUtils.loadCert("client.pem");
-    File clientKey = TestUtils.loadCert("client.key");
+    InputStream caCert = TlsTesting.loadCert("ca.pem");
+    InputStream clientCert = TlsTesting.loadCert("client.pem");
+    InputStream clientKey = TlsTesting.loadCert("client.key");
     SslContext clientContext = GrpcSslContexts.forClient()
         .trustManager(caCert)
-        .ciphers(TestUtils.preferredTestCiphers(), SupportedCipherSuiteFilter.INSTANCE)
         .keyManager(clientCert, clientKey)
         .build();
-    ProtocolNegotiator negotiator = ProtocolNegotiators.tls(clientContext, clientExecutorPool);
+    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
@@ -724,6 +896,179 @@ public void tlsNegotiationServerExecutorShouldSucceed() throws Exception {
     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;
@@ -731,11 +1076,37 @@ private Throwable getRootCause(Throwable t) {
     return getRootCause(t.getCause());
   }
 
-  private ProtocolNegotiator newNegotiator() throws IOException {
-    File caCert = TestUtils.loadCert("ca.pem");
-    SslContext clientContext = GrpcSslContexts.forClient().trustManager(caCert)
-        .ciphers(TestUtils.preferredTestCiphers(), SupportedCipherSuiteFilter.INSTANCE).build();
-    return ProtocolNegotiators.tls(clientContext);
+  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) {
@@ -758,11 +1129,30 @@ private NettyClientTransport newTransport(ProtocolNegotiator negotiator, int max
       keepAliveTimeNano = KEEPALIVE_TIME_NANOS_DISABLED;
     }
     NettyClientTransport transport = new NettyClientTransport(
-        address, channelFactory, new HashMap<ChannelOption<?>, Object>(), group,
-        negotiator, false, DEFAULT_WINDOW_SIZE, maxMsgSize, maxHeaderListSize,
-        keepAliveTimeNano, keepAliveTimeoutNano,
-        false, authority, userAgent, tooManyPingsRunnable,
-        new TransportTracer(), eagAttributes, new SocketPicker(), new FakeChannelLogger(), false);
+        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,
+        new MetricRecorder() {
+        },
+        Ticker.systemTicker());
     transports.add(transport);
     return transport;
   }
@@ -771,23 +1161,45 @@ 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 {
+    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,
+        new FixedObjectPool<>(group),
+        new FixedObjectPool<>(group),
+        false,
+        negotiator,
         Collections.<ServerStreamTracer.Factory>emptyList(),
         TransportTracer.getDefaultFactory(),
         maxStreamsPerConnection,
         false,
-        DEFAULT_WINDOW_SIZE, DEFAULT_MAX_MESSAGE_SIZE, maxHeaderListSize,
-        DEFAULT_SERVER_KEEPALIVE_TIME_NANOS, DEFAULT_SERVER_KEEPALIVE_TIMEOUT_NANOS,
+        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_CONNECTION_AGE_NANOS_DISABLED,
+        MAX_CONNECTION_AGE_GRACE_NANOS_INFINITE,
+        true,
+        0,
+        MAX_RST_COUNT_DISABLED,
+        0,
         Attributes.EMPTY,
-        channelz);
+        channelz,
+        new MetricRecorder() {});
     server.start(serverListener);
     address = TestUtils.testServerAddress((InetSocketAddress) server.getListenSocketAddress());
     authority = GrpcUtil.authorityFromHostAndPort(address.getHostString(), address.getPort());
@@ -801,10 +1213,9 @@ private void callMeMaybe(Runnable r) {
 
   private static SslContext createSslContext() {
     try {
-      File serverCert = TestUtils.loadCert("server1.pem");
-      File key = TestUtils.loadCert("server1.key");
-      return GrpcSslContexts.forServer(serverCert, key)
-          .ciphers(TestUtils.preferredTestCiphers(), SupportedCipherSuiteFilter.INSTANCE).build();
+      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);
     }
@@ -824,11 +1235,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, CallOptions.DEFAULT);
+      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)));
@@ -857,11 +1277,6 @@ private static final class TestClientStreamListener implements ClientStreamListe
     public void headersRead(Metadata headers) {
     }
 
-    @Override
-    public void closed(Status status, Metadata trailers) {
-      closed(status, RpcProgress.PROCESSED, trailers);
-    }
-
     @Override
     public void closed(Status status, RpcProgress rpcProgress, Metadata trailers) {
       if (status.isOk()) {
@@ -887,12 +1302,10 @@ 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;
     }
 
@@ -925,6 +1338,15 @@ 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) {
@@ -932,9 +1354,9 @@ public ServerTransportListener transportCreated(final ServerTransport transport)
       return new ServerTransportListener() {
         @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(new Metadata());
+          stream.writeHeaders(responseHeaders, true);
           stream.request(1);
           streamListeners.add(listener);
         }
@@ -981,9 +1403,15 @@ 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().addBefore(ctx.name(), null, grpcHandler);
+      ctx.pipeline().addAfter(ctx.name(), null, grpcHandler);
     }
 
     public void fail(ChannelHandlerContext ctx, Throwable cause) {
@@ -1027,4 +1455,62 @@ 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 04f65eed145..c971294fbb6 100644
--- a/netty/src/test/java/io/grpc/netty/NettyHandlerTestBase.java
+++ b/netty/src/test/java/io/grpc/netty/NettyHandlerTestBase.java
@@ -16,8 +16,8 @@
 
 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.AdditionalAnswers.delegatesTo;
 import static org.mockito.ArgumentMatchers.any;
@@ -30,6 +30,7 @@
 
 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;
@@ -37,7 +38,6 @@
 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;
@@ -64,8 +64,11 @@
 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;
@@ -80,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;
 
@@ -102,18 +105,24 @@ 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(Http2HeadersDecoder headersDecoder) throws Exception {
-    content = Unpooled.copiedBuffer("hello world", UTF_8);
     frameWriter = mock(Http2FrameWriter.class, delegatesTo(new DefaultHttp2FrameWriter()));
     frameReader = new DefaultHttp2FrameReader(headersDecoder);
 
@@ -229,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() {
@@ -248,8 +257,8 @@ protected final void channelRead(Object obj) throws Exception {
     channel.writeInbound(obj);
   }
 
-  protected ByteBuf grpcDataFrame(int streamId, boolean endStream, byte[] content) {
-    final ByteBuf compressionFrame = Unpooled.buffer(content.length);
+  protected ByteBuf grpcFrame(byte[] message) {
+    final ByteBuf compressionFrame = Unpooled.buffer(message.length);
     MessageFramer framer = new MessageFramer(
         new MessageFramer.Sink() {
           @Override
@@ -258,23 +267,22 @@ public void deliverFrame(
             if (frame != null) {
               ByteBuf bytebuf = ((NettyWritableBuffer) frame).bytebuf();
               compressionFrame.writeBytes(bytebuf);
+              bytebuf.release();
             }
           }
         },
         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);
+    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);
@@ -328,6 +336,8 @@ 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, true);
@@ -404,6 +414,7 @@ public void dataSizeSincePingAccumulates() throws Exception {
     channelRead(dataFrame(3, false, buff.copy()));
 
     assertEquals(length * 3, handler.flowControlPing().getDataSincePing());
+    buff.release();
   }
 
   @Test
@@ -415,18 +426,15 @@ public void windowUpdateMatchesTarget() throws Exception {
     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();
     channelRead(pingFrame(true, pingData));
@@ -444,8 +452,10 @@ public void windowShouldNotExceedMaxWindowSize() throws Exception {
     Http2Stream connectionStream = connection().connectionStream();
     Http2LocalFlowController localFlowController = connection().local().flowController();
     int maxWindow = handler.flowControlPing().maxWindow();
+    fakeClock.forwardTime(10, TimeUnit.SECONDS);
 
     handler.flowControlPing().setDataSizeAndSincePing(maxWindow);
+    fakeClock.forwardTime(1, TimeUnit.SECONDS);
     long payload = handler.flowControlPing().payload();
     channelRead(pingFrame(true, payload));
 
@@ -456,8 +466,8 @@ public void windowShouldNotExceedMaxWindowSize() throws Exception {
   public void transportTracer_windowSizeDefault() throws Exception {
     manualSetUp();
     TransportStats transportStats = transportTracer.getStats();
-    assertEquals(Http2CodecUtil.DEFAULT_WINDOW_SIZE, transportStats.remoteFlowControlWindow);
-    assertEquals(flowControlWindow, transportStats.localFlowControlWindow);
+    assertEquals(Http2CodecUtil.DEFAULT_WINDOW_SIZE, transportStats.localFlowControlWindow);
+    assertEquals(flowControlWindow, transportStats.remoteFlowControlWindow);
   }
 
   @Test
@@ -465,31 +475,31 @@ public void transportTracer_windowSize() throws Exception {
     flowControlWindow = 1024 * 1024;
     manualSetUp();
     TransportStats transportStats = transportTracer.getStats();
-    assertEquals(Http2CodecUtil.DEFAULT_WINDOW_SIZE, transportStats.remoteFlowControlWindow);
-    assertEquals(flowControlWindow, transportStats.localFlowControlWindow);
+    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.remoteFlowControlWindow);
     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.remoteFlowControlWindow);
-    assertEquals(flowControlWindow, after.localFlowControlWindow);
+        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.remoteFlowControlWindow);
-    assertEquals(flowControlWindow, before.localFlowControlWindow);
+    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.
@@ -497,8 +507,130 @@ public void transportTracer_windowUpdate_local() throws Exception {
         connection().connectionStream(), 8 * Http2CodecUtil.DEFAULT_WINDOW_SIZE);
 
     TransportStats after = transportTracer.getStats();
-    assertEquals(Http2CodecUtil.DEFAULT_WINDOW_SIZE, after.remoteFlowControlWindow);
+    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 8090e601911..4f10504c07d 100644
--- a/netty/src/test/java/io/grpc/netty/NettyReadableBufferTest.java
+++ b/netty/src/test/java/io/grpc/netty/NettyReadableBufferTest.java
@@ -16,12 +16,17 @@
 
 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;
@@ -52,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 6d8192322aa..f3b73a515b5 100644
--- a/netty/src/test/java/io/grpc/netty/NettyServerBuilderTest.java
+++ b/netty/src/test/java/io/grpc/netty/NettyServerBuilderTest.java
@@ -16,20 +16,19 @@
 
 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 com.google.common.truth.Truth;
-import io.grpc.ServerStreamTracer;
+import io.grpc.MetricRecorder;
 import io.netty.channel.EventLoopGroup;
 import io.netty.channel.local.LocalServerChannel;
 import io.netty.handler.ssl.SslContext;
 import java.net.InetSocketAddress;
 import java.util.concurrent.TimeUnit;
-import org.junit.Rule;
 import org.junit.Test;
-import org.junit.rules.ExpectedException;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 
@@ -39,18 +38,16 @@
 @RunWith(JUnit4.class)
 public class NettyServerBuilderTest {
 
-  @SuppressWarnings("deprecation") // https://github.com/grpc/grpc-java/issues/7467
-  @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());
+    NettyServer server = builder.buildTransportServers(
+        ImmutableList.of(),
+        new MetricRecorder() {});
 
-    Truth.assertThat(server.getListenSocketAddresses()).hasSize(2);
+    assertThat(server.getListenSocketAddresses()).hasSize(2);
   }
 
   @Test
@@ -63,105 +60,112 @@ public void failIfSslContextIsNotServer() {
     SslContext sslContext = mock(SslContext.class);
     when(sslContext.isClient()).thenReturn(true);
 
-    thrown.expect(IllegalArgumentException.class);
-    thrown.expectMessage("Client SSL context can not be used for server");
-    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() {
-    thrown.expect(IllegalArgumentException.class);
-    thrown.expectMessage("keepalive time must be positive");
-
-    builder.keepAliveTime(-10L, TimeUnit.HOURS);
+    IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
+        () -> builder.keepAliveTime(-10L, TimeUnit.HOURS));
+    assertThat(e).hasMessageThat().isEqualTo("keepalive time must be positive：-10");
   }
 
   @Test
   public void failIfKeepAliveTimeoutNegative() {
-    thrown.expect(IllegalArgumentException.class);
-    thrown.expectMessage("keepalive timeout must be positive");
-
-    builder.keepAliveTimeout(-10L, TimeUnit.HOURS);
+    IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
+        () -> builder.keepAliveTimeout(-10L, TimeUnit.HOURS));
+    assertThat(e).hasMessageThat().isEqualTo("keepalive timeout must be positive: -10");
   }
 
   @Test
   public void failIfMaxConcurrentCallsPerConnectionNegative() {
-    thrown.expect(IllegalArgumentException.class);
-    thrown.expectMessage("max must be positive");
-
-    builder.maxConcurrentCallsPerConnection(0);
+    IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
+        () -> builder.maxConcurrentCallsPerConnection(0));
+    assertThat(e).hasMessageThat().isEqualTo("max must be positive: 0");
   }
 
   @Test
   public void failIfMaxInboundMetadataSizeNonPositive() {
-    thrown.expect(IllegalArgumentException.class);
-    thrown.expectMessage("maxInboundMetadataSize must be positive");
+    IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
+        () -> builder.maxInboundMetadataSize(0));
+    assertThat(e).hasMessageThat().isEqualTo("maxInboundMetadataSize must be positive: 0");
+  }
 
-    builder.maxInboundMetadataSize(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 failIfMaxConnectionIdleNegative() {
-    thrown.expect(IllegalArgumentException.class);
-    thrown.expectMessage("max connection idle must be positive");
+  public void failIfMaxInboundMetadataSizeSmallerThanSoft() {
+    IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
+        () -> builder.maxInboundMetadataSize(100, 80));
+    assertThat(e).hasMessageThat().isEqualTo("maxInboundMetadataSize: 80 "
+        + "must be greater than softLimitHeaderListSize: 100");
+  }
 
-    builder.maxConnectionIdle(-1, TimeUnit.HOURS);
+  @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() {
-    thrown.expect(IllegalArgumentException.class);
-    thrown.expectMessage("max connection age must be positive");
-
-    builder.maxConnectionAge(-1, TimeUnit.HOURS);
+    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() {
-    thrown.expect(IllegalArgumentException.class);
-    thrown.expectMessage("max connection age grace must be non-negative");
-
-    builder.maxConnectionAgeGrace(-1, TimeUnit.HOURS);
+    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() {
-    thrown.expect(IllegalArgumentException.class);
-    thrown.expectMessage("permit keepalive time must be non-negative");
-
-    builder.permitKeepAliveTime(-1, TimeUnit.HOURS);
+    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);
-    thrown.expect(IllegalStateException.class);
-    thrown.expectMessage(
-        "All of BossEventLoopGroup, WorkerEventLoopGroup and ChannelType should be provided");
-
-    builder.assertEventLoopsAndChannelType();
+    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);
-    thrown.expect(IllegalStateException.class);
-    thrown.expectMessage(
-        "All of BossEventLoopGroup, WorkerEventLoopGroup and ChannelType should be provided");
-
-    builder.assertEventLoopsAndChannelType();
+    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);
-    thrown.expect(IllegalStateException.class);
-    thrown.expectMessage(
-        "All of BossEventLoopGroup, WorkerEventLoopGroup and ChannelType should be provided");
-
-    builder.assertEventLoopsAndChannelType();
+    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
@@ -186,4 +190,5 @@ public void useNioTransport_shouldNotThrow() {
 
     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 6e1179bafa2..1c8d2b5479d 100644
--- a/netty/src/test/java/io/grpc/netty/NettyServerHandlerTest.java
+++ b/netty/src/test/java/io/grpc/netty/NettyServerHandlerTest.java
@@ -16,23 +16,25 @@
 
 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 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.AdditionalAnswers.delegatesTo;
 import static org.mockito.ArgumentMatchers.any;
@@ -41,6 +43,7 @@
 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;
@@ -56,11 +59,14 @@
 import io.grpc.Attributes;
 import io.grpc.InternalStatus;
 import io.grpc.Metadata;
+import io.grpc.MetricRecorder;
 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;
@@ -70,10 +76,10 @@
 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.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;
@@ -83,9 +89,12 @@
 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;
@@ -98,8 +107,9 @@
 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;
 
 /**
@@ -110,29 +120,24 @@ public class NettyServerHandlerTest extends NettyHandlerTestBase<NettyServerHand
 
   @Rule
   public final TestRule globalTimeout = new DisableOnDebug(Timeout.seconds(10));
-
-  private static final int STREAM_ID = 3;
-
+  @Rule
+  public final MockitoRule mocks = MockitoJUnit.rule();
   private static final AsciiString HTTP_FAKE_METHOD = AsciiString.of("FAKE");
-
-
   @Mock
   private ServerStreamListener streamListener;
-
   @Mock
   private ServerStreamTracer.Factory streamTracerFactory;
-
   private final ServerTransportListener transportListener =
       mock(ServerTransportListener.class, delegatesTo(new ServerTransportListenerImpl()));
   private final TestServerStreamTracer streamTracer = new TestServerStreamTracer();
-
+  private final MetricRecorder metricRecorder = mock(MetricRecorder.class);
   private NettyServerStream stream;
   private KeepAliveManager spyKeepAliveManager;
-
   final Queue<InputStream> streamListenerMessageQueue = new LinkedList<>();
 
   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;
@@ -140,6 +145,8 @@ public class NettyServerHandlerTest extends NettyHandlerTestBase<NettyServerHand
   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 {
 
@@ -160,8 +167,6 @@ public void transportTerminated() {
 
   @Before
   public void setUp() {
-    MockitoAnnotations.initMocks(this);
-
     when(streamTracerFactory.newServerStreamTracer(anyString(), any(Metadata.class)))
         .thenReturn(streamTracer);
 
@@ -178,8 +183,8 @@ public Void answer(InvocationOnMock invocation) throws Throwable {
               return null;
             }
           })
-      .when(streamListener)
-      .messagesAvailable(any(StreamListener.MessageProducer.class));
+        .when(streamListener)
+        .messagesAvailable(any(StreamListener.MessageProducer.class));
   }
 
   @Override
@@ -199,6 +204,19 @@ protected void manualSetUp() throws Exception {
     // Simulate receipt of initial remote settings.
     ByteBuf serializedSettings = serializeSettings(new Http2Settings());
     channelRead(serializedSettings);
+    channel().releaseOutbound();
+  }
+
+  @Test
+  public void tcpMetrics_recorded() throws Exception {
+    manualSetUp();
+    handler().channelActive(ctx());
+    // Verify that channelActive triggered TcpMetrics
+    verify(metricRecorder, atLeastOnce()).addLongCounter(
+        eq(io.grpc.InternalTcpMetrics.CONNECTIONS_CREATED_INSTRUMENT),
+        eq(1L),
+        any(),
+        any());
   }
 
   @Test
@@ -220,10 +238,11 @@ public void sendFrameShouldSucceed() throws Exception {
     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));
   }
 
@@ -258,10 +277,11 @@ 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);
+    channel().releaseOutbound();
     verify(streamListener, atLeastOnce())
         .messagesAvailable(any(StreamListener.MessageProducer.class));
     InputStream message = streamListenerMessageQueue.poll();
-    assertArrayEquals(ByteBufUtil.getBytes(content()), ByteStreams.toByteArray(message));
+    assertArrayEquals(contentAsArray(), ByteStreams.toByteArray(message));
     message.close();
     assertNull("no additional message expected", streamListenerMessageQueue.poll());
 
@@ -350,6 +370,56 @@ public void closeShouldGracefullyCloseChannel() throws Exception {
     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()),
+        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();
@@ -381,7 +451,7 @@ public void shouldAdvertiseMaxConcurrentStreams() throws Exception {
     verifyWrite().writeSettings(
         any(ChannelHandlerContext.class), captor.capture(), any(ChannelPromise.class));
 
-    assertEquals(maxConcurrentStreams, captor.getValue().maxConcurrentStreams().intValue());
+    assertEquals(maxConcurrentStreams, captor.getValue().maxConcurrentStreams().longValue());
   }
 
   @Test
@@ -393,7 +463,7 @@ public void shouldAdvertiseMaxHeaderListSize() throws Exception {
     verifyWrite().writeSettings(
         any(ChannelHandlerContext.class), captor.capture(), any(ChannelPromise.class));
 
-    assertEquals(maxHeaderListSize, captor.getValue().maxHeaderListSize().intValue());
+    assertEquals(maxHeaderListSize, captor.getValue().maxHeaderListSize().longValue());
   }
 
   @Test
@@ -413,11 +483,41 @@ public void connectionWindowShouldBeOverridden() throws Exception {
   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();
@@ -432,7 +532,7 @@ public void headersWithInvalidContentTypeShouldFail() throws Exception {
         .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; encoding=utf-8");
+        .set(CONTENT_TYPE_HEADER, "text/plain; charset=utf-8");
 
     verifyWrite()
         .writeHeaders(
@@ -457,7 +557,8 @@ public void headersWithInvalidMethodShouldFail() throws Exception {
         .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; encoding=utf-8");
+        .set(CONTENT_TYPE_HEADER, "text/plain; charset=utf-8")
+        .set(HttpHeaderNames.ALLOW, HTTP_METHOD);
 
     verifyWrite()
         .writeHeaders(
@@ -481,7 +582,7 @@ public void headersWithMissingPathShouldFail() throws Exception {
         .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; encoding=utf-8");
+        .set(CONTENT_TYPE_HEADER, "text/plain; charset=utf-8");
 
     verifyWrite()
         .writeHeaders(
@@ -506,7 +607,7 @@ public void headersWithInvalidPathShouldFail() throws Exception {
         .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; encoding=utf-8");
+        .set(CONTENT_TYPE_HEADER, "text/plain; charset=utf-8");
 
     verifyWrite()
         .writeHeaders(
@@ -537,6 +638,124 @@ 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();
@@ -633,7 +852,7 @@ public void keepAliveManager_pingTimeout() throws Exception {
 
     fakeClock().forwardNanos(keepAliveTimeoutInNanos);
 
-    assertTrue(!channel().isOpen());
+    assertFalse(channel().isOpen());
   }
 
   @Test
@@ -663,7 +882,7 @@ public void keepAliveEnforcer_sendingDataResetsCounters() throws Exception {
     future.get();
     for (int i = 0; i < 10; i++) {
       future = enqueue(
-          new SendGrpcFrameCommand(stream.transportState(), content().retainedSlice(), false));
+          new SendGrpcFrameCommand(stream.transportState(), content(), false));
       future.get();
       channel().releaseOutbound();
       channelRead(pingFrame(false /* isAck */, 1L));
@@ -766,7 +985,7 @@ public void maxConnectionIdle_goAwaySent_pingAck() throws Exception {
         eq(ctx()), eq(0), eq(Http2Error.NO_ERROR.code()), any(ByteBuf.class),
         any(ChannelPromise.class));
     // channel closed
-    assertTrue(!channel().isOpen());
+    assertFalse(channel().isOpen());
   }
 
   @Test
@@ -796,7 +1015,7 @@ public void maxConnectionIdle_goAwaySent_pingTimeout() throws Exception {
         eq(ctx()), eq(0), eq(Http2Error.NO_ERROR.code()), any(ByteBuf.class),
         any(ChannelPromise.class));
     // channel closed
-    assertTrue(!channel().isOpen());
+    assertFalse(channel().isOpen());
   }
 
   @Test
@@ -840,7 +1059,7 @@ public void maxConnectionIdle_activeThenRst_pingAck() throws Exception {
         eq(ctx()), eq(STREAM_ID), eq(Http2Error.NO_ERROR.code()), any(ByteBuf.class),
         any(ChannelPromise.class));
     // channel closed
-    assertTrue(!channel().isOpen());
+    assertFalse(channel().isOpen());
   }
 
   @Test
@@ -884,7 +1103,7 @@ public void maxConnectionIdle_activeThenRst_pingTimeoutk() throws Exception {
         eq(ctx()), eq(STREAM_ID), eq(Http2Error.NO_ERROR.code()), any(ByteBuf.class),
         any(ChannelPromise.class));
     // channel closed
-    assertTrue(!channel().isOpen());
+    assertFalse(channel().isOpen());
   }
 
   @Test
@@ -938,7 +1157,7 @@ public void maxConnectionAge_goAwaySent_pingAck() throws Exception {
         eq(ctx()), eq(0), eq(Http2Error.NO_ERROR.code()), any(ByteBuf.class),
         any(ChannelPromise.class));
     // channel closed
-    assertTrue(!channel().isOpen());
+    assertFalse(channel().isOpen());
   }
 
   @Test
@@ -969,7 +1188,7 @@ public void maxConnectionAge_goAwaySent_pingTimeout() throws Exception {
         eq(ctx()), eq(0), eq(Http2Error.NO_ERROR.code()), any(ByteBuf.class),
         any(ChannelPromise.class));
     // channel closed
-    assertTrue(!channel().isOpen());
+    assertFalse(channel().isOpen());
   }
 
   @Test
@@ -1037,7 +1256,7 @@ public void maxConnectionAgeGrace_channelClosedAfterGracePeriod_withPingTimeout(
     fakeClock().forwardTime(2, TimeUnit.MILLISECONDS);
 
     // channel closed
-    assertTrue(!channel().isOpen());
+    assertFalse(channel().isOpen());
   }
 
   @Test
@@ -1077,7 +1296,91 @@ public void maxConnectionAgeGrace_channelClosedAfterGracePeriod_withPingAck()
     fakeClock().forwardTime(2, TimeUnit.MILLISECONDS);
 
     // channel closed
-    assertTrue(!channel().isOpen());
+    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 {
@@ -1099,11 +1402,7 @@ 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
@@ -1119,6 +1418,7 @@ protected NettyServerHandler newHandler() {
         autoFlowControl,
         flowControlWindow,
         maxHeaderListSize,
+        softLimitHeaderListSize,
         DEFAULT_MAX_MESSAGE_SIZE,
         keepAliveTimeInNanos,
         keepAliveTimeoutInNanos,
@@ -1127,7 +1427,11 @@ protected NettyServerHandler newHandler() {
         maxConnectionAgeGraceInNanos,
         permitKeepAliveWithoutCalls,
         permitKeepAliveTimeInNanos,
-        Attributes.EMPTY);
+        maxRstCount,
+        maxRstPeriodNanos,
+        Attributes.EMPTY,
+        fakeClock().getTicker(),
+        metricRecorder);
   }
 
   @Override
@@ -1139,4 +1443,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/NettyServerStreamTest.java b/netty/src/test/java/io/grpc/netty/NettyServerStreamTest.java
index 4463d55eb74..2f2933ae103 100644
--- a/netty/src/test/java/io/grpc/netty/NettyServerStreamTest.java
+++ b/netty/src/test/java/io/grpc/netty/NettyServerStreamTest.java
@@ -17,12 +17,16 @@
 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 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;
@@ -32,8 +36,11 @@
 import static org.mockito.Mockito.verifyNoMoreInteractions;
 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;
@@ -43,11 +50,14 @@
 import io.grpc.internal.TransportTracer;
 import io.netty.buffer.EmptyByteBuf;
 import io.netty.buffer.UnpooledByteBufAllocator;
+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;
@@ -55,13 +65,17 @@
 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;
 
@@ -93,8 +107,8 @@ public Void answer(InvocationOnMock invocation) throws Throwable {
               return null;
             }
           })
-      .when(serverListener)
-      .messagesAvailable(ArgumentMatchers.<StreamListener.MessageProducer>any());
+        .when(serverListener)
+        .messagesAvailable(ArgumentMatchers.<StreamListener.MessageProducer>any());
   }
 
   @Test
@@ -104,7 +118,7 @@ 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);
@@ -124,13 +138,107 @@ public void writeMessageShouldSendResponse() throws Exception {
         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);
@@ -276,20 +384,42 @@ 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);
     StatsTraceContext statsTraceCtx = StatsTraceContext.NOOP;
     TransportTracer transportTracer = new TransportTracer();
     NettyServerStream.TransportState state = new NettyServerStream.TransportState(
-        handler, channel.eventLoop(), 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, transportTracer);
+        "test-authority", statsTraceCtx);
     stream.transportState().setListener(serverListener);
     state.onStreamAllocated();
     verify(serverListener, atLeastOnce()).onReady();
@@ -299,7 +429,7 @@ protected NettyServerStream createStream() {
 
   @Override
   protected void sendHeadersIfServer() {
-    stream.writeHeaders(new Metadata());
+    stream.writeHeaders(new Metadata(), true);
   }
 
   @Override
diff --git a/netty/src/test/java/io/grpc/netty/NettyServerTest.java b/netty/src/test/java/io/grpc/netty/NettyServerTest.java
index 3f277ed4356..61c3f9e219e 100644
--- a/netty/src/test/java/io/grpc/netty/NettyServerTest.java
+++ b/netty/src/test/java/io/grpc/netty/NettyServerTest.java
@@ -37,6 +37,7 @@
 import io.grpc.InternalChannelz.SocketStats;
 import io.grpc.InternalInstrumented;
 import io.grpc.Metadata;
+import io.grpc.MetricRecorder;
 import io.grpc.ServerStreamTracer;
 import io.grpc.internal.FixedObjectPool;
 import io.grpc.internal.ServerListener;
@@ -73,15 +74,19 @@
 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.MockitoAnnotations;
+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 =
@@ -96,7 +101,6 @@ public class NettyServerTest {
 
   @Before
   public void setup() throws Exception {
-    MockitoAnnotations.initMocks(this);
     when(mockEventLoopGroup.next()).thenReturn(mockEventLoop);
     when(mockEventLoop
         .submit(ArgumentMatchers.<Callable<Map<ChannelFuture, SocketAddress>>>any()))
@@ -130,28 +134,35 @@ class NoHandlerProtocolNegotiator implements ProtocolNegotiator {
     }
 
     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, 1, // ignore
-        1, 1, // ignore
-        true, 0, // ignore
-        Attributes.EMPTY,
-        channelz);
+    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, mock(MetricRecorder.class));
     final SettableFuture<Void> serverShutdownCalled = SettableFuture.create();
     ns.start(new ServerListener() {
       @Override
@@ -180,28 +191,35 @@ 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, 1, // ignore
-        1, 1, // ignore
-        true, 0, // ignore
-        Attributes.EMPTY,
-        channelz);
+    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, mock(MetricRecorder.class));
     final SettableFuture<Void> shutdownCompleted = SettableFuture.create();
     ns.start(new ServerListener() {
       @Override
@@ -253,28 +271,35 @@ public void multiPortConnections() throws Exception {
     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, 1, // ignore
-        1, 1, // ignore
-        true, 0, // ignore
-        Attributes.EMPTY,
-        channelz);
+    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, mock(MetricRecorder.class));
     final SettableFuture<Void> shutdownCompleted = SettableFuture.create();
     ns.start(new ServerListener() {
       @Override
@@ -314,28 +339,35 @@ public void run() {}
   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, 1, // ignore
-        1, 1, // ignore
-        true, 0, // ignore
-        Attributes.EMPTY,
-        channelz);
+    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, mock(MetricRecorder.class));
 
     assertThat(ns.getListenSocketAddress()).isEqualTo(addr);
     assertThat(ns.getListenSocketAddresses()).isEqualTo(addresses);
@@ -388,28 +420,35 @@ class TestProtocolNegotiator implements ProtocolNegotiator {
         .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, 1, // ignore
-        1, 1, // ignore
-        true, 0, // ignore
-        eagAttributes,
-        channelz);
+    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, mock(MetricRecorder.class));
     ns.start(new ServerListener() {
       @Override
       public ServerTransportListener transportCreated(ServerTransport transport) {
@@ -435,28 +474,35 @@ public void serverShutdown() {}
   @Test
   public void channelzListenSocket() throws Exception {
     InetSocketAddress addr = new InetSocketAddress(0);
-    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, 1, // ignore
-        1, 1, // ignore
-        true, 0, // ignore
-        Attributes.EMPTY,
-        channelz);
+    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, mock(MetricRecorder.class));
     final SettableFuture<Void> shutdownCompleted = SettableFuture.create();
     ns.start(new ServerListener() {
       @Override
@@ -486,9 +532,8 @@ public void run() {}
     assertEquals(ns.getListenSocketAddress(), socketStats.local);
     assertNull(socketStats.remote);
 
-    // TODO(zpencer): uncomment when sock options are exposed
     // by default, there are some socket options set on the listen socket
-    // assertThat(socketStats.socketOptions.additional).isNotEmpty();
+    assertThat(socketStats.socketOptions.others).isNotEmpty();
 
     // Cleanup
     ns.shutdown();
@@ -595,11 +640,17 @@ private NettyServer getServer(List<SocketAddress> addr, EventLoopGroup ev) {
         1, // ignore
         1, // ignore
         1, // ignore
-        1, 1, // ignore
-        1, 1, // ignore
-        true, 0, // ignore
+        1, // ignore
+        1,
+        1, // ignore
+        1,
+        1, // ignore
+        true,
+        0, // ignore
+        0,
+        0, // ignore
         Attributes.EMPTY,
-        channelz);
+        channelz, mock(MetricRecorder.class));
   }
 
   private static class NoopServerTransportListener implements ServerTransportListener {
diff --git a/netty/src/test/java/io/grpc/netty/NettyStreamTestBase.java b/netty/src/test/java/io/grpc/netty/NettyStreamTestBase.java
index 0f7d54e7942..ce42e3d25df 100644
--- a/netty/src/test/java/io/grpc/netty/NettyStreamTestBase.java
+++ b/netty/src/test/java/io/grpc/netty/NettyStreamTestBase.java
@@ -16,8 +16,8 @@
 
 package io.grpc.netty;
 
-import static com.google.common.base.Charsets.US_ASCII;
 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;
@@ -45,10 +45,12 @@
 import java.io.InputStream;
 import java.util.Queue;
 import org.junit.Before;
+import org.junit.Rule;
 import org.junit.Test;
 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;
 
 /**
@@ -58,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;
 
@@ -86,8 +91,6 @@ public abstract class NettyStreamTestBase<T extends Stream> {
   /** Set up for test. */
   @Before
   public void setUp() {
-    MockitoAnnotations.initMocks(this);
-
     when(channel.alloc()).thenReturn(UnpooledByteBufAllocator.DEFAULT);
     when(channel.pipeline()).thenReturn(pipeline);
     when(channel.eventLoop()).thenReturn(eventLoop);
@@ -138,13 +141,6 @@ 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();
diff --git a/netty/src/test/java/io/grpc/netty/NettyTestUtil.java b/netty/src/test/java/io/grpc/netty/NettyTestUtil.java
index d030f53d118..802a6efcd58 100644
--- a/netty/src/test/java/io/grpc/netty/NettyTestUtil.java
+++ b/netty/src/test/java/io/grpc/netty/NettyTestUtil.java
@@ -67,7 +67,9 @@ public Executor getObject() {
       inUse = true;
       return new Executor() {
         @Override
-        public void execute(Runnable var1) { }
+        public void execute(Runnable var1) {
+          var1.run();
+        }
       };
     }
 
diff --git a/netty/src/test/java/io/grpc/netty/NettyTransportTest.java b/netty/src/test/java/io/grpc/netty/NettyTransportTest.java
index 6aa6ca1b32a..22758a8b727 100644
--- a/netty/src/test/java/io/grpc/netty/NettyTransportTest.java
+++ b/netty/src/test/java/io/grpc/netty/NettyTransportTest.java
@@ -20,11 +20,14 @@
 import static org.junit.Assert.assertEquals;
 
 import com.google.common.util.concurrent.SettableFuture;
+import io.grpc.Attributes;
 import io.grpc.ChannelLogger;
+import io.grpc.MetricRecorder;
 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;
@@ -69,7 +72,7 @@ protected InternalServer newServer(
         .forAddress(new InetSocketAddress("localhost", 0))
         .flowControlWindow(AbstractTransportTest.TEST_FLOW_CONTROL_WINDOW)
         .setTransportTracerFactory(fakeClockTransportTracer)
-        .buildTransportServers(streamTracerFactories);
+        .buildTransportServers(streamTracerFactories, new MetricRecorder() {});
   }
 
   @Override
@@ -79,7 +82,7 @@ protected InternalServer newServer(
         .forAddress(new InetSocketAddress("localhost", port))
         .flowControlWindow(AbstractTransportTest.TEST_FLOW_CONTROL_WINDOW)
         .setTransportTracerFactory(fakeClockTransportTracer)
-        .buildTransportServers(streamTracerFactories);
+        .buildTransportServers(streamTracerFactories, new MetricRecorder() {});
   }
 
   @Override
@@ -126,7 +129,7 @@ public void channelHasUnresolvedHostname() throws Exception {
             .setChannelLogger(logger), logger);
     Runnable runnable = transport.start(new ManagedClientTransport.Listener() {
       @Override
-      public void transportShutdown(Status s) {
+      public void transportShutdown(Status s, DisconnectError e) {
         future.set(s);
       }
 
@@ -144,6 +147,11 @@ 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();
diff --git a/netty/src/test/java/io/grpc/netty/NettyWritableBufferAllocatorTest.java b/netty/src/test/java/io/grpc/netty/NettyWritableBufferAllocatorTest.java
index d577ec46b03..0b741ae24b3 100644
--- a/netty/src/test/java/io/grpc/netty/NettyWritableBufferAllocatorTest.java
+++ b/netty/src/test/java/io/grpc/netty/NettyWritableBufferAllocatorTest.java
@@ -40,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/ProtocolNegotiatorsTest.java b/netty/src/test/java/io/grpc/netty/ProtocolNegotiatorsTest.java
index d20ec1570d3..403b1b64329 100644
--- a/netty/src/test/java/io/grpc/netty/ProtocolNegotiatorsTest.java
+++ b/netty/src/test/java/io/grpc/netty/ProtocolNegotiatorsTest.java
@@ -16,14 +16,15 @@
 
 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.ArgumentMatchers.any;
 import static org.mockito.Mockito.mock;
@@ -31,6 +32,7 @@
 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;
@@ -44,15 +46,17 @@
 import io.grpc.InternalChannelz;
 import io.grpc.InternalChannelz.Security;
 import io.grpc.Metadata;
+import io.grpc.MetricRecorder;
 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.GrpcAttributes;
+import io.grpc.internal.DisconnectError;
 import io.grpc.internal.GrpcAttributes;
 import io.grpc.internal.InternalServer;
 import io.grpc.internal.ManagedClientTransport;
@@ -60,12 +64,15 @@
 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.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;
@@ -105,21 +112,23 @@
 import io.netty.handler.proxy.ProxyConnectException;
 import io.netty.handler.ssl.ApplicationProtocolConfig;
 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.SupportedCipherSuiteFilter;
-import io.netty.handler.ssl.util.SelfSignedCertificate;
 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.cert.Certificate;
+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;
@@ -132,6 +141,7 @@
 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;
@@ -140,7 +150,6 @@
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.DisableOnDebug;
-import org.junit.rules.ExpectedException;
 import org.junit.rules.TestRule;
 import org.junit.rules.Timeout;
 import org.junit.runner.RunWith;
@@ -168,8 +177,6 @@ public static void loadCerts() throws Exception {
 
   private static final int TIMEOUT_SECONDS = 60;
   @Rule public final TestRule globalTimeout = new DisableOnDebug(Timeout.seconds(TIMEOUT_SECONDS));
-  @SuppressWarnings("deprecation") // https://github.com/grpc/grpc-java/issues/7467
-  @Rule public final ExpectedException thrown = ExpectedException.none();
 
   private final EventLoopGroup group = new DefaultEventLoop();
   private Channel chan;
@@ -183,13 +190,13 @@ public static void loadCerts() throws Exception {
   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);
   }
@@ -220,13 +227,52 @@ public ChannelCredentials withoutBearerTokens() {
   }
 
   @Test
-  public void fromClient_tls() {
+  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
@@ -344,7 +390,9 @@ private Object expectHandshake(
         .buildTransportFactory();
     InternalServer server = NettyServerBuilder
         .forPort(0, serverCreds)
-        .buildTransportServers(Collections.<ServerStreamTracer.Factory>emptyList());
+        .buildTransportServers(
+            Collections.<ServerStreamTracer.Factory>emptyList(),
+            new MetricRecorder() {});
     server.start(serverListener);
 
     ManagedClientTransport.Listener clientTransportListener =
@@ -365,7 +413,7 @@ private Object expectHandshake(
     } else {
       ArgumentCaptor<Status> captor = ArgumentCaptor.forClass(Status.class);
       verify(clientTransportListener, timeout(TIMEOUT_SECONDS * 1000))
-          .transportShutdown(captor.capture());
+          .transportShutdown(captor.capture(), any(DisconnectError.class));
       result = captor.getValue();
     }
 
@@ -414,7 +462,17 @@ public void from_tls_clientAuthRequire_noClientCert() throws Exception {
         .trustManager(caCert)
         .build();
     Status status = expectFailedHandshake(channelCreds, serverCreds);
-    assertThat(status.getDescription()).isEqualTo("ssl exception");
+    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
@@ -465,19 +523,26 @@ public void from_tls_clientAuthOptional_clientCert() throws Exception {
 
   @Test
   public void from_tls_managers() throws Exception {
-    SelfSignedCertificate cert = new SelfSignedCertificate(TestUtils.TEST_SERVER_HOST);
     KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType());
     keyStore.load(null);
-    keyStore.setKeyEntry("mykey", cert.key(), new char[0], new Certificate[] {cert.cert()});
+    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);
-    certStore.setCertificateEntry("mycert", cert.cert());
     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()
@@ -491,8 +556,7 @@ public void from_tls_managers() throws Exception {
         .build();
     InternalChannelz.Tls tls = expectSuccessfulHandshake(channelCreds, serverCreds);
     assertThat(((X509Certificate) tls.remoteCert).getSubjectX500Principal().getName())
-        .isEqualTo("CN=" + TestUtils.TEST_SERVER_HOST);
-    cert.delete();
+        .isEqualTo("CN=*.test.google.com,O=Example\\, Co.,L=Chicago,ST=Illinois,C=US");
   }
 
   @Test
@@ -583,7 +647,7 @@ public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
             latch.countDown();
             super.handlerAdded(ctx);
           }
-        });
+        }, noopLogger);
 
     ChannelHandler lateAddingHandler = new ChannelInboundHandlerAdapter() {
       @Override
@@ -627,7 +691,7 @@ public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
             latch.countDown();
             super.handlerAdded(ctx);
           }
-        });
+        }, noopLogger);
 
     LocalAddress addr = new LocalAddress("local");
     ChannelFuture cf = new Bootstrap()
@@ -653,11 +717,10 @@ public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
   }
 
   @Test
-  public void tlsHandler_failsOnNullEngine() throws Exception {
-    thrown.expect(NullPointerException.class);
-    thrown.expectMessage("ssl");
-
-    Object unused = ProtocolNegotiators.serverTls(null);
+  public void tlsHandler_failsOnNullEngine() {
+    NullPointerException e = assertThrows(NullPointerException.class,
+        () -> ProtocolNegotiators.serverTls(null));
+    assertThat(e).hasMessageThat().isEqualTo("sslContext");
   }
 
 
@@ -776,8 +839,8 @@ public String applicationProtocol() {
       }
     };
 
-    File serverCert = TestUtils.loadCert("server1.pem");
-    File key = TestUtils.loadCert("server1.key");
+    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,
@@ -786,7 +849,6 @@ public String applicationProtocol() {
         alpnList);
 
     sslContext = GrpcSslContexts.forServer(serverCert, key)
-        .ciphers(TestUtils.preferredTestCiphers(), SupportedCipherSuiteFilter.INSTANCE)
         .applicationProtocolConfig(apn).build();
 
     ChannelHandler handler = new ServerTlsHandler(grpcHandler, sslContext, null);
@@ -813,8 +875,8 @@ public String applicationProtocol() {
       }
     };
 
-    File serverCert = TestUtils.loadCert("server1.pem");
-    File key = TestUtils.loadCert("server1.key");
+    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,
@@ -823,7 +885,6 @@ public String applicationProtocol() {
         alpnList);
 
     sslContext = GrpcSslContexts.forServer(serverCert, key)
-        .ciphers(TestUtils.preferredTestCiphers(), SupportedCipherSuiteFilter.INSTANCE)
         .applicationProtocolConfig(apn).build();
     ChannelHandler handler = new ServerTlsHandler(grpcHandler, sslContext, null);
     pipeline.addLast(handler);
@@ -860,7 +921,9 @@ public String applicationProtocol() {
     };
     DefaultEventLoopGroup elg = new DefaultEventLoopGroup(1);
 
-    ClientTlsHandler handler = new ClientTlsHandler(grpcHandler, sslContext, "authority", elg);
+    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);
@@ -884,8 +947,8 @@ public String applicationProtocol() {
     };
     DefaultEventLoopGroup elg = new DefaultEventLoopGroup(1);
 
-    File clientCert = TestUtils.loadCert("client.pem");
-    File key = TestUtils.loadCert("client.key");
+    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,
@@ -895,10 +958,11 @@ public String applicationProtocol() {
 
     sslContext = GrpcSslContexts.forClient()
         .keyManager(clientCert, key)
-        .ciphers(TestUtils.preferredTestCiphers(), SupportedCipherSuiteFilter.INSTANCE)
         .applicationProtocolConfig(apn).build();
 
-    ClientTlsHandler handler = new ClientTlsHandler(grpcHandler, sslContext, "authority", elg);
+    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);
@@ -921,7 +985,9 @@ public String applicationProtocol() {
     };
     DefaultEventLoopGroup elg = new DefaultEventLoopGroup(1);
 
-    ClientTlsHandler handler = new ClientTlsHandler(grpcHandler, sslContext, "authority", elg);
+    ClientTlsHandler handler = new ClientTlsHandler(grpcHandler, sslContext,
+        "authority", elg, noopLogger, Optional.absent(),
+        getClientTlsProtocolNegotiator(), null);
     pipeline.addLast(handler);
 
     final AtomicReference<Throwable> error = new AtomicReference<>();
@@ -948,7 +1014,9 @@ public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
 
   @Test
   public void clientTlsHandler_closeDuringNegotiation() throws Exception {
-    ClientTlsHandler handler = new ClientTlsHandler(grpcHandler, sslContext, "authority", null);
+    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);
 
@@ -960,6 +1028,12 @@ public void clientTlsHandler_closeDuringNegotiation() throws Exception {
         .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(grpcHandler, sslContext, null);
@@ -986,9 +1060,8 @@ public boolean isLoggable(LogRecord record) {
 
   @Test
   public void tls_failsOnNullSslContext() {
-    thrown.expect(NullPointerException.class);
-
-    Object unused = ProtocolNegotiators.tls(null);
+    assertThrows(NullPointerException.class,
+        () -> ProtocolNegotiators.tls(null, null));
   }
 
   @Test
@@ -1018,23 +1091,23 @@ public void tls_invalidHost() throws SSLException {
   }
 
   @Test
-  public void httpProxy_nullAddressNpe() throws Exception {
-    thrown.expect(NullPointerException.class);
-    Object unused =
-        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);
-    Object unused = 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()));
   }
 
@@ -1052,7 +1125,7 @@ public void httpProxy_completes() throws Exception {
         .bind(proxy).sync().channel();
 
     ProtocolNegotiator nego =
-        ProtocolNegotiators.httpProxy(proxy, null, null, ProtocolNegotiators.plaintext());
+        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 =
@@ -1115,7 +1188,7 @@ public void httpProxy_500() throws Exception {
         .bind(proxy).sync().channel();
 
     ProtocolNegotiator nego =
-        ProtocolNegotiators.httpProxy(proxy, null, null, ProtocolNegotiators.plaintext());
+        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 =
@@ -1146,14 +1219,84 @@ public void httpProxy_500() throws Exception {
     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();
-    thrown.expect(ProxyConnectException.class);
     try {
-      negotiationFuture.sync();
+      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);
@@ -1174,7 +1317,7 @@ public void userEventTriggered(ChannelHandlerContext ctx, Object evt) {
         .sync()
         .channel();
     Channel c = new Bootstrap()
-        .handler(new WaitUntilActiveHandler(next))
+        .handler(new WaitUntilActiveHandler(next, noopLogger))
         .channel(LocalChannel.class).group(group)
         .connect(addr)
         .sync()
@@ -1200,13 +1343,18 @@ public void userEventTriggered(ChannelHandlerContext ctx, Object evt) {
 
   @Test
   public void clientTlsHandler_firesNegotiation() throws Exception {
-    SelfSignedCertificate cert = new SelfSignedCertificate("authority");
-    SslContext clientSslContext =
-        GrpcSslContexts.configure(SslContextBuilder.forClient().trustManager(cert.cert())).build();
-    SslContext serverSslContext =
-        GrpcSslContexts.configure(SslContextBuilder.forServer(cert.key(), cert.cert())).build();
+    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);
+    ClientTlsProtocolNegotiator pn = new ClientTlsProtocolNegotiator(clientSslContext,
+        null, Optional.absent(), null, null);
     WriteBufferingAndExceptionHandler clientWbaeh =
         new WriteBufferingAndExceptionHandler(pn.newHandler(gh));
 
@@ -1338,7 +1486,7 @@ private static FakeGrpcHttp2ConnectionHandler newHandler(boolean noop) {
           new DefaultHttp2ConnectionDecoder(conn, encoder, new DefaultHttp2FrameReader());
       Http2Settings settings = new Http2Settings();
       return new FakeGrpcHttp2ConnectionHandler(
-          /*channelUnused=*/ null, decoder, encoder, settings, noop);
+          /*channelUnused=*/ null, decoder, encoder, settings, noop, noopLogger);
     }
 
     private final boolean noop;
@@ -1351,8 +1499,9 @@ private static FakeGrpcHttp2ConnectionHandler newHandler(boolean noop) {
         Http2ConnectionDecoder decoder,
         Http2ConnectionEncoder encoder,
         Http2Settings initialSettings,
-        boolean noop) {
-      super(channelUnused, decoder, encoder, initialSettings);
+        boolean noop,
+        ChannelLogger negotiationLogger) {
+      super(channelUnused, decoder, encoder, initialSettings, negotiationLogger);
       this.noop = noop;
     }
 
@@ -1389,7 +1538,7 @@ public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
 
     @Override
     public String getAuthority() {
-      return "authority";
+      return "foo.test.google.fr";
     }
   }
 
diff --git a/netty/src/test/java/io/grpc/netty/TcpMetricsTest.java b/netty/src/test/java/io/grpc/netty/TcpMetricsTest.java
new file mode 100644
index 00000000000..f75a98b46df
--- /dev/null
+++ b/netty/src/test/java/io/grpc/netty/TcpMetricsTest.java
@@ -0,0 +1,616 @@
+/*
+ * 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.netty;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNotSame;
+import static org.junit.Assert.assertTrue;
+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.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+
+import io.grpc.InternalTcpMetrics;
+import io.grpc.MetricRecorder;
+import io.netty.util.concurrent.ScheduledFuture;
+import java.net.InetAddress;
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Objects;
+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.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+@RunWith(JUnit4.class)
+public class TcpMetricsTest {
+
+  @Rule
+  public final MockitoRule mocks = MockitoJUnit.rule();
+
+  @Mock
+  private MetricRecorder metricRecorder;
+
+  private ConfigurableFakeWithTcpInfo channel;
+  private TcpMetrics metrics;
+
+  @Before
+  public void setUp() throws Exception {
+    FakeEpollTcpInfo dummyInfo = new FakeEpollTcpInfo();
+    channel = new ConfigurableFakeWithTcpInfo(dummyInfo);
+    metrics = new TcpMetrics(metricRecorder);
+  }
+
+  @After
+  public void tearDown() throws Exception {
+    TcpMetrics.epollInfo = TcpMetrics.loadEpollInfo();
+  }
+
+  @Test
+  public void metricsInitialization() {
+
+    assertNotNull(InternalTcpMetrics.CONNECTIONS_CREATED_INSTRUMENT);
+    assertNotNull(InternalTcpMetrics.CONNECTION_COUNT_INSTRUMENT);
+    assertNotNull(InternalTcpMetrics.PACKETS_RETRANSMITTED_INSTRUMENT);
+    assertNotNull(InternalTcpMetrics.RECURRING_RETRANSMITS_INSTRUMENT);
+    assertNotNull(InternalTcpMetrics.MIN_RTT_INSTRUMENT);
+  }
+
+  public static class FakeEpollTcpInfo {
+    long totalRetrans;
+    long retransmits;
+    long rtt;
+
+    public void setValues(long totalRetrans, long retransmits, long rtt) {
+      this.totalRetrans = totalRetrans;
+      this.retransmits = retransmits;
+      this.rtt = rtt;
+    }
+
+    @SuppressWarnings("unused")
+    public long totalRetrans() {
+      return totalRetrans;
+    }
+
+    @SuppressWarnings("unused")
+    public long retrans() {
+      return retransmits;
+    }
+
+    @SuppressWarnings("unused")
+    public long rtt() {
+      return rtt;
+    }
+  }
+
+  @Test
+  public void tracker_recordTcpInfo_reflectionSuccess() throws Exception {
+    MetricRecorder recorder = mock(MetricRecorder.class);
+    TcpMetrics.epollInfo = new TcpMetrics.EpollInfo(
+        ConfigurableFakeWithTcpInfo.class,
+        FakeEpollTcpInfo.class.getConstructor(),
+        ConfigurableFakeWithTcpInfo.class.getMethod("tcpInfo", FakeEpollTcpInfo.class),
+        FakeEpollTcpInfo.class.getMethod("totalRetrans"),
+        FakeEpollTcpInfo.class.getMethod("retrans"),
+        FakeEpollTcpInfo.class.getMethod("rtt"));
+    TcpMetrics tracker = new TcpMetrics(recorder);
+
+    FakeEpollTcpInfo infoSource = new FakeEpollTcpInfo();
+    infoSource.setValues(123, 4, 5000);
+    ConfigurableFakeWithTcpInfo channel = new ConfigurableFakeWithTcpInfo(infoSource);
+    channel.writeInbound("dummy");
+
+    tracker.channelInactive(channel);
+
+    verify(recorder).addLongCounter(
+        eq(Objects.requireNonNull(InternalTcpMetrics.PACKETS_RETRANSMITTED_INSTRUMENT)),
+        eq(123L), any(), any());
+    verify(recorder).addLongCounter(
+        eq(Objects.requireNonNull(InternalTcpMetrics.RECURRING_RETRANSMITS_INSTRUMENT)),
+        eq(4L), any(), any());
+    verify(recorder).recordDoubleHistogram(
+        eq(Objects.requireNonNull(InternalTcpMetrics.MIN_RTT_INSTRUMENT)),
+        eq(0.005), any(), any());
+  }
+
+  @Test
+  public void tracker_periodicRecord_doesNotRecordRecurringRetransmits() throws Exception {
+    MetricRecorder recorder = mock(MetricRecorder.class);
+    TcpMetrics.epollInfo = new TcpMetrics.EpollInfo(
+        ConfigurableFakeWithTcpInfo.class,
+        FakeEpollTcpInfo.class.getConstructor(),
+        ConfigurableFakeWithTcpInfo.class.getMethod("tcpInfo", FakeEpollTcpInfo.class),
+        FakeEpollTcpInfo.class.getMethod("totalRetrans"),
+        FakeEpollTcpInfo.class.getMethod("retrans"),
+        FakeEpollTcpInfo.class.getMethod("rtt"));
+    TcpMetrics tracker = new TcpMetrics(recorder);
+
+    FakeEpollTcpInfo infoSource = new FakeEpollTcpInfo();
+    infoSource.setValues(123, 4, 5000);
+    ConfigurableFakeWithTcpInfo channel = new ConfigurableFakeWithTcpInfo(infoSource);
+
+    tracker.channelActive(channel);
+
+    ScheduledFuture<?> timer = tracker.getReportTimer();
+    assertNotNull("Timer should be scheduled", timer);
+
+    long delay = timer.getDelay(TimeUnit.MILLISECONDS);
+    channel.advanceTimeBy(delay + 1, TimeUnit.MILLISECONDS);
+    channel.runScheduledPendingTasks();
+
+    verify(recorder).addLongCounter(
+        eq(Objects.requireNonNull(InternalTcpMetrics.PACKETS_RETRANSMITTED_INSTRUMENT)),
+        eq(123L), any(), any());
+    verify(recorder).recordDoubleHistogram(
+        eq(Objects.requireNonNull(InternalTcpMetrics.MIN_RTT_INSTRUMENT)),
+        eq(0.005), any(), any());
+    // Should NOT record recurring retransmits during periodic polling
+    verify(recorder, org.mockito.Mockito.never())
+        .addLongCounter(
+            eq(Objects.requireNonNull(InternalTcpMetrics.RECURRING_RETRANSMITS_INSTRUMENT)),
+            anyLong(), any(), any());
+  }
+
+  @Test
+  public void tracker_channelInactive_recordsRecurringRetransmits_raw_notDelta() throws Exception {
+    MetricRecorder recorder = mock(MetricRecorder.class);
+    TcpMetrics.epollInfo = new TcpMetrics.EpollInfo(
+        ConfigurableFakeWithTcpInfo.class,
+        FakeEpollTcpInfo.class.getConstructor(),
+        ConfigurableFakeWithTcpInfo.class.getMethod("tcpInfo", FakeEpollTcpInfo.class),
+        FakeEpollTcpInfo.class.getMethod("totalRetrans"),
+        FakeEpollTcpInfo.class.getMethod("retrans"),
+        FakeEpollTcpInfo.class.getMethod("rtt"));
+    TcpMetrics tracker = new TcpMetrics(recorder);
+
+    FakeEpollTcpInfo infoSource = new FakeEpollTcpInfo();
+    infoSource.setValues(123, 4, 5000);
+    ConfigurableFakeWithTcpInfo channel = new ConfigurableFakeWithTcpInfo(infoSource);
+
+    tracker.channelActive(channel);
+
+    ScheduledFuture<?> timer = tracker.getReportTimer();
+    assertNotNull("Timer should be scheduled", timer);
+
+    long delay = timer.getDelay(TimeUnit.MILLISECONDS);
+    channel.advanceTimeBy(delay + 1, TimeUnit.MILLISECONDS);
+    channel.runScheduledPendingTasks();
+
+    org.mockito.Mockito.clearInvocations(recorder);
+
+    // Let's just create a new channel instance where tcpInfo sets retrans=5.
+    FakeEpollTcpInfo infoSource2 = new FakeEpollTcpInfo();
+    infoSource2.setValues(130, 5, 5000);
+    ConfigurableFakeWithTcpInfo channel2 = new ConfigurableFakeWithTcpInfo(infoSource2);
+
+    tracker.channelInactive(channel2);
+
+    // It should record delta for totalRetrans (130 - 123 = 7)
+    verify(recorder).addLongCounter(
+        eq(Objects.requireNonNull(InternalTcpMetrics.PACKETS_RETRANSMITTED_INSTRUMENT)),
+        eq(7L), any(), any());
+    // But for recurringRetransmits it MUST record the raw value 5, not the delta!
+    verify(recorder).addLongCounter(
+        eq(Objects.requireNonNull(InternalTcpMetrics.RECURRING_RETRANSMITS_INSTRUMENT)),
+        eq(5L), any(), any());
+  }
+
+  @Test
+  public void tracker_periodicRecord_reportsDeltaForTotalRetrans() throws Exception {
+    MetricRecorder recorder = mock(MetricRecorder.class);
+    TcpMetrics.epollInfo = new TcpMetrics.EpollInfo(
+        ConfigurableFakeWithTcpInfo.class,
+        FakeEpollTcpInfo.class.getConstructor(),
+        ConfigurableFakeWithTcpInfo.class.getMethod("tcpInfo", FakeEpollTcpInfo.class),
+        FakeEpollTcpInfo.class.getMethod("totalRetrans"),
+        FakeEpollTcpInfo.class.getMethod("retrans"),
+        FakeEpollTcpInfo.class.getMethod("rtt"));
+    TcpMetrics tracker = new TcpMetrics(recorder);
+
+    FakeEpollTcpInfo infoSource = new FakeEpollTcpInfo();
+    infoSource.setValues(123, 4, 5000);
+    ConfigurableFakeWithTcpInfo channel = new ConfigurableFakeWithTcpInfo(infoSource);
+
+    tracker.channelActive(channel);
+
+    ScheduledFuture<?> timer = tracker.getReportTimer();
+    assertNotNull("Timer should be scheduled", timer);
+
+    long delay = timer.getDelay(TimeUnit.MILLISECONDS);
+    channel.advanceTimeBy(delay + 1, TimeUnit.MILLISECONDS);
+    channel.runScheduledPendingTasks();
+
+    verify(recorder).addLongCounter(
+        eq(Objects.requireNonNull(InternalTcpMetrics.PACKETS_RETRANSMITTED_INSTRUMENT)),
+        eq(123L), any(), any());
+
+    org.mockito.Mockito.clearInvocations(recorder);
+
+    // Change tcpInfo for second periodic record
+    infoSource.setValues(150, 2, 6000); // 150 - 123 = 27
+
+    ScheduledFuture<?> newTimer = tracker.getReportTimer();
+    assertNotNull("New timer should be scheduled", newTimer);
+    assertNotSame("Timer should be a new instance", timer, newTimer);
+    long newDelay = newTimer.getDelay(TimeUnit.MILLISECONDS);
+    channel.advanceTimeBy(newDelay + 1, TimeUnit.MILLISECONDS);
+    channel.runScheduledPendingTasks();
+
+    // Only the delta (150 - 123 = 27) should be recorded
+    verify(recorder).addLongCounter(
+        eq(Objects.requireNonNull(InternalTcpMetrics.PACKETS_RETRANSMITTED_INSTRUMENT)),
+        eq(27L), any(), any());
+    verify(recorder).recordDoubleHistogram(
+        eq(Objects.requireNonNull(InternalTcpMetrics.MIN_RTT_INSTRUMENT)),
+        eq(0.006), any(), any());
+    verify(recorder, org.mockito.Mockito.never())
+        .addLongCounter(
+            eq(Objects.requireNonNull(InternalTcpMetrics.RECURRING_RETRANSMITS_INSTRUMENT)),
+            anyLong(), any(), any());
+  }
+
+  @Test
+  public void tracker_periodicRecord_doesNotReportZeroDeltaForTotalRetrans() throws Exception {
+    MetricRecorder recorder = mock(MetricRecorder.class);
+    TcpMetrics.epollInfo = new TcpMetrics.EpollInfo(
+        ConfigurableFakeWithTcpInfo.class,
+        FakeEpollTcpInfo.class.getConstructor(),
+        ConfigurableFakeWithTcpInfo.class.getMethod("tcpInfo", FakeEpollTcpInfo.class),
+        FakeEpollTcpInfo.class.getMethod("totalRetrans"),
+        FakeEpollTcpInfo.class.getMethod("retrans"),
+        FakeEpollTcpInfo.class.getMethod("rtt"));
+    TcpMetrics tracker = new TcpMetrics(recorder);
+
+    FakeEpollTcpInfo infoSource = new FakeEpollTcpInfo();
+    infoSource.setValues(123, 4, 5000);
+    ConfigurableFakeWithTcpInfo channel = new ConfigurableFakeWithTcpInfo(infoSource);
+
+    tracker.channelActive(channel);
+
+    ScheduledFuture<?> timer = tracker.getReportTimer();
+    assertNotNull("Timer should be scheduled", timer);
+
+    long delay = timer.getDelay(TimeUnit.MILLISECONDS);
+    channel.advanceTimeBy(delay + 1, TimeUnit.MILLISECONDS);
+    channel.runScheduledPendingTasks();
+
+    verify(recorder).addLongCounter(
+        eq(Objects.requireNonNull(InternalTcpMetrics.PACKETS_RETRANSMITTED_INSTRUMENT)),
+        eq(123L), any(), any());
+
+    org.mockito.Mockito.clearInvocations(recorder);
+
+    // Keep tcpInfo the same for second periodic record
+    ScheduledFuture<?> newTimer = tracker.getReportTimer();
+    assertNotNull("New timer should be scheduled", newTimer);
+    assertNotSame("Timer should be a new instance", timer, newTimer);
+    long newDelay = newTimer.getDelay(TimeUnit.MILLISECONDS);
+    channel.advanceTimeBy(newDelay + 1, TimeUnit.MILLISECONDS);
+    channel.runScheduledPendingTasks();
+
+    // NO delta (123 - 123 = 0), so it should not be recorded
+    verify(recorder, org.mockito.Mockito.never())
+        .addLongCounter(
+            eq(Objects.requireNonNull(InternalTcpMetrics.PACKETS_RETRANSMITTED_INSTRUMENT)),
+            anyLong(), any(), any());
+
+    // MIN_RTT should be recorded again!
+    verify(recorder).recordDoubleHistogram(
+        eq(Objects.requireNonNull(InternalTcpMetrics.MIN_RTT_INSTRUMENT)),
+        eq(0.005), any(), any());
+  }
+
+  public static class ConfigurableFakeWithTcpInfo extends
+      io.netty.channel.embedded.EmbeddedChannel {
+    private final FakeEpollTcpInfo infoToCopy;
+
+    public ConfigurableFakeWithTcpInfo(FakeEpollTcpInfo infoToCopy) {
+      this.infoToCopy = infoToCopy;
+    }
+
+    public void tcpInfo(FakeEpollTcpInfo info) {
+      info.totalRetrans = infoToCopy.totalRetrans;
+      info.retransmits = infoToCopy.retransmits;
+      info.rtt = infoToCopy.rtt;
+    }
+  }
+
+  private static class AddressOverrideEmbeddedChannel extends
+      io.netty.channel.embedded.EmbeddedChannel {
+    private final SocketAddress local;
+    private final SocketAddress remote;
+
+    public AddressOverrideEmbeddedChannel(SocketAddress local, SocketAddress remote) {
+      this.local = local;
+      this.remote = remote;
+    }
+
+    @Override
+    public SocketAddress localAddress() {
+      return local;
+    }
+
+    @Override
+    public SocketAddress remoteAddress() {
+      return remote;
+    }
+  }
+
+  @Test
+  public void tracker_reportsDeltas_correctly() throws Exception {
+    MetricRecorder recorder = mock(MetricRecorder.class);
+
+    TcpMetrics.epollInfo = new TcpMetrics.EpollInfo(
+        ConfigurableFakeWithTcpInfo.class,
+        FakeEpollTcpInfo.class.getConstructor(),
+        ConfigurableFakeWithTcpInfo.class.getMethod("tcpInfo", FakeEpollTcpInfo.class),
+        FakeEpollTcpInfo.class.getMethod("totalRetrans"),
+        FakeEpollTcpInfo.class.getMethod("retrans"),
+        FakeEpollTcpInfo.class.getMethod("rtt"));
+    TcpMetrics tracker = new TcpMetrics(recorder);
+
+    FakeEpollTcpInfo infoSource = new FakeEpollTcpInfo();
+    ConfigurableFakeWithTcpInfo channel = new ConfigurableFakeWithTcpInfo(infoSource);
+
+    // 10 retransmits total
+    infoSource.setValues(10, 2, 1000);
+    tracker.recordTcpInfo(channel);
+
+    verify(recorder).addLongCounter(
+        eq(Objects.requireNonNull(InternalTcpMetrics.PACKETS_RETRANSMITTED_INSTRUMENT)),
+        eq(10L), any(), any());
+
+    // 15 retransmits total (delta 5)
+    infoSource.setValues(15, 0, 1000);
+    tracker.recordTcpInfo(channel);
+
+    verify(recorder).addLongCounter(
+        eq(Objects.requireNonNull(InternalTcpMetrics.PACKETS_RETRANSMITTED_INSTRUMENT)),
+        eq(5L), any(), any());
+
+    // 15 retransmits total (delta 0) - should NOT report
+    // also set retransmits to 1
+    infoSource.setValues(15, 1, 1000);
+    tracker.recordTcpInfo(channel);
+    // Verify no new interactions with this specific metric and value
+    // We can't easily verify "no interaction" for specific value without capturing.
+    verify(recorder, org.mockito.Mockito.times(1)).addLongCounter(
+        eq(Objects.requireNonNull(InternalTcpMetrics.PACKETS_RETRANSMITTED_INSTRUMENT)),
+        eq(10L), any(), any());
+    verify(recorder, org.mockito.Mockito.times(1)).addLongCounter(
+        eq(Objects.requireNonNull(InternalTcpMetrics.PACKETS_RETRANSMITTED_INSTRUMENT)),
+        eq(5L), any(), any());
+    // Total interactions for packetsRetransmitted should be 2
+    verify(recorder, org.mockito.Mockito.times(2)).addLongCounter(
+        eq(Objects.requireNonNull(InternalTcpMetrics.PACKETS_RETRANSMITTED_INSTRUMENT)),
+        anyLong(), any(), any());
+
+    // recurringRetransmits should NOT have been reported yet (periodic calls)
+    verify(recorder, org.mockito.Mockito.times(0)).addLongCounter(
+        eq(Objects.requireNonNull(InternalTcpMetrics.RECURRING_RETRANSMITS_INSTRUMENT)),
+        anyLong(), any(), any());
+
+    // Close channel - should report recurringRetransmits
+    tracker.channelInactive(channel);
+    verify(recorder, org.mockito.Mockito.times(1)).addLongCounter(
+        eq(Objects.requireNonNull(InternalTcpMetrics.RECURRING_RETRANSMITS_INSTRUMENT)),
+        eq(1L), // From last infoSource setValues(15, 1, 1000)
+        any(), any());
+  }
+
+  @Test
+  public void tracker_recordTcpInfo_reflectionFailure() {
+    MetricRecorder recorder = mock(MetricRecorder.class);
+
+    TcpMetrics.epollInfo = null;
+    TcpMetrics tracker = new TcpMetrics(recorder);
+
+    io.netty.channel.embedded.EmbeddedChannel channel = new
+        io.netty.channel.embedded.EmbeddedChannel();
+
+    // Should catch exception and ignore
+    tracker.channelInactive(channel);
+  }
+
+  @Test
+  public void registeredMetrics_haveCorrectOptionalLabels() {
+    List<String> expectedOptionalLabels = Arrays.asList(
+        "network.local.address",
+        "network.local.port",
+        "network.peer.address",
+        "network.peer.port");
+
+    assertEquals(
+        expectedOptionalLabels,
+        InternalTcpMetrics.CONNECTIONS_CREATED_INSTRUMENT.getOptionalLabelKeys());
+    assertEquals(
+        expectedOptionalLabels,
+        InternalTcpMetrics.CONNECTION_COUNT_INSTRUMENT.getOptionalLabelKeys());
+
+    assertEquals(
+        expectedOptionalLabels,
+        Objects.requireNonNull(InternalTcpMetrics.PACKETS_RETRANSMITTED_INSTRUMENT)
+            .getOptionalLabelKeys());
+    assertEquals(
+        expectedOptionalLabels,
+        Objects.requireNonNull(InternalTcpMetrics.RECURRING_RETRANSMITS_INSTRUMENT)
+            .getOptionalLabelKeys());
+    assertEquals(
+        expectedOptionalLabels,
+        Objects.requireNonNull(InternalTcpMetrics.MIN_RTT_INSTRUMENT).getOptionalLabelKeys());
+  }
+
+  @Test
+  public void channelActive_extractsLabels_ipv4() throws Exception {
+    InetAddress localInet = InetAddress.getByAddress(new byte[] {127, 0, 0, 1});
+    InetAddress remoteInet = InetAddress.getByAddress(new byte[] {127, 0, 0, 2});
+
+    AddressOverrideEmbeddedChannel channel = new AddressOverrideEmbeddedChannel(
+        new InetSocketAddress(localInet, 8080),
+        new InetSocketAddress(remoteInet, 443));
+
+    metrics.channelActive(channel);
+
+    verify(metricRecorder).addLongCounter(
+        eq(InternalTcpMetrics.CONNECTIONS_CREATED_INSTRUMENT), eq(1L),
+        eq(Collections.emptyList()),
+        eq(Arrays.asList("127.0.0.1", "8080", "127.0.0.2", "443")));
+    verify(metricRecorder).addLongUpDownCounter(
+        eq(InternalTcpMetrics.CONNECTION_COUNT_INSTRUMENT), eq(1L),
+        eq(Collections.emptyList()),
+        eq(Arrays.asList("127.0.0.1", "8080", "127.0.0.2", "443")));
+    verifyNoMoreInteractions(metricRecorder);
+  }
+
+  @Test
+  public void channelInactive_extractsLabels_ipv6() throws Exception {
+    InetAddress localInet = InetAddress.getByAddress(new byte[] {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1});
+    InetAddress remoteInet = InetAddress.getByAddress(new byte[] {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2});
+
+    AddressOverrideEmbeddedChannel channel = new AddressOverrideEmbeddedChannel(
+        new InetSocketAddress(localInet, 8080),
+        new InetSocketAddress(remoteInet, 443));
+
+    metrics.channelInactive(channel);
+
+    verify(metricRecorder).addLongUpDownCounter(
+        eq(InternalTcpMetrics.CONNECTION_COUNT_INSTRUMENT), eq(-1L),
+        eq(Collections.emptyList()),
+        eq(Arrays.asList("0:0:0:0:0:0:0:1", "8080", "0:0:0:0:0:0:0:2", "443")));
+    verifyNoMoreInteractions(metricRecorder);
+  }
+
+  @Test
+  public void channelActive_extractsLabels_nonInetAddress() {
+    SocketAddress dummyAddress = new SocketAddress() {
+    };
+    AddressOverrideEmbeddedChannel channel = new AddressOverrideEmbeddedChannel(
+        dummyAddress, dummyAddress);
+
+    metrics.channelActive(channel);
+
+    verify(metricRecorder).addLongCounter(
+        eq(InternalTcpMetrics.CONNECTIONS_CREATED_INSTRUMENT), eq(1L),
+        eq(Collections.emptyList()),
+        eq(Arrays.asList("", "", "", "")));
+    verify(metricRecorder).addLongUpDownCounter(
+        eq(InternalTcpMetrics.CONNECTION_COUNT_INSTRUMENT), eq(1L),
+        eq(Collections.emptyList()),
+        eq(Arrays.asList("", "", "", "")));
+    verifyNoMoreInteractions(metricRecorder);
+  }
+
+  @Test
+  public void channelActive_incrementsCounts() {
+    metrics.channelActive(channel);
+    verify(metricRecorder).addLongCounter(
+        eq(InternalTcpMetrics.CONNECTIONS_CREATED_INSTRUMENT), eq(1L),
+        eq(Collections.emptyList()),
+        eq(Arrays.asList("", "", "", "")));
+    verify(metricRecorder).addLongUpDownCounter(
+        eq(InternalTcpMetrics.CONNECTION_COUNT_INSTRUMENT), eq(1L),
+        eq(Collections.emptyList()),
+        eq(Arrays.asList("", "", "", "")));
+    verifyNoMoreInteractions(metricRecorder);
+  }
+
+  @Test
+  public void channelInactive_decrementsCount_noEpoll_noError() {
+    metrics.channelInactive(channel);
+    verify(metricRecorder).addLongUpDownCounter(
+        eq(InternalTcpMetrics.CONNECTION_COUNT_INSTRUMENT), eq(-1L),
+        eq(Collections.emptyList()),
+        eq(Arrays.asList("", "", "", "")));
+    verifyNoMoreInteractions(metricRecorder);
+  }
+
+  @Test
+  public void channelActive_schedulesReportTimer() throws Exception {
+    TcpMetrics.epollInfo = new TcpMetrics.EpollInfo(
+        ConfigurableFakeWithTcpInfo.class,
+        FakeEpollTcpInfo.class.getConstructor(),
+        ConfigurableFakeWithTcpInfo.class.getMethod("tcpInfo", FakeEpollTcpInfo.class),
+        FakeEpollTcpInfo.class.getMethod("totalRetrans"),
+        FakeEpollTcpInfo.class.getMethod("retrans"),
+        FakeEpollTcpInfo.class.getMethod("rtt"));
+
+    metrics = new TcpMetrics(metricRecorder);
+
+    FakeEpollTcpInfo infoSource = new FakeEpollTcpInfo();
+    ConfigurableFakeWithTcpInfo channel = new ConfigurableFakeWithTcpInfo(infoSource);
+
+    metrics.channelActive(channel);
+
+    ScheduledFuture<?> timer = metrics.getReportTimer();
+    assertNotNull("Timer should be scheduled", timer);
+
+    long delay = timer.getDelay(TimeUnit.MILLISECONDS);
+    assertTrue("Delay should be >= 30000 but was " + delay, delay >= 30_000);
+    assertTrue("Delay should be <= 330000 but was " + delay, delay <= 330_000);
+
+    // Advance time to trigger the task
+    channel.advanceTimeBy(delay + 1, TimeUnit.MILLISECONDS);
+    channel.runScheduledPendingTasks();
+
+    // Verify rescheduling
+    ScheduledFuture<?> newTimer = metrics.getReportTimer();
+    assertNotNull("New timer should be scheduled", newTimer);
+    assertNotSame("Timer should be a new instance", timer, newTimer);
+
+    long newDelay = newTimer.getDelay(TimeUnit.MILLISECONDS);
+    // Re-arming jitter is 90% to 110%, so 270,000 ms to 330,000 ms
+    assertTrue("Delay should be >= 270000 but was " + newDelay, newDelay >= 270_000);
+    assertTrue("Delay should be <= 330000 but was " + newDelay, newDelay <= 330_000);
+  }
+
+  @Test
+  public void channelInactive_cancelsReportTimer() throws Exception {
+    TcpMetrics.epollInfo = new TcpMetrics.EpollInfo(
+        ConfigurableFakeWithTcpInfo.class,
+        FakeEpollTcpInfo.class.getConstructor(),
+        ConfigurableFakeWithTcpInfo.class.getMethod("tcpInfo", FakeEpollTcpInfo.class),
+        FakeEpollTcpInfo.class.getMethod("totalRetrans"),
+        FakeEpollTcpInfo.class.getMethod("retrans"),
+        FakeEpollTcpInfo.class.getMethod("rtt"));
+
+    metrics = new TcpMetrics(metricRecorder);
+
+    FakeEpollTcpInfo infoSource = new FakeEpollTcpInfo();
+    ConfigurableFakeWithTcpInfo channel = new ConfigurableFakeWithTcpInfo(infoSource);
+
+    metrics.channelActive(channel);
+
+    ScheduledFuture<?> timer = metrics.getReportTimer();
+    assertNotNull("Timer should be scheduled", timer);
+
+    metrics.channelInactive(channel);
+
+    assertTrue("Timer should be cancelled", timer.isCancelled());
+  }
+}
diff --git a/netty/src/test/java/io/grpc/netty/TlsTest.java b/netty/src/test/java/io/grpc/netty/TlsTest.java
index 344297a321f..c5b46563878 100644
--- a/netty/src/test/java/io/grpc/netty/TlsTest.java
+++ b/netty/src/test/java/io/grpc/netty/TlsTest.java
@@ -49,6 +49,7 @@
 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;
@@ -185,6 +186,57 @@ public void basicClientServerIntegrationTest() throws Exception {
     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.
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..1766a8e4134
--- /dev/null
+++ b/netty/src/test/java/io/grpc/netty/UdsNameResolverProviderTest.java
@@ -0,0 +1,157 @@
+/*
+ * 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 com.google.common.truth.TruthJUnit.assume;
+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.Uri;
+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.Arrays;
+import java.util.List;
+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.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(Parameterized.class)
+public class UdsNameResolverProviderTest {
+  private static final int DEFAULT_PORT = 887;
+
+  @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();
+
+  @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 = newNameResolver("unix:sock.sock", args);
+    DomainSocketAddress domainSocketAddress = startAndGetUniqueResolvedAddress(udsNameResolver);
+    assertThat(domainSocketAddress.path()).isEqualTo("sock.sock");
+  }
+
+  @Test
+  public void testUnixAbsolutePath() {
+    UdsNameResolver udsNameResolver = newNameResolver("unix:/sock.sock", args);
+    DomainSocketAddress domainSocketAddress = startAndGetUniqueResolvedAddress(udsNameResolver);
+    assertThat(domainSocketAddress.path()).isEqualTo("/sock.sock");
+  }
+
+  @Test
+  public void testUnixAbsoluteAlternatePath() {
+    UdsNameResolver udsNameResolver = newNameResolver("unix:///sock.sock", args);
+    DomainSocketAddress domainSocketAddress = startAndGetUniqueResolvedAddress(udsNameResolver);
+    assertThat(domainSocketAddress.path()).isEqualTo("/sock.sock");
+  }
+
+  @Test
+  public void testUnixPathWithAuthority() {
+    try {
+      newNameResolver("unix://localhost/sock.sock", args);
+      fail("exception expected");
+    } catch (IllegalArgumentException e) {
+      assertThat(e).hasMessageThat().isEqualTo("authority not supported: localhost");
+    }
+  }
+
+  @Test
+  public void testUnixAbsolutePathDoesNotIncludeQueryOrFragment() {
+    UdsNameResolver udsNameResolver = newNameResolver("unix:///sock.sock?query#fragment", args);
+    DomainSocketAddress domainSocketAddress = startAndGetUniqueResolvedAddress(udsNameResolver);
+    assertThat(domainSocketAddress.path()).isEqualTo("/sock.sock");
+  }
+
+  @Test
+  public void testUnixRelativePathDoesNotIncludeQueryOrFragment() {
+    // This test fails without RFC 3986 support because of a bug in the legacy java.net.URI-based
+    // NRP implementation.
+    assume().that(enableRfc3986UrisParam).isTrue();
+
+    UdsNameResolver udsNameResolver = newNameResolver("unix:sock.sock?query#fragment", args);
+    DomainSocketAddress domainSocketAddress = startAndGetUniqueResolvedAddress(udsNameResolver);
+    assertThat(domainSocketAddress.path()).isEqualTo("sock.sock");
+  }
+
+  private UdsNameResolver newNameResolver(String uriString, NameResolver.Args args) {
+    return enableRfc3986UrisParam
+        ? (UdsNameResolver) udsNameResolverProvider.newNameResolver(Uri.create(uriString), args)
+        : udsNameResolverProvider.newNameResolver(URI.create(uriString), args);
+  }
+
+  private DomainSocketAddress startAndGetUniqueResolvedAddress(UdsNameResolver udsNameResolver) {
+    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);
+    return (DomainSocketAddress) addresses.get(0);
+  }
+}
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..7bf808c18ce
--- /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("somehost", "sock.sock", args);
+      fail("exception expected");
+    } catch (IllegalArgumentException e) {
+      assertThat(e).hasMessageThat().isEqualTo("authority not supported: somehost");
+    }
+  }
+}
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 90330a5fe96..95f57732117 100644
--- a/netty/src/test/java/io/grpc/netty/UtilsTest.java
+++ b/netty/src/test/java/io/grpc/netty/UtilsTest.java
@@ -19,6 +19,7 @@
 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;
 
@@ -28,6 +29,7 @@
 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;
@@ -70,6 +72,21 @@ public void testStatusFromThrowable() {
     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();
diff --git a/netty/src/test/java/io/grpc/netty/WriteQueueTest.java b/netty/src/test/java/io/grpc/netty/WriteQueueTest.java
index 209d0a3c1fa..a83822fd70a 100644
--- a/netty/src/test/java/io/grpc/netty/WriteQueueTest.java
+++ b/netty/src/test/java/io/grpc/netty/WriteQueueTest.java
@@ -40,8 +40,9 @@
 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)
@@ -49,6 +50,8 @@ public class WriteQueueTest {
 
   @Rule
   public final Timeout globalTimeout = Timeout.seconds(60);
+  @Rule
+  public final MockitoRule mocks = MockitoJUnit.rule();
 
   private final Object lock = new Object();
 
@@ -66,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);
diff --git a/okhttp/BUILD.bazel b/okhttp/BUILD.bazel
index d690086df8f..74a9f7a4300 100644
--- a/okhttp/BUILD.bazel
+++ b/okhttp/BUILD.bazel
@@ -1,3 +1,6 @@
+load("@rules_java//java:defs.bzl", "java_library")
+load("@rules_jvm_external//:defs.bzl", "artifact")
+
 java_library(
     name = "okhttp",
     srcs = glob([
@@ -11,12 +14,12 @@ java_library(
     deps = [
         "//api",
         "//core:internal",
-        "@com_google_code_findbugs_jsr305//jar",
-        "@com_google_errorprone_error_prone_annotations//jar",
-        "@com_google_guava_guava//jar",
-        "@com_google_j2objc_j2objc_annotations//jar",
-        "@com_squareup_okhttp_okhttp//jar",
-        "@com_squareup_okio_okio//jar",
-        "@io_perfmark_perfmark_api//jar",
+        "//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 d28d4e00ca2..6c542feec9c 100644
--- a/okhttp/build.gradle
+++ b/okhttp/build.gradle
@@ -8,24 +8,39 @@ plugins {
 
 description = "gRPC: OkHttp"
 
-evaluationDependsOn(project(':grpc-core').path)
+tasks.named("jar").configure {
+    manifest {
+        attributes('Automatic-Module-Name': 'io.grpc.okhttp')
+    }
+}
 
 dependencies {
-    api project(':grpc-core')
-    api (libraries.okhttp) {
-        // prefer our own versions instead of okhttp's dependency
-        exclude group: 'com.squareup.okio', module: 'okio'
-    }
-    implementation libraries.okio
-    guavaDependency 'implementation'
-    perfmarkDependency 'implementation'
+    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.
-    testImplementation project(':grpc-core').sourceSets.test.output,
-            project(':grpc-api').sourceSets.test.output,
+    testImplementation testFixtures(project(':grpc-core')),
+            testFixtures(project(':grpc-api')),
             project(':grpc-testing'),
-            project(':grpc-netty')
-    signature "org.codehaus.mojo.signature:java17:1.0@signature"
-    signature "net.sf.androidscents.signature:android-api-level-14:4.0_r4@signature"
+            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 {
@@ -33,15 +48,19 @@ project.sourceSets {
     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 {
-    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/**'
 }
 
-jacocoTestReport {
+tasks.named("jacocoTestReport").configure {
     classDirectories.from = sourceSets.main.output.collect {
         fileTree(dir: it,
         exclude: [
diff --git a/okhttp/src/main/java/io/grpc/okhttp/AsyncSink.java b/okhttp/src/main/java/io/grpc/okhttp/AsyncSink.java
index a8cfbcaad2f..01ee23b905c 100644
--- a/okhttp/src/main/java/io/grpc/okhttp/AsyncSink.java
+++ b/okhttp/src/main/java/io/grpc/okhttp/AsyncSink.java
@@ -19,21 +19,26 @@
 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 javax.annotation.concurrent.GuardedBy;
 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.
+ * 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 {
 
@@ -41,6 +46,7 @@ final class AsyncSink implements Sink {
   private final Buffer buffer = new Buffer();
   private final SerializingExecutor serializingExecutor;
   private final TransportExceptionHandler transportExceptionHandler;
+  private final int maxQueuedControlFrames;
 
   @GuardedBy("lock")
   private boolean writeEnqueued = false;
@@ -51,15 +57,26 @@ final class AsyncSink implements Sink {
   private Sink sink;
   @Nullable
   private Socket socket;
+  private boolean controlFramesExceeded;
+  private int controlFramesInWrite;
+  @GuardedBy("lock")
+  private int queuedControlFrames;
 
-  private AsyncSink(SerializingExecutor executor, TransportExceptionHandler exceptionHandler) {
+  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) {
-    return new AsyncSink(executor, exceptionHandler);
+      SerializingExecutor executor, TransportExceptionHandler exceptionHandler,
+      int maxQueuedControlFrames) {
+    return new AsyncSink(executor, exceptionHandler, maxQueuedControlFrames);
   }
 
   /**
@@ -74,41 +91,63 @@ void becomeConnected(Sink sink, Socket socket) {
     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");
     }
-    PerfMark.startTask("AsyncSink.write");
-    try {
+    try (TaskCloseable ignore = PerfMark.traceTask("AsyncSink.write")) {
+      boolean closeSocket = false;
       synchronized (lock) {
         buffer.write(source, byteCount);
-        if (writeEnqueued || flushEnqueued || buffer.completeSegmentByteCount() <= 0) {
-          return;
+
+        queuedControlFrames += controlFramesInWrite;
+        controlFramesInWrite = 0;
+        if (!controlFramesExceeded && queuedControlFrames > maxQueuedControlFrames) {
+          controlFramesExceeded = true;
+          closeSocket = true;
+        } else {
+          if (writeEnqueued || flushEnqueued || buffer.completeSegmentByteCount() <= 0) {
+            return;
+          }
+          writeEnqueued = true;
         }
-        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 {
-          PerfMark.startTask("WriteRunnable.runWrite");
-          PerfMark.linkIn(link);
           Buffer buf = new Buffer();
-          try {
+          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());
-          } finally {
-            PerfMark.stopTask("WriteRunnable.runWrite");
+            synchronized (lock) {
+              queuedControlFrames -= writingControlFrames;
+            }
           }
         }
       });
-    } finally {
-      PerfMark.stopTask("AsyncSink.write");
     }
   }
 
@@ -117,8 +156,7 @@ public void flush() throws IOException {
     if (closed) {
       throw new IOException("closed");
     }
-    PerfMark.startTask("AsyncSink.flush");
-    try {
+    try (TaskCloseable ignore = PerfMark.traceTask("AsyncSink.flush")) {
       synchronized (lock) {
         if (flushEnqueued) {
           return;
@@ -129,23 +167,18 @@ public void flush() throws IOException {
         final Link link = PerfMark.linkOut();
         @Override
         public void doRun() throws IOException {
-          PerfMark.startTask("WriteRunnable.runFlush");
-          PerfMark.linkIn(link);
           Buffer buf = new Buffer();
-          try {
+          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();
-          } finally {
-            PerfMark.stopTask("WriteRunnable.runFlush");
           }
         }
       });
-    } finally {
-      PerfMark.stopTask("AsyncSink.flush");
     }
   }
 
@@ -163,6 +196,13 @@ public void close() {
     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) {
@@ -197,4 +237,30 @@ public final void run() {
 
     public abstract void doRun() throws IOException;
   }
-}
\ No newline at end of file
+
+  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
index 9f7074121fc..2e21b1547d8 100644
--- a/okhttp/src/main/java/io/grpc/okhttp/ExceptionHandlingFrameWriter.java
+++ b/okhttp/src/main/java/io/grpc/okhttp/ExceptionHandlingFrameWriter.java
@@ -31,6 +31,12 @@
 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());
@@ -39,23 +45,14 @@ final class ExceptionHandlingFrameWriter implements FrameWriter {
 
   private final FrameWriter frameWriter;
 
-  private final OkHttpFrameLogger frameLogger;
+  private final OkHttpFrameLogger frameLogger =
+      new OkHttpFrameLogger(Level.FINE, OkHttpClientTransport.class);
 
   ExceptionHandlingFrameWriter(
       TransportExceptionHandler transportExceptionHandler, FrameWriter frameWriter) {
-    this(transportExceptionHandler, frameWriter,
-        new OkHttpFrameLogger(Level.FINE, OkHttpClientTransport.class));
-  }
-
-  @VisibleForTesting
-  ExceptionHandlingFrameWriter(
-      TransportExceptionHandler transportExceptionHandler,
-      FrameWriter frameWriter,
-      OkHttpFrameLogger frameLogger) {
     this.transportExceptionHandler =
         checkNotNull(transportExceptionHandler, "transportExceptionHandler");
     this.frameWriter = Preconditions.checkNotNull(frameWriter, "frameWriter");
-    this.frameLogger = Preconditions.checkNotNull(frameLogger, "frameLogger");
   }
 
   @Override
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 15008f8040f..ff2033b35be 100644
--- a/okhttp/src/main/java/io/grpc/okhttp/Headers.java
+++ b/okhttp/src/main/java/io/grpc/okhttp/Headers.java
@@ -16,9 +16,6 @@
 
 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;
@@ -39,7 +36,7 @@ class Headers {
   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);
 
   /**
@@ -58,10 +55,7 @@ public static List<Header> createRequestHeaders(
     Preconditions.checkNotNull(defaultPath, "defaultPath");
     Preconditions.checkNotNull(authority, "authority");
 
-    // Discard any application supplied duplicates of the reserved headers
-    headers.discardAll(GrpcUtil.CONTENT_TYPE_KEY);
-    headers.discardAll(GrpcUtil.TE_HEADER);
-    headers.discardAll(GrpcUtil.USER_AGENT_KEY);
+    stripNonApplicationHeaders(headers);
 
     // 7 is the number of explicit add calls below.
     List<Header> okhttpHeaders = new ArrayList<>(7 + InternalMetadata.headerCount(headers));
@@ -89,27 +83,72 @@ public static List<Header> createRequestHeaders(
     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/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/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 f7d0d973802..43bc92af092 100644
--- a/okhttp/src/main/java/io/grpc/okhttp/OkHttpChannelBuilder.java
+++ b/okhttp/src/main/java/io/grpc/okhttp/OkHttpChannelBuilder.java
@@ -17,11 +17,13 @@
 package io.grpc.okhttp;
 
 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.google.errorprone.annotations.CheckReturnValue;
 import io.grpc.CallCredentials;
 import io.grpc.ChannelCredentials;
 import io.grpc.ChannelLogger;
@@ -29,34 +31,40 @@
 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.ManagedChannelBuilder;
 import io.grpc.TlsChannelCredentials;
-import io.grpc.internal.AbstractManagedChannelImplBuilder;
 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.KeepAliveManager;
 import io.grpc.internal.ManagedChannelImplBuilder;
 import io.grpc.internal.ManagedChannelImplBuilder.ChannelBuilderDefaultPortProvider;
 import io.grpc.internal.ManagedChannelImplBuilder.ClientTransportFactoryBuilder;
-import io.grpc.internal.SharedResourceHolder;
+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.cert.CertificateFactory;
+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;
@@ -66,25 +74,23 @@
 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.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;
-import javax.net.ssl.TrustManagerFactory;
-import javax.security.auth.x500.X500Principal;
 
 /** Convenience class for building channels with the OkHttp transport. */
 @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1785")
-public final 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();
 
 
@@ -100,19 +106,35 @@ private enum NegotiationType {
     PLAINTEXT
   }
 
-  @VisibleForTesting
+  // @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_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,
+              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();
+
+  // @VisibleForTesting
+  static final ConnectionSpec INTERNAL_LEGACY_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_128_GCM_SHA256,
               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)
+              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)
           .tlsVersions(TlsVersion.TLS_1_2)
           .supportsTlsExtensions(true)
           .build();
@@ -130,6 +152,8 @@ 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) {
@@ -161,14 +185,15 @@ public static OkHttpChannelBuilder forTarget(String target, ChannelCredentials c
     return new OkHttpChannelBuilder(target, creds, result.callCredentials, result.factory);
   }
 
-  private Executor transportExecutor;
-  private ScheduledExecutorService scheduledExecutorService;
+  private ObjectPool<Executor> transportExecutorPool = DEFAULT_TRANSPORT_EXECUTOR_POOL;
+  private ObjectPool<ScheduledExecutorService> scheduledExecutorServicePool =
+      SharedResourcePool.forResource(GrpcUtil.TIMER_SERVICE);
 
   private SocketFactory socketFactory;
   private SSLSocketFactory sslSocketFactory;
   private final boolean freezeSecurityConfiguration;
   private HostnameVerifier hostnameVerifier;
-  private ConnectionSpec connectionSpec = INTERNAL_DEFAULT_CONNECTION_SPEC;
+  private ConnectionSpec connectionSpec = initialConnectionSpec();
   private NegotiationType negotiationType = NegotiationType.TLS;
   private long keepAliveTimeNanos = KEEPALIVE_TIME_NANOS_DISABLED;
   private long keepAliveTimeoutNanos = DEFAULT_KEEPALIVE_TIMEOUT_NANOS;
@@ -183,6 +208,12 @@ public static OkHttpChannelBuilder forTarget(String target, ChannelCredentials c
    */
   private final boolean useGetForSafeMethods = false;
 
+  private static ConnectionSpec initialConnectionSpec() {
+    return (OkHttpProtocolNegotiator.get() instanceof OkHttpProtocolNegotiator.AndroidNegotiator)
+        ? INTERNAL_DEFAULT_CONNECTION_SPEC
+        : INTERNAL_LEGACY_CONNECTION_SPEC;
+  }
+
   private OkHttpChannelBuilder(String host, int port) {
     this(GrpcUtil.authorityFromHostAndPort(host, port));
   }
@@ -192,6 +223,7 @@ private OkHttpChannelBuilder(String target) {
         new OkHttpChannelTransportFactoryBuilder(),
         new OkHttpChannelDefaultPortProvider());
     this.freezeSecurityConfiguration = false;
+    this.channelCredentials = null;
   }
 
   OkHttpChannelBuilder(
@@ -204,6 +236,7 @@ private OkHttpChannelBuilder(String target) {
     this.sslSocketFactory = factory;
     this.negotiationType = factory == null ? NegotiationType.PLAINTEXT : NegotiationType.TLS;
     this.freezeSecurityConfiguration = true;
+    this.channelCredentials = channelCreds;
   }
 
   private final class OkHttpChannelTransportFactoryBuilder
@@ -241,7 +274,11 @@ OkHttpChannelBuilder setTransportTracerFactory(TransportTracer.Factory transport
    * to shutdown the executor when appropriate.
    */
   public OkHttpChannelBuilder transportExecutor(@Nullable Executor transportExecutor) {
-    this.transportExecutor = transportExecutor;
+    if (transportExecutor == null) {
+      this.transportExecutorPool = DEFAULT_TRANSPORT_EXECUTOR_POOL;
+    } else {
+      this.transportExecutorPool = new FixedObjectPool<>(transportExecutor);
+    }
     return this;
   }
 
@@ -397,6 +434,34 @@ public OkHttpChannelBuilder connectionSpec(
     return this;
   }
 
+  /**
+   * 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 OkHttpChannelBuilder usePlaintext() {
@@ -434,8 +499,8 @@ public OkHttpChannelBuilder useTransportSecurity() {
    */
   public OkHttpChannelBuilder scheduledExecutorService(
       ScheduledExecutorService scheduledExecutorService) {
-    this.scheduledExecutorService =
-        checkNotNull(scheduledExecutorService, "scheduledExecutorService");
+    this.scheduledExecutorServicePool =
+        new FixedObjectPool<>(checkNotNull(scheduledExecutorService, "scheduledExecutorService"));
     return this;
   }
 
@@ -471,11 +536,11 @@ public OkHttpChannelBuilder maxInboundMessageSize(int max) {
     return this;
   }
 
-  ClientTransportFactory buildTransportFactory() {
+  OkHttpTransportFactory buildTransportFactory() {
     boolean enableKeepAlive = keepAliveTimeNanos != KEEPALIVE_TIME_NANOS_DISABLED;
     return new OkHttpTransportFactory(
-        transportExecutor,
-        scheduledExecutorService,
+        transportExecutorPool,
+        scheduledExecutorServicePool,
         socketFactory,
         createSslSocketFactory(),
         hostnameVerifier,
@@ -488,7 +553,8 @@ ClientTransportFactory buildTransportFactory() {
         keepAliveWithoutCalls,
         maxInboundMetadataSize,
         transportTracerFactory,
-        useGetForSafeMethods);
+        useGetForSafeMethods,
+        channelCredentials);
   }
 
   OkHttpChannelBuilder disableCheckAuthority() {
@@ -554,7 +620,16 @@ static SslSocketFactoryResult sslSocketFactoryFrom(ChannelCredentials creds) {
       if (tlsCreds.getKeyManagers() != null) {
         km = tlsCreds.getKeyManagers().toArray(new KeyManager[0]);
       } else if (tlsCreds.getPrivateKey() != null) {
-        return SslSocketFactoryResult.error("byte[]-based private key unsupported. Use KeyManager");
+        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) {
@@ -609,7 +684,27 @@ static SslSocketFactoryResult sslSocketFactoryFrom(ChannelCredentials creds) {
     }
   }
 
-  static TrustManager[] createTrustManager(byte[] rootCerts) throws GeneralSecurityException {
+  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);
@@ -617,20 +712,25 @@ static TrustManager[] createTrustManager(byte[] rootCerts) throws GeneralSecurit
       // Shouldn't really happen, as we're not loading any data.
       throw new GeneralSecurityException(ex);
     }
-    CertificateFactory cf = CertificateFactory.getInstance("X.509");
-    ByteArrayInputStream in = new ByteArrayInputStream(rootCerts);
+    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 {
-      X509Certificate cert = (X509Certificate) cf.generateCertificate(in);
-      X500Principal principal = cert.getSubjectX500Principal();
-      ks.setCertificateEntry(principal.getName("RFC2253"), cert);
+      return io.grpc.internal.CertificateUtils.createTrustManager(rootCertsStream);
     } finally {
-      GrpcUtil.closeQuietly(in);
+      GrpcUtil.closeQuietly(rootCertsStream);
     }
+  }
 
-    TrustManagerFactory trustManagerFactory =
-        TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
-    trustManagerFactory.init(ks);
-    return trustManagerFactory.getTrustManagers();
+  static Collection<Class<? extends SocketAddress>> getSupportedSocketAddressTypes() {
+    return Collections.singleton(InetSocketAddress.class);
   }
 
   static final class SslSocketFactoryResult {
@@ -678,30 +778,31 @@ public SslSocketFactoryResult withCallCredentials(CallCredentials callCreds) {
    */
   @Internal
   static final class OkHttpTransportFactory implements ClientTransportFactory {
-    private final Executor executor;
-    private final boolean usingSharedExecutor;
-    private final boolean usingSharedScheduler;
-    private final TransportTracer.Factory transportTracerFactory;
-    private final SocketFactory socketFactory;
-    @Nullable private final SSLSocketFactory sslSocketFactory;
+    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 HostnameVerifier hostnameVerifier;
-    private final ConnectionSpec connectionSpec;
-    private final int maxMessageSize;
+    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;
-    private final int flowControlWindow;
+    final int flowControlWindow;
     private final boolean keepAliveWithoutCalls;
-    private final int maxInboundMetadataSize;
-    private final ScheduledExecutorService timeoutService;
-    private final boolean useGetForSafeMethods;
+    final int maxInboundMetadataSize;
+    final boolean useGetForSafeMethods;
+    private final ChannelCredentials channelCredentials;
     private boolean closed;
 
     private OkHttpTransportFactory(
-        Executor executor,
-        @Nullable ScheduledExecutorService timeoutService,
+        ObjectPool<Executor> executorPool,
+        ObjectPool<ScheduledExecutorService> scheduledExecutorServicePool,
         @Nullable SocketFactory socketFactory,
         @Nullable SSLSocketFactory sslSocketFactory,
         @Nullable HostnameVerifier hostnameVerifier,
@@ -714,10 +815,12 @@ private OkHttpTransportFactory(
         boolean keepAliveWithoutCalls,
         int maxInboundMetadataSize,
         TransportTracer.Factory transportTracerFactory,
-        boolean useGetForSafeMethods) {
-      usingSharedScheduler = timeoutService == null;
-      this.timeoutService = usingSharedScheduler
-          ? SharedResourceHolder.get(GrpcUtil.TIMER_SERVICE) : timeoutService;
+        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;
@@ -731,16 +834,10 @@ private OkHttpTransportFactory(
       this.keepAliveWithoutCalls = keepAliveWithoutCalls;
       this.maxInboundMetadataSize = maxInboundMetadataSize;
       this.useGetForSafeMethods = useGetForSafeMethods;
+      this.channelCredentials = channelCredentials;
 
-      usingSharedExecutor = executor == null;
       this.transportTracerFactory =
           Preconditions.checkNotNull(transportTracerFactory, "transportTracerFactory");
-      if (usingSharedExecutor) {
-        // The executor was unspecified, using the shared executor.
-        this.executor = SharedResourceHolder.get(SHARED_EXECUTOR);
-      } else {
-        this.executor = executor;
-      }
     }
 
     @Override
@@ -759,22 +856,14 @@ public void run() {
       InetSocketAddress inetSocketAddr = (InetSocketAddress) addr;
       // TODO(carl-mastrangelo): Pass channelLogger in.
       OkHttpClientTransport transport = new OkHttpClientTransport(
+          this,
           inetSocketAddr,
           options.getAuthority(),
           options.getUserAgent(),
           options.getEagAttributes(),
-          executor,
-          socketFactory,
-          sslSocketFactory,
-          hostnameVerifier,
-          connectionSpec,
-          maxMessageSize,
-          flowControlWindow,
           options.getHttpConnectProxiedSocketAddress(),
           tooManyPingsRunnable,
-          maxInboundMetadataSize,
-          transportTracerFactory.create(),
-          useGetForSafeMethods);
+          channelCredentials);
       if (enableKeepAlive) {
         transport.enableKeepAlive(
             true, keepAliveTimeNanosState.get(), keepAliveTimeoutNanos, keepAliveWithoutCalls);
@@ -784,7 +873,7 @@ public void run() {
 
     @Override
     public ScheduledExecutorService getScheduledExecutorService() {
-      return timeoutService;
+      return scheduledExecutorService;
     }
 
     @Nullable
@@ -796,8 +885,8 @@ public SwapChannelCredentialsResult swapChannelCredentials(ChannelCredentials ch
         return null;
       }
       ClientTransportFactory factory = new OkHttpTransportFactory(
-          executor,
-          timeoutService,
+          executorPool,
+          scheduledExecutorServicePool,
           socketFactory,
           result.factory,
           hostnameVerifier,
@@ -810,7 +899,8 @@ public SwapChannelCredentialsResult swapChannelCredentials(ChannelCredentials ch
           keepAliveWithoutCalls,
           maxInboundMetadataSize,
           transportTracerFactory,
-          useGetForSafeMethods);
+          useGetForSafeMethods,
+          channelCredentials);
       return new SwapChannelCredentialsResult(factory, result.callCredentials);
     }
 
@@ -821,13 +911,13 @@ public void close() {
       }
       closed = true;
 
-      if (usingSharedScheduler) {
-        SharedResourceHolder.release(GrpcUtil.TIMER_SERVICE, timeoutService);
-      }
+      executorPool.returnObject(executor);
+      scheduledExecutorServicePool.returnObject(scheduledExecutorService);
+    }
 
-      if (usingSharedExecutor) {
-        SharedResourceHolder.release(SHARED_EXECUTOR, executor);
-      }
+    @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 19f99d05029..bf2a9be6fee 100644
--- a/okhttp/src/main/java/io/grpc/okhttp/OkHttpChannelProvider.java
+++ b/okhttp/src/main/java/io/grpc/okhttp/OkHttpChannelProvider.java
@@ -20,6 +20,8 @@
 import io.grpc.Internal;
 import io.grpc.InternalServiceProviders;
 import io.grpc.ManagedChannelProvider;
+import java.net.SocketAddress;
+import java.util.Collection;
 
 /**
  * Provider for {@link OkHttpChannelBuilder} instances.
@@ -57,4 +59,9 @@ public NewChannelBuilderResult newChannelBuilder(String target, ChannelCredentia
     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 baf659a6278..8dd55d9f23e 100644
--- a/okhttp/src/main/java/io/grpc/okhttp/OkHttpClientStream.java
+++ b/okhttp/src/main/java/io/grpc/okhttp/OkHttpClientStream.java
@@ -21,6 +21,7 @@
 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;
@@ -35,8 +36,8 @@
 import io.grpc.okhttp.internal.framed.Header;
 import io.perfmark.PerfMark;
 import io.perfmark.Tag;
+import io.perfmark.TaskCloseable;
 import java.util.List;
-import javax.annotation.concurrent.GuardedBy;
 import okio.Buffer;
 
 /**
@@ -53,8 +54,6 @@ class OkHttpClientStream extends AbstractClientStream {
   private final String userAgent;
   private final StatsTraceContext statsTraceCtx;
   private String authority;
-  private Object outboundFlowState;
-  private volatile int id = ABSENT_ID;
   private final TransportState state;
   private final Sink sink = new Sink();
   private final Attributes attributes;
@@ -100,7 +99,8 @@ class OkHttpClientStream extends AbstractClientStream {
             outboundFlow,
             transport,
             initialWindowSize,
-            method.getFullMethodName());
+            method.getFullMethodName(),
+            callOptions);
   }
 
   @Override
@@ -120,10 +120,6 @@ public MethodDescriptor.MethodType getType() {
     return method.getType();
   }
 
-  public int id() {
-    return id;
-  }
-
   /**
    * Returns whether the stream uses GET. This is not known until after {@link Sink#writeHeaders} is
    * invoked.
@@ -145,60 +141,52 @@ public Attributes getAttributes() {
   class Sink implements AbstractClientStream.Sink {
     @Override
     public void writeHeaders(Metadata metadata, byte[] payload) {
-      PerfMark.startTask("OkHttpClientStream$Sink.writeHeaders");
-      String defaultPath = "/" + method.getFullMethodName();
-      if (payload != null) {
-        useGet = true;
-        defaultPath += "?" + BaseEncoding.base64().encode(payload);
-      }
-      try {
+      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);
         }
-      } finally {
-        PerfMark.stopTask("OkHttpClientStream$Sink.writeHeaders");
       }
     }
 
     @Override
     public void writeFrame(
         WritableBuffer frame, boolean endOfStream, boolean flush, int numMessages) {
-      PerfMark.startTask("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);
+      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);
+          }
         }
-      }
 
-      try {
         synchronized (state.lock) {
           state.sendBuffer(buffer, endOfStream, flush);
           getTransportTracer().reportMessageSent(numMessages);
         }
-      } finally {
-        PerfMark.stopTask("OkHttpClientStream$Sink.writeFrame");
       }
     }
 
     @Override
     public void cancel(Status reason) {
-      PerfMark.startTask("OkHttpClientStream$Sink.cancel");
-      try {
+      try (TaskCloseable ignore = PerfMark.traceTask("OkHttpClientStream$Sink.cancel")) {
         synchronized (state.lock) {
           state.cancel(reason, true, null);
         }
-      } finally {
-        PerfMark.stopTask("OkHttpClientStream$Sink.cancel");
       }
     }
   }
 
-  class TransportState extends Http2ClientStreamTransportState {
+  class TransportState extends Http2ClientStreamTransportState
+      implements OutboundFlowController.Stream {
     private final int initialWindowSize;
     private final Object lock;
     @GuardedBy("lock")
@@ -223,6 +211,9 @@ class TransportState extends Http2ClientStreamTransportState {
     @GuardedBy("lock")
     private boolean canStart = true;
     private final Tag tag;
+    @GuardedBy("lock")
+    private OutboundFlowController.StreamState outboundFlowState;
+    private int id = ABSENT_ID;
 
     public TransportState(
         int maxMessageSize,
@@ -232,8 +223,9 @@ public TransportState(
         OutboundFlowController outboundFlow,
         OkHttpClientTransport transport,
         int initialWindowSize,
-        String methodName) {
-      super(maxMessageSize, statsTraceCtx, OkHttpClientStream.this.getTransportTracer());
+        String methodName,
+        CallOptions options) {
+      super(maxMessageSize, statsTraceCtx, OkHttpClientStream.this.getTransportTracer(), options);
       this.lock = checkNotNull(lock, "lock");
       this.frameWriter = frameWriter;
       this.outboundFlow = outboundFlow;
@@ -249,6 +241,7 @@ public TransportState(
     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();
@@ -260,7 +253,9 @@ public void start(int streamId) {
         requestHeaders = null;
 
         if (pendingData.size() > 0) {
-          outboundFlow.data(pendingDataHasEndOfStream, id, pendingData, flushPendingData);
+          outboundFlow.data(
+              pendingDataHasEndOfStream, outboundFlowState, pendingData, flushPendingData);
+
         }
         canStart = false;
       }
@@ -328,11 +323,12 @@ public void transportHeadersReceived(List<Header> headers, boolean endOfStream)
      * Must be called with holding the transport lock.
      */
     @GuardedBy("lock")
-    public void transportDataReceived(okio.Buffer frame, boolean endOfStream) {
+    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;
+      window -= length + paddingLen;
+      processedWindow -= paddingLen;
       if (window < 0) {
         frameWriter.rstStream(id(), ErrorCode.FLOW_CONTROL_ERROR);
         transport.finishStream(
@@ -396,7 +392,7 @@ private void sendBuffer(Buffer buffer, boolean endOfStream, boolean flush) {
         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);
+        outboundFlow.data(endOfStream, outboundFlowState, buffer, flush);
       }
     }
 
@@ -413,19 +409,21 @@ private void streamReady(Metadata metadata, String path) {
               transport.isUsingPlaintext());
       // TODO(b/145386688): This access should be guarded by 'this.transport.lock'; instead found:
       // 'this.lock'
-      transport.streamReadyToStart(OkHttpClientStream.this);
+      transport.streamReadyToStart(OkHttpClientStream.this, authority);
     }
 
     Tag tag() {
       return tag;
     }
-  }
 
-  void setOutboundFlowState(Object outboundFlowState) {
-    this.outboundFlowState = outboundFlowState;
-  }
+    int id() {
+      return id;
+    }
 
-  Object getOutboundFlowState() {
-    return outboundFlowState;
+    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 0347ffc770d..4764a6a1387 100644
--- a/okhttp/src/main/java/io/grpc/okhttp/OkHttpClientTransport.java
+++ b/okhttp/src/main/java/io/grpc/okhttp/OkHttpClientTransport.java
@@ -17,7 +17,6 @@
 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;
 
@@ -28,12 +27,11 @@
 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;
@@ -46,20 +44,29 @@
 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.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,33 +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;
@@ -106,10 +131,16 @@
 /**
  * A okhttp-based {@link ConnectionClientTransport} implementation.
  */
-class OkHttpClientTransport implements ConnectionClientTransport, TransportExceptionHandler {
+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.class);
@@ -140,6 +171,26 @@ 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;
@@ -147,9 +198,8 @@ private static Map<ErrorCode, Status> buildErrorCodeToStatusMap() {
   // Returns new unstarted stopwatches
   private final Supplier<Stopwatch> stopwatchFactory;
   private final int initialWindowSize;
+  private final Variant variant;
   private Listener listener;
-  private FrameReader testFrameReader;
-  private OkHttpFrameLogger testFrameLogger;
   @GuardedBy("lock")
   private ExceptionHandlingFrameWriter frameWriter;
   private OutboundFlowController outboundFlow;
@@ -162,6 +212,7 @@ private static Map<ErrorCode, Status> buildErrorCodeToStatusMap() {
   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;
@@ -191,8 +242,6 @@ private static Map<ErrorCode, Status> buildErrorCodeToStatusMap() {
   @GuardedBy("lock")
   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 keepAliveTimeNanos;
@@ -203,6 +252,19 @@ private static Map<ErrorCode, Status> buildErrorCodeToStatusMap() {
   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>() {
@@ -223,98 +285,120 @@ protected void handleNotInUse() {
   @Nullable
   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,
-      Attributes eagAttrs,
-      Executor executor,
-      @Nullable SocketFactory socketFactory,
-      @Nullable SSLSocketFactory sslSocketFactory,
-      @Nullable HostnameVerifier hostnameVerifier,
-      ConnectionSpec connectionSpec,
-      int maxMessageSize,
-      int initialWindowSize,
-      @Nullable HttpConnectProxiedSocketAddress proxiedAddr,
-      Runnable tooManyPingsRunnable,
-      int maxInboundMetadataSize,
-      TransportTracer transportTracer,
-      boolean useGetForSafeMethods) {
+  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.initialWindowSize = initialWindowSize;
-    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.socketFactory = socketFactory == null ? SocketFactory.getDefault() : socketFactory;
-    this.sslSocketFactory = sslSocketFactory;
-    this.hostnameVerifier = hostnameVerifier;
-    this.connectionSpec = Preconditions.checkNotNull(connectionSpec, "connectionSpec");
-    this.stopwatchFactory = GrpcUtil.STOPWATCH_SUPPLIER;
+    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.proxiedAddr = proxiedAddr;
     this.tooManyPingsRunnable =
         Preconditions.checkNotNull(tooManyPingsRunnable, "tooManyPingsRunnable");
-    this.maxInboundMetadataSize = maxInboundMetadataSize;
-    this.transportTracer = Preconditions.checkNotNull(transportTracer);
+    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 = useGetForSafeMethods;
+    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(
+      OkHttpTransportFactory transportFactory,
       String userAgent,
-      Executor executor,
-      FrameReader frameReader,
-      FrameWriter testFrameWriter,
-      OkHttpFrameLogger testFrameLogger,
-      int nextStreamId,
-      Socket socket,
       Supplier<Stopwatch> stopwatchFactory,
+      Variant variant,
       @Nullable Runnable connectingCallback,
       SettableFuture<Void> connectedFuture,
-      int maxMessageSize,
-      int initialWindowSize,
-      Runnable tooManyPingsRunnable,
-      TransportTracer transportTracer) {
-    useGetForSafeMethods = false;
-    address = null;
-    this.maxMessageSize = maxMessageSize;
-    this.initialWindowSize = initialWindowSize;
-    defaultAuthority = "notarealauthority:80";
-    this.userAgent = GrpcUtil.getGrpcUserAgent("okhttp", userAgent);
-    this.executor = Preconditions.checkNotNull(executor, "executor");
-    serializingExecutor = new SerializingExecutor(executor);
-    this.socketFactory = SocketFactory.getDefault();
-    this.testFrameReader = Preconditions.checkNotNull(frameReader, "frameReader");
-    this.testFrameWriter = Preconditions.checkNotNull(testFrameWriter, "testFrameWriter");
-    this.testFrameLogger = Preconditions.checkNotNull(testFrameLogger, "testFrameLogger");
-    this.socket = Preconditions.checkNotNull(socket, "socket");
-    this.nextStreamId = nextStreamId;
-    this.stopwatchFactory = stopwatchFactory;
-    this.connectionSpec = null;
+      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.proxiedAddr = null;
-    this.tooManyPingsRunnable =
-        Preconditions.checkNotNull(tooManyPingsRunnable, "tooManyPingsRunnable");
-    this.maxInboundMetadataSize = Integer.MAX_VALUE;
-    this.transportTracer = Preconditions.checkNotNull(transportTracer, "transportTracer");
-    this.logId = InternalLogId.allocate(getClass(), String.valueOf(socket.getInetAddress()));
-    initTransportTracer();
   }
 
   // sslSocketFactory is set to null when use plaintext.
@@ -328,8 +412,10 @@ private void initTransportTracer() {
         @Override
         public TransportTracer.FlowControlWindows read() {
           synchronized (lock) {
-            long local = -1; // okhttp does not track the local window size
-            long remote = outboundFlow == null ? -1 : outboundFlow.windowUpdate(null, 0);
+            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);
           }
         }
@@ -348,10 +434,6 @@ void enableKeepAlive(boolean enable, long keepAliveTimeNanos,
     this.keepAliveWithoutCalls = keepAliveWithoutCalls;
   }
 
-  private boolean isForTest() {
-    return address == null;
-  }
-
   @Override
   public void ping(final PingCallback callback, Executor executor) {
     long data = 0;
@@ -387,12 +469,14 @@ public void ping(final PingCallback callback, Executor executor) {
   }
 
   @Override
-  public OkHttpClientStream newStream(final MethodDescriptor<?, ?> method,
-      final Metadata headers, CallOptions callOptions) {
+  public OkHttpClientStream newStream(
+      MethodDescriptor<?, ?> method, Metadata headers, CallOptions callOptions,
+      ClientStreamTracer[] tracers) {
     Preconditions.checkNotNull(method, "method");
     Preconditions.checkNotNull(headers, "headers");
-    StatsTraceContext statsTraceCtx =
-        StatsTraceContext.newClientContext(callOptions, attributes, headers);
+    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(
@@ -406,31 +490,124 @@ public OkHttpClientStream newStream(final MethodDescriptor<?, ?> method,
           initialWindowSize,
           defaultAuthority,
           userAgent,
-          statsTraceCtx,
+          statsTraceContext,
           transportTracer,
           callOptions,
           useGetForSafeMethods);
     }
   }
 
+  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) {
+  void streamReadyToStart(OkHttpClientStream clientStream, String authority) {
     if (goAwayStatus != null) {
       clientStream.transportState().transportReportStatus(
-          goAwayStatus, RpcProgress.REFUSED, true, new Metadata());
-    } else if (streams.size() >= maxConcurrentStreams) {
-      pendingStreams.add(clientStream);
-      setInUse(clientStream);
+          goAwayStatus, RpcProgress.MISCARRIED, true, new Metadata());
     } else {
-      startStream(clientStream);
+      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(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);
     // TODO(b/145386688): This access should be guarded by 'stream.transportState().lock'; instead
@@ -480,59 +657,38 @@ public Runnable start(Listener listener) {
     this.listener = Preconditions.checkNotNull(listener, "listener");
 
     if (enableKeepAlive) {
-      scheduler = SharedResourceHolder.get(TIMER_SERVICE);
       keepAliveManager = new KeepAliveManager(
           new ClientKeepAlivePinger(this), scheduler, keepAliveTimeNanos, keepAliveTimeoutNanos,
           keepAliveWithoutCalls);
       keepAliveManager.onTransportStarted();
     }
-    if (isForTest()) {
-      synchronized (lock) {
-        frameWriter = new ExceptionHandlingFrameWriter(OkHttpClientTransport.this, testFrameWriter,
-            testFrameLogger);
-        outboundFlow = new OutboundFlowController(OkHttpClientTransport.this, frameWriter);
-      }
-      serializingExecutor.execute(new Runnable() {
-        @Override
-        public void run() {
-          if (connectingCallback != null) {
-            connectingCallback.run();
-          }
-          clientFrameHandler = new ClientFrameHandler(testFrameReader, testFrameLogger);
-          executor.execute(clientFrameHandler);
-          synchronized (lock) {
-            maxConcurrentStreams = Integer.MAX_VALUE;
-            startPendingStreams();
-          }
-          connectedFuture.set(null);
-        }
-      });
-      return null;
-    }
 
-    final AsyncSink asyncSink = AsyncSink.sink(serializingExecutor, this);
-    final Variant variant = new Http2();
-    FrameWriter rawFrameWriter = variant.newWriter(Okio.buffer(asyncSink), true);
+    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() {
-        // 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();
-        } catch (InterruptedException e) {
-          Thread.currentThread().interrupt();
-        }
         // Use closed source on failure so that the reader immediately shuts down.
         BufferedSource source = Okio.buffer(new Source() {
           @Override
@@ -549,9 +705,23 @@ public Timeout timeout() {
           public void close() {
           }
         });
-        Socket sock;
-        SSLSession sslSession = null;
         try {
+          // 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 {
@@ -595,6 +765,7 @@ sslSocketFactory, hostnameVerifier, sock, getOverridenHost(), getOverridenPort()
           return;
         } finally {
           clientFrameHandler = new ClientFrameHandler(variant.newReader(source, true));
+          latchForExtraThread.countDown();
         }
         synchronized (lock) {
           socket = Preconditions.checkNotNull(sock, "socket");
@@ -604,6 +775,21 @@ sslSocketFactory, hostnameVerifier, sock, getOverridenHost(), getOverridenPort()
         }
       }
     });
+
+    executor.execute(new Runnable() {
+      @Override
+      public void run() {
+        try {
+          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();
@@ -614,12 +800,20 @@ sslSocketFactory, hostnameVerifier, sock, getOverridenHost(), getOverridenPort()
     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);
-        synchronized (lock) {
-          maxConcurrentStreams = Integer.MAX_VALUE;
-          startPendingStreams();
+        if (connectedFuture != null) {
+          connectedFuture.set(null);
         }
       }
     });
@@ -629,8 +823,7 @@ public void run() {
   /**
    * Should only be called once when the transport is first established.
    */
-  @VisibleForTesting
-  void sendConnectionPrefaceAndSettings() {
+  private void sendConnectionPrefaceAndSettings() {
     synchronized (lock) {
       frameWriter.connectionPreface();
       Settings settings = new Settings();
@@ -645,8 +838,8 @@ void sendConnectionPrefaceAndSettings() {
 
   private Socket createHttpProxySocket(InetSocketAddress address, InetSocketAddress proxyAddress,
       String proxyUsername, String proxyPassword) throws StatusException {
+    Socket sock = null;
     try {
-      Socket sock;
       // The proxy address may not be resolved
       if (proxyAddress.getAddress() != null) {
         sock = socketFactory.createSocket(proxyAddress.getAddress(), proxyAddress.getPort());
@@ -655,6 +848,9 @@ private Socket createHttpProxySocket(InetSocketAddress address, InetSocketAddres
             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));
@@ -662,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");
@@ -694,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())
@@ -791,13 +995,18 @@ public void shutdown(Status reason) {
       }
 
       goAwayStatus = reason;
-      listener.transportShutdown(goAwayStatus);
+      listener.transportShutdown(goAwayStatus, SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
       stopIfNecessary();
     }
   }
 
   @Override
   public void shutdownNow(Status reason) {
+    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();
@@ -809,7 +1018,10 @@ public void shutdownNow(Status reason) {
       }
 
       for (OkHttpClientStream stream : pendingStreams) {
-        stream.transportState().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();
@@ -826,9 +1038,16 @@ public Attributes getAttributes() {
   /**
    * 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;
     }
   }
 
@@ -849,6 +1068,13 @@ int getPendingStreamSize() {
     }
   }
 
+  @VisibleForTesting
+  void setNextStreamId(int nextStreamId) {
+    synchronized (lock) {
+      this.nextStreamId = nextStreamId;
+    }
+  }
+
   /**
    * Finish all active streams due to an IOException, then close the transport.
    */
@@ -870,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
@@ -892,7 +1124,7 @@ private void startGoAway(int lastKnownStreamId, ErrorCode errorCode, Status stat
 
       for (OkHttpClientStream stream : pendingStreams) {
         stream.transportState().transportReportStatus(
-            status, RpcProgress.REFUSED, true, new Metadata());
+            status, RpcProgress.MISCARRIED, true, new Metadata());
         maybeClearInUse(stream);
       }
       pendingStreams.clear();
@@ -902,7 +1134,7 @@ private void startGoAway(int lastKnownStreamId, ErrorCode errorCode, Status stat
   }
 
   /**
-   * 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.
@@ -940,8 +1172,8 @@ void finishStream(
         }
         if (!startPendingStreams()) {
           stopIfNecessary();
-          maybeClearInUse(stream);
         }
+        maybeClearInUse(stream);
       }
     }
   }
@@ -961,8 +1193,6 @@ private void stopIfNecessary() {
 
     if (keepAliveManager != null) {
       keepAliveManager.onTransportTermination();
-      // KeepAliveManager should stop using the scheduler after onTransportTermination gets called.
-      scheduler = SharedResourceHolder.release(TIMER_SERVICE, scheduler);
     }
 
     if (ping != null) {
@@ -1017,12 +1247,12 @@ private void setInUse(OkHttpClientStream stream) {
     }
   }
 
-  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");
       }
     }
   }
@@ -1075,24 +1305,19 @@ public ListenableFuture<SocketStats> getStats() {
   /**
    * Runnable which reads frames and dispatches them to in flight calls.
    */
-  @VisibleForTesting
   class ClientFrameHandler implements FrameReader.Handler, Runnable {
 
-    private final OkHttpFrameLogger logger;
+    private final OkHttpFrameLogger logger =
+        new OkHttpFrameLogger(Level.FINE, OkHttpClientTransport.class);
     FrameReader frameReader;
     boolean firstSettings = true;
 
     ClientFrameHandler(FrameReader frameReader) {
-      this(frameReader, new OkHttpFrameLogger(Level.FINE, OkHttpClientTransport.class));
-    }
-
-    @VisibleForTesting
-    ClientFrameHandler(FrameReader frameReader, OkHttpFrameLogger frameLogger) {
       this.frameReader = frameReader;
-      logger = frameLogger;
     }
 
     @Override
+    @SuppressWarnings("Finally")
     public void run() {
       String threadName = Thread.currentThread().getName();
       Thread.currentThread().setName("OkHttpClientTransport");
@@ -1106,8 +1331,14 @@ 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(
@@ -1119,6 +1350,15 @@ public void run() {
           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();
         Thread.currentThread().setName(threadName);
@@ -1130,7 +1370,8 @@ public void run() {
      */
     @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);
@@ -1138,7 +1379,7 @@ public void data(boolean inFinished, int streamId, BufferedSource in, int length
       if (stream == null) {
         if (mayHaveCreatedStream(streamId)) {
           synchronized (lock) {
-            frameWriter.rstStream(streamId, ErrorCode.INVALID_STREAM);
+            frameWriter.rstStream(streamId, ErrorCode.STREAM_CLOSED);
           }
           in.skip(length);
         } else {
@@ -1156,12 +1397,12 @@ public void data(boolean inFinished, int streamId, BufferedSource in, int length
         synchronized (lock) {
           // TODO(b/145386688): This access should be guarded by 'stream.transportState().lock';
           // instead found: 'OkHttpClientTransport.this.lock'
-          stream.transportState().transportDataReceived(buf, inFinished);
+          stream.transportState().transportDataReceived(buf, inFinished, paddedLength - length);
         }
       }
 
       // connection window update
-      connectionUnacknowledgedBytesRead += length;
+      connectionUnacknowledgedBytesRead += paddedLength;
       if (connectionUnacknowledgedBytesRead >= initialWindowSize * DEFAULT_WINDOW_UPDATE_RATIO) {
         synchronized (lock) {
           frameWriter.windowUpdate(0, connectionUnacknowledgedBytesRead);
@@ -1189,6 +1430,7 @@ public void headers(boolean outFinished,
         if (metadataSize > maxInboundMetadataSize) {
           failedStatus = Status.RESOURCE_EXHAUSTED.withDescription(
               String.format(
+                  Locale.US,
                   "Response %s metadata larger than %d: %d",
                   inFinished ? "trailer" : "header",
                   maxInboundMetadataSize,
@@ -1199,7 +1441,7 @@ public void headers(boolean outFinished,
         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;
           }
@@ -1271,6 +1513,7 @@ public void settings(boolean clearPrevious, Settings settings) {
           outboundWindowSizeIncreased = outboundFlow.initialOutboundWindowSize(initialWindowSize);
         }
         if (firstSettings) {
+          attributes = listener.filterTransport(attributes);
           listener.transportReady();
           firstSettings = false;
         }
@@ -1304,8 +1547,9 @@ public void ping(boolean ack, int payload1, int payload2) {
               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");
@@ -1378,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;
         }
@@ -1401,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/OkHttpProtocolNegotiator.java b/okhttp/src/main/java/io/grpc/okhttp/OkHttpProtocolNegotiator.java
index d09d6cccedd..3f5a4d8cb2b 100644
--- a/okhttp/src/main/java/io/grpc/okhttp/OkHttpProtocolNegotiator.java
+++ b/okhttp/src/main/java/io/grpc/okhttp/OkHttpProtocolNegotiator.java
@@ -19,6 +19,8 @@
 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;
@@ -120,7 +122,6 @@ public String getSelectedProtocol(SSLSocket socket) {
     return platform.getSelectedProtocol(socket);
   }
 
-  @VisibleForTesting
   static final class AndroidNegotiator extends OkHttpProtocolNegotiator {
     // setUseSessionTickets(boolean)
     private static final OptionalMethod<Socket> SET_USE_SESSION_TICKETS =
@@ -247,7 +248,9 @@ protected void configureTlsExtensions(
           } else {
             SET_USE_SESSION_TICKETS.invokeOptionalWithoutCheckedException(sslSocket, true);
           }
-          if (SET_SERVER_NAMES != null && SNI_HOST_NAME != null) {
+          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 {
diff --git a/okhttp/src/main/java/io/grpc/okhttp/OkHttpReadableBuffer.java b/okhttp/src/main/java/io/grpc/okhttp/OkHttpReadableBuffer.java
index 821f2e5fd84..d65453722f0 100644
--- a/okhttp/src/main/java/io/grpc/okhttp/OkHttpReadableBuffer.java
+++ b/okhttp/src/main/java/io/grpc/okhttp/OkHttpReadableBuffer.java
@@ -21,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}.
@@ -40,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 {
@@ -64,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..50097e1922e
--- /dev/null
+++ b/okhttp/src/main/java/io/grpc/okhttp/OkHttpServerBuilder.java
@@ -0,0 +1,576 @@
+/*
+ * 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 static io.grpc.internal.GrpcUtil.DEFAULT_SERVER_PERMIT_KEEPALIVE_TIME_NANOS;
+
+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.MetricRecorder;
+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(
+      new ServerImplBuilder.ClientTransportServersBuilder() {
+        @Override
+        public InternalServer buildClientTransportServers(
+            List<? extends ServerStreamTracer.Factory> streamTracerFactories,
+            MetricRecorder metricRecorder) {
+          return buildTransportServers(streamTracerFactories);
+        }
+      });
+  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 = DEFAULT_SERVER_PERMIT_KEEPALIVE_TIME_NANOS;
+  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 5df85732ede..1406b39adfd 100644
--- a/okhttp/src/main/java/io/grpc/okhttp/OkHttpSettingsUtil.java
+++ b/okhttp/src/main/java/io/grpc/okhttp/OkHttpSettingsUtil.java
@@ -24,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 1004dcd93f9..a8b038c91f4 100644
--- a/okhttp/src/main/java/io/grpc/okhttp/OkHttpTlsUpgrader.java
+++ b/okhttp/src/main/java/io/grpc/okhttp/OkHttpTlsUpgrader.java
@@ -19,13 +19,13 @@
 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;
@@ -52,7 +52,7 @@ final class OkHttpTlsUpgrader {
    * @throws RuntimeException if the upgrade negotiation failed.
    */
   public static SSLSocket upgrade(SSLSocketFactory sslSocketFactory,
-      HostnameVerifier hostnameVerifier, Socket socket, String host, int port,
+      @Nonnull HostnameVerifier hostnameVerifier, Socket socket, String host, int port,
       ConnectionSpec spec) throws IOException {
     Preconditions.checkNotNull(sslSocketFactory, "sslSocketFactory");
     Preconditions.checkNotNull(socket, "socket");
@@ -67,9 +67,6 @@ public static SSLSocket upgrade(SSLSocketFactory sslSocketFactory,
         "Only " + TLS_PROTOCOLS + " are supported, but negotiated protocol is %s",
         negotiatedProtocol);
 
-    if (hostnameVerifier == null) {
-      hostnameVerifier = OkHostnameVerifier.INSTANCE;
-    }
     if (!hostnameVerifier.verify(canonicalizeHost(host), sslSocket.getSession())) {
       throw new SSLPeerUnverifiedException("Cannot verify hostname: " + host);
     }
diff --git a/okhttp/src/main/java/io/grpc/okhttp/OkHttpWritableBufferAllocator.java b/okhttp/src/main/java/io/grpc/okhttp/OkHttpWritableBufferAllocator.java
index 481ada61c96..58896a5dbb0 100644
--- a/okhttp/src/main/java/io/grpc/okhttp/OkHttpWritableBufferAllocator.java
+++ b/okhttp/src/main/java/io/grpc/okhttp/OkHttpWritableBufferAllocator.java
@@ -27,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.
@@ -45,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 c935363213d..2c959ee0768 100644
--- a/okhttp/src/main/java/io/grpc/okhttp/OutboundFlowController.java
+++ b/okhttp/src/main/java/io/grpc/okhttp/OutboundFlowController.java
@@ -25,6 +25,8 @@
 import com.google.common.base.Preconditions;
 import io.grpc.okhttp.internal.framed.FrameWriter;
 import java.io.IOException;
+import java.util.Arrays;
+import java.util.Collections;
 import javax.annotation.Nullable;
 import okio.Buffer;
 
@@ -33,17 +35,16 @@
  * streams.
  */
 class OutboundFlowController {
-  private final OkHttpClientTransport transport;
+  private final Transport transport;
   private final FrameWriter frameWriter;
   private int initialWindowSize;
-  private final OutboundFlowState connectionState;
+  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 OutboundFlowState(CONNECTION_STREAM_ID, DEFAULT_WINDOW_SIZE);
+    connectionState = new StreamState(CONNECTION_STREAM_ID, DEFAULT_WINDOW_SIZE, null);
   }
 
   /**
@@ -55,22 +56,15 @@ class OutboundFlowController {
    *
    * @return true, if new window size is increased, false otherwise.
    */
-  boolean 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, initialWindowSize);
-        stream.setOutboundFlowState(state);
-      } else {
-        state.incrementStreamWindow(delta);
-      }
+    for (StreamState state : transport.getActiveStreams()) {
+      state.incrementStreamWindow(delta);
     }
 
     return delta > 0;
@@ -82,15 +76,14 @@ boolean initialOutboundWindowSize(int newWindowSize) {
    *
    * <p>Must be called with holding transport lock.
    */
-  int windowUpdate(@Nullable OkHttpClientStream stream, int delta) {
+  public int windowUpdate(@Nullable StreamState state, int delta) {
     final int updatedWindow;
-    if (stream == null) {
+    if (state == null) {
       // Update the connection window and write any pending frames for all streams.
       updatedWindow = connectionState.incrementStreamWindow(delta);
       writeStreams();
     } else {
       // Update the stream window and write any pending frames for the stream.
-      OutboundFlowState state = state(stream);
       updatedWindow = state.incrementStreamWindow(delta);
 
       WriteStatus writeStatus = new WriteStatus();
@@ -105,18 +98,9 @@ int windowUpdate(@Nullable OkHttpClientStream stream, int delta) {
   /**
    * 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.hasPendingData();
     int size = (int) source.size();
@@ -130,7 +114,7 @@ void data(boolean outFinished, int streamId, Buffer source, boolean flush) {
         state.write(source, window, false);
       }
       // Queue remaining data in the buffer
-      state.enqueue(source, (int) source.size(), outFinished);
+      state.enqueueData(source, (int) source.size(), outFinished);
     }
 
     if (flush) {
@@ -138,7 +122,19 @@ void data(boolean outFinished, int streamId, Buffer source, boolean 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) {
@@ -146,13 +142,9 @@ void flush() {
     }
   }
 
-  private OutboundFlowState state(OkHttpClientStream stream) {
-    OutboundFlowState state = (OutboundFlowState) stream.getOutboundFlowState();
-    if (state == null) {
-      state = new OutboundFlowState(stream, initialWindowSize);
-      stream.setOutboundFlowState(state);
-    }
-    return state;
+  public StreamState createState(Stream stream, int streamId) {
+    return new StreamState(
+        streamId, initialWindowSize, Preconditions.checkNotNull(stream, "stream"));
   }
 
   /**
@@ -160,15 +152,15 @@ private OutboundFlowState state(OkHttpClientStream stream) {
    *
    * <p>Must be called with holding transport lock.
    */
-  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) {
@@ -179,7 +171,7 @@ 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;
@@ -187,8 +179,7 @@ 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();
     }
@@ -213,25 +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 Buffer pendingWriteBuffer;
-    final int streamId;
-    int window;
-    int allocatedBytes;
-    OkHttpClientStream stream;
-    boolean pendingBufferHasEndOfStream = false;
-
-    OutboundFlowState(int streamId, int initialWindowSize) {
+  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;
       window = initialWindowSize;
-      pendingWriteBuffer = new Buffer();
-    }
-
-    OutboundFlowState(OkHttpClientStream stream, int initialWindowSize) {
-      this(stream.id(), initialWindowSize);
       this.stream = stream;
     }
 
@@ -305,6 +300,10 @@ int writeBytes(int bytes, WriteStatus writeStatus) {
         // Update the threshold.
         maxBytes = min(bytes - bytesAttempted, writableWindow());
       }
+      if (!hasPendingData() && noPendingDataRunnable != null) {
+        noPendingDataRunnable.run();
+        noPendingDataRunnable = null;
+      }
       return bytesAttempted;
     }
 
@@ -328,14 +327,20 @@ void write(Buffer buffer, int bytesToSend, boolean endOfStream) {
         } catch (IOException e) {
           throw new RuntimeException(e);
         }
-        stream.transportState().onSentBytes(frameBytes);
+        stream.onSentBytes(frameBytes);
         bytesToWrite -= frameBytes;
       } while (bytesToWrite > 0);
     }
 
-    void enqueue(Buffer buffer, int size, boolean endOfStream) {
+    void enqueueData(Buffer buffer, int size, boolean endOfStream) {
       this.pendingWriteBuffer.write(buffer, size);
       this.pendingBufferHasEndOfStream |= endOfStream;
     }
+
+    void notifyWhenNoPendingData(Runnable noPendingDataRunnable) {
+      Preconditions.checkState(
+          this.noPendingDataRunnable == null, "pending data notification already requested");
+      this.noPendingDataRunnable = noPendingDataRunnable;
+    }
   }
-}
\ No newline at end of file
+}
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/SslSocketFactoryServerCredentials.java b/okhttp/src/main/java/io/grpc/okhttp/SslSocketFactoryServerCredentials.java
new file mode 100644
index 00000000000..ad9af056afc
--- /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_LEGACY_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 2dc5f1e1ec9..4546143cf3b 100644
--- a/okhttp/src/main/java/io/grpc/okhttp/Utils.java
+++ b/okhttp/src/main/java/io/grpc/okhttp/Utils.java
@@ -17,6 +17,7 @@
 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;
@@ -29,7 +30,6 @@
 import java.util.List;
 import java.util.logging.Level;
 import java.util.logging.Logger;
-import javax.annotation.CheckReturnValue;
 
 /**
  * Common utility methods for OkHttp transport.
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/okhttp/AsyncSinkTest.java b/okhttp/src/test/java/io/grpc/okhttp/AsyncSinkTest.java
index 2bda131b346..478e18d0a2b 100644
--- a/okhttp/src/test/java/io/grpc/okhttp/AsyncSinkTest.java
+++ b/okhttp/src/test/java/io/grpc/okhttp/AsyncSinkTest.java
@@ -30,11 +30,11 @@
 import static org.mockito.Mockito.timeout;
 import static org.mockito.Mockito.verify;
 
-import com.google.common.base.Charsets;
 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;
@@ -56,7 +56,7 @@ public class AsyncSinkTest {
   private final QueueingExecutor queueingExecutor = new QueueingExecutor();
   private final TransportExceptionHandler exceptionHandler = mock(TransportExceptionHandler.class);
   private final AsyncSink sink =
-      AsyncSink.sink(new SerializingExecutor(queueingExecutor), exceptionHandler);
+      AsyncSink.sink(new SerializingExecutor(queueingExecutor), exceptionHandler, 10000);
 
   @Test
   public void noCoalesceRequired() throws IOException {
@@ -73,8 +73,8 @@ public void noCoalesceRequired() throws IOException {
 
   @Test
   public void flushCoalescing_shouldNotMergeTwoDistinctFlushes() throws IOException {
-    byte[] firstData = "a string".getBytes(Charsets.UTF_8);
-    byte[] secondData = "a longer string".getBytes(Charsets.UTF_8);
+    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();
@@ -95,8 +95,8 @@ public void flushCoalescing_shouldNotMergeTwoDistinctFlushes() throws IOExceptio
 
   @Test
   public void flushCoalescing_shouldMergeTwoQueuedFlushesAndWrites() throws IOException {
-    byte[] firstData = "a string".getBytes(Charsets.UTF_8);
-    byte[] secondData = "a longer string".getBytes(Charsets.UTF_8);
+    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());
@@ -115,8 +115,8 @@ public void flushCoalescing_shouldMergeTwoQueuedFlushesAndWrites() throws IOExce
 
   @Test
   public void flushCoalescing_shouldMergeWrites() throws IOException {
-    byte[] firstData = "a string".getBytes(Charsets.UTF_8);
-    byte[] secondData = "a longer string".getBytes(Charsets.UTF_8);
+    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());
diff --git a/okhttp/src/test/java/io/grpc/okhttp/ExceptionHandlingFrameWriterTest.java b/okhttp/src/test/java/io/grpc/okhttp/ExceptionHandlingFrameWriterTest.java
index c26edcd0df8..8829abac034 100644
--- a/okhttp/src/test/java/io/grpc/okhttp/ExceptionHandlingFrameWriterTest.java
+++ b/okhttp/src/test/java/io/grpc/okhttp/ExceptionHandlingFrameWriterTest.java
@@ -16,9 +16,9 @@
 
 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.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;
@@ -50,8 +50,7 @@ public class ExceptionHandlingFrameWriterTest {
   private final TransportExceptionHandler transportExceptionHandler =
       mock(TransportExceptionHandler.class);
   private final ExceptionHandlingFrameWriter exceptionHandlingFrameWriter =
-      new ExceptionHandlingFrameWriter(transportExceptionHandler, mockedFrameWriter,
-          new OkHttpFrameLogger(Level.FINE, logger));
+      new ExceptionHandlingFrameWriter(transportExceptionHandler, mockedFrameWriter);
 
   @Test
   public void exception() throws IOException {
@@ -194,4 +193,4 @@ public void close() throws SecurityException {
 
     logger.removeHandler(handler);
   }
-}
\ No newline at end of file
+}
diff --git a/okhttp/src/test/java/io/grpc/okhttp/OkHttpChannelBuilderTest.java b/okhttp/src/test/java/io/grpc/okhttp/OkHttpChannelBuilderTest.java
index 0063fc82ca0..89d37536b70 100644
--- a/okhttp/src/test/java/io/grpc/okhttp/OkHttpChannelBuilderTest.java
+++ b/okhttp/src/test/java/io/grpc/okhttp/OkHttpChannelBuilderTest.java
@@ -22,6 +22,7 @@
 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;
@@ -34,31 +35,29 @@
 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.internal.testing.TestUtils;
 import io.grpc.testing.GrpcCleanupRule;
-import io.netty.handler.ssl.util.SelfSignedCertificate;
+import io.grpc.testing.TlsTesting;
+import java.io.InputStream;
 import java.net.InetAddress;
 import java.net.InetSocketAddress;
 import java.net.Socket;
-import java.security.KeyStore;
-import java.security.cert.Certificate;
 import java.util.concurrent.ScheduledExecutorService;
 import javax.net.SocketFactory;
-import javax.net.ssl.KeyManagerFactory;
+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.TrustManagerFactory;
+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;
 
@@ -68,8 +67,6 @@
 @RunWith(JUnit4.class)
 public class OkHttpChannelBuilderTest {
 
-  @SuppressWarnings("deprecation") // https://github.com/grpc/grpc-java/issues/7467
-  @Rule public final ExpectedException thrown = ExpectedException.none();
   @Rule public final GrpcCleanupRule grpcCleanupRule = new GrpcCleanupRule();
 
   @Test
@@ -101,10 +98,9 @@ private void overrideAuthorityIsReadableHelper(OkHttpChannelBuilder builder,
   @Test
   public void failOverrideInvalidAuthority() {
     OkHttpChannelBuilder builder = OkHttpChannelBuilder.forAddress("good", 1234);
-
-    thrown.expect(IllegalArgumentException.class);
-    thrown.expectMessage("Invalid authority:");
-    builder.overrideAuthority("[invalidauthority");
+    IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
+        () -> builder.overrideAuthority("[invalidauthority"));
+    assertThat(e).hasMessageThat().isEqualTo("Invalid authority: [invalidauthority");
   }
 
   @Test
@@ -120,17 +116,16 @@ public void enableCheckAuthorityFailOverrideInvalidAuthority() {
         .disableCheckAuthority()
         .enableCheckAuthority();
 
-    thrown.expect(IllegalArgumentException.class);
-    thrown.expectMessage("Invalid authority:");
-    builder.overrideAuthority("[invalidauthority");
+    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");
-
-    OkHttpChannelBuilder.forAddress("invalid_authority", 1234);
+    IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
+        () -> OkHttpChannelBuilder.forAddress("invalid_authority", 1234));
+    assertThat(e.getMessage()).isEqualTo("Invalid host or port: invalid_authority 1234");
   }
 
   @Test
@@ -167,16 +162,12 @@ public void sslSocketFactoryFrom_unsupportedTls() {
 
   @Test
   public void sslSocketFactoryFrom_tls_customRoots() throws Exception {
-    SelfSignedCertificate cert = new SelfSignedCertificate(TestUtils.TEST_SERVER_HOST);
-    KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType());
-    keyStore.load(null);
-    keyStore.setKeyEntry("mykey", cert.key(), new char[0], new Certificate[] {cert.cert()});
-    KeyManagerFactory keyManagerFactory =
-        KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
-    keyManagerFactory.init(keyStore, new char[0]);
-
     SSLContext serverContext = SSLContext.getInstance("TLS");
-    serverContext.init(keyManagerFactory.getKeyManagers(), null, null);
+    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();
@@ -193,9 +184,12 @@ public void sslSocketFactoryFrom_tls_customRoots() throws Exception {
       }
     }).start();
 
-    ChannelCredentials creds = TlsChannelCredentials.newBuilder()
-        .trustManager(cert.certificate())
+    ChannelCredentials creds;
+    try (InputStream ca = TlsTesting.loadCert("ca.pem")) {
+      creds = TlsChannelCredentials.newBuilder()
+        .trustManager(ca)
         .build();
+    }
     OkHttpChannelBuilder.SslSocketFactoryResult result =
         OkHttpChannelBuilder.sslSocketFactoryFrom(creds);
     SSLSocket socket =
@@ -207,24 +201,19 @@ public void sslSocketFactoryFrom_tls_customRoots() throws Exception {
 
   @Test
   public void sslSocketFactoryFrom_tls_mtls() throws Exception {
-    SelfSignedCertificate cert = new SelfSignedCertificate(TestUtils.TEST_SERVER_HOST);
-    KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType());
-    keyStore.load(null);
-    keyStore.setKeyEntry("mykey", cert.key(), new char[0], new Certificate[] {cert.cert()});
-    KeyManagerFactory keyManagerFactory =
-        KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
-    keyManagerFactory.init(keyStore, new char[0]);
-
-    KeyStore certStore = KeyStore.getInstance(KeyStore.getDefaultType());
-    certStore.load(null);
-    certStore.setCertificateEntry("mycert", cert.cert());
-    TrustManagerFactory trustManagerFactory =
-        TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
-    trustManagerFactory.init(certStore);
+    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(
-        keyManagerFactory.getKeyManagers(), trustManagerFactory.getTrustManagers(), null);
+    serverContext.init(keyManagers, trustManagers, null);
     final SSLServerSocket serverListenSocket =
         (SSLServerSocket) serverContext.getServerSocketFactory().createServerSocket(0);
     serverListenSocket.setNeedClientAuth(true);
@@ -243,8 +232,8 @@ public void sslSocketFactoryFrom_tls_mtls() throws Exception {
     }).start();
 
     ChannelCredentials creds = TlsChannelCredentials.newBuilder()
-        .keyManager(keyManagerFactory.getKeyManagers())
-        .trustManager(trustManagerFactory.getTrustManagers())
+        .keyManager(keyManagers)
+        .trustManager(trustManagers)
         .build();
     OkHttpChannelBuilder.SslSocketFactoryResult result =
         OkHttpChannelBuilder.sslSocketFactoryFrom(creds);
@@ -252,15 +241,64 @@ public void sslSocketFactoryFrom_tls_mtls() throws Exception {
         (SSLSocket) result.factory.createSocket("localhost", serverListenSocket.getLocalPort());
     socket.getSession(); // Force handshake
     assertThat(((X500Principal) serverSocket.get().getSession().getPeerPrincipal()).getName())
-        .isEqualTo("CN=" + TestUtils.TEST_SERVER_HOST);
+        .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_byteKeyUnsupported() throws Exception {
+  public void sslSocketFactoryFrom_tls_mtls_passwordUnsupported() throws Exception {
     ChannelCredentials creds = TlsChannelCredentials.newBuilder()
-        .keyManager(TestUtils.loadCert("server1.pem"), TestUtils.loadCert("server1.key"))
+        .keyManager(
+            TlsTesting.loadCert("server1.pem"), TlsTesting.loadCert("server1.key"), "password")
         .build();
     OkHttpChannelBuilder.SslSocketFactoryResult result =
         OkHttpChannelBuilder.sslSocketFactoryFrom(creds);
@@ -354,10 +392,10 @@ public ChannelCredentials withoutBearerTokens() {
 
   @Test
   public void failForUsingClearTextSpecDirectly() {
-    thrown.expect(IllegalArgumentException.class);
-    thrown.expectMessage("plaintext ConnectionSpec is not accepted");
-
-    OkHttpChannelBuilder.forAddress("host", 1234).connectionSpec(ConnectionSpec.CLEARTEXT);
+    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
diff --git a/okhttp/src/test/java/io/grpc/okhttp/OkHttpClientStreamTest.java b/okhttp/src/test/java/io/grpc/okhttp/OkHttpClientStreamTest.java
index 99a9159eab0..1c98d6ee30d 100644
--- a/okhttp/src/test/java/io/grpc/okhttp/OkHttpClientStreamTest.java
+++ b/okhttp/src/test/java/io/grpc/okhttp/OkHttpClientStreamTest.java
@@ -20,6 +20,7 @@
 import static io.grpc.internal.ClientStreamListener.RpcProgress.PROCESSED;
 import static org.junit.Assert.assertEquals;
 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.times;
@@ -46,6 +47,7 @@
 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;
@@ -53,12 +55,15 @@
 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;
 
@@ -77,7 +82,6 @@ public class OkHttpClientStreamTest {
 
   @Before
   public void setUp() {
-    MockitoAnnotations.initMocks(this);
     methodDescriptor = MethodDescriptor.<Void, Void>newBuilder()
         .setType(MethodDescriptor.MethodType.UNARY)
         .setFullMethodName("testService/test")
@@ -241,12 +245,13 @@ public void getUnaryRequest() throws IOException {
     // 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));
+    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));
+    verify(transport).streamReadyToStart(eq(stream), any(String.class));
     stream.transportState().start(3);
 
     verify(mockedFrameWriter)
diff --git a/okhttp/src/test/java/io/grpc/okhttp/OkHttpClientTransportFactoryTest.java b/okhttp/src/test/java/io/grpc/okhttp/OkHttpClientTransportFactoryTest.java
index dbd1023198d..dea99174c96 100644
--- a/okhttp/src/test/java/io/grpc/okhttp/OkHttpClientTransportFactoryTest.java
+++ b/okhttp/src/test/java/io/grpc/okhttp/OkHttpClientTransportFactoryTest.java
@@ -16,8 +16,8 @@
 
 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 0994bc90004..f87912c44ea 100644
--- a/okhttp/src/test/java/io/grpc/okhttp/OkHttpClientTransportTest.java
+++ b/okhttp/src/test/java/io/grpc/okhttp/OkHttpClientTransportTest.java
@@ -16,15 +16,15 @@
 
 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.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.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.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;
@@ -45,8 +45,8 @@
 import static org.mockito.Mockito.timeout;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.verifyNoInteractions;
-import static org.mockito.Mockito.verifyNoMoreInteractions;
 
+import com.google.common.base.Preconditions;
 import com.google.common.base.Stopwatch;
 import com.google.common.base.Supplier;
 import com.google.common.base.Ticker;
@@ -56,6 +56,7 @@
 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;
@@ -66,28 +67,35 @@
 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.TransportTracer;
+import io.grpc.internal.SimpleDisconnectError;
 import io.grpc.okhttp.OkHttpClientTransport.ClientFrameHandler;
 import io.grpc.okhttp.OkHttpFrameLogger.Direction;
-import io.grpc.okhttp.internal.ConnectionSpec;
+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;
@@ -111,12 +119,15 @@
 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.SSLSocketFactory;
+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;
@@ -127,7 +138,8 @@
 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}.
@@ -143,46 +155,40 @@ public class OkHttpClientTransportTest {
   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 int DEFAULT_MAX_INBOUND_METADATA_SIZE = Integer.MAX_VALUE;
   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);
-
-  private FrameWriter frameWriter;
+  @Rule public final MockitoRule mocks = MockitoJUnit.rule();
 
   private MethodDescriptor<Void, Void> method = TestMethodDescriptors.voidMethod();
 
   @Mock
   private ManagedClientTransport.Listener transportListener;
 
-  private final SocketFactory socketFactory = null;
-  private final SSLSocketFactory sslSocketFactory = null;
-  private final HostnameVerifier hostnameVerifier = null;
-  private final TransportTracer transportTracer = new TransportTracer();
   private final Queue<Buffer> capturedBuffer = new ArrayDeque<>();
   private OkHttpClientTransport clientTransport;
-  private MockFrameReader frameReader;
-  private Socket socket;
+  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;
   private Runnable tooManyPingsRunnable = new Runnable() {
     @Override public void run() {
       throw new AssertionError();
     }
   };
-
-  /** Set up for test. */
-  @Before
-  public void setUp() {
-    MockitoAnnotations.initMocks(this);
-    frameReader = new MockFrameReader();
-    socket = new MockSocket(frameReader);
-    MockFrameWriter mockFrameWriter = new MockFrameWriter(socket, capturedBuffer);
-    frameWriter = mock(FrameWriter.class, AdditionalAnswers.delegatesTo(mockFrameWriter));
-  }
+  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() {
@@ -191,27 +197,24 @@ public void tearDown() {
 
   private void initTransport() throws Exception {
     startTransport(
-        DEFAULT_START_STREAM_ID, null, true, DEFAULT_MAX_MESSAGE_SIZE, INITIAL_WINDOW_SIZE, null);
+        DEFAULT_START_STREAM_ID, null, true, null, null);
   }
 
   private void initTransport(int startId) throws Exception {
-    startTransport(startId, null, true, DEFAULT_MAX_MESSAGE_SIZE, INITIAL_WINDOW_SIZE, null);
+    startTransport(startId, null, true, null, null);
   }
 
-  private void initTransportAndDelayConnected() throws Exception {
-    delayConnectedCallback = new DelayConnectedCallback();
-    startTransport(
-        DEFAULT_START_STREAM_ID,
-        delayConnectedCallback,
-        false,
-        DEFAULT_MAX_MESSAGE_SIZE,
-        INITIAL_WINDOW_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, int initialWindowSize, String userAgent)
-      throws Exception {
+                              boolean waitingForConnected, String userAgent,
+                              HostnameVerifier hostnameVerifier, boolean useSslSocket)
+          throws Exception {
     connectedFuture = SettableFuture.create();
     final Ticker ticker = new Ticker() {
       @Override
@@ -225,52 +228,69 @@ 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,
-        executor,
-        frameReader,
-        frameWriter,
-        new OkHttpFrameLogger(Level.FINE, logger),
-        startId,
-        socket,
         stopwatchSupplier,
+        new FakeVariant(frameReader, frameWriter),
         connectingCallback,
         connectedFuture,
-        maxMessageSize,
-        initialWindowSize,
-        tooManyPingsRunnable,
-        new TransportTracer());
+        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(
+        channelBuilder.buildTransportFactory(),
         address,
         "hostname",
-        /*agent=*/ null,
+        /*userAgent=*/ null,
         EAG_ATTRS,
-        executor,
-        socketFactory,
-        sslSocketFactory,
-        hostnameVerifier,
-        OkHttpChannelBuilder.INTERNAL_DEFAULT_CONNECTION_SPEC,
-        DEFAULT_MAX_MESSAGE_SIZE,
-        INITIAL_WINDOW_SIZE,
         NO_PROXY,
         tooManyPingsRunnable,
-        DEFAULT_MAX_INBOUND_METADATA_SIZE,
-        transportTracer,
-        false);
+        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.
@@ -296,29 +316,35 @@ public void close() throws SecurityException {
     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();
-    OkHttpClientStream stream =
-        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT);
+    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);
-    LogRecord log = logs.remove(0);
+    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());
+    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);
+    frameHandler().data(false, 3, createMessageFrame(new String(new char[1000])),
+        1000, 1000);
     assertThat(logs).hasSize(1);
     log = logs.remove(0);
     String data = log.getMessage();
@@ -382,12 +408,12 @@ public void close() throws SecurityException {
 
   @Test
   public void maxMessageSizeShouldBeEnforced() throws Exception {
-    // Allow the response payloads of up to 1 byte.
-    startTransport(3, null, true, 1, INITIAL_WINDOW_SIZE, null);
+    channelBuilder.maxInboundMessageSize(1);
+    initTransport();
 
     MockStreamListener listener = new MockStreamListener();
-    OkHttpClientStream stream =
-        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT);
+    ClientStream stream =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream.start(listener);
     stream.request(1);
     assertContainStream(3);
@@ -397,7 +423,8 @@ 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(Code.RESOURCE_EXHAUSTED, listener.status.getCode());
@@ -406,10 +433,8 @@ public void maxMessageSizeShouldBeEnforced() throws Exception {
 
   @Test
   public void includeInitialWindowSizeInFirstSettings() throws Exception {
-    int initialWindowSize = 65535;
-    startTransport(
-            DEFAULT_START_STREAM_ID, null, true, DEFAULT_MAX_MESSAGE_SIZE, initialWindowSize, null);
-    clientTransport.sendConnectionPrefaceAndSettings();
+    channelBuilder.flowControlWindow(65535);
+    initTransport();
 
     ArgumentCaptor<Settings> settings = ArgumentCaptor.forClass(Settings.class);
     verify(frameWriter, timeout(TIME_OUT_MS)).settings(settings.capture());
@@ -422,10 +447,8 @@ public void includeInitialWindowSizeInFirstSettings() throws Exception {
    */
   @Test
   public void includeInitialWindowSizeInFirstSettings_largeWindowSize() throws Exception {
-    int initialWindowSize = 75535; // 65535 + 10000
-    startTransport(
-            DEFAULT_START_STREAM_ID, null, true, DEFAULT_MAX_MESSAGE_SIZE, initialWindowSize, null);
-    clientTransport.sendConnectionPrefaceAndSettings();
+    channelBuilder.flowControlWindow(75535); // 65535 + 10000
+    initTransport();
 
     ArgumentCaptor<Settings> settings = ArgumentCaptor.forClass(Settings.class);
     verify(frameWriter, timeout(TIME_OUT_MS)).settings(settings.capture());
@@ -442,12 +465,12 @@ public void nextFrameThrowIoException() throws Exception {
     initTransport();
     MockStreamListener listener1 = new MockStreamListener();
     MockStreamListener listener2 = new MockStreamListener();
-    OkHttpClientStream stream1 =
-        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT);
+    ClientStream stream1 =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream1.start(listener1);
     stream1.request(1);
-    OkHttpClientStream stream2 =
-        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT);
+    ClientStream stream2 =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream2.start(listener2);
     stream2.request(1);
     assertEquals(2, activeStreamCount());
@@ -462,7 +485,8 @@ public void nextFrameThrowIoException() throws Exception {
     assertEquals(NETWORK_ISSUE_MESSAGE, listener1.status.getCause().getMessage());
     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();
   }
@@ -476,8 +500,8 @@ public void nextFrameThrowIoException() throws Exception {
   public void nextFrameThrowsError() throws Exception {
     initTransport();
     MockStreamListener listener = new MockStreamListener();
-    OkHttpClientStream stream =
-        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT);
+    ClientStream stream =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream.start(listener);
     stream.request(1);
     assertEquals(1, activeStreamCount());
@@ -488,7 +512,8 @@ public void nextFrameThrowsError() throws Exception {
     assertEquals(0, activeStreamCount());
     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();
   }
@@ -497,14 +522,15 @@ public void nextFrameThrowsError() throws Exception {
   public void nextFrameReturnFalse() throws Exception {
     initTransport();
     MockStreamListener listener = new MockStreamListener();
-    OkHttpClientStream stream =
-        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT);
+    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();
   }
@@ -515,8 +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(), CallOptions.DEFAULT);
+    ClientStream stream =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream.start(listener);
     stream.request(numMessages);
     assertContainStream(3);
@@ -524,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();
@@ -545,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();
   }
@@ -553,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();
   }
@@ -565,8 +595,8 @@ public void receivedDataForInvalidStreamShouldKillConnection() throws Exception
   public void invalidInboundHeadersCancelStream() throws Exception {
     initTransport();
     MockStreamListener listener = new MockStreamListener();
-    OkHttpClientStream stream =
-        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT);
+    ClientStream stream =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream.start(listener);
     stream.request(1);
     assertContainStream(3);
@@ -575,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());
@@ -589,8 +620,8 @@ public void invalidInboundHeadersCancelStream() throws Exception {
   public void invalidInboundTrailersPropagateToMetadata() throws Exception {
     initTransport();
     MockStreamListener listener = new MockStreamListener();
-    OkHttpClientStream stream =
-        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT);
+    ClientStream stream =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream.start(listener);
     stream.request(1);
     assertContainStream(3);
@@ -609,8 +640,8 @@ public void invalidInboundTrailersPropagateToMetadata() throws Exception {
   public void readStatus() throws Exception {
     initTransport();
     MockStreamListener listener = new MockStreamListener();
-    OkHttpClientStream stream =
-        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT);
+    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);
@@ -623,8 +654,8 @@ public void readStatus() throws Exception {
   public void receiveReset() throws Exception {
     initTransport();
     MockStreamListener listener = new MockStreamListener();
-    OkHttpClientStream stream =
-        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT);
+    ClientStream stream =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream.start(listener);
     assertContainStream(3);
     frameHandler().rstStream(3, ErrorCode.PROTOCOL_ERROR);
@@ -640,13 +671,14 @@ public void receiveReset() throws Exception {
   public void receiveResetNoError() throws Exception {
     initTransport();
     MockStreamListener listener = new MockStreamListener();
-    OkHttpClientStream stream =
-        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT);
+    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());
+    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);
@@ -660,8 +692,8 @@ public void receiveResetNoError() throws Exception {
   public void cancelStream() throws Exception {
     initTransport();
     MockStreamListener listener = new MockStreamListener();
-    OkHttpClientStream stream =
-        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT);
+    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));
@@ -675,8 +707,8 @@ public void cancelStream() throws Exception {
   public void addDefaultUserAgent() throws Exception {
     initTransport();
     MockStreamListener listener = new MockStreamListener();
-    OkHttpClientStream stream =
-        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT);
+    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));
@@ -692,10 +724,10 @@ public void addDefaultUserAgent() throws Exception {
 
   @Test
   public void overrideDefaultUserAgent() throws Exception {
-    startTransport(3, null, true, DEFAULT_MAX_MESSAGE_SIZE, INITIAL_WINDOW_SIZE, "fakeUserAgent");
+    startTransport(3, null, true, "fakeUserAgent", null);
     MockStreamListener listener = new MockStreamListener();
-    OkHttpClientStream stream =
-        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT);
+    ClientStream stream =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream.start(listener);
     List<Header> expectedHeaders = Arrays.asList(HTTP_SCHEME_HEADER, METHOD_HEADER,
         new Header(Header.TARGET_AUTHORITY, "notarealauthority:80"),
@@ -713,8 +745,8 @@ public void overrideDefaultUserAgent() throws Exception {
   public void cancelStreamForDeadlineExceeded() throws Exception {
     initTransport();
     MockStreamListener listener = new MockStreamListener();
-    OkHttpClientStream stream =
-        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT);
+    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));
@@ -727,8 +759,8 @@ public void writeMessage() throws Exception {
     initTransport();
     final String message = "Hello Server";
     MockStreamListener listener = new MockStreamListener();
-    OkHttpClientStream stream =
-        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT);
+    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());
@@ -742,28 +774,84 @@ public void writeMessage() throws Exception {
     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, stats.remoteFlowControlWindow);
-    // okhttp does not track local window sizes
-    assertEquals(-1, stats.localFlowControlWindow);
+    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, before.remoteFlowControlWindow);
-    // okhttp does not track local window sizes
-    assertEquals(-1, before.localFlowControlWindow);
+    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 + 1000, after.remoteFlowControlWindow);
-    // okhttp does not track local window sizes
-    assertEquals(-1, after.localFlowControlWindow);
+    assertEquals(INITIAL_WINDOW_SIZE / 2, after.remoteFlowControlWindow);
+    assertEquals(INITIAL_WINDOW_SIZE + 1000, after.localFlowControlWindow);
   }
 
   @Test
@@ -771,13 +859,13 @@ public void windowUpdate() throws Exception {
     initTransport();
     MockStreamListener listener1 = new MockStreamListener();
     MockStreamListener listener2 = new MockStreamListener();
-    OkHttpClientStream stream1 =
-        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT);
+    ClientStream stream1 =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream1.start(listener1);
     stream1.request(2);
 
-    OkHttpClientStream stream2 =
-        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT);
+    ClientStream stream2 =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream2.start(listener2);
     stream2.request(2);
     assertEquals(2, activeStreamCount());
@@ -789,15 +877,18 @@ public void windowUpdate() throws Exception {
 
     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));
@@ -805,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));
 
@@ -837,8 +929,8 @@ public void windowUpdate() throws Exception {
   public void windowUpdateWithInboundFlowControl() throws Exception {
     initTransport();
     MockStreamListener listener = new MockStreamListener();
-    OkHttpClientStream stream =
-        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT);
+    ClientStream stream =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream.start(listener);
     int messageLength = INITIAL_WINDOW_SIZE / 2 + 1;
     byte[] fakeMessage = new byte[messageLength];
@@ -846,7 +938,8 @@ public void windowUpdateWithInboundFlowControl() throws Exception {
     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));
@@ -873,8 +966,8 @@ public void windowUpdateWithInboundFlowControl() throws Exception {
   public void outboundFlowControl() throws Exception {
     initTransport();
     MockStreamListener listener = new MockStreamListener();
-    OkHttpClientStream stream =
-        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT);
+    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
@@ -919,8 +1012,8 @@ public void outboundFlowControl_smallWindowSize() throws Exception {
     setInitialWindowSize(initialOutboundWindowSize);
 
     MockStreamListener listener = new MockStreamListener();
-    OkHttpClientStream stream =
-            clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT);
+    ClientStream stream =
+            clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream.start(listener);
 
     int messageLength = 75;
@@ -962,8 +1055,8 @@ public void outboundFlowControl_bigWindowSize() throws Exception {
     frameHandler().windowUpdate(0, 65535);
 
     MockStreamListener listener = new MockStreamListener();
-    OkHttpClientStream stream =
-            clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT);
+    ClientStream stream =
+            clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream.start(listener);
 
     int messageLength = 100000;
@@ -998,8 +1091,8 @@ public void outboundFlowControl_bigWindowSize() throws Exception {
   public void outboundFlowControlWithInitialWindowSizeChange() throws Exception {
     initTransport();
     MockStreamListener listener = new MockStreamListener();
-    OkHttpClientStream stream =
-        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT);
+    ClientStream stream =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream.start(listener);
     int messageLength = 20;
     setInitialWindowSize(HEADER_LENGTH + 10);
@@ -1044,8 +1137,8 @@ public void outboundFlowControlWithInitialWindowSizeChange() throws Exception {
   public void outboundFlowControlWithInitialWindowSizeChangeInMiddleOfStream() throws Exception {
     initTransport();
     MockStreamListener listener = new MockStreamListener();
-    OkHttpClientStream stream =
-        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT);
+    ClientStream stream =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream.start(listener);
     int messageLength = 20;
     setInitialWindowSize(HEADER_LENGTH + 10);
@@ -1079,17 +1172,18 @@ public void stopNormally() throws Exception {
     initTransport();
     MockStreamListener listener1 = new MockStreamListener();
     MockStreamListener listener2 = new MockStreamListener();
-    OkHttpClientStream stream1 =
-        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT);
+    ClientStream stream1 =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream1.start(listener1);
-    OkHttpClientStream stream2 =
-        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT);
+    ClientStream stream2 =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream2.start(listener2);
     assertEquals(2, activeStreamCount());
     clientTransport.shutdown(SHUTDOWN_REASON);
 
     assertEquals(2, activeStreamCount());
-    verify(transportListener).transportShutdown(same(SHUTDOWN_REASON));
+    verify(transportListener).transportShutdown(same(SHUTDOWN_REASON),
+        eq(SimpleDisconnectError.SUBCHANNEL_SHUTDOWN));
 
     stream1.cancel(Status.CANCELLED);
     stream2.cancel(Status.CANCELLED);
@@ -1109,12 +1203,12 @@ public void receiveGoAway() throws Exception {
     // start 2 streams.
     MockStreamListener listener1 = new MockStreamListener();
     MockStreamListener listener2 = new MockStreamListener();
-    OkHttpClientStream stream1 =
-        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT);
+    ClientStream stream1 =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream1.start(listener1);
     stream1.request(1);
-    OkHttpClientStream stream2 =
-        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT);
+    ClientStream stream2 =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream2.start(listener2);
     stream2.request(1);
     assertEquals(2, activeStreamCount());
@@ -1123,7 +1217,8 @@ public void receiveGoAway() throws Exception {
     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.
@@ -1136,7 +1231,7 @@ 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);
@@ -1150,7 +1245,8 @@ public void receiveGoAway() throws Exception {
     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());
@@ -1167,8 +1263,8 @@ public void streamIdExhausted() throws Exception {
     initTransport(startId);
 
     MockStreamListener listener = new MockStreamListener();
-    OkHttpClientStream stream =
-        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT);
+    ClientStream stream =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream.start(listener);
     stream.request(1);
 
@@ -1181,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();
   }
@@ -1203,12 +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(), CallOptions.DEFAULT);
+    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(), CallOptions.DEFAULT);
+    ClientStream stream2 =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream2.start(listener2);
     String sentMessage = "hello";
     InputStream input = new ByteArrayInputStream(sentMessage.getBytes(UTF_8));
@@ -1240,8 +1337,8 @@ public void pendingStreamCancelled() throws Exception {
     initTransport();
     setMaxConcurrentStreams(0);
     MockStreamListener listener = new MockStreamListener();
-    OkHttpClientStream stream =
-        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT);
+    ClientStream stream =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream.start(listener);
     waitForStreamPending(1);
     stream.cancel(Status.CANCELLED);
@@ -1259,12 +1356,12 @@ public void pendingStreamFailedByGoAway() throws Exception {
     setMaxConcurrentStreams(1);
     final MockStreamListener listener1 = new MockStreamListener();
     final MockStreamListener listener2 = new MockStreamListener();
-    OkHttpClientStream stream1 =
-        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT);
+    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(), CallOptions.DEFAULT);
+    ClientStream stream2 =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream2.start(listener2);
 
     waitForStreamPending(1);
@@ -1289,8 +1386,8 @@ 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(), CallOptions.DEFAULT);
+    ClientStream stream =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream.start(listener);
     waitForStreamPending(1);
 
@@ -1313,16 +1410,16 @@ public void pendingStreamFailedByIdExhausted() throws Exception {
     final MockStreamListener listener2 = new MockStreamListener();
     final MockStreamListener listener3 = new MockStreamListener();
 
-    OkHttpClientStream stream1 =
-        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT);
+    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(), CallOptions.DEFAULT);
+    ClientStream stream2 =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream2.start(listener2);
-    OkHttpClientStream stream3 =
-        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT);
+    ClientStream stream3 =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream3.start(listener3);
 
     waitForStreamPending(2);
@@ -1345,8 +1442,8 @@ public void pendingStreamFailedByIdExhausted() throws Exception {
   public void receivingWindowExceeded() throws Exception {
     initTransport();
     MockStreamListener listener = new MockStreamListener();
-    OkHttpClientStream stream =
-        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT);
+    ClientStream stream =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream.start(listener);
     stream.request(1);
 
@@ -1356,7 +1453,7 @@ public void receivingWindowExceeded() throws Exception {
     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());
@@ -1397,8 +1494,8 @@ public void duplexStreamingHeadersShouldNotBeFlushed() throws Exception {
   private void shouldHeadersBeFlushed(boolean shouldBeFlushed) throws Exception {
     initTransport();
     MockStreamListener listener = new MockStreamListener();
-    OkHttpClientStream stream =
-        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT);
+    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), ArgumentMatchers.<Header>anyList());
@@ -1414,12 +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(), CallOptions.DEFAULT);
+    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(
@@ -1436,16 +1534,18 @@ public void receiveDataWithoutHeader() throws Exception {
   public void receiveDataWithoutHeaderAndTrailer() throws Exception {
     initTransport();
     MockStreamListener listener = new MockStreamListener();
-    OkHttpClientStream stream =
-        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT);
+    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());
@@ -1458,12 +1558,13 @@ public void receiveDataWithoutHeaderAndTrailer() throws Exception {
   public void receiveLongEnoughDataWithoutHeaderAndTrailer() throws Exception {
     initTransport();
     MockStreamListener listener = new MockStreamListener();
-    OkHttpClientStream stream =
-        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT);
+    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));
@@ -1479,14 +1580,15 @@ public void receiveLongEnoughDataWithoutHeaderAndTrailer() throws Exception {
   public void receiveDataForUnknownStreamUpdateConnectionWindow() throws Exception {
     initTransport();
     MockStreamListener listener = new MockStreamListener();
-    OkHttpClientStream stream =
-        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT);
+    ClientStream stream =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream.start(listener);
     stream.cancel(Status.CANCELLED);
 
     Buffer buffer = createMessageFrame(
         new byte[INITIAL_WINDOW_SIZE / 2 + 1]);
-    frameHandler().data(false, 3, buffer, (int) buffer.size());
+    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 + INITIAL_WINDOW_SIZE / 2 + 1);
@@ -1494,10 +1596,12 @@ public void receiveDataForUnknownStreamUpdateConnectionWindow() throws Exception
         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();
   }
@@ -1506,8 +1610,8 @@ public void receiveDataForUnknownStreamUpdateConnectionWindow() throws Exception
   public void receiveWindowUpdateForUnknownStream() throws Exception {
     initTransport();
     MockStreamListener listener = new MockStreamListener();
-    OkHttpClientStream stream =
-        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT);
+    ClientStream stream =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream.start(listener);
     stream.cancel(Status.CANCELLED);
     // This should be ignored.
@@ -1517,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();
   }
@@ -1526,8 +1631,8 @@ public void receiveWindowUpdateForUnknownStream() throws Exception {
   public void shouldBeInitiallyReady() throws Exception {
     initTransport();
     MockStreamListener listener = new MockStreamListener();
-    OkHttpClientStream stream =
-        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT);
+    ClientStream stream =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream.start(listener);
     assertTrue(stream.isReady());
     assertTrue(listener.isOnReadyCalled());
@@ -1544,8 +1649,8 @@ public void notifyOnReady() throws Exception {
         AbstractStream.TransportState.DEFAULT_ONREADY_THRESHOLD - HEADER_LENGTH - 1;
     setInitialWindowSize(0);
     MockStreamListener listener = new MockStreamListener();
-    OkHttpClientStream stream =
-        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT);
+    ClientStream stream =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream.start(listener);
     assertTrue(stream.isReady());
     // Be notified at the beginning.
@@ -1650,16 +1755,14 @@ public void ping_failsWhenTransportShutdown() throws Exception {
     clientTransport.shutdown(SHUTDOWN_REASON);
     // ping failed on channel shutdown
     assertEquals(1, callback.invocationCount);
-    assertTrue(callback.failureCause instanceof StatusException);
-    assertSame(SHUTDOWN_REASON, ((StatusException) callback.failureCause).getStatus());
+    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);
-    assertSame(SHUTDOWN_REASON, ((StatusException) callback.failureCause).getStatus());
+    assertSame(SHUTDOWN_REASON, callback.failureCause);
     shutdownAndVerify();
   }
 
@@ -1674,105 +1777,42 @@ public void ping_failsIfTransportFails() throws Exception {
     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(), CallOptions.DEFAULT);
-    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.
-    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 cancelBeforeConnected() throws Exception {
-    initTransportAndDelayConnected();
-    final String message = "Hello Server";
-    MockStreamListener listener = new MockStreamListener();
-    OkHttpClientStream stream =
-        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT);
-    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(), CallOptions.DEFAULT);
-    stream.start(listener);
+    SettableFuture<Void> delayed = SettableFuture.create();
+    Runnable connectingCallback = () -> Futures.getUnchecked(delayed);
+    startTransport(
+        DEFAULT_START_STREAM_ID,
+        connectingCallback,
+        false,
+        null, null);
     clientTransport.shutdown(SHUTDOWN_REASON);
-    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());
+    delayed.set(null);
     shutdownAndVerify();
   }
 
   @Test
   public void invalidAuthorityPropagates() {
     clientTransport = new OkHttpClientTransport(
-        new InetSocketAddress("host", 1234),
+        channelBuilder.buildTransportFactory(),
+        new InetSocketAddress("localhost", 1234),
         "invalid_authority",
         "userAgent",
         EAG_ATTRS,
-        executor,
-        socketFactory,
-        sslSocketFactory,
-        hostnameVerifier,
-        ConnectionSpec.CLEARTEXT,
-        DEFAULT_MAX_MESSAGE_SIZE,
-        INITIAL_WINDOW_SIZE,
         NO_PROXY,
         tooManyPingsRunnable,
-        DEFAULT_MAX_INBOUND_METADATA_SIZE,
-        transportTracer,
-        false);
+        null);
 
     String host = clientTransport.getOverridenHost();
     int port = clientTransport.getOverridenPort();
@@ -1784,33 +1824,27 @@ public void invalidAuthorityPropagates() {
   @Test
   public void unreachableServer() throws Exception {
     clientTransport = new OkHttpClientTransport(
+        channelBuilder.buildTransportFactory(),
         new InetSocketAddress("localhost", 0),
         "authority",
         "userAgent",
         EAG_ATTRS,
-        executor,
-        socketFactory,
-        sslSocketFactory,
-        hostnameVerifier,
-        ConnectionSpec.CLEARTEXT,
-        DEFAULT_MAX_MESSAGE_SIZE,
-        INITIAL_WINDOW_SIZE,
         NO_PROXY,
         tooManyPingsRunnable,
-        DEFAULT_MAX_INBOUND_METADATA_SIZE,
-        new TransportTracer(),
-        false);
+        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(), CallOptions.DEFAULT).start(streamListener);
+    clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers)
+        .start(streamListener);
     streamListener.waitUntilStreamClosed();
     assertEquals(Status.UNAVAILABLE.getCode(), streamListener.status.getCode());
   }
@@ -1822,28 +1856,21 @@ public void customSocketFactory() throws Exception {
 
     clientTransport =
         new OkHttpClientTransport(
+            channelBuilder.socketFactory(socketFactory).buildTransportFactory(),
             new InetSocketAddress("localhost", 0),
             "authority",
             "userAgent",
             EAG_ATTRS,
-            executor,
-            socketFactory,
-            sslSocketFactory,
-            hostnameVerifier,
-            ConnectionSpec.CLEARTEXT,
-            DEFAULT_MAX_MESSAGE_SIZE,
-            INITIAL_WINDOW_SIZE,
             NO_PROXY,
             tooManyPingsRunnable,
-            DEFAULT_MAX_INBOUND_METADATA_SIZE,
-            new TransportTracer(),
-            false);
+            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());
     assertSame(exception, status.getCause());
   }
@@ -1853,24 +1880,17 @@ 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,
-        executor,
-        socketFactory,
-        sslSocketFactory,
-        hostnameVerifier,
-        ConnectionSpec.CLEARTEXT,
-        DEFAULT_MAX_MESSAGE_SIZE,
-        INITIAL_WINDOW_SIZE,
         HttpConnectProxiedSocketAddress.newBuilder()
             .setTargetAddress(targetAddress)
-            .setProxyAddress(serverSocket.getLocalSocketAddress()).build(),
+            .setProxyAddress(new InetSocketAddress("localhost", serverSocket.getLocalPort()))
+            .build(),
         tooManyPingsRunnable,
-        DEFAULT_MAX_INBOUND_METADATA_SIZE,
-        transportTracer,
-        false);
+        null);
     clientTransport.start(transportListener);
 
     Socket sock = serverSocket.accept();
@@ -1899,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();
@@ -1910,24 +1931,17 @@ public void proxy_500() throws Exception {
     ServerSocket serverSocket = new ServerSocket(0);
     InetSocketAddress targetAddress = InetSocketAddress.createUnresolved("theservice", 80);
     clientTransport = new OkHttpClientTransport(
+        channelBuilder.buildTransportFactory(),
         targetAddress,
         "authority",
         "userAgent",
         EAG_ATTRS,
-        executor,
-        socketFactory,
-        sslSocketFactory,
-        hostnameVerifier,
-        ConnectionSpec.CLEARTEXT,
-        DEFAULT_MAX_MESSAGE_SIZE,
-        INITIAL_WINDOW_SIZE,
         HttpConnectProxiedSocketAddress.newBuilder()
             .setTargetAddress(targetAddress)
-            .setProxyAddress(serverSocket.getLocalSocketAddress()).build(),
+            .setProxyAddress(new InetSocketAddress("localhost", serverSocket.getLocalPort()))
+            .build(),
         tooManyPingsRunnable,
-        DEFAULT_MAX_INBOUND_METADATA_SIZE,
-        transportTracer,
-        false);
+        null);
     clientTransport.start(transportListener);
 
     Socket sock = serverSocket.accept();
@@ -1946,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();
   }
@@ -1966,38 +1981,65 @@ public void proxy_immediateServerClose() throws Exception {
     ServerSocket serverSocket = new ServerSocket(0);
     InetSocketAddress targetAddress = InetSocketAddress.createUnresolved("theservice", 80);
     clientTransport = new OkHttpClientTransport(
+        channelBuilder.buildTransportFactory(),
         targetAddress,
         "authority",
         "userAgent",
         EAG_ATTRS,
-        executor,
-        socketFactory,
-        sslSocketFactory,
-        hostnameVerifier,
-        ConnectionSpec.CLEARTEXT,
-        DEFAULT_MAX_MESSAGE_SIZE,
-        INITIAL_WINDOW_SIZE,
         HttpConnectProxiedSocketAddress.newBuilder()
             .setTargetAddress(targetAddress)
-            .setProxyAddress(serverSocket.getLocalSocketAddress()).build(),
+            .setProxyAddress(new InetSocketAddress("localhost", serverSocket.getLocalPort()))
+            .build(),
         tooManyPingsRunnable,
-        DEFAULT_MAX_INBOUND_METADATA_SIZE,
-        transportTracer,
-        false);
+        null);
     clientTransport.start(transportListener);
 
     Socket sock = serverSocket.accept();
     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
@@ -2050,14 +2092,14 @@ public void goAway_streamListenerRpcProgress() throws Exception {
     MockStreamListener listener1 = new MockStreamListener();
     MockStreamListener listener2 = new MockStreamListener();
     MockStreamListener listener3 = new MockStreamListener();
-    OkHttpClientStream stream1 =
-        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT);
+    ClientStream stream1 =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream1.start(listener1);
-    OkHttpClientStream stream2 =
-        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT);
+    ClientStream stream2 =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream2.start(listener2);
-    OkHttpClientStream stream3 =
-        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT);
+    ClientStream stream3 =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream3.start(listener3);
     waitForStreamPending(1);
 
@@ -2072,7 +2114,7 @@ public void goAway_streamListenerRpcProgress() throws Exception {
     listener3.waitUntilStreamClosed();
     assertNull(listener1.rpcProgress);
     assertEquals(REFUSED, listener2.rpcProgress);
-    assertEquals(REFUSED, listener3.rpcProgress);
+    assertEquals(MISCARRIED, listener3.rpcProgress);
     assertEquals(1, activeStreamCount());
     assertContainStream(DEFAULT_START_STREAM_ID);
 
@@ -2090,14 +2132,14 @@ public void reset_streamListenerRpcProgress() throws Exception {
     MockStreamListener listener1 = new MockStreamListener();
     MockStreamListener listener2 = new MockStreamListener();
     MockStreamListener listener3 = new MockStreamListener();
-    OkHttpClientStream stream1 =
-        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT);
+    ClientStream stream1 =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream1.start(listener1);
-    OkHttpClientStream stream2 =
-        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT);
+    ClientStream stream2 =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream2.start(listener2);
-    OkHttpClientStream stream3 =
-        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT);
+    ClientStream stream3 =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream3.start(listener3);
 
     assertEquals(3, activeStreamCount());
@@ -2125,6 +2167,59 @@ public void reset_streamListenerRpcProgress() throws Exception {
     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() {
     return clientTransport.getActiveStreams().length;
   }
@@ -2154,8 +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(), CallOptions.DEFAULT);
+    ClientStream stream =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream.start(listener);
     listener.waitUntilStreamClosed();
     assertFalse(listener.status.isOk());
@@ -2178,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;
   }
 
@@ -2299,11 +2399,6 @@ public void messagesAvailable(MessageProducer producer) {
       }
     }
 
-    @Override
-    public void closed(Status status, Metadata trailers) {
-      closed(status, PROCESSED, trailers);
-    }
-
     @Override
     public void closed(Status status, RpcProgress rpcProgress, Metadata trailers) {
       this.status = status;
@@ -2348,10 +2443,20 @@ 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
@@ -2363,12 +2468,140 @@ public synchronized void close() {
     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) {
@@ -2377,16 +2610,12 @@ 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(SHUTDOWN_REASON);
     assertEquals(0, activeStreamCount());
@@ -2398,19 +2627,6 @@ private void shutdownAndVerify() {
     frameReader.assertClosed();
   }
 
-  private static class DelayConnectedCallback implements Runnable {
-    SettableFuture<Void> delayed = SettableFuture.create();
-
-    @Override
-    public void run() {
-      Futures.getUnchecked(delayed);
-    }
-
-    void allowConnected() {
-      delayed.set(null);
-    }
-  }
-
   private static TransportStats getTransportStats(InternalInstrumented<SocketStats> obj)
       throws ExecutionException, InterruptedException {
     return obj.getStats().get().data;
@@ -2429,10 +2645,6 @@ public MockFrameWriter(Socket socket, Queue<Buffer> capturedBuffer) {
       this.capturedBuffer = capturedBuffer;
     }
 
-    void setSocket(Socket socket) {
-      this.socket = socket;
-    }
-
     @Override
     public void close() throws IOException {
       socket.close();
@@ -2522,4 +2734,65 @@ public Socket createSocket(InetAddress inetAddress, int i, InetAddress inetAddre
       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;
+    }
+
+    @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 3a4a21b2467..4353dc2597b 100644
--- a/okhttp/src/test/java/io/grpc/okhttp/OkHttpProtocolNegotiatorTest.java
+++ b/okhttp/src/test/java/io/grpc/okhttp/OkHttpProtocolNegotiatorTest.java
@@ -16,10 +16,12 @@
 
 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.assertThrows;
 import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.doThrow;
 import static org.mockito.Mockito.mock;
@@ -37,9 +39,7 @@
 import javax.net.ssl.SSLParameters;
 import javax.net.ssl.SSLSession;
 import javax.net.ssl.SSLSocket;
-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.ArgumentMatchers;
@@ -49,9 +49,6 @@
  */
 @RunWith(JUnit4.class)
 public class OkHttpProtocolNegotiatorTest {
-  @SuppressWarnings("deprecation") // https://github.com/grpc/grpc-java/issues/7467
-  @Rule public final ExpectedException thrown = ExpectedException.none();
-
   private final SSLSocket sock = mock(SSLSocket.class);
   private final Platform platform = mock(Platform.class);
 
@@ -118,21 +115,19 @@ public void negotiate_handshakeFails() throws IOException {
     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("TLS ALPN 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
@@ -150,7 +145,7 @@ public void negotiate_success() throws Exception {
 
   // Checks that the super class is properly invoked.
   @Test
-  public void negotiate_android_handshakeFails() throws Exception {
+  public void negotiate_android_handshakeFails() {
     when(platform.getTlsExtensionType()).thenReturn(TlsExtensionType.ALPN_AND_NPN);
     AndroidNegotiator negotiator = new AndroidNegotiator(platform);
 
@@ -161,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
diff --git a/okhttp/src/test/java/io/grpc/okhttp/OkHttpReadableBufferTest.java b/okhttp/src/test/java/io/grpc/okhttp/OkHttpReadableBufferTest.java
index 2ece98ffb97..be8dbf0e62b 100644
--- a/okhttp/src/test/java/io/grpc/okhttp/OkHttpReadableBufferTest.java
+++ b/okhttp/src/test/java/io/grpc/okhttp/OkHttpReadableBufferTest.java
@@ -46,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/OkHttpTransportTest.java b/okhttp/src/test/java/io/grpc/okhttp/OkHttpTransportTest.java
index 44e493c259f..076eea3349a 100644
--- a/okhttp/src/test/java/io/grpc/okhttp/OkHttpTransportTest.java
+++ b/okhttp/src/test/java/io/grpc/okhttp/OkHttpTransportTest.java
@@ -16,6 +16,7 @@
 
 package io.grpc.okhttp;
 
+import io.grpc.InsecureServerCredentials;
 import io.grpc.ServerStreamTracer;
 import io.grpc.internal.AbstractTransportTest;
 import io.grpc.internal.ClientTransportFactory;
@@ -23,8 +24,6 @@
 import io.grpc.internal.GrpcUtil;
 import io.grpc.internal.InternalServer;
 import io.grpc.internal.ManagedClientTransport;
-import io.grpc.netty.InternalNettyServerBuilder;
-import io.grpc.netty.NettyServerBuilder;
 import java.net.InetSocketAddress;
 import java.util.List;
 import java.util.concurrent.TimeUnit;
@@ -53,21 +52,17 @@ public void releaseClientFactory() {
   @Override
   protected InternalServer newServer(
       List<ServerStreamTracer.Factory> streamTracerFactories) {
-    NettyServerBuilder builder = NettyServerBuilder
-        .forPort(0)
-        .flowControlWindow(AbstractTransportTest.TEST_FLOW_CONTROL_WINDOW);
-    InternalNettyServerBuilder.setTransportTracerFactory(builder, fakeClockTransportTracer);
-    return InternalNettyServerBuilder.buildTransportServers(builder, streamTracerFactories);
+    return newServer(0, streamTracerFactories);
   }
 
   @Override
   protected InternalServer newServer(
       int port, List<ServerStreamTracer.Factory> streamTracerFactories) {
-    NettyServerBuilder builder = NettyServerBuilder
-        .forAddress(new InetSocketAddress(port))
-        .flowControlWindow(AbstractTransportTest.TEST_FLOW_CONTROL_WINDOW);
-    InternalNettyServerBuilder.setTransportTracerFactory(builder, fakeClockTransportTracer);
-    return InternalNettyServerBuilder.buildTransportServers(builder, streamTracerFactories);
+    return OkHttpServerBuilder
+        .forPort(port, InsecureServerCredentials.create())
+        .flowControlWindow(AbstractTransportTest.TEST_FLOW_CONTROL_WINDOW)
+        .setTransportTracerFactory(fakeClockTransportTracer)
+        .buildTransportServers(streamTracerFactories);
   }
 
   @Override
@@ -100,11 +95,4 @@ protected long fakeCurrentTimeNanos() {
   protected boolean haveTransportTracer() {
     return true;
   }
-
-  @Override
-  @org.junit.Test
-  @org.junit.Ignore
-  public void clientChecksInboundMetadataSize_trailer() {
-    // Server-side is flaky due to https://github.com/netty/netty/pull/8332
-  }
 }
diff --git a/okhttp/src/test/java/io/grpc/okhttp/OkHttpWritableBufferAllocatorTest.java b/okhttp/src/test/java/io/grpc/okhttp/OkHttpWritableBufferAllocatorTest.java
index e606b6b9a50..c19224822a8 100644
--- a/okhttp/src/test/java/io/grpc/okhttp/OkHttpWritableBufferAllocatorTest.java
+++ b/okhttp/src/test/java/io/grpc/okhttp/OkHttpWritableBufferAllocatorTest.java
@@ -16,11 +16,13 @@
 
 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;
@@ -38,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
@@ -54,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/OptionalMethodTest.java b/okhttp/src/test/java/io/grpc/okhttp/OptionalMethodTest.java
index 1879ce9d6a4..dedf6bc8e44 100644
--- a/okhttp/src/test/java/io/grpc/okhttp/OptionalMethodTest.java
+++ b/okhttp/src/test/java/io/grpc/okhttp/OptionalMethodTest.java
@@ -50,6 +50,7 @@ public String testMethod(String arg) {
   }
 
   private static class PrivateClass {
+    @SuppressWarnings("UnusedMethod")
     public String testMethod(String arg) {
       return arg;
     }
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 895ba7ff7c7..1c97e027b4a 100644
--- a/okhttp/src/test/java/io/grpc/okhttp/UtilsTest.java
+++ b/okhttp/src/test/java/io/grpc/okhttp/UtilsTest.java
@@ -16,7 +16,9 @@
 
 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;
@@ -25,9 +27,8 @@
 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;
 
@@ -37,16 +38,12 @@
 @RunWith(JUnit4.class)
 public class UtilsTest {
 
-  @SuppressWarnings("deprecation") // https://github.com/grpc/grpc-java/issues/7467
-  @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
@@ -95,6 +92,9 @@ public void getSocketOptions() throws Exception {
     assertEquals("5000", socketOptions.others.get("SO_SNDBUF"));
     assertEquals("true", socketOptions.others.get("SO_KEEPALIVE"));
     assertEquals("true", socketOptions.others.get("SO_OOBINLINE"));
-    assertEquals("8", socketOptions.others.get("IP_TOS"));
+    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/main/java/io/grpc/okhttp/internal/CipherSuite.java b/okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/CipherSuite.java
index 70fa796f248..1a9aab284bb 100644
--- a/okhttp/third_party/okhttp/main/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;
@@ -372,6 +388,12 @@ private CipherSuite(
     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/main/java/io/grpc/okhttp/internal/ConnectionSpec.java b/okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/ConnectionSpec.java
index 457e9c301f3..b84a1ff94ee 100644
--- a/okhttp/third_party/okhttp/main/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/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/main/java/io/grpc/okhttp/internal/OkHostnameVerifier.java b/okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/OkHostnameVerifier.java
index 34bb56ee2d6..f6efb2d90e7 100644
--- a/okhttp/third_party/okhttp/main/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++) {
@@ -198,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("*")) {
@@ -254,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/main/java/io/grpc/okhttp/internal/Platform.java b/okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/Platform.java
index 45d874e300c..29ea8055b26 100644
--- 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
@@ -28,11 +28,8 @@
 import java.net.InetSocketAddress;
 import java.net.Socket;
 import java.net.SocketException;
-import java.security.AccessController;
 import java.security.KeyManagementException;
 import java.security.NoSuchAlgorithmException;
-import java.security.PrivilegedActionException;
-import java.security.PrivilegedExceptionAction;
 import java.security.Provider;
 import java.security.Security;
 import java.util.ArrayList;
@@ -218,41 +215,21 @@ private static Platform findPlatform() {
       SSLContext context = SSLContext.getInstance("TLS", sslProvider);
       context.init(null, null, null);
       SSLEngine engine = context.createSSLEngine();
-      Method getEngineApplicationProtocol =
-          AccessController.doPrivileged(
-              new PrivilegedExceptionAction<Method>() {
-                @Override
-                public Method run() throws Exception {
-                  return SSLEngine.class.getMethod("getApplicationProtocol");
-                }
-              });
+      Method getEngineApplicationProtocol = SSLEngine.class.getMethod("getApplicationProtocol");
       getEngineApplicationProtocol.invoke(engine);
 
       Method setApplicationProtocols =
-          AccessController.doPrivileged(
-              new PrivilegedExceptionAction<Method>() {
-                @Override
-                public Method run() throws Exception {
-                  return SSLParameters.class.getMethod("setApplicationProtocols", String[].class);
-                }
-              });
-      Method getApplicationProtocol =
-          AccessController.doPrivileged(
-              new PrivilegedExceptionAction<Method>() {
-                @Override
-                public Method run() throws Exception {
-                  return SSLSocket.class.getMethod("getApplicationProtocol");
-                }
-              });
+          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 (PrivilegedActionException ignored) {
-      // On older Java
     } catch (IllegalAccessException ignored) {
       // On older Java
+    } catch (NoSuchMethodException ignored) {
+      // On older Java
     } catch (InvocationTargetException ignored) {
       // On older Java
     }
@@ -306,7 +283,7 @@ private static boolean isAtLeastAndroid41() {
 
   /**
    * Select the first recognized security provider according to the preference order returned by
-   * {@link Security#getProviders}. If a recognized provider is not found then warn but continue.
+   * {@link Security#getProviders}.
    */
   private static Provider getAndroidSecurityProvider() {
     Provider[] providers = Security.getProviders();
@@ -318,7 +295,6 @@ private static Provider getAndroidSecurityProvider() {
         }
       }
     }
-    logger.log(Level.WARNING, "Unable to find Conscrypt");
     return null;
   }
 
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/main/java/io/grpc/okhttp/internal/TlsVersion.java b/okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/TlsVersion.java
index 548f4acbc5b..6692c80fad4 100644
--- a/okhttp/third_party/okhttp/main/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
index 556d849c705..cad74a026b1 100644
--- 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
@@ -19,31 +19,15 @@
 
 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. */
@@ -52,192 +36,16 @@ public final class Util {
   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) {
-        // The method is defined to ignore checked exceptions
-      }
-    }
-  }
-
-  /**
-   * 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) {
-        // The method is defined to ignore checked exceptions
-      }
-    }
-  }
-
-  /**
-   * 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) {
-        // The method is defined to ignore checked exceptions
-      }
-    }
-  }
-
-  /**
-   * 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<>(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<>(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}.
@@ -264,30 +72,4 @@ private static <T> List<T> intersect(T[] first, T[] second) {
     }
     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/main/java/io/grpc/okhttp/internal/framed/FrameReader.java b/okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/framed/FrameReader.java
index 585ccb15355..490673eff6a 100644
--- a/okhttp/third_party/okhttp/main/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;
 
     /**
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
index 484cc5673dc..fa9458e2024 100644
--- 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
@@ -354,6 +354,13 @@ int readInt(int firstByte, int prefixMask) throws IOException {
         if ((b & 0x80) != 0) { // Equivalent to (b >= 128) since b is in [0..255].
           result += (b & 0x7f) << shift;
           shift += 7;
+          // We can safely store 31 bits, and then next byte will have 7 more bits. While the next
+          // byte may not have high bits set to cause an overflow, that's only useful for 256+ MiB
+          // values, which is excessive. This also gives us at least one bit of spare, which is
+          // necessary to store the carry from the addition.
+          if (shift >= 28) {
+            throw new IOException("Varint overflowed");
+          }
         } else {
           result += b << shift; // Last byte.
           break;
@@ -483,9 +490,14 @@ void writeHeaders(List<io.grpc.okhttp.internal.framed.Header> headerBlock) throw
           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.
+        } else if (name.startsWith(PSEUDO_PREFIX)
+            && !io.grpc.okhttp.internal.framed.Header.TARGET_AUTHORITY.equals(name)
+            && !io.grpc.okhttp.internal.framed.Header.TARGET_PATH.equals(name)) {
+          // Allow :authority and :path pseudo headers to be indexed. Other pseudo headers are not
+          // indexed.
+          // This is a departure from the original Chrome-inspired behavior, as gRPC paths
+          // (ServiceName/MethodName)
+          // are stable and benefit from indexing.
           writeInt(headerNameIndex, PREFIX_4_BITS, 0);
           writeByteString(value);
         } else {
@@ -508,6 +520,9 @@ void writeInt(int value, int prefixMask, int bits) throws IOException {
       // Write the mask to start a multibyte value.
       out.writeByte(bits | prefixMask);
       value -= prefixMask;
+      if (value > 0xfffffff) {
+        throw new IOException("Varint would overflow reader");
+      }
 
       // Write 7 bits at a time 'til we're done.
       while (value >= 0x80) {
diff --git a/okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/framed/Http2.java b/okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/framed/Http2.java
index 197a7f72fc8..0eb49b9f076 100644
--- a/okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/framed/Http2.java
+++ b/okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/framed/Http2.java
@@ -23,6 +23,7 @@
 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;
@@ -219,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;
@@ -229,9 +230,10 @@ 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);
     }
 
@@ -589,12 +591,12 @@ 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));
   }
 
   /**
@@ -683,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/main/java/io/grpc/okhttp/internal/framed/Settings.java b/okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/framed/Settings.java
index 0d0ecce9982..591b59129ed 100644
--- a/okhttp/third_party/okhttp/main/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/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
index 26580f85e54..8635151c6b9 100644
--- 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
@@ -272,14 +272,18 @@ public void readerEviction() throws IOException {
 
   /**
    * http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-12#appendix-C.2.2
+   *
+   * <p>This test mimics the draft example which uses ":path", but since gRPC-Java now indexes
+   * ":path" for performance, we use ":method" (with a non-static value like "PUT") to verify the
+   * "Literal Header Field without Indexing - Indexed Name" representation.
    */
   @Test public void literalHeaderFieldWithoutIndexingIndexedName() throws IOException {
-    List<Header> headerBlock = headerEntries(":path", "/sample/path");
+    List<Header> headerBlock = headerEntries(":method", "PUT");
 
-    bytesIn.writeByte(0x04); // == Literal not indexed ==
-    // Indexed name (idx = 4) -> :path
-    bytesIn.writeByte(0x0c); // Literal value (len = 12)
-    bytesIn.writeUtf8("/sample/path");
+    bytesIn.writeByte(0x02); // == Literal not indexed ==
+    // Indexed name (idx = 2) -> :method
+    bytesIn.writeByte(0x03); // Literal value (len = 3)
+    bytesIn.writeUtf8("PUT");
 
     hpackWriter.writeHeaders(headerBlock);
     assertEquals(bytesIn, bytesOut);
@@ -455,7 +459,7 @@ public void theSameHeaderAfterOneIncrementalIndexed() throws IOException {
       hpackReader.readHeaders();
       fail();
     } catch (IOException e) {
-      assertEquals("Header index too large -2147483521", e.getMessage());
+      assertEquals("Varint overflowed", e.getMessage());
     }
   }
 
@@ -497,7 +501,7 @@ public void theSameHeaderAfterOneIncrementalIndexed() throws IOException {
       hpackReader.readHeaders();
       fail();
     } catch (IOException e) {
-      assertEquals("Invalid dynamic table size update -2147483648", e.getMessage());
+      assertEquals("Varint overflowed", e.getMessage());
     }
   }
 
@@ -856,11 +860,53 @@ private void checkReadThirdRequestWithHuffman() {
     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 max29BitValue() throws IOException {
+    hpackWriter.writeInt(0x100000fe, 0xff, 0xff);
+    assertBytes(0xff, 0xff, 0xff, 0xff, 0x7f);
+    assertEquals(0x100000fe,
+        newReader(byteStream(0xff, 0xff, 0xff, 0x7f)).readInt(0xff, 0xff));
+  }
+
+  @Test public void beyondMax29BitValue() throws IOException {
+    try {
+      hpackWriter.writeInt(0x100000ff, 0xff, 0xff);
+      fail();
+    } catch (IOException e) {
+      assertEquals("Varint would overflow reader", e.getMessage());
+    }
+    try {
+      newReader(byteStream(0xff, 0xff, 0xff, 0xff, 0x80)).readInt(0xff, 0xff);
+      fail();
+    } catch (IOException e) {
+      assertEquals("Varint overflowed", e.getMessage());
+    }
+  }
+
+  @Test public void beyondMax29BitValue_smallPrefix() throws IOException {
+    try {
+      hpackWriter.writeInt(0x10000001, 1, 1);
+      fail();
+    } catch (IOException e) {
+      assertEquals("Varint would overflow reader", e.getMessage());
+    }
+    try {
+      newReader(byteStream(0xff, 0xff, 0xff, 0xff, 0x80)).readInt(1, 1);
+      fail();
+    } catch (IOException e) {
+      assertEquals("Varint overflowed", e.getMessage());
+    }
+  }
+
+  @Test public void readerAbortsLongVarintsWithZeros() throws IOException {
+    try {
+      // The reader should fail before getting to the end, because it will overflow as soon as there
+      // is a 1 bit, and the only reason to use this many continuations is to eventually have a 1
+      // bit.
+      newReader(byteStream(0x80, 0x80, 0x80, 0x80, 0x80)).readInt(31, 31);
+      fail();
+    } catch (IOException e) {
+      assertEquals("Varint overflowed", e.getMessage());
+    }
   }
 
   @Test public void prefixMask() throws IOException {
@@ -1062,14 +1108,29 @@ public void dynamicTableIndexedHeader() throws IOException {
   }
 
   @Test
-  public void doNotIndexPseudoHeaders() throws IOException {
+  public void pseudoHeaderIndexing() throws IOException {
+    // :method is not indexed (unless it's GET or POST, which are in the static table)
     hpackWriter.writeHeaders(headerEntries(":method", "PUT"));
     assertBytes(0x02, 3, 'P', 'U', 'T');
     assertEquals(0, hpackWriter.dynamicTableHeaderCount);
 
+    // :path should now be indexed
     hpackWriter.writeHeaders(headerEntries(":path", "/okhttp"));
-    assertBytes(0x04, 7, '/', 'o', 'k', 'h', 't', 't', 'p');
-    assertEquals(0, hpackWriter.dynamicTableHeaderCount);
+    assertBytes(0x44, 7, '/', 'o', 'k', 'h', 't', 't', 'p');
+    assertEquals(1, hpackWriter.dynamicTableHeaderCount);
+    // Second time should be an index
+    hpackWriter.writeHeaders(headerEntries(":path", "/okhttp"));
+    assertBytes(0xbe);
+    assertEquals(1, hpackWriter.dynamicTableHeaderCount);
+
+    // :authority should be indexed
+    hpackWriter.writeHeaders(headerEntries(":authority", "test.com"));
+    assertBytes(0x41, 8, 't', 'e', 's', 't', '.', 'c', 'o', 'm');
+    assertEquals(2, hpackWriter.dynamicTableHeaderCount);
+    // Second time should be an index
+    hpackWriter.writeHeaders(headerEntries(":authority", "test.com"));
+    assertBytes(0xbe);
+    assertEquals(2, hpackWriter.dynamicTableHeaderCount);
   }
 
   @Test
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..87ad61c9f27
--- /dev/null
+++ b/opentelemetry/src/main/java/io/grpc/opentelemetry/GrpcOpenTelemetry.java
@@ -0,0 +1,471 @@
+/*
+ * 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());
+    serverBuilder.addMetricSink(sink);
+  }
+
+  @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..f783b9495dd
--- /dev/null
+++ b/opentelemetry/src/main/java/io/grpc/opentelemetry/OpenTelemetryMetricsModule.java
@@ -0,0 +1,768 @@
+/*
+ * 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.CUSTOM_LABEL_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.Grpc;
+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.internal.StatsTraceContext.ServerCallMethodListener;
+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 boolean customLabelEnabled;
+  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.customLabelEnabled = optionalLabels.contains(CUSTOM_LABEL_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 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(info.getCallOptions());
+      recordFinishedAttempt();
+    }
+
+    void recordFinishedAttempt() {
+      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);
+      }
+      if (module.customLabelEnabled) {
+        builder.put(
+            CUSTOM_LABEL_KEY, info.getCallOptions().getOption(Grpc.CALL_OPTION_CUSTOM_LABEL));
+      }
+      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, attemptsState.otelContext);
+      }
+      if (module.resource.clientTotalSentCompressedMessageSizeCounter() != null) {
+        module.resource.clientTotalSentCompressedMessageSizeCounter()
+            .record(outboundWireSize, attribute, attemptsState.otelContext);
+      }
+      if (module.resource.clientTotalReceivedCompressedMessageSizeCounter() != null) {
+        module.resource.clientTotalReceivedCompressedMessageSizeCounter()
+            .record(inboundWireSize, attribute, attemptsState.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 final Context otelContext;
+    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,
+        CallOptions callOptions,
+        String fullMethodName,
+        List<OpenTelemetryPlugin.ClientCallPlugin> callPlugins, Context otelContext) {
+      this.module = checkNotNull(module, "module");
+      this.target = checkNotNull(target, "target");
+      this.fullMethodName = checkNotNull(fullMethodName, "fullMethodName");
+      this.callPlugins = checkNotNull(callPlugins, "callPlugins");
+      this.otelContext = checkNotNull(otelContext, "otelContext");
+      this.attemptDelayStopwatch = module.stopwatchSupplier.get();
+      this.callStopWatch = module.stopwatchSupplier.get().start();
+
+      AttributesBuilder builder = io.opentelemetry.api.common.Attributes.builder()
+          .put(METHOD_KEY, fullMethodName)
+          .put(TARGET_KEY, target);
+      if (module.customLabelEnabled) {
+        builder.put(
+            CUSTOM_LABEL_KEY, callOptions.getOption(Grpc.CALL_OPTION_CUSTOM_LABEL));
+      }
+      io.opentelemetry.api.common.Attributes attribute = builder.build();
+
+      // Record here in case mewClientStreamTracer() would never be called.
+      if (module.resource.clientAttemptCountCounter() != null) {
+        module.resource.clientAttemptCountCounter().add(1, attribute, otelContext);
+      }
+    }
+
+    @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) {
+        AttributesBuilder builder = io.opentelemetry.api.common.Attributes.builder()
+            .put(METHOD_KEY, fullMethodName)
+            .put(TARGET_KEY, target);
+        if (module.customLabelEnabled) {
+          builder.put(
+              CUSTOM_LABEL_KEY, info.getCallOptions().getOption(Grpc.CALL_OPTION_CUSTOM_LABEL));
+        }
+        io.opentelemetry.api.common.Attributes attribute = builder.build();
+        if (module.resource.clientAttemptCountCounter() != null) {
+          module.resource.clientAttemptCountCounter().add(1, attribute, otelContext);
+        }
+      }
+      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(CallOptions callOptions) {
+      boolean shouldRecordFinishedCall = false;
+      synchronized (lock) {
+        if (--activeStreams == 0) {
+          attemptDelayStopwatch.start();
+          if (callEnded && !finishedCallToBeRecorded) {
+            shouldRecordFinishedCall = true;
+            finishedCallToBeRecorded = true;
+          }
+        }
+      }
+      if (shouldRecordFinishedCall) {
+        recordFinishedCall(callOptions);
+      }
+    }
+
+    void callEnded(Status status, CallOptions callOptions) {
+      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(callOptions);
+      }
+    }
+
+    void recordFinishedCall(CallOptions callOptions) {
+      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
+      AttributesBuilder builder = io.opentelemetry.api.common.Attributes.builder()
+          .put(METHOD_KEY, fullMethodName)
+          .put(TARGET_KEY, target);
+      if (module.customLabelEnabled) {
+        builder.put(CUSTOM_LABEL_KEY, callOptions.getOption(Grpc.CALL_OPTION_CUSTOM_LABEL));
+      }
+      io.opentelemetry.api.common.Attributes baseAttributes = builder.build();
+
+      // 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
+      implements ServerCallMethodListener {
+    @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 Context otelContext = Context.root();
+    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 io.grpc.Context filterContext(io.grpc.Context context) {
+      Baggage baggage = BAGGAGE_KEY.get(context);
+      if (baggage != null) {
+        otelContext = Context.current().with(baggage);
+      } else {
+        otelContext = Context.current();
+      }
+      return context;
+    }
+
+    @Override
+    public void serverCallMethodResolved(MethodDescriptor<?, ?> method) {
+      isGeneratedMethod = method.isSampledToLocalTracing();
+    }
+
+    @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, otelContext);
+      }
+    }
+
+    @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) {
+      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);
+      recordClosedStream(
+          status,
+          elapsedTimeNanos,
+          outboundWireSize,
+          inboundWireSize,
+          isGeneratedMethod);
+    }
+
+    private void recordClosedStream(
+        Status status,
+        long elapsedTimeNanos,
+        long closedOutboundWireSize,
+        long closedInboundWireSize,
+        boolean generatedMethod) {
+      AttributesBuilder builder =
+          io.opentelemetry.api.common.Attributes.builder()
+              .put(METHOD_KEY, recordMethodName(fullMethodName, generatedMethod))
+              .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(closedOutboundWireSize, attributes, otelContext);
+      }
+      if (module.resource.serverTotalReceivedCompressedMessageSizeCounter() != null) {
+        module.resource.serverTotalReceivedCompressedMessageSizeCounter()
+            .record(closedInboundWireSize, 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);
+        }
+      }
+      final CallOptions finalCallOptions = 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, callOptions,
+          recordMethodName(method.getFullMethodName(), method.isSampledToLocalTracing()),
+          callPlugins, Context.current());
+      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, finalCallOptions);
+                  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..c09a1a2beca
--- /dev/null
+++ b/opentelemetry/src/main/java/io/grpc/opentelemetry/internal/OpenTelemetryConstants.java
@@ -0,0 +1,76 @@
+/*
+ * 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> CUSTOM_LABEL_KEY =
+      AttributeKey.stringKey("grpc.client.call.custom");
+
+  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..f0bd6f93098
--- /dev/null
+++ b/opentelemetry/src/test/java/io/grpc/opentelemetry/GrpcOpenTelemetryTest.java
@@ -0,0 +1,173 @@
+/*
+ * 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.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());
+    verify(mockServerBuiler).addMetricSink(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.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..7c9db875196
--- /dev/null
+++ b/opentelemetry/src/test/java/io/grpc/opentelemetry/OpenTelemetryMetricsModuleTest.java
@@ -0,0 +1,2162 @@
+/*
+ * 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.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyDouble;
+import static org.mockito.Mockito.mock;
+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.Grpc;
+import io.grpc.KnownLength;
+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.ServerServiceDefinition;
+import io.grpc.ServerStreamTracer;
+import io.grpc.ServerStreamTracer.ServerCallInfo;
+import io.grpc.ServiceDescriptor;
+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.internal.StatsTraceContext.ServerCallMethodListener;
+import io.grpc.opentelemetry.GrpcOpenTelemetry.TargetFilter;
+import io.grpc.opentelemetry.OpenTelemetryMetricsModule.CallAttemptsTracerFactory;
+import io.grpc.opentelemetry.internal.OpenTelemetryConstants;
+import io.grpc.stub.ClientCalls;
+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.baggage.propagation.W3CBaggagePropagator;
+import io.opentelemetry.api.common.AttributeKey;
+import io.opentelemetry.api.metrics.DoubleHistogram;
+import io.opentelemetry.api.metrics.Meter;
+import io.opentelemetry.context.Context;
+import io.opentelemetry.context.Scope;
+import io.opentelemetry.context.propagation.ContextPropagators;
+import io.opentelemetry.sdk.OpenTelemetrySdk;
+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(NAME_RESOLUTION_DELAYED, 10L);
+  private static final ClientStreamTracer.StreamInfo STREAM_INFO =
+      ClientStreamTracer.StreamInfo.newBuilder().setCallOptions(CALL_OPTIONS).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 GrpcCleanupRule grpcCleanup = new GrpcCleanupRule();
+  @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;
+
+  private Server server;
+  private ManagedChannel channel;
+
+  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);
+
+  }
+
+  @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, CallOptions.DEFAULT.withOption(CUSTOM_OPTION, "customvalue"));
+
+    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, CALL_OPTIONS, method.getFullMethodName(),
+            emptyList(), Context.root());
+    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, CALL_OPTIONS);
+
+    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, CALL_OPTIONS, method.getFullMethodName(),
+             emptyList(), Context.root());
+    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, CALL_OPTIONS);
+
+    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, CALL_OPTIONS,
+            method.getFullMethodName(), emptyList(), Context.root());
+    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, CALL_OPTIONS);
+
+    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, CALL_OPTIONS,
+            method.getFullMethodName(), emptyList(), Context.root());
+
+    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, CALL_OPTIONS);
+
+    // 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, CALL_OPTIONS,
+            method.getFullMethodName(), emptyList(), Context.root());
+
+    // 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, CALL_OPTIONS);
+
+    // 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, CALL_OPTIONS,
+            method.getFullMethodName(), emptyList(), Context.root());
+    fakeClock.forwardTime(3000, MILLISECONDS);
+    Status status = Status.DEADLINE_EXCEEDED.withDescription("5 seconds");
+    callAttemptsTracerFactory.callEnded(status, CALL_OPTIONS);
+
+    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, CALL_OPTIONS, method.getFullMethodName(),
+            emptyList(), Context.root());
+
+    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, CALL_OPTIONS);
+
+    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, CALL_OPTIONS, method.getFullMethodName(),
+            emptyList(), Context.root());
+
+    ClientStreamTracer tracer =
+        callAttemptsTracerFactory.newClientStreamTracer(STREAM_INFO, new Metadata());
+    tracer.streamClosed(Status.OK);
+    callAttemptsTracerFactory.callEnded(Status.OK, CALL_OPTIONS);
+
+    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, CALL_OPTIONS, method.getFullMethodName(),
+            emptyList(), Context.root());
+
+    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, CALL_OPTIONS);
+
+    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, CALL_OPTIONS, method.getFullMethodName(),
+            emptyList(), Context.root());
+
+    ClientStreamTracer tracer =
+        callAttemptsTracerFactory.newClientStreamTracer(STREAM_INFO, new Metadata());
+    tracer.streamClosed(Status.OK);
+    callAttemptsTracerFactory.callEnded(Status.OK, CALL_OPTIONS);
+
+    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 customLabel_present() {
+    Map<String, Boolean> enabledMetrics = ImmutableMap.of(
+        CLIENT_CALL_HEDGES, true,
+        CLIENT_CALL_RETRIES, true,
+        CLIENT_CALL_RETRY_DELAY, true,
+        CLIENT_CALL_TRANSPARENT_RETRIES, true
+    );
+    String target = "target:///";
+    String customValue = "some-random-value";
+    CallOptions callOptions =
+        STREAM_INFO.getCallOptions().withOption(Grpc.CALL_OPTION_CUSTOM_LABEL, customValue);
+    OpenTelemetryMetricsResource resource = GrpcOpenTelemetry.createMetricInstruments(testMeter,
+        enabledMetrics, disableDefaultMetrics);
+    String customLabel = "grpc.client.call.custom";
+    OpenTelemetryMetricsModule module = new OpenTelemetryMetricsModule(
+        fakeClock.getStopwatchSupplier(), resource, Arrays.asList(customLabel),
+        emptyList());
+    OpenTelemetryMetricsModule.CallAttemptsTracerFactory callAttemptsTracerFactory =
+        new CallAttemptsTracerFactory(
+            module, target, callOptions, method.getFullMethodName(), emptyList(), Context.root());
+
+    ClientStreamTracer.StreamInfo streamInfo =
+        STREAM_INFO.toBuilder().setCallOptions(callOptions).build();
+    ClientStreamTracer tracer =
+        callAttemptsTracerFactory.newClientStreamTracer(streamInfo, new Metadata());
+    tracer.streamClosed(Status.UNAVAILABLE);
+
+    tracer = callAttemptsTracerFactory.newClientStreamTracer(streamInfo, new Metadata());
+    tracer.streamClosed(Status.UNAVAILABLE);
+
+    tracer = callAttemptsTracerFactory.newClientStreamTracer(
+        streamInfo.toBuilder().setIsTransparentRetry(true).build(), new Metadata());
+    tracer.streamClosed(Status.UNAVAILABLE);
+
+    tracer = callAttemptsTracerFactory.newClientStreamTracer(
+        streamInfo.toBuilder().setIsHedging(true).build(), new Metadata());
+    tracer.streamClosed(Status.OK);
+    callAttemptsTracerFactory.callEnded(Status.OK, callOptions);
+
+    AttributeKey<String> attributeKey = AttributeKey.stringKey(customLabel);
+
+    assertThat(sortByName(openTelemetryTesting.getMetrics()))
+        .satisfiesExactly(
+            metric -> assertThat(metric)
+                .hasName(CLIENT_ATTEMPT_DURATION_INSTRUMENT_NAME)
+                .hasHistogramSatisfying(
+                    histogram -> histogram.hasPointsSatisfying(
+                        point -> point.hasAttribute(attributeKey, customValue),
+                        point -> point.hasAttribute(attributeKey, customValue))),
+            metric -> assertThat(metric)
+                .hasName(CLIENT_ATTEMPT_RECV_TOTAL_COMPRESSED_MESSAGE_SIZE)
+                .hasHistogramSatisfying(
+                    histogram -> histogram.hasPointsSatisfying(
+                        point -> point.hasAttribute(attributeKey, customValue),
+                        point -> point.hasAttribute(attributeKey, customValue))),
+            metric -> assertThat(metric)
+                .hasName(CLIENT_ATTEMPT_SENT_TOTAL_COMPRESSED_MESSAGE_SIZE)
+                .hasHistogramSatisfying(
+                    histogram -> histogram.hasPointsSatisfying(
+                        point -> point.hasAttribute(attributeKey, customValue),
+                        point -> point.hasAttribute(attributeKey, customValue))),
+            metric -> assertThat(metric)
+                .hasName(CLIENT_ATTEMPT_COUNT_INSTRUMENT_NAME)
+                .hasLongSumSatisfying(
+                    longSum -> longSum.hasPointsSatisfying(
+                        point -> point.hasAttribute(attributeKey, customValue))),
+            metric -> assertThat(metric)
+                .hasName(CLIENT_CALL_DURATION)
+                .hasHistogramSatisfying(
+                    histogram -> histogram.hasPointsSatisfying(
+                        point -> point.hasAttribute(attributeKey, customValue))),
+            metric -> assertThat(metric)
+                .hasName(CLIENT_CALL_HEDGES)
+                .hasHistogramSatisfying(
+                    histogram -> histogram.hasPointsSatisfying(
+                        point -> point.hasAttribute(attributeKey, customValue))),
+            metric -> assertThat(metric)
+                .hasName(CLIENT_CALL_RETRIES)
+                .hasHistogramSatisfying(
+                    histogram -> histogram.hasPointsSatisfying(
+                        point -> point.hasAttribute(attributeKey, customValue))),
+            metric -> assertThat(metric)
+                .hasName(CLIENT_CALL_RETRY_DELAY)
+                .hasHistogramSatisfying(
+                    histogram -> histogram.hasPointsSatisfying(
+                        point -> point.hasAttribute(attributeKey, customValue))),
+            metric -> assertThat(metric)
+                .hasName(CLIENT_CALL_TRANSPARENT_RETRIES)
+                .hasHistogramSatisfying(
+                    histogram -> histogram.hasPointsSatisfying(
+                        point -> point.hasAttribute(attributeKey, customValue))));
+  }
+
+  @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 serverMetrics_methodResolvedBeforeStreamClosed_generatedMethodRecordsName() {
+    OpenTelemetryMetricsResource resource = GrpcOpenTelemetry.createMetricInstruments(testMeter,
+        enabledMetricsMap, disableDefaultMetrics);
+    OpenTelemetryMetricsModule module = newOpenTelemetryMetricsModule(resource);
+    ServerStreamTracer.Factory tracerFactory = module.getServerTracerFactory();
+    ServerStreamTracer tracer =
+        tracerFactory.newServerStreamTracer(method.getFullMethodName(), new Metadata());
+
+    ((ServerCallMethodListener) tracer).serverCallMethodResolved(method);
+    fakeClock.forwardTime(10, 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())
+        .anySatisfy(
+            metric ->
+                assertThat(metric)
+                    .hasName(SERVER_CALL_DURATION)
+                    .hasUnit("s")
+                    .hasHistogramSatisfying(
+                        histogram ->
+                            histogram.hasPointsSatisfying(
+                                point ->
+                                    point
+                                        .hasCount(1)
+                                        .hasSum(0.01)
+                                        .hasAttributes(serverAttributes))));
+  }
+
+  @Test
+  public void serverMetrics_methodResolvedBeforeStreamClosed_nonGeneratedMethodRecordsOther() {
+    MethodDescriptor<String, String> nonGeneratedMethod =
+        method.toBuilder().setSampledToLocalTracing(false).build();
+    OpenTelemetryMetricsResource resource = GrpcOpenTelemetry.createMetricInstruments(testMeter,
+        enabledMetricsMap, disableDefaultMetrics);
+    OpenTelemetryMetricsModule module = newOpenTelemetryMetricsModule(resource);
+    ServerStreamTracer.Factory tracerFactory = module.getServerTracerFactory();
+    ServerStreamTracer tracer =
+        tracerFactory.newServerStreamTracer(nonGeneratedMethod.getFullMethodName(), new Metadata());
+
+    ((ServerCallMethodListener) tracer).serverCallMethodResolved(nonGeneratedMethod);
+    fakeClock.forwardTime(10, MILLISECONDS);
+    tracer.streamClosed(Status.CANCELLED);
+
+    io.opentelemetry.api.common.Attributes serverAttributes =
+        io.opentelemetry.api.common.Attributes.of(
+            METHOD_KEY, "other",
+            STATUS_KEY, Code.CANCELLED.toString());
+
+    assertThat(openTelemetryTesting.getMetrics())
+        .anySatisfy(
+            metric ->
+                assertThat(metric)
+                    .hasName(SERVER_CALL_DURATION)
+                    .hasUnit("s")
+                    .hasHistogramSatisfying(
+                        histogram ->
+                            histogram.hasPointsSatisfying(
+                                point ->
+                                    point
+                                        .hasCount(1)
+                                        .hasSum(0.01)
+                                        .hasAttributes(serverAttributes))));
+  }
+
+  @Test
+  public void serverMetrics_serverCallStarted_nonGeneratedMethodRecordsOther() {
+    MethodDescriptor<String, String> nonGeneratedMethod =
+        method.toBuilder().setSampledToLocalTracing(false).build();
+    OpenTelemetryMetricsResource resource = GrpcOpenTelemetry.createMetricInstruments(testMeter,
+        enabledMetricsMap, disableDefaultMetrics);
+    OpenTelemetryMetricsModule module = newOpenTelemetryMetricsModule(resource);
+    ServerStreamTracer.Factory tracerFactory = module.getServerTracerFactory();
+    ServerStreamTracer tracer =
+        tracerFactory.newServerStreamTracer(nonGeneratedMethod.getFullMethodName(), new Metadata());
+    tracer.serverCallStarted(
+        new CallInfo<>(nonGeneratedMethod, Attributes.EMPTY, null));
+
+    io.opentelemetry.api.common.Attributes startedAttributes =
+        io.opentelemetry.api.common.Attributes.of(METHOD_KEY, "other");
+
+    assertThat(openTelemetryTesting.getMetrics())
+        .anySatisfy(
+            metric ->
+                assertThat(metric)
+                    .hasName(SERVER_CALL_COUNT)
+                    .hasUnit("{call}")
+                    .hasLongSumSatisfying(
+                        longSum ->
+                            longSum.hasPointsSatisfying(
+                                point ->
+                                    point
+                                        .hasAttributes(startedAttributes)
+                                        .hasValue(1))));
+
+    fakeClock.forwardTime(10, MILLISECONDS);
+    tracer.streamClosed(Status.CANCELLED);
+
+    io.opentelemetry.api.common.Attributes closedAttributes =
+        io.opentelemetry.api.common.Attributes.of(
+            METHOD_KEY, "other",
+            STATUS_KEY, Code.CANCELLED.toString());
+
+    assertThat(openTelemetryTesting.getMetrics())
+        .anySatisfy(
+            metric ->
+                assertThat(metric)
+                    .hasName(SERVER_CALL_DURATION)
+                    .hasUnit("s")
+                    .hasHistogramSatisfying(
+                        histogram ->
+                            histogram.hasPointsSatisfying(
+                                point ->
+                                    point
+                                        .hasCount(1)
+                                        .hasSum(0.01)
+                                        .hasAttributes(closedAttributes))));
+  }
+
+  @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 serverMetrics_recordsBaggage() {
+    DoubleHistogram mockDurationHistogram = mock(DoubleHistogram.class);
+    OpenTelemetryMetricsResource mockResource = OpenTelemetryMetricsResource.builder()
+        .serverCallDurationCounter(mockDurationHistogram)
+        .build();
+
+    OpenTelemetryMetricsModule module = newOpenTelemetryMetricsModule(mockResource);
+    ServerStreamTracer.Factory tracerFactory = module.getServerTracerFactory();
+
+    Baggage baggage = Baggage.builder()
+        .put("baggage-key-1", "baggage-val-1")
+        .build();
+
+    io.grpc.Context grpcContext = io.grpc.Context.ROOT
+        .withValue(OpenTelemetryConstants.BAGGAGE_KEY, baggage);
+    io.grpc.Context previous = grpcContext.attach();
+
+    ServerStreamTracer tracer;
+    try {
+      tracer = tracerFactory.newServerStreamTracer(
+          method.getFullMethodName(), new Metadata());
+      tracer.filterContext(grpcContext);
+      tracer.serverCallStarted(
+          new CallInfo<>(method, Attributes.EMPTY, null));
+    } finally {
+      grpcContext.detach(previous);
+    }
+
+    try (io.opentelemetry.context.Scope scope = Context.root().makeCurrent()) {
+      tracer.streamClosed(Status.CANCELLED);
+    }
+
+    ArgumentCaptor<Context> contextCaptor = ArgumentCaptor.forClass(Context.class);
+    verify(mockDurationHistogram).record(
+        anyDouble(),
+        any(),
+        contextCaptor.capture());
+
+    Baggage capturedBaggage = Baggage.fromContext(contextCaptor.getValue());
+    assertNotNull("Captured context should have baggage", capturedBaggage);
+    assertEquals(
+        "baggage-val-1", capturedBaggage.getEntryValue("baggage-key-1"));
+  }
+
+  @Test
+  public void serverMetrics_recordsBaggage_endToEnd() throws Exception {
+    DoubleHistogram mockDurationHistogram = mock(DoubleHistogram.class);
+    OpenTelemetryMetricsResource mockResource = OpenTelemetryMetricsResource.builder()
+        .serverCallDurationCounter(mockDurationHistogram)
+        .build();
+
+    OpenTelemetry openTelemetry = OpenTelemetrySdk
+        .builder()
+        .setPropagators(ContextPropagators.create(
+            W3CBaggagePropagator.getInstance()))
+        .build();
+
+    OpenTelemetryMetricsModule module = newOpenTelemetryMetricsModule(mockResource);
+    OpenTelemetryTracingModule tracingModule = new OpenTelemetryTracingModule(openTelemetry);
+
+    String serverName = InProcessServerBuilder.generateName();
+    InProcessServerBuilder serverBuilder = InProcessServerBuilder
+        .forName(serverName).directExecutor();
+
+    serverBuilder.addStreamTracerFactory(tracingModule.getServerTracerFactory());
+    serverBuilder.intercept(tracingModule.getServerSpanPropagationInterceptor());
+    serverBuilder.addStreamTracerFactory(module.getServerTracerFactory());
+
+    serverBuilder.addService(ServerServiceDefinition.builder(
+            ServiceDescriptor.newBuilder("package1.service2")
+                .addMethod(method)
+                .build())
+        .addMethod(method, new ServerCallHandler<String, String>() {
+          @Override
+          public ServerCall.Listener<String> startCall(
+              ServerCall<String, String> call, Metadata headers) {
+            call.sendHeaders(new Metadata());
+            call.sendMessage("response");
+            call.close(Status.OK, new Metadata());
+            return new ServerCall.Listener<String>() {
+            };
+          }
+        }).build());
+    grpcCleanup.register(serverBuilder.build().start());
+
+    InProcessChannelBuilder channelBuilder = InProcessChannelBuilder
+        .forName(serverName).directExecutor();
+    channelBuilder.intercept(tracingModule.getClientInterceptor());
+    channelBuilder.intercept(module.getClientInterceptor(serverName));
+    Channel channel = grpcCleanup.register(channelBuilder.intercept(new ClientInterceptor() {
+      @Override
+      public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
+          MethodDescriptor<ReqT, RespT> method, CallOptions callOptions, Channel next) {
+        return next.newCall(method, callOptions);
+      }
+    }).build());
+
+    Baggage baggage = Baggage.builder()
+        .put("baggage-key-1", "baggage-val-1")
+        .build();
+
+    Context otelContext = Context.root().with(baggage);
+
+    try (Scope scope = otelContext.makeCurrent()) {
+      ClientCalls.blockingUnaryCall(channel,
+          method, CallOptions.DEFAULT, "request");
+    }
+
+    ArgumentCaptor<Context> contextCaptor = ArgumentCaptor.forClass(Context.class);
+    verify(mockDurationHistogram).record(
+        anyDouble(),
+        any(),
+        contextCaptor.capture());
+
+    Baggage capturedBaggage = Baggage.fromContext(contextCaptor.getValue());
+    assertNotNull("Captured context should have baggage", capturedBaggage);
+    assertEquals(
+        "baggage-val-1", capturedBaggage.getEntryValue("baggage-key-1"));
+  }
+    
+  private static List<MetricData> sortByName(List<MetricData> metrics) {
+    metrics.sort((m1, m2) -> m1.getName().compareTo(m2.getName()));
+    return metrics;
+  }
+}
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
index 85cd9669e1f..97a5e492d80 100644
--- a/protobuf-lite/BUILD.bazel
+++ b/protobuf-lite/BUILD.bazel
@@ -1,3 +1,6 @@
+load("@rules_java//java:defs.bzl", "java_library")
+load("@rules_jvm_external//:defs.bzl", "artifact")
+
 java_library(
     name = "protobuf-lite",
     srcs = glob([
@@ -6,11 +9,10 @@ java_library(
     visibility = ["//visibility:public"],
     deps = [
         "//api",
-        "@com_google_code_findbugs_jsr305//jar",
-        "@com_google_guava_guava//jar",
-        "@com_google_j2objc_j2objc_annotations//jar",
+        artifact("com.google.code.findbugs:jsr305"),
+        artifact("com.google.guava:guava"),
     ] + select({
-        ":android": ["@com_google_protobuf_javalite//:protobuf_javalite"],
+        ":android": ["@com_google_protobuf//:protobuf_javalite"],
         "//conditions:default": ["@com_google_protobuf//:protobuf_java"],
     }),
 )
diff --git a/protobuf-lite/build.gradle b/protobuf-lite/build.gradle
index 000d8c721e0..c1e5b51ae35 100644
--- a/protobuf-lite/build.gradle
+++ b/protobuf-lite/build.gradle
@@ -11,21 +11,35 @@ description = 'gRPC: Protobuf Lite'
 
 dependencies {
     api project(':grpc-api'),
-            libraries.protobuf_lite
-    implementation libraries.jsr305
-    guavaDependency 'implementation'
+            libraries.protobuf.javalite
+    implementation libraries.jsr305,
+            libraries.guava
 
     testImplementation project(':grpc-core')
 
-    signature "org.codehaus.mojo.signature:java17:1.0@signature"
-    signature "net.sf.androidscents.signature:android-api-level-14:4.0_r4@signature"
+    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.protobuf.lite')
+    }
 }
 
-compileTestJava {
+tasks.named("compileTestJava").configure {
     options.compilerArgs += [
         "-Xlint:-cast"
     ]
-    options.errorprone.excludedPaths = ".*/build/generated/source/proto/.*"
+    options.errorprone.excludedPaths = ".*/build/generated/sources/proto/.*"
 }
 
 protobuf {
@@ -33,7 +47,7 @@ protobuf {
         if (project.hasProperty('protoc')) {
             path = project.protoc
         } else {
-            artifact = "com.google.protobuf:protoc:${protocVersion}"
+            artifact = libs.protobuf.protoc.get()
         }
     }
     generateProtoTasks {
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 ddba5b8d5b1..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
@@ -38,8 +38,12 @@
 
 /**
  * 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")
+@ExperimentalApi("Will remain experimental as protobuf lite API is not stable")
 public final class ProtoLiteUtils {
 
   // default visibility to avoid synthetic accessors
@@ -69,7 +73,6 @@ public final class ProtoLiteUtils {
    *
    * @since 1.0.0
    */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1787")
   public static void setExtensionRegistry(ExtensionRegistryLite newRegistry) {
     globalRegistry = checkNotNull(newRegistry, "newRegistry");
   }
@@ -81,7 +84,19 @@ public static void setExtensionRegistry(ExtensionRegistryLite newRegistry) {
    */
   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);
+    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);
   }
 
   /**
@@ -117,18 +132,20 @@ 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;
 
     @SuppressWarnings("unchecked")
-    MessageMarshaller(T defaultInstance) {
-      this.defaultInstance = defaultInstance;
-      parser = (Parser<T>) defaultInstance.getParserForType();
+    MessageMarshaller(T defaultInstance, int recursionLimit) {
+      this.defaultInstance = checkNotNull(defaultInstance, "defaultInstance cannot be null");
+      this.parser = (Parser<T>) defaultInstance.getParserForType();
+      this.recursionLimit = recursionLimit;
     }
 
-
     @SuppressWarnings("unchecked")
     @Override
     public Class<T> getMessageClass() {
@@ -211,6 +228,10 @@ public T parse(InputStream stream) {
       // when parsing.
       cis.setSizeLimit(Integer.MAX_VALUE);
 
+      if (recursionLimit >= 0) {
+        cis.setRecursionLimit(recursionLimit);
+      }
+
       try {
         return parseFrom(cis);
       } catch (InvalidProtocolBufferException ipbe) {
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 6ea836f96a7..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
@@ -16,10 +16,12 @@
 
 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;
@@ -36,14 +38,13 @@
 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;
 
@@ -51,10 +52,7 @@
 @RunWith(JUnit4.class)
 public class ProtoLiteUtilsTest {
 
-  @SuppressWarnings("deprecation") // https://github.com/grpc/grpc-java/issues/7467
-  @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
@@ -85,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);
@@ -97,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();
@@ -105,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());
@@ -212,14 +210,13 @@ public void metadataMarshaller_invalid() {
 
   @Test
   public void extensionRegistry_notNull() {
-    thrown.expect(NullPointerException.class);
-    thrown.expectMessage("newRegistry");
-
-    ProtoLiteUtils.setExtensionRegistry(null);
+    NullPointerException e = assertThrows(NullPointerException.class,
+        () -> ProtoLiteUtils.setExtensionRegistry(null));
+    assertThat(e).hasMessageThat().isEqualTo("newRegistry");
   }
 
   @Test
-  public void parseFromKnowLengthInputStream() throws Exception {
+  public void parseFromKnowLengthInputStream() {
     Marshaller<Type> marshaller = ProtoLiteUtils.marshaller(Type.getDefaultInstance());
     Type expect = Type.newBuilder().setName("expected name").build();
 
@@ -232,21 +229,106 @@ 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);
+  }
+
+  @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 byte[] source;
+    private final byte[] source;
 
     private CustomKnownLengthInputStream(byte[] source) {
       this.source = source;
     }
 
     @Override
-    public int available() throws IOException {
+    public int available() {
       return source.length - position;
     }
 
     @Override
-    public int read() throws IOException {
+    public int read() {
       if (position == source.length) {
         return -1;
       }
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/BUILD.bazel b/protobuf/BUILD.bazel
index 42085eea583..a31f8b6f6f5 100644
--- a/protobuf/BUILD.bazel
+++ b/protobuf/BUILD.bazel
@@ -1,3 +1,6 @@
+load("@rules_java//java:defs.bzl", "java_library")
+load("@rules_jvm_external//:defs.bzl", "artifact")
+
 java_library(
     name = "protobuf",
     srcs = glob([
@@ -7,10 +10,10 @@ java_library(
     deps = [
         "//api",
         "//protobuf-lite",
-        "@com_google_api_grpc_proto_google_common_protos//jar",
-        "@com_google_code_findbugs_jsr305//jar",
-        "@com_google_guava_guava//jar",
-        "@com_google_j2objc_j2objc_annotations//jar",
         "@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 af7f51c836e..c477e41dceb 100644
--- a/protobuf/build.gradle
+++ b/protobuf/build.gradle
@@ -9,25 +9,41 @@ plugins {
 
 description = 'gRPC: Protobuf'
 
+tasks.named("jar").configure {
+    manifest {
+        attributes('Automatic-Module-Name': 'io.grpc.protobuf')
+    }
+}
+
 dependencies {
     api project(':grpc-api'),
             libraries.jsr305,
-            libraries.protobuf
-    guavaDependency 'implementation'
+            libraries.protobuf.java
+    implementation libraries.guava
 
-    api (libraries.google_api_protos) {
+    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'
-        // Prefer our more up-to-date protobuf over 3.2.0
-        exclude group: 'com.google.protobuf', module: 'protobuf-java'
     }
 
-    api (project(':grpc-protobuf-lite')) {
+    implementation (project(':grpc-protobuf-lite')) {
         exclude group: 'com.google.protobuf', module: 'protobuf-javalite'
     }
 
-    signature "org.codehaus.mojo.signature:java17:1.0@signature"
+    signature (libraries.signature.java) {
+        artifact {
+            extension = "signature"
+        }
+    }
+    signature (libraries.signature.android) {
+        artifact {
+            extension = "signature"
+        }
+    }
 }
 
-javadoc.options.links 'https://developers.google.com/protocol-buffers/docs/reference/java/'
+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/ProtoMethodDescriptorSupplier.java b/protobuf/src/main/java/io/grpc/protobuf/ProtoMethodDescriptorSupplier.java
index e5b2f38e3c0..e7cd3ed336f 100644
--- a/protobuf/src/main/java/io/grpc/protobuf/ProtoMethodDescriptorSupplier.java
+++ b/protobuf/src/main/java/io/grpc/protobuf/ProtoMethodDescriptorSupplier.java
@@ -16,8 +16,8 @@
 
 package io.grpc.protobuf;
 
+import com.google.errorprone.annotations.CheckReturnValue;
 import com.google.protobuf.Descriptors.MethodDescriptor;
-import javax.annotation.CheckReturnValue;
 
 /**
  * Provides access to the underlying proto service method descriptor.
diff --git a/protobuf/src/main/java/io/grpc/protobuf/ProtoUtils.java b/protobuf/src/main/java/io/grpc/protobuf/ProtoUtils.java
index c936b3c1b48..d403789eb5f 100644
--- a/protobuf/src/main/java/io/grpc/protobuf/ProtoUtils.java
+++ b/protobuf/src/main/java/io/grpc/protobuf/ProtoUtils.java
@@ -18,7 +18,6 @@
 
 import com.google.protobuf.ExtensionRegistry;
 import com.google.protobuf.Message;
-import io.grpc.ExperimentalApi;
 import io.grpc.Metadata;
 import io.grpc.MethodDescriptor.Marshaller;
 import io.grpc.protobuf.lite.ProtoLiteUtils;
@@ -43,7 +42,6 @@ public final class ProtoUtils {
    *
    * @since 1.16.0
    */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1787")
   public static void setExtensionRegistry(ExtensionRegistry registry) {
     ProtoLiteUtils.setExtensionRegistry(registry);
   }
@@ -57,6 +55,18 @@ public static <T extends Message> Marshaller<T> marshaller(final T defaultInstan
     return ProtoLiteUtils.marshaller(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.
+   *
+   * @since 1.56.0
+   */
+  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.
    *
@@ -70,10 +80,9 @@ public static <T extends Message> Metadata.Key<T> keyForProto(T instance) {
 
   /**
    * Produce a metadata marshaller for a protobuf type.
-   * 
+   *
    * @since 1.13.0
    */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/4477")
   public static <T extends Message> Metadata.BinaryMarshaller<T> metadataMarshaller(T instance) {
     return ProtoLiteUtils.metadataMarshaller(instance);
   }
diff --git a/protobuf/src/main/java/io/grpc/protobuf/StatusProto.java b/protobuf/src/main/java/io/grpc/protobuf/StatusProto.java
index 988e1938af0..0ebc1e714f6 100644
--- a/protobuf/src/main/java/io/grpc/protobuf/StatusProto.java
+++ b/protobuf/src/main/java/io/grpc/protobuf/StatusProto.java
@@ -103,6 +103,25 @@ public static StatusException toStatusException(
     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");
diff --git a/protobuf/src/test/java/io/grpc/protobuf/StatusProtoTest.java b/protobuf/src/test/java/io/grpc/protobuf/StatusProtoTest.java
index cf9c2c564ab..47c045bf952 100644
--- a/protobuf/src/test/java/io/grpc/protobuf/StatusProtoTest.java
+++ b/protobuf/src/test/java/io/grpc/protobuf/StatusProtoTest.java
@@ -176,6 +176,14 @@ public void fromThrowable_shouldReturnNullIfNoEmbeddedStatus() {
     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";
diff --git a/repositories.bzl b/repositories.bzl
index 3ed5291a88b..889d15f71e2 100644
--- a/repositories.bzl
+++ b/repositories.bzl
@@ -9,39 +9,47 @@ load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
 #         # 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.0.1",
-    "com.google.auth:google-auth-library-credentials:0.22.0",
-    "com.google.auth:google-auth-library-oauth2-http:0.22.0",
+    "com.google.api.grpc:proto-google-common-protos:2.64.1",
+    "com.google.auth:google-auth-library-credentials:1.42.1",
+    "com.google.auth:google-auth-library-oauth2-http:1.42.1",
+    "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:jar:2.8.6",
-    "com.google.errorprone:error_prone_annotations:2.4.0",
+    "com.google.code.gson:gson:2.13.2",
+    "com.google.errorprone:error_prone_annotations:2.48.0",
     "com.google.guava:failureaccess:1.0.1",
-    "com.google.guava:guava:29.0-android",
-    "com.google.j2objc:j2objc-annotations:1.3",
-    "com.google.truth:truth:1.0.1",
-    "com.squareup.okhttp:okhttp:2.7.4",
-    "com.squareup.okio:okio:1.17.5",
-    "io.netty:netty-buffer:4.1.52.Final",
-    "io.netty:netty-codec-http2:4.1.52.Final",
-    "io.netty:netty-codec-http:4.1.52.Final",
-    "io.netty:netty-codec-socks:4.1.52.Final",
-    "io.netty:netty-codec:4.1.52.Final",
-    "io.netty:netty-common:4.1.52.Final",
-    "io.netty:netty-handler-proxy:4.1.52.Final",
-    "io.netty:netty-handler:4.1.52.Final",
-    "io.netty:netty-resolver:4.1.52.Final",
-    "io.netty:netty-tcnative-boringssl-static:2.0.34.Final",
-    "io.netty:netty-transport-native-epoll:jar:linux-x86_64:4.1.52.Final",
-    "io.netty:netty-transport:4.1.52.Final",
-    "io.opencensus:opencensus-api:0.24.0",
-    "io.opencensus:opencensus-contrib-grpc-metrics:0.24.0",
-    "io.perfmark:perfmark-api:0.23.0",
-    "junit:junit:4.12",
-    "org.apache.tomcat:annotations-api:6.0.53",
-    "org.codehaus.mojo:animal-sniffer-annotations:1.19",
+    "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.133.Final",
+    "io.netty:netty-codec-http2:4.1.133.Final",
+    "io.netty:netty-codec-http:4.1.133.Final",
+    "io.netty:netty-codec-socks:4.1.133.Final",
+    "io.netty:netty-codec:4.1.133.Final",
+    "io.netty:netty-common:4.1.133.Final",
+    "io.netty:netty-handler-proxy:4.1.133.Final",
+    "io.netty:netty-handler:4.1.133.Final",
+    "io.netty:netty-resolver:4.1.133.Final",
+    "io.netty:netty-tcnative-boringssl-static:2.0.75.Final",
+    "io.netty:netty-tcnative-classes:2.0.75.Final",
+    "io.netty:netty-transport-native-epoll:jar:linux-x86_64:4.1.133.Final",
+    "io.netty:netty-transport-native-unix-common:4.1.133.Final",
+    "io.netty:netty-transport:4.1.133.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.mockito:mockito-core:4.4.0",
+    "org.checkerframework:checker-qual:3.49.5",
+    "org.codehaus.mojo:animal-sniffer-annotations:1.27",
 ]
+# GRPC_DEPS_END
 
 # For use with maven_install's override_targets.
 # maven_install(
@@ -50,58 +58,58 @@ IO_GRPC_GRPC_JAVA_ARTIFACTS = [
 # )
 #
 # If you have your own overrides as well, you can use:
-#     override_targets = dict(
-#         IO_GRPC_GRPC_JAVA_OVERRIDE_TARGETS,
+#     override_targets = {
 #         "your.target:artifact": "@//third_party/artifact",
-#     )
-#
-# To combine OVERRIDE_TARGETS from multiple libraries:
-#     override_targets = dict(
-#         IO_GRPC_GRPC_JAVA_OVERRIDE_TARGETS.items() +
-#         OTHER_OVERRIDE_TARGETS.items(),
-#         "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_javalite//:protobuf_java_lite",
+    "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_protobuf_javalite"):
-        com_google_protobuf_javalite()
+    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()
-
-    native.bind(
-        name = "guava",
-        actual = "@com_google_guava_guava//jar",
-    )
-    native.bind(
-        name = "gson",
-        actual = "@com_google_code_gson_gson//jar",
-    )
-    native.bind(
-        name = "error_prone_annotations",
-        actual = "@com_google_errorprone_error_prone_annotations//jar",
-    )
+    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,
@@ -109,24 +117,15 @@ def com_google_protobuf():
     # This statement defines the @com_google_protobuf repo.
     http_archive(
         name = "com_google_protobuf",
-        sha256 = "b37e96e81842af659605908a421960a5dc809acbc888f6b947bc320f8628e5b1",
-        strip_prefix = "protobuf-3.12.0",
-        urls = ["https://github.com/protocolbuffers/protobuf/archive/v3.12.0.zip"],
-    )
-
-def com_google_protobuf_javalite():
-    # java_lite_proto_library rules implicitly depend on @com_google_protobuf_javalite
-    http_archive(
-        name = "com_google_protobuf_javalite",
-        sha256 = "b37e96e81842af659605908a421960a5dc809acbc888f6b947bc320f8628e5b1",
-        strip_prefix = "protobuf-3.12.0",
-        urls = ["https://github.com/protocolbuffers/protobuf/archive/v3.12.0.zip"],
+        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 = "5848a4e034126bece0c37c16554fb80625615aedf1acad4e2a3cdbaaa76944eb",
-        strip_prefix = "grpc-proto-cf828d0e1155e5ea58b46d7184ee5596e03ddcb8",
-        urls = ["https://github.com/grpc/grpc-proto/archive/cf828d0e1155e5ea58b46d7184ee5596e03ddcb8.zip"],
+        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
index 0da03fc924b..70c17a9c8b6 100644
--- a/rls/BUILD.bazel
+++ b/rls/BUILD.bazel
@@ -1,3 +1,5 @@
+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(
@@ -8,15 +10,18 @@ java_library(
     visibility = ["//visibility:public"],
     deps = [
         ":rls_java_grpc",
+        "//:auto_value_annotations",
         "//api",
         "//core",
         "//core:internal",
-        "//core:util",
         "//stub",
-        "@com_google_code_findbugs_jsr305//jar",
-        "@com_google_guava_guava//jar",
-        "@io_grpc_grpc_proto//:rls_java_proto",
+        "//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"),
     ],
 )
 
diff --git a/rls/build.gradle b/rls/build.gradle
index 32004a7d43a..10b1d5fc371 100644
--- a/rls/build.gradle
+++ b/rls/build.gradle
@@ -1,5 +1,5 @@
 plugins {
-    id "java"
+    id "java-library"
     id "maven-publish"
     id "com.google.protobuf"
     id "jacoco"
@@ -8,31 +8,55 @@ plugins {
 
 description = "gRPC: RouteLookupService Loadbalancing plugin"
 
-evaluationDependsOn(project(':grpc-core').path)
+tasks.named("jar").configure {
+    manifest {
+        attributes('Automatic-Module-Name': 'io.grpc.rls')
+    }
+}
 
 dependencies {
-    implementation project(':grpc-core'),
+    implementation project(':grpc-util'),
+            project(':grpc-core'),
             project(':grpc-protobuf'),
-            project(':grpc-stub')
-    guavaDependency 'implementation'
-    compileOnly libraries.javax_annotation
+            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'),
-            project(':grpc-core').sourceSets.test.output  // for FakeClock
-    signature "org.codehaus.mojo.signature:java17:1.0@signature"
+            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/.*",
+            "|")
 }
 
-javadoc {
+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
+    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*'
 }
 
-jacocoTestReport {
+tasks.named("jacocoTestReport").configure {
     classDirectories.from = sourceSets.main.output.collect {
         fileTree(dir: it, exclude: ['**/io/grpc/lookup/**'])
     }
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
index 4f1f8b6cd44..be060e576a4 100644
--- a/rls/src/generated/main/grpc/io/grpc/lookup/v1/RouteLookupServiceGrpc.java
+++ b/rls/src/generated/main/grpc/io/grpc/lookup/v1/RouteLookupServiceGrpc.java
@@ -4,14 +4,12 @@
 
 /**
  */
-@javax.annotation.Generated(
-    value = "by gRPC proto compiler",
-    comments = "Source: grpc/lookup/v1/rls.proto")
+@io.grpc.stub.annotations.GrpcGenerated
 public final class RouteLookupServiceGrpc {
 
   private RouteLookupServiceGrpc() {}
 
-  public static final String SERVICE_NAME = "grpc.lookup.v1.RouteLookupService";
+  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,
@@ -59,6 +57,21 @@ public RouteLookupServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptio
     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
    */
@@ -91,34 +104,35 @@ public RouteLookupServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.Cal
 
   /**
    */
-  public static abstract class RouteLookupServiceImplBase implements io.grpc.BindableService {
+  public interface AsyncService {
 
     /**
      * <pre>
      * Lookup returns a target for a single key.
      * </pre>
      */
-    public void routeLookup(io.grpc.lookup.v1.RouteLookupRequest request,
+    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 io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
-          .addMethod(
-            getRouteLookupMethod(),
-            io.grpc.stub.ServerCalls.asyncUnaryCall(
-              new MethodHandlers<
-                io.grpc.lookup.v1.RouteLookupRequest,
-                io.grpc.lookup.v1.RouteLookupResponse>(
-                  this, METHODID_ROUTE_LOOKUP)))
-          .build();
+      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> {
+  public static final class RouteLookupServiceStub
+      extends io.grpc.stub.AbstractAsyncStub<RouteLookupServiceStub> {
     private RouteLookupServiceStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -143,8 +157,37 @@ public void routeLookup(io.grpc.lookup.v1.RouteLookupRequest request,
   }
 
   /**
+   * 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> {
+  public static final class RouteLookupServiceBlockingStub
+      extends io.grpc.stub.AbstractBlockingStub<RouteLookupServiceBlockingStub> {
     private RouteLookupServiceBlockingStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -168,8 +211,10 @@ public io.grpc.lookup.v1.RouteLookupResponse routeLookup(io.grpc.lookup.v1.Route
   }
 
   /**
+   * 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> {
+  public static final class RouteLookupServiceFutureStub
+      extends io.grpc.stub.AbstractFutureStub<RouteLookupServiceFutureStub> {
     private RouteLookupServiceFutureStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -200,10 +245,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 RouteLookupServiceImplBase serviceImpl;
+    private final AsyncService serviceImpl;
     private final int methodId;
 
-    MethodHandlers(RouteLookupServiceImplBase serviceImpl, int methodId) {
+    MethodHandlers(AsyncService serviceImpl, int methodId) {
       this.serviceImpl = serviceImpl;
       this.methodId = methodId;
     }
@@ -232,6 +277,18 @@ public io.grpc.stub.StreamObserver<Req> invoke(
     }
   }
 
+  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() {}
@@ -255,9 +312,9 @@ private static final class RouteLookupServiceFileDescriptorSupplier
   private static final class RouteLookupServiceMethodDescriptorSupplier
       extends RouteLookupServiceBaseDescriptorSupplier
       implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
-    private final String methodName;
+    private final java.lang.String methodName;
 
-    RouteLookupServiceMethodDescriptorSupplier(String methodName) {
+    RouteLookupServiceMethodDescriptorSupplier(java.lang.String methodName) {
       this.methodName = methodName;
     }
 
diff --git a/rls/src/main/java/io/grpc/rls/AdaptiveThrottler.java b/rls/src/main/java/io/grpc/rls/AdaptiveThrottler.java
index 55f3f72453e..576b234b0c3 100644
--- a/rls/src/main/java/io/grpc/rls/AdaptiveThrottler.java
+++ b/rls/src/main/java/io/grpc/rls/AdaptiveThrottler.java
@@ -21,7 +21,7 @@
 
 import com.google.common.annotations.VisibleForTesting;
 import com.google.common.base.MoreObjects;
-import io.grpc.internal.TimeProvider;
+import com.google.common.base.Ticker;
 import java.util.concurrent.ThreadLocalRandom;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicLongFieldUpdater;
@@ -44,7 +44,7 @@ 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 = 1.2f;
+  private static final float DEFAULT_RATIO_FOR_ACCEPT = 2.0f;
 
   /**
    * The duration of history of calls used by Adaptive Throttler.
@@ -60,7 +60,7 @@ final class AdaptiveThrottler implements Throttler {
    * is currently accepting.
    */
   private final float ratioForAccepts;
-  private final TimeProvider timeProvider;
+  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
@@ -79,10 +79,10 @@ private AdaptiveThrottler(Builder builder) {
     this.historySeconds = builder.historySeconds;
     this.requestsPadding = builder.requestsPadding;
     this.ratioForAccepts = builder.ratioForAccepts;
-    this.timeProvider = builder.timeProvider;
+    this.ticker = builder.ticker;
     long internalNanos = TimeUnit.SECONDS.toNanos(historySeconds);
-    this.requestStat = new TimeBasedAccumulator(internalNanos, timeProvider);
-    this.throttledStat = new TimeBasedAccumulator(internalNanos, timeProvider);
+    this.requestStat = new TimeBasedAccumulator(internalNanos, ticker);
+    this.throttledStat = new TimeBasedAccumulator(internalNanos, ticker);
   }
 
   @Override
@@ -92,7 +92,7 @@ public boolean shouldThrottle() {
 
   @VisibleForTesting
   boolean shouldThrottle(float random) {
-    long nowNanos = timeProvider.currentTimeNanos();
+    long nowNanos = ticker.read();
     if (getThrottleProbability(nowNanos) <= random) {
       return false;
     }
@@ -118,7 +118,7 @@ float getThrottleProbability(long nowNanos) {
 
   @Override
   public void registerBackendResponse(boolean throttled) {
-    long now = timeProvider.currentTimeNanos();
+    long now = ticker.read();
     requestStat.increment(now);
     if (throttled) {
       throttledStat.increment(now);
@@ -150,7 +150,7 @@ static final class Builder {
     private float ratioForAccepts = DEFAULT_RATIO_FOR_ACCEPT;
     private int historySeconds = DEFAULT_HISTORY_SECONDS;
     private int requestsPadding = DEFAULT_REQUEST_PADDING;
-    private TimeProvider timeProvider = TimeProvider.SYSTEM_TIME_PROVIDER;
+    private Ticker ticker = Ticker.systemTicker();
 
     public Builder setRatioForAccepts(float ratioForAccepts) {
       this.ratioForAccepts = ratioForAccepts;
@@ -167,8 +167,8 @@ public Builder setRequestsPadding(int requestsPadding) {
       return this;
     }
 
-    public Builder setTimeProvider(TimeProvider timeProvider) {
-      this.timeProvider = checkNotNull(timeProvider, "timeProvider");
+    public Builder setTicker(Ticker ticker) {
+      this.ticker = checkNotNull(ticker, "ticker");
       return this;
     }
 
@@ -205,9 +205,6 @@ void increment() {
       }
     }
 
-    // Represents a slot which is not initialized and is unusable.
-    private static final Slot NULL_SLOT = new Slot(-1);
-
     /** The array of slots. */
     private final AtomicReferenceArray<Slot> slots = new AtomicReferenceArray<>(NUM_SLOTS);
 
@@ -224,7 +221,7 @@ void increment() {
      */
     private volatile int currentIndex;
 
-    private final TimeProvider timeProvider;
+    private final Ticker ticker;
 
     /**
      * Interval constructor.
@@ -232,7 +229,7 @@ void increment() {
      * @param internalNanos is the stat interval in nanoseconds
      * @throws IllegalArgumentException if the supplied interval is too small to be effective
      */
-    TimeBasedAccumulator(long internalNanos, TimeProvider timeProvider) {
+    TimeBasedAccumulator(long internalNanos, Ticker ticker) {
       checkArgument(
           internalNanos >= NUM_SLOTS,
           "Interval must be greater than %s",
@@ -240,30 +237,27 @@ void increment() {
       this.interval = internalNanos;
       this.slotNanos = internalNanos / NUM_SLOTS;
       this.currentIndex = 0;
-      for (int i = 0; i < NUM_SLOTS; i++) {
-        slots.set(i, NULL_SLOT);
-      }
-      this.timeProvider = checkNotNull(timeProvider, "ticker");
+      this.ticker = checkNotNull(ticker, "ticker");
     }
 
     /** Gets the current slot. */
     private Slot getSlot(long now) {
       Slot currentSlot = slots.get(currentIndex);
-      if (now < currentSlot.endNanos) {
+      if (currentSlot != null && now - currentSlot.endNanos < 0) {
         return currentSlot;
       } else {
         long slotBoundary = getSlotEndTime(now);
         synchronized (this) {
           int index = currentIndex;
           currentSlot = slots.get(index);
-          if (now < currentSlot.endNanos) {
+          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_SLOT or an old slot.
+          // racing readers will see null or an old slot.
           currentIndex = newIndex;
           return nextSlot;
         }
@@ -294,7 +288,7 @@ long getInterval() {
      *
      * @param now is the time used to increment the count
      */
-    final void increment(long now) {
+    void increment(long now) {
       getSlot(now).increment();
     }
 
@@ -304,28 +298,33 @@ final void increment(long now) {
      * @param now the current time
      * @return the statistic count
      */
-    final long get(long now) {
+    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 = Long.MAX_VALUE;
+      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 || currentSlotEnd > prevSlotEnd) {
+        if (currentSlotEnd - intervalStart <= 0
+            || (prevSlotEnd != null && currentSlotEnd - prevSlotEnd > 0)) {
           break;
         }
         prevSlotEnd = currentSlotEnd;
 
-        if (currentSlotEnd > intervalEnd) {
+        if (currentSlotEnd - intervalEnd > 0) {
           continue;
         }
         accumulated = accumulated + currentSlot.count;
@@ -337,7 +336,7 @@ final long get(long now) {
     public String toString() {
       return MoreObjects.toStringHelper(this)
           .add("interval", interval)
-          .add("current_count", get(timeProvider.currentTimeNanos()))
+          .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
index 87d01360f49..a2846fd04c8 100644
--- a/rls/src/main/java/io/grpc/rls/CachingRlsLbClient.java
+++ b/rls/src/main/java/io/grpc/rls/CachingRlsLbClient.java
@@ -23,35 +23,37 @@
 import com.google.common.base.Converter;
 import com.google.common.base.MoreObjects;
 import com.google.common.base.MoreObjects.ToStringHelper;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableMap;
+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;
+import io.grpc.Grpc;
 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.LongCounterMetricInstrument;
+import io.grpc.LongGaugeMetricInstrument;
 import io.grpc.ManagedChannel;
 import io.grpc.ManagedChannelBuilder;
 import io.grpc.Metadata;
-import io.grpc.NameResolver.ConfigOrError;
+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.SynchronizationContext;
-import io.grpc.SynchronizationContext.ScheduledHandle;
 import io.grpc.internal.BackoffPolicy;
 import io.grpc.internal.ExponentialBackoffPolicy;
-import io.grpc.internal.TimeProvider;
 import io.grpc.lookup.v1.RouteLookupServiceGrpc;
 import io.grpc.lookup.v1.RouteLookupServiceGrpc.RouteLookupServiceStub;
 import io.grpc.rls.ChildLoadBalancerHelper.ChildLoadBalancerHelperProvider;
-import io.grpc.rls.LbPolicyConfiguration.ChildLbStatusListener;
-import io.grpc.rls.LbPolicyConfiguration.ChildLoadBalancingPolicy;
 import io.grpc.rls.LbPolicyConfiguration.ChildPolicyWrapper;
 import io.grpc.rls.LbPolicyConfiguration.RefCountedChildPolicyWrapperFactory;
 import io.grpc.rls.LruCache.EvictionListener;
@@ -59,19 +61,22 @@
 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.rls.Throttler.ThrottledException;
 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.CheckReturnValue;
 import javax.annotation.Nullable;
-import javax.annotation.concurrent.GuardedBy;
 import javax.annotation.concurrent.ThreadSafe;
 
 /**
@@ -86,26 +91,32 @@ final class CachingRlsLbClient {
       REQUEST_CONVERTER = new RlsProtoConverters.RouteLookupRequestConverter().reverse();
   private static final Converter<RouteLookupResponse, io.grpc.lookup.v1.RouteLookupResponse>
       RESPONSE_CONVERTER = new RouteLookupResponseConverter().reverse();
-
-  // System property to use direct path enabled OobChannel, by default direct path is enabled.
-  private static final String RLS_ENABLE_OOB_CHANNEL_DIRECTPATH_PROPERTY =
-      "io.grpc.rls.CachingRlsLbClient.enable_oobchannel_directpath";
-  @VisibleForTesting
-  static boolean enableOobChannelDirectPath =
-      Boolean.parseBoolean(System.getProperty(RLS_ENABLE_OOB_CHANNEL_DIRECTPATH_PROPERTY, "false"));
+  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 LinkedHashLruCache<RouteLookupRequest, CacheEntry> linkedHashLruCache;
+  private final RlsAsyncLruCache linkedHashLruCache;
+  private final Future<?> periodicCleaner;
   // any RPC on the fly will cached in this map
   @GuardedBy("lock")
-  private final Map<RouteLookupRequest, PendingCacheEntry> pendingCallCache = new HashMap<>();
+  private final Map<RouteLookupRequestKey, PendingCacheEntry> pendingCallCache = new HashMap<>();
 
-  private final SynchronizationContext synchronizationContext;
   private final ScheduledExecutorService scheduledExecutorService;
-  private final TimeProvider timeProvider;
+  private final Ticker ticker;
   private final Throttler throttler;
 
   private final LbPolicyConfiguration lbPolicyConfig;
@@ -119,26 +130,62 @@ final class CachingRlsLbClient {
   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"),
+        Arrays.asList("grpc.client.call.custom"),
+        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"),
+        Arrays.asList("grpc.client.call.custom"),
+        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"),
+        Arrays.asList("grpc.client.call.custom"), 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();
-    synchronizationContext = helper.getSynchronizationContext();
     lbPolicyConfig = checkNotNull(builder.lbPolicyConfig, "lbPolicyConfig");
     RouteLookupConfig rlsConfig = lbPolicyConfig.getRouteLookupConfig();
-    maxAgeNanos = TimeUnit.MILLISECONDS.toNanos(rlsConfig.getMaxAgeInMillis());
-    staleAgeNanos = TimeUnit.MILLISECONDS.toNanos(rlsConfig.getStaleAgeInMillis());
-    callTimeoutNanos = TimeUnit.MILLISECONDS.toNanos(rlsConfig.getLookupServiceTimeoutInMillis());
-    timeProvider = checkNotNull(builder.timeProvider, "timeProvider");
+    maxAgeNanos = rlsConfig.maxAgeInNanos();
+    staleAgeNanos = rlsConfig.staleAgeInNanos();
+    callTimeoutNanos = rlsConfig.lookupServiceTimeoutInNanos();
+    ticker = checkNotNull(builder.ticker, "ticker");
     throttler = checkNotNull(builder.throttler, "throttler");
     linkedHashLruCache =
         new RlsAsyncLruCache(
-            rlsConfig.getCacheSizeBytes(),
-            builder.evictionListener,
-            scheduledExecutorService,
-            timeProvider);
+            rlsConfig.cacheSizeBytes(),
+            new AutoCleaningEvictionListener(builder.evictionListener),
+            ticker,
+            helper);
+    periodicCleaner =
+        scheduledExecutorService.scheduleAtFixedRate(this::periodicClean, 1, 1, TimeUnit.MINUTES);
     logger = helper.getChannelLogger();
     String serverHost = null;
     try {
@@ -153,26 +200,54 @@ private CachingRlsLbClient(Builder builder) {
     }
     RlsRequestFactory requestFactory = new RlsRequestFactory(
         lbPolicyConfig.getRouteLookupConfig(), serverHost);
-    rlsPicker = new RlsPicker(requestFactory);
+    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.getLookupService(), helper.getUnsafeChannelCredentials());
+        rlsConfig.lookupService(), helper.getUnsafeChannelCredentials());
     rlsChannelBuilder.overrideAuthority(helper.getAuthority());
-    if (enableOobChannelDirectPath) {
-      Map<String, ?> directPathServiceConfig =
-          getDirectPathServiceConfig(rlsConfig.getLookupService());
+    Map<String, ?> routeLookupChannelServiceConfig =
+        lbPolicyConfig.getRouteLookupChannelServiceConfig();
+    if (routeLookupChannelServiceConfig != null) {
       logger.log(
           ChannelLogLevel.DEBUG,
-          "RLS channel direct path enabled. RLS channel service config: {0}",
-          directPathServiceConfig);
-      rlsChannelBuilder.defaultServiceConfig(directPathServiceConfig);
+          "RLS channel service config: {0}",
+          routeLookupChannelServiceConfig);
+      rlsChannelBuilder.defaultServiceConfig(routeLookupChannelServiceConfig);
       rlsChannelBuilder.disableServiceConfigLookUp();
     }
     rlsChannel = rlsChannelBuilder.build();
-    helper.updateBalancingState(ConnectivityState.CONNECTING, rlsPicker);
+    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");
@@ -181,59 +256,115 @@ private CachingRlsLbClient(Builder builder) {
         new ChildLoadBalancerHelperProvider(helper, new SubchannelStateManagerImpl(), rlsPicker);
     refCountedChildPolicyWrapperFactory =
         new RefCountedChildPolicyWrapperFactory(
-            childLbHelperProvider, new BackoffRefreshListener());
+            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");
   }
 
-  private static ImmutableMap<String, Object> getDirectPathServiceConfig(String serviceName) {
-    ImmutableMap<String, Object> pickFirstStrategy =
-        ImmutableMap.<String, Object>of("pick_first", ImmutableMap.of());
+  void init() {
+    synchronized (lock) {
+      refCountedChildPolicyWrapperFactory.init();
+    }
+  }
 
-    ImmutableMap<String, Object> childPolicy =
-        ImmutableMap.<String, Object>of(
-            "childPolicy", ImmutableList.of(pickFirstStrategy),
-            "serviceName", serviceName);
+  Status acceptResolvedAddressFactory(ResolvedAddressFactory childLbResolvedAddressFactory) {
+    synchronized (lock) {
+      return refCountedChildPolicyWrapperFactory.acceptResolvedAddressFactory(
+          childLbResolvedAddressFactory);
+    }
+  }
 
-    ImmutableMap<String, Object> grpcLbPolicy =
-        ImmutableMap.<String, Object>of("grpclb", childPolicy);
+  /**
+   * 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()));
+  }
 
-    return ImmutableMap.<String, Object>of("loadBalancingConfig", ImmutableList.of(grpcLbPolicy));
+  private void periodicClean() {
+    synchronized (lock) {
+      linkedHashLruCache.cleanupExpiredEntries();
+    }
   }
 
-  @CheckReturnValue
-  private ListenableFuture<RouteLookupResponse> asyncRlsCall(RouteLookupRequest request) {
-    final SettableFuture<RouteLookupResponse> response = SettableFuture.create();
+  /** 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, "Request is throttled");
-      response.setException(new ThrottledException());
-      return response;
+      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));
     }
-    io.grpc.lookup.v1.RouteLookupRequest routeLookupRequest = REQUEST_CONVERTER.convert(request);
-    logger.log(ChannelLogLevel.DEBUG, "Sending RouteLookupRequest: {0}", routeLookupRequest);
+    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, "Received RouteLookupResponse: {0}", 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, "Error looking up route:", t);
+                logger.log(ChannelLogLevel.DEBUG,
+                    "[RLS Entry {0}] RouteLookup failed: {1}", routeLookupRequestKey, t);
                 response.setException(t);
-                throttler.registerBackendResponse(false);
-                helper.propagateRlsError();
+                throttler.registerBackendResponse(true);
               }
 
               @Override
               public void onCompleted() {
-                throttler.registerBackendResponse(true);
+                throttler.registerBackendResponse(false);
               }
             });
-    return response;
+    return CachedRouteLookupResponse.pendingResponse(
+        createPendingEntry(routeLookupRequestKey, response, backoffPolicy));
   }
 
   /**
@@ -242,19 +373,26 @@ public void onCompleted() {
    * changed after the return.
    */
   @CheckReturnValue
-  final CachedRouteLookupResponse get(final RouteLookupRequest request) {
+  final CachedRouteLookupResponse get(final RouteLookupRequestKey routeLookupRequestKey) {
     synchronized (lock) {
       final CacheEntry cacheEntry;
-      cacheEntry = linkedHashLruCache.read(request);
-      if (cacheEntry == null) {
-        return handleNewRequest(request);
+      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
-        logger.log(ChannelLogLevel.DEBUG, "Cache hit for the request");
         DataCacheEntry dataEntry = ((DataCacheEntry) cacheEntry);
-        if (dataEntry.isStaled(timeProvider.currentTimeNanos())) {
+        if (dataEntry.isStaled(ticker.read())) {
           dataEntry.maybeRefresh();
         }
         return CachedRouteLookupResponse.dataEntry((DataCacheEntry) cacheEntry);
@@ -267,51 +405,100 @@ final CachedRouteLookupResponse get(final RouteLookupRequest request) {
   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();
     }
   }
 
-  /**
-   * Populates async cache entry for new request. This is only methods directly modifies the cache,
-   * any status change is happening via event (async request finished, timed out, etc) in {@link
-   * PendingCacheEntry}, {@link DataCacheEntry} and {@link BackoffCacheEntry}.
-   */
-  private CachedRouteLookupResponse handleNewRequest(RouteLookupRequest request) {
+  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) {
-      PendingCacheEntry pendingEntry = pendingCallCache.get(request);
-      if (pendingEntry != null) {
-        return CachedRouteLookupResponse.pendingResponse(pendingEntry);
+      boolean clientClosed = pendingCallCache.remove(entry.routeLookupRequestKey) == null;
+      if (clientClosed) {
+        return;
       }
 
-      ListenableFuture<RouteLookupResponse> asyncCall = asyncRlsCall(request);
-      if (!asyncCall.isDone()) {
-        pendingEntry = new PendingCacheEntry(request, asyncCall);
-        pendingCallCache.put(request, pendingEntry);
-        return CachedRouteLookupResponse.pendingResponse(pendingEntry);
-      } else {
-        // async call returned finished future is most likely throttled
-        try {
-          RouteLookupResponse response = asyncCall.get();
-          DataCacheEntry dataEntry = new DataCacheEntry(request, response);
-          linkedHashLruCache.cache(request, dataEntry);
-          return CachedRouteLookupResponse.dataEntry(dataEntry);
-        } catch (Exception e) {
-          BackoffCacheEntry backoffEntry =
-              new BackoffCacheEntry(request, Status.fromThrowable(e), backoffProvider.get());
-          linkedHashLruCache.cache(request, backoffEntry);
-          return CachedRouteLookupResponse.backoffEntry(backoffEntry);
-        }
+      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();
       }
     }
   }
 
-  void requestConnection() {
-    rlsChannel.getState(true);
+  @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 {
@@ -336,16 +523,10 @@ public void updateBalancingState(ConnectivityState newState, SubchannelPicker ne
       super.updateBalancingState(newState, newPicker);
     }
 
-    void propagateRlsError() {
-      getSynchronizationContext().execute(new Runnable() {
-        @Override
-        public void run() {
-          if (picker != null) {
-            // Refresh the channel state and let pending RPCs reprocess the picker.
-            updateBalancingState(state, picker);
-          }
-        }
-      });
+    void triggerPendingRpcProcessing() {
+      checkState(state != null, "updateBalancingState hasn't yet been called");
+      helper.getSynchronizationContext().execute(
+          () -> super.updateBalancingState(state, picker));
     }
   }
 
@@ -397,6 +578,15 @@ ChildPolicyWrapper getChildPolicyWrapper() {
       return dataCacheEntry.getChildPolicyWrapper();
     }
 
+    @VisibleForTesting
+    @Nullable
+    ChildPolicyWrapper getChildPolicyWrapper(String target) {
+      if (!hasData()) {
+        return null;
+      }
+      return dataCacheEntry.getChildPolicyWrapper(target);
+    }
+
     @Nullable
     String getHeaderData() {
       if (!hasData()) {
@@ -438,137 +628,70 @@ public String toString() {
   }
 
   /** A pending cache entry when the async RouteLookup RPC is still on the fly. */
-  final class PendingCacheEntry {
+  static final class PendingCacheEntry {
     private final ListenableFuture<RouteLookupResponse> pendingCall;
-    private final RouteLookupRequest request;
+    private final RouteLookupRequestKey routeLookupRequestKey;
+    @Nullable
     private final BackoffPolicy backoffPolicy;
 
     PendingCacheEntry(
-        RouteLookupRequest request, ListenableFuture<RouteLookupResponse> pendingCall) {
-      this(request, pendingCall, null);
-    }
-
-    PendingCacheEntry(
-        RouteLookupRequest request,
+        RouteLookupRequestKey routeLookupRequestKey,
         ListenableFuture<RouteLookupResponse> pendingCall,
         @Nullable BackoffPolicy backoffPolicy) {
-      this.request = checkNotNull(request, "request");
-      this.pendingCall = pendingCall;
-      this.backoffPolicy = backoffPolicy == null ? backoffProvider.get() : backoffPolicy;
-      pendingCall.addListener(
-          new Runnable() {
-            @Override
-            public void run() {
-              handleDoneFuture();
-            }
-          },
-          synchronizationContext);
-    }
-
-    private void handleDoneFuture() {
-      synchronized (lock) {
-        pendingCallCache.remove(request);
-        if (pendingCall.isCancelled()) {
-          return;
-        }
-
-        try {
-          transitionToDataEntry(pendingCall.get());
-        } catch (Exception e) {
-          if (e instanceof ThrottledException) {
-            transitionToBackOff(Status.RESOURCE_EXHAUSTED.withCause(e));
-          } else {
-            transitionToBackOff(Status.fromThrowable(e));
-          }
-        }
-      }
-    }
-
-    private void transitionToDataEntry(RouteLookupResponse routeLookupResponse) {
-      synchronized (lock) {
-        logger.log(
-            ChannelLogLevel.DEBUG,
-            "Transition to data cache: routeLookupResponse={0}",
-            routeLookupResponse);
-        linkedHashLruCache.cache(request, new DataCacheEntry(request, routeLookupResponse));
-      }
-    }
-
-    private void transitionToBackOff(Status status) {
-      synchronized (lock) {
-        logger.log(ChannelLogLevel.DEBUG, "Transition to back off: status={0}", status);
-        linkedHashLruCache.cache(request, new BackoffCacheEntry(request, status, backoffPolicy));
-      }
+      this.routeLookupRequestKey = checkNotNull(routeLookupRequestKey, "request");
+      this.pendingCall = checkNotNull(pendingCall, "pendingCall");
+      this.backoffPolicy = backoffPolicy;
     }
 
     @Override
     public String toString() {
       return MoreObjects.toStringHelper(this)
-          .add("request", request)
+          .add("routeLookupRequestKey", routeLookupRequestKey)
           .toString();
     }
   }
 
   /** Common cache entry data for {@link RlsAsyncLruCache}. */
-  abstract class CacheEntry {
+  abstract static class CacheEntry {
 
-    protected final RouteLookupRequest request;
+    protected final RouteLookupRequestKey routeLookupRequestKey;
 
-    CacheEntry(RouteLookupRequest request) {
-      this.request = checkNotNull(request, "request");
+    CacheEntry(RouteLookupRequestKey routeLookupRequestKey) {
+      this.routeLookupRequestKey = checkNotNull(routeLookupRequestKey, "request");
     }
 
     abstract int getSizeBytes();
 
-    final boolean isExpired() {
-      return isExpired(timeProvider.currentTimeNanos());
-    }
-
     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 ChildPolicyWrapper childPolicyWrapper;
+    private final List<ChildPolicyWrapper> childPolicyWrappers;
 
-    DataCacheEntry(RouteLookupRequest request, final RouteLookupResponse response) {
-      super(request);
+    // GuardedBy CachingRlsLbClient.lock
+    DataCacheEntry(RouteLookupRequestKey routeLookupRequestKey,
+        final RouteLookupResponse response) {
+      super(routeLookupRequestKey);
       this.response = checkNotNull(response, "response");
-      // TODO(creamsoup) fallback to other targets if first one is not available
-      childPolicyWrapper =
+      checkState(!response.targets().isEmpty(), "No targets returned by RLS");
+      childPolicyWrappers =
           refCountedChildPolicyWrapperFactory
-              .createOrGet(response.getTargets().get(0));
-      long now = timeProvider.currentTimeNanos();
+              .createOrGet(response.targets());
+      long now = ticker.read();
+      minEvictionTime = now + MIN_EVICTION_TIME_DELTA_NANOS;
       expireTime = now + maxAgeNanos;
       staleTime = now + staleAgeNanos;
-
-      if (childPolicyWrapper.getPicker() != null) {
-        childPolicyWrapper.refreshState();
-      } else {
-        createChildLbPolicy();
-      }
-    }
-
-    private void createChildLbPolicy() {
-      ChildLoadBalancingPolicy childPolicy = lbPolicyConfig.getLoadBalancingPolicy();
-      LoadBalancerProvider lbProvider = childPolicy.getEffectiveLbProvider();
-      ConfigOrError lbConfig =
-          lbProvider
-              .parseLoadBalancingPolicyConfig(
-                  childPolicy.getEffectiveChildPolicy(childPolicyWrapper.getTarget()));
-
-      LoadBalancer lb = lbProvider.newLoadBalancer(childPolicyWrapper.getHelper());
-      logger.log(
-          ChannelLogLevel.DEBUG,
-          "RLS child lb created. config: {0}",
-          lbConfig.getConfig());
-      lb.handleResolvedAddresses(childLbResolvedAddressFactory.create(lbConfig.getConfig()));
-      lb.requestConnection();
     }
 
     /**
@@ -586,68 +709,89 @@ private void createChildLbPolicy() {
      * </pre>
      */
     void maybeRefresh() {
-      synchronized (lock) {
-        if (pendingCallCache.containsKey(request)) {
+      synchronized (lock) { // Lock is already held, but ErrorProne can't tell
+        if (pendingCallCache.containsKey(routeLookupRequestKey)) {
           // pending already requested
           return;
         }
-        final ListenableFuture<RouteLookupResponse> asyncCall = asyncRlsCall(request);
-        if (!asyncCall.isDone()) {
-          pendingCallCache.put(request, new PendingCacheEntry(request, asyncCall));
-        } else {
-          // async call returned finished future is most likely throttled
-          try {
-            RouteLookupResponse response = asyncCall.get();
-            linkedHashLruCache.cache(request, new DataCacheEntry(request, response));
-          } catch (InterruptedException e) {
-            Thread.currentThread().interrupt();
-          } catch (Exception e) {
-            BackoffCacheEntry backoffEntry =
-                new BackoffCacheEntry(request, Status.fromThrowable(e), backoffProvider.get());
-            linkedHashLruCache.cache(request, backoffEntry);
-          }
+        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() {
-      return childPolicyWrapper;
+      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() {
-      // size of strings and java object overhead, actual memory usage is more than this.
-      return
-          (response.getTargets().get(0).length() + response.getHeaderData().length()) * 2 + 38 * 2;
+      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;
+      return expireTime - now <= 0;
     }
 
     boolean isStaled(long now) {
-      return staleTime <= now;
+      return staleTime - now <= 0;
+    }
+
+    @Override
+    protected boolean isOldEnoughToBeEvicted(long now) {
+      return minEvictionTime - now <= 0;
     }
 
     @Override
     void cleanup() {
-      refCountedChildPolicyWrapperFactory.release(childPolicyWrapper);
+      synchronized (lock) {
+        for (ChildPolicyWrapper policyWrapper : childPolicyWrappers) {
+          refCountedChildPolicyWrapperFactory.release(policyWrapper);
+        }
+      }
     }
 
     @Override
     public String toString() {
       return MoreObjects.toStringHelper(this)
-          .add("request", request)
+          .add("request", routeLookupRequestKey)
           .add("response", response)
           .add("expireTime", expireTime)
           .add("staleTime", staleTime)
-          .add("childPolicyWrapper", childPolicyWrapper)
+          .add("childPolicyWrappers", childPolicyWrappers)
           .toString();
     }
   }
@@ -656,64 +800,19 @@ public String toString() {
    * Implementation of {@link CacheEntry} contains error. This entry will transition to pending
    * status when the backoff time is expired.
    */
-  private final class BackoffCacheEntry extends CacheEntry {
+  private static final class BackoffCacheEntry extends CacheEntry {
 
     private final Status status;
-    private final ScheduledHandle scheduledHandle;
     private final BackoffPolicy backoffPolicy;
-    private final long expireNanos;
-    private boolean shutdown = false;
+    private final long expiryTimeNanos;
+    private Future<?> scheduledFuture;
 
-    BackoffCacheEntry(RouteLookupRequest request, Status status, BackoffPolicy backoffPolicy) {
-      super(request);
+    BackoffCacheEntry(RouteLookupRequestKey routeLookupRequestKey, Status status,
+        BackoffPolicy backoffPolicy, long expiryTimeNanos) {
+      super(routeLookupRequestKey);
       this.status = checkNotNull(status, "status");
       this.backoffPolicy = checkNotNull(backoffPolicy, "backoffPolicy");
-      long delayNanos = backoffPolicy.nextBackoffNanos();
-      this.expireNanos = timeProvider.currentTimeNanos() + delayNanos;
-      this.scheduledHandle =
-          synchronizationContext.schedule(
-              new Runnable() {
-                @Override
-                public void run() {
-                  transitionToPending();
-                }
-              },
-              delayNanos,
-              TimeUnit.NANOSECONDS,
-              scheduledExecutorService);
-    }
-
-    /** Forcefully refreshes cache entry by ignoring the backoff timer. */
-    void forceRefresh() {
-      if (scheduledHandle.isPending()) {
-        scheduledHandle.cancel();
-        transitionToPending();
-      }
-    }
-
-    private void transitionToPending() {
-      synchronized (lock) {
-        if (shutdown) {
-          return;
-        }
-        ListenableFuture<RouteLookupResponse> call = asyncRlsCall(request);
-        if (!call.isDone()) {
-          PendingCacheEntry pendingEntry = new PendingCacheEntry(request, call, backoffPolicy);
-          pendingCallCache.put(request, pendingEntry);
-          linkedHashLruCache.invalidate(request);
-        } else {
-          try {
-            RouteLookupResponse response = call.get();
-            linkedHashLruCache.cache(request, new DataCacheEntry(request, response));
-          } catch (InterruptedException e) {
-            Thread.currentThread().interrupt();
-          } catch (Exception e) {
-            linkedHashLruCache.cache(
-                request,
-                new BackoffCacheEntry(request, Status.fromThrowable(e), backoffPolicy));
-          }
-        }
-      }
+      this.expiryTimeNanos = expiryTimeNanos;
     }
 
     Status getStatus() {
@@ -722,29 +821,27 @@ Status getStatus() {
 
     @Override
     int getSizeBytes() {
-      return 0;
+      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 now) {
-      return expireNanos <= now;
+    boolean isExpired(long nowNanos) {
+      return nowNanos > expiryTimeNanos;
     }
 
     @Override
     void cleanup() {
-      if (shutdown) {
-        return;
-      }
-      shutdown = true;
-      if (!scheduledHandle.isPending()) {
-        scheduledHandle.cancel();
-      }
+      scheduledFuture.cancel(false);
     }
 
     @Override
     public String toString() {
       return MoreObjects.toStringHelper(this)
-          .add("request", request)
+          .add("request", routeLookupRequestKey)
           .add("status", status)
           .toString();
     }
@@ -762,8 +859,8 @@ static final class Builder {
     private LbPolicyConfiguration lbPolicyConfig;
     private Throttler throttler = new HappyThrottler();
     private ResolvedAddressFactory resolvedAddressFactory;
-    private TimeProvider timeProvider = TimeProvider.SYSTEM_TIME_PROVIDER;
-    private EvictionListener<RouteLookupRequest, CacheEntry> evictionListener;
+    private Ticker ticker = Ticker.systemTicker();
+    private EvictionListener<RouteLookupRequestKey, CacheEntry> evictionListener;
     private BackoffPolicy.Provider backoffProvider = new ExponentialBackoffPolicy.Provider();
 
     Builder setHelper(Helper helper) {
@@ -791,13 +888,13 @@ Builder setResolvedAddressesFactory(
       return this;
     }
 
-    Builder setTimeProvider(TimeProvider timeProvider) {
-      this.timeProvider = checkNotNull(timeProvider, "timeProvider");
+    Builder setTicker(Ticker ticker) {
+      this.ticker = checkNotNull(ticker, "ticker");
       return this;
     }
 
     Builder setEvictionListener(
-        @Nullable EvictionListener<RouteLookupRequest, CacheEntry> evictionListener) {
+        @Nullable EvictionListener<RouteLookupRequestKey, CacheEntry> evictionListener) {
       this.evictionListener = evictionListener;
       return this;
     }
@@ -808,7 +905,9 @@ Builder setBackoffProvider(BackoffPolicy.Provider provider) {
     }
 
     CachingRlsLbClient build() {
-      return new CachingRlsLbClient(this);
+      CachingRlsLbClient client = new CachingRlsLbClient(this);
+      client.init();
+      return client;
     }
   }
 
@@ -817,17 +916,17 @@ CachingRlsLbClient build() {
    * CacheEntry#cleanup()} after original {@link EvictionListener} is finished.
    */
   private static final class AutoCleaningEvictionListener
-      implements EvictionListener<RouteLookupRequest, CacheEntry> {
+      implements EvictionListener<RouteLookupRequestKey, CacheEntry> {
 
-    private final EvictionListener<RouteLookupRequest, CacheEntry> delegate;
+    private final EvictionListener<RouteLookupRequestKey, CacheEntry> delegate;
 
     AutoCleaningEvictionListener(
-        @Nullable EvictionListener<RouteLookupRequest, CacheEntry> delegate) {
+        @Nullable EvictionListener<RouteLookupRequestKey, CacheEntry> delegate) {
       this.delegate = delegate;
     }
 
     @Override
-    public void onEviction(RouteLookupRequest key, CacheEntry value, EvictionType cause) {
+    public void onEviction(RouteLookupRequestKey key, CacheEntry value, EvictionType cause) {
       if (delegate != null) {
         delegate.onEviction(key, value, cause);
       }
@@ -852,60 +951,45 @@ public void registerBackendResponse(boolean throttled) {
 
   /** Implementation of {@link LinkedHashLruCache} for RLS. */
   private static final class RlsAsyncLruCache
-      extends LinkedHashLruCache<RouteLookupRequest, CacheEntry> {
+      extends LinkedHashLruCache<RouteLookupRequestKey, CacheEntry> {
+    private final RlsLbHelper helper;
 
     RlsAsyncLruCache(long maxEstimatedSizeBytes,
-        @Nullable EvictionListener<RouteLookupRequest, CacheEntry> evictionListener,
-        ScheduledExecutorService ses, TimeProvider timeProvider) {
-      super(
-          maxEstimatedSizeBytes,
-          new AutoCleaningEvictionListener(evictionListener),
-          1,
-          TimeUnit.MINUTES,
-          ses,
-          timeProvider);
+        @Nullable EvictionListener<RouteLookupRequestKey, CacheEntry> evictionListener,
+        Ticker ticker, RlsLbHelper helper) {
+      super(maxEstimatedSizeBytes, evictionListener, ticker);
+      this.helper = checkNotNull(helper, "helper");
     }
 
     @Override
-    protected boolean isExpired(RouteLookupRequest key, CacheEntry value, long nowNanos) {
-      return value.isExpired();
+    protected boolean isExpired(RouteLookupRequestKey key, CacheEntry value, long nowNanos) {
+      return value.isExpired(nowNanos);
     }
 
     @Override
-    protected int estimateSizeOf(RouteLookupRequest key, CacheEntry value) {
+    protected int estimateSizeOf(RouteLookupRequestKey key, CacheEntry value) {
       return value.getSizeBytes();
     }
 
     @Override
     protected boolean shouldInvalidateEldestEntry(
-        RouteLookupRequest eldestKey, CacheEntry eldestValue) {
+        RouteLookupRequestKey eldestKey, CacheEntry eldestValue, long now) {
+      if (!eldestValue.isOldEnoughToBeEvicted(now)) {
+        return false;
+      }
+
       // eldest entry should be evicted if size limit exceeded
-      return true;
+      return this.estimatedSizeBytes() > this.estimatedMaxSizeBytes();
     }
-  }
 
-  /**
-   * LbStatusListener refreshes {@link BackoffCacheEntry} when lb state is changed to {@link
-   * ConnectivityState#READY} from {@link ConnectivityState#TRANSIENT_FAILURE}.
-   */
-  private final class BackoffRefreshListener implements ChildLbStatusListener {
+    public CacheEntry cacheAndClean(RouteLookupRequestKey key, CacheEntry value) {
+      CacheEntry newEntry = cache(key, value);
 
-    @Nullable
-    private ConnectivityState prevState = null;
-
-    @Override
-    public void onStatusChanged(ConnectivityState newState) {
-      if (prevState == ConnectivityState.TRANSIENT_FAILURE
-          && newState == ConnectivityState.READY) {
-        synchronized (lock) {
-          for (CacheEntry value : linkedHashLruCache.values()) {
-            if (value instanceof BackoffCacheEntry) {
-              ((BackoffCacheEntry) value).forceRefresh();
-            }
-          }
-        }
+      // force cleanup if new entry pushed cache over max size (in bytes)
+      if (fitToLimit()) {
+        helper.triggerPendingRpcProcessing();
       }
-      prevState = newState;
+      return newEntry;
     }
   }
 
@@ -917,106 +1001,104 @@ public void onStatusChanged(ConnectivityState newState) {
   final class RlsPicker extends SubchannelPicker {
 
     private final RlsRequestFactory requestFactory;
+    private final String lookupService;
 
-    RlsPicker(RlsRequestFactory requestFactory) {
+    RlsPicker(RlsRequestFactory requestFactory, String lookupService) {
       this.requestFactory = checkNotNull(requestFactory, "requestFactory");
+      this.lookupService = checkNotNull(lookupService, "rlsConfig");
     }
 
     @Override
     public PickResult pickSubchannel(PickSubchannelArgs args) {
-      String[] methodName = args.getMethodDescriptor().getFullMethodName().split("/", 2);
-      RouteLookupRequest request =
-          requestFactory.create(methodName[0], methodName[1], args.getHeaders());
-      final CachedRouteLookupResponse response = CachingRlsLbClient.this.get(request);
-      logger.log(ChannelLogLevel.DEBUG,
-          "Got route lookup cache entry for service={0}, method={1}, headers={2}:\n {3}",
-          new Object[]{methodName[0], methodName[1], args.getHeaders(), response});
+      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().getDefaultTarget();
+      String defaultTarget = lbPolicyConfig.getRouteLookupConfig().defaultTarget();
       boolean hasFallback = defaultTarget != null && !defaultTarget.isEmpty();
       if (response.hasData()) {
         ChildPolicyWrapper childPolicyWrapper = response.getChildPolicyWrapper();
-        SubchannelPicker picker = childPolicyWrapper.getPicker();
+        SubchannelPicker picker =
+            (childPolicyWrapper != null) ? childPolicyWrapper.getPicker() : null;
         if (picker == null) {
           return PickResult.withNoResult();
         }
-        PickResult result = picker.pickSubchannel(args);
-        if (result.getStatus().isOk()) {
-          return result;
-        }
-        if (hasFallback) {
-          return useFallback(args);
+        // 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)),
+              Arrays.asList(determineCustomLabel(args)));
         }
-        return PickResult.withError(result.getStatus());
+        return pickResult;
       } else if (response.hasError()) {
         if (hasFallback) {
           return useFallback(args);
         }
-        return PickResult.withError(response.getStatus());
+        helper.getMetricRecorder().addLongCounter(FAILED_PICKS_COUNTER, 1,
+            Arrays.asList(helper.getChannelTarget(), lookupService),
+            Arrays.asList(determineCustomLabel(args)));
+        return PickResult.withError(
+            convertRlsServerStatus(response.getStatus(),
+                lbPolicyConfig.getRouteLookupConfig().lookupService()));
       } else {
         return PickResult.withNoResult();
       }
     }
 
-    private ChildPolicyWrapper fallbackChildPolicyWrapper;
-
     /** Uses Subchannel connected to default target. */
     private PickResult useFallback(PickSubchannelArgs args) {
-      // TODO(creamsoup) wait until lb is ready
-      startFallbackChildPolicy();
       SubchannelPicker picker = fallbackChildPolicyWrapper.getPicker();
       if (picker == null) {
         return PickResult.withNoResult();
       }
-      return picker.pickSubchannel(args);
+      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)),
+            Arrays.asList(determineCustomLabel(args)));
+      }
+      return pickResult;
     }
 
-    private void startFallbackChildPolicy() {
-      String defaultTarget = lbPolicyConfig.getRouteLookupConfig().getDefaultTarget();
-      logger.log(ChannelLogLevel.DEBUG, "starting fallback to {0}", defaultTarget);
-      synchronized (lock) {
-        if (fallbackChildPolicyWrapper != null) {
-          return;
-        }
-        fallbackChildPolicyWrapper = refCountedChildPolicyWrapperFactory.createOrGet(defaultTarget);
+    private String determineMetricsPickResult(PickResult pickResult) {
+      if (pickResult.getStatus().isOk()) {
+        return "complete";
+      } else if (pickResult.isDrop()) {
+        return "drop";
+      } else {
+        return "fail";
       }
-      LoadBalancerProvider lbProvider =
-          lbPolicyConfig.getLoadBalancingPolicy().getEffectiveLbProvider();
-      final LoadBalancer lb =
-          lbProvider.newLoadBalancer(fallbackChildPolicyWrapper.getHelper());
-      final ConfigOrError lbConfig =
-          lbProvider
-              .parseLoadBalancingPolicyConfig(
-                  lbPolicyConfig
-                      .getLoadBalancingPolicy()
-                      .getEffectiveChildPolicy(defaultTarget));
-      helper.getSynchronizationContext().execute(
-          new Runnable() {
-            @Override
-            public void run() {
-              lb.handleResolvedAddresses(
-                  childLbResolvedAddressFactory.create(lbConfig.getConfig()));
-              lb.requestConnection();
-            }
-          });
     }
 
+    private String determineCustomLabel(PickSubchannelArgs args) {
+      return args.getCallOptions().getOption(Grpc.CALL_OPTION_CUSTOM_LABEL);
+    }
+
+    // GuardedBy CachingRlsLbClient.lock
     void close() {
-      if (fallbackChildPolicyWrapper != null) {
-        refCountedChildPolicyWrapperFactory.release(fallbackChildPolicyWrapper);
+      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().getLookupService())
+          .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
index 884447ec878..73b2e7591e4 100644
--- a/rls/src/main/java/io/grpc/rls/ChildLbResolvedAddressFactory.java
+++ b/rls/src/main/java/io/grpc/rls/ChildLbResolvedAddressFactory.java
@@ -16,7 +16,6 @@
 
 package io.grpc.rls;
 
-import static com.google.common.base.Preconditions.checkArgument;
 import static com.google.common.base.Preconditions.checkNotNull;
 
 import io.grpc.Attributes;
@@ -33,8 +32,7 @@ final class ChildLbResolvedAddressFactory implements ResolvedAddressFactory {
 
   ChildLbResolvedAddressFactory(
       List<EquivalentAddressGroup> addresses, Attributes attributes) {
-    checkArgument(addresses != null && !addresses.isEmpty(), "Address must be provided");
-    this.addresses = Collections.unmodifiableList(addresses);
+    this.addresses = Collections.unmodifiableList(checkNotNull(addresses, "addresses"));
     this.attributes = checkNotNull(attributes, "attributes");
   }
 
diff --git a/rls/src/main/java/io/grpc/rls/ChildLoadBalancerHelper.java b/rls/src/main/java/io/grpc/rls/ChildLoadBalancerHelper.java
index 3131aba7551..7a5d5dcc645 100644
--- a/rls/src/main/java/io/grpc/rls/ChildLoadBalancerHelper.java
+++ b/rls/src/main/java/io/grpc/rls/ChildLoadBalancerHelper.java
@@ -77,6 +77,10 @@ static final class ChildLoadBalancerHelperProvider {
       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
index f54e441ffe5..77ed080e654 100644
--- a/rls/src/main/java/io/grpc/rls/LbPolicyConfiguration.java
+++ b/rls/src/main/java/io/grpc/rls/LbPolicyConfiguration.java
@@ -22,12 +22,16 @@
 
 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;
@@ -38,18 +42,21 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
-import java.util.concurrent.atomic.AtomicLong;
 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, ChildLoadBalancingPolicy policy) {
+      RouteLookupConfig routeLookupConfig, @Nullable Map<String, ?> routeLookupChannelServiceConfig,
+      ChildLoadBalancingPolicy policy) {
     this.routeLookupConfig = checkNotNull(routeLookupConfig, "routeLookupConfig");
+    this.routeLookupChannelServiceConfig = routeLookupChannelServiceConfig;
     this.policy = checkNotNull(policy, "policy");
   }
 
@@ -57,6 +64,11 @@ RouteLookupConfig getRouteLookupConfig() {
     return routeLookupConfig;
   }
 
+  @Nullable
+  Map<String, ?> getRouteLookupChannelServiceConfig() {
+    return routeLookupChannelServiceConfig;
+  }
+
   ChildLoadBalancingPolicy getLoadBalancingPolicy() {
     return policy;
   }
@@ -71,18 +83,20 @@ public boolean equals(Object o) {
     }
     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, policy);
+    return Objects.hash(routeLookupConfig, routeLookupChannelServiceConfig, policy);
   }
 
   @Override
   public String toString() {
     return MoreObjects.toStringHelper(this)
         .add("routeLookupConfig", routeLookupConfig)
+        .add("routeLookupChannelServiceConfig", routeLookupChannelServiceConfig)
         .add("policy", policy)
         .toString();
   }
@@ -189,33 +203,68 @@ public String toString() {
     }
   }
 
-  /** Factory for {@link ChildPolicyWrapper}. */
+  /** 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 ChildLbStatusListener childLbStatusListener;
+    private final ChildLoadBalancingPolicy childPolicy;
+    private ResolvedAddressFactory childLbResolvedAddressFactory;
 
     public RefCountedChildPolicyWrapperFactory(
-        ChildLoadBalancerHelperProvider childLbHelperProvider,
-        ChildLbStatusListener childLbStatusListener) {
+        ChildLoadBalancingPolicy childPolicy,
+        ResolvedAddressFactory childLbResolvedAddressFactory,
+        ChildLoadBalancerHelperProvider childLbHelperProvider) {
+      this.childPolicy = checkNotNull(childPolicy, "childPolicy");
+      this.childLbResolvedAddressFactory =
+          checkNotNull(childLbResolvedAddressFactory, "childLbResolvedAddressFactory");
       this.childLbHelperProvider = checkNotNull(childLbHelperProvider, "childLbHelperProvider");
-      this.childLbStatusListener = checkNotNull(childLbStatusListener, "childLbStatusListener");
+    }
+
+    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, childLbHelperProvider, childLbStatusListener);
+        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;
       }
+    }
 
-      return pooledChildPolicyWrapper.getObject();
+    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) {
@@ -238,16 +287,44 @@ 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,
-        ChildLoadBalancerHelperProvider childLbHelperProvider,
-        ChildLbStatusListener childLbStatusListener) {
+        ChildLoadBalancingPolicy childPolicy,
+        ChildLoadBalancerHelperProvider childLbHelperProvider) {
       this.target = target;
-      this.helper =
-          new ChildPolicyReportingHelper(childLbHelperProvider, childLbStatusListener);
+      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() {
@@ -262,8 +339,30 @@ ChildPolicyReportingHelper getHelper() {
       return helper;
     }
 
+    public ConnectivityState getState() {
+      return state;
+    }
+
     void refreshState() {
-      helper.updateBalancingState(state, picker);
+      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
@@ -284,14 +383,11 @@ public String toString() {
     final class ChildPolicyReportingHelper extends ForwardingLoadBalancerHelper {
 
       private final ChildLoadBalancerHelper delegate;
-      private final ChildLbStatusListener listener;
 
       ChildPolicyReportingHelper(
-          ChildLoadBalancerHelperProvider childHelperProvider,
-          ChildLbStatusListener listener) {
+          ChildLoadBalancerHelperProvider childHelperProvider) {
         checkNotNull(childHelperProvider, "childHelperProvider");
         this.delegate = childHelperProvider.forTarget(getTarget());
-        this.listener = checkNotNull(listener, "listener");
       }
 
       @Override
@@ -304,22 +400,14 @@ public void updateBalancingState(ConnectivityState newState, SubchannelPicker ne
         picker = newPicker;
         state = newState;
         super.updateBalancingState(newState, newPicker);
-        listener.onStatusChanged(newState);
       }
     }
   }
 
-  /** Listener for child lb status change events. */
-  interface ChildLbStatusListener {
-
-    /** Notifies when child lb status changes. */
-    void onStatusChanged(ConnectivityState newState);
-  }
-
   private static final class RefCountedChildPolicyWrapper
       implements ObjectPool<ChildPolicyWrapper> {
 
-    private final AtomicLong refCnt = new AtomicLong();
+    private long refCnt;
     @Nullable
     private ChildPolicyWrapper childPolicyWrapper;
 
@@ -330,7 +418,7 @@ private RefCountedChildPolicyWrapper(ChildPolicyWrapper childPolicyWrapper) {
     @Override
     public ChildPolicyWrapper getObject() {
       checkState(!isReleased(), "ChildPolicyWrapper is already released");
-      refCnt.getAndIncrement();
+      refCnt++;
       return childPolicyWrapper;
     }
 
@@ -343,9 +431,10 @@ public ChildPolicyWrapper returnObject(Object object) {
       checkState(
           childPolicyWrapper == object,
           "returned object doesn't match the pooled childPolicyWrapper");
-      long newCnt = refCnt.decrementAndGet();
+      long newCnt = --refCnt;
       checkState(newCnt != -1, "Cannot return never pooled childPolicyWrapper");
       if (newCnt == 0) {
+        childPolicyWrapper.shutdown();
         childPolicyWrapper = null;
       }
       return null;
@@ -363,7 +452,7 @@ static RefCountedChildPolicyWrapper of(ChildPolicyWrapper childPolicyWrapper) {
     public String toString() {
       return MoreObjects.toStringHelper(this)
           .add("object", childPolicyWrapper)
-          .add("refCnt", refCnt.get())
+          .add("refCnt", refCnt)
           .toString();
     }
   }
diff --git a/rls/src/main/java/io/grpc/rls/LinkedHashLruCache.java b/rls/src/main/java/io/grpc/rls/LinkedHashLruCache.java
index 2d60f103a60..9a961759693 100644
--- a/rls/src/main/java/io/grpc/rls/LinkedHashLruCache.java
+++ b/rls/src/main/java/io/grpc/rls/LinkedHashLruCache.java
@@ -21,7 +21,8 @@
 import static com.google.common.base.Preconditions.checkState;
 
 import com.google.common.base.MoreObjects;
-import io.grpc.internal.TimeProvider;
+import com.google.common.base.Ticker;
+import com.google.errorprone.annotations.CheckReturnValue;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Iterator;
@@ -29,46 +30,32 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
-import java.util.concurrent.ScheduledExecutorService;
-import java.util.concurrent.ScheduledFuture;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicLong;
-import javax.annotation.CheckReturnValue;
 import javax.annotation.Nullable;
-import javax.annotation.concurrent.GuardedBy;
-import javax.annotation.concurrent.ThreadSafe;
 
 /**
  * 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. On top of this, LruCache also proactively removes
- * expired entries based on configured time interval.
+ * it will remove based on access order of entry. To proactively clean up expired entries, call
+ * {@link #cleanupExpiredEntries()} (e.g., via a recurring timer).
  */
-@ThreadSafe
 abstract class LinkedHashLruCache<K, V> implements LruCache<K, V> {
 
-  private final Object lock = new Object();
-
-  @GuardedBy("lock")
   private final LinkedHashMap<K, SizedValue> delegate;
-  private final PeriodicCleaner periodicCleaner;
-  private final TimeProvider timeProvider;
-  private final EvictionListener<K, SizedValue> evictionListener;
-  private final AtomicLong estimatedSizeBytes = new AtomicLong();
+  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,
-      int cleaningInterval,
-      TimeUnit cleaningIntervalUnit,
-      ScheduledExecutorService ses,
-      final TimeProvider timeProvider) {
+      final Ticker ticker) {
     checkState(estimatedMaxSizeBytes > 0, "max estimated cache size should be positive");
     this.estimatedMaxSizeBytes = estimatedMaxSizeBytes;
-    this.evictionListener = new SizeHandlingEvictionListener(evictionListener);
-    this.timeProvider = checkNotNull(timeProvider, "timeProvider");
+    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),
@@ -76,15 +63,15 @@ abstract class LinkedHashLruCache<K, V> implements LruCache<K, V> {
         /* accessOrder= */ true) {
       @Override
       protected boolean removeEldestEntry(Map.Entry<K, SizedValue> eldest) {
-        if (estimatedSizeBytes.get() <= LinkedHashLruCache.this.estimatedMaxSizeBytes) {
+        if (estimatedSizeBytes <= LinkedHashLruCache.this.estimatedMaxSizeBytes) {
           return false;
         }
 
         // first, remove at most 1 expired entry
-        boolean removed = cleanupExpiredEntries(1, timeProvider.currentTimeNanos());
+        boolean removed = cleanupExpiredEntries(1, ticker.read());
         // handles size based eviction if necessary no expired entry
-        boolean shouldRemove =
-            !removed && shouldInvalidateEldestEntry(eldest.getKey(), eldest.getValue().value);
+        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);
@@ -92,7 +79,6 @@ protected boolean removeEldestEntry(Map.Entry<K, SizedValue> eldest) {
         return false;
       }
     };
-    periodicCleaner = new PeriodicCleaner(ses, cleaningInterval, cleaningIntervalUnit).start();
   }
 
   /**
@@ -100,7 +86,7 @@ protected boolean removeEldestEntry(Map.Entry<K, SizedValue> eldest) {
    * that LruCache is access level and the eldest is determined by access pattern.
    */
   @SuppressWarnings("unused")
-  protected boolean shouldInvalidateEldestEntry(K eldestKey, V eldestValue) {
+  protected boolean shouldInvalidateEldestEntry(K eldestKey, V eldestValue, long now) {
     return true;
   }
 
@@ -116,18 +102,20 @@ 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) {
-    synchronized (lock) {
-      SizedValue entry = readInternal(key);
-      if (entry == null) {
-        return;
-      }
-      int prevSize = entry.size;
-      int newSize = estimateSizeOf(key, entry.value);
-      entry.size = newSize;
-      estimatedSizeBytes.addAndGet(newSize - prevSize);
+    SizedValue entry = readInternal(key);
+    if (entry == null) {
+      return;
     }
+    int prevSize = entry.size;
+    int newSize = estimateSizeOf(key, entry.value);
+    entry.size = newSize;
+    estimatedSizeBytes += newSize - prevSize;
   }
 
   /**
@@ -135,7 +123,7 @@ public void updateEntrySize(K key) {
    * #estimateSizeOf(java.lang.Object, java.lang.Object)}.
    */
   public long estimatedSizeBytes() {
-    return estimatedSizeBytes.get();
+    return estimatedSizeBytes;
   }
 
   @Override
@@ -145,12 +133,10 @@ public final V cache(K key, V value) {
     checkNotNull(value, "value");
     SizedValue existing;
     int size = estimateSizeOf(key, value);
-    synchronized (lock) {
-      estimatedSizeBytes.addAndGet(size);
-      existing = delegate.put(key, new SizedValue(size, value));
-      if (existing != null) {
-        evictionListener.onEviction(key, existing, EvictionType.REPLACED);
-      }
+    estimatedSizeBytes += size;
+    existing = delegate.put(key, new SizedValue(size, value));
+    if (existing != null) {
+      fireOnEviction(key, existing, EvictionType.REPLACED);
     }
     return existing == null ? null : existing.value;
   }
@@ -170,14 +156,11 @@ public final V read(K key) {
   @CheckReturnValue
   private SizedValue readInternal(K key) {
     checkNotNull(key, "key");
-    synchronized (lock) {
-      SizedValue existing = delegate.get(key);
-      if (existing != null && isExpired(key, existing.value, timeProvider.currentTimeNanos())) {
-        invalidate(key, EvictionType.EXPIRED);
-        return null;
-      }
-      return existing;
+    SizedValue existing = delegate.get(key);
+    if (existing != null && isExpired(key, existing.value, ticker.read())) {
+      return null;
     }
+    return existing;
   }
 
   @Override
@@ -190,25 +173,22 @@ public final V invalidate(K key) {
   private V invalidate(K key, EvictionType cause) {
     checkNotNull(key, "key");
     checkNotNull(cause, "cause");
-    synchronized (lock) {
-      SizedValue existing = delegate.remove(key);
-      if (existing != null) {
-        evictionListener.onEviction(key, existing, cause);
-      }
-      return existing == null ? null : existing.value;
+    SizedValue existing = delegate.remove(key);
+    if (existing != null) {
+      fireOnEviction(key, existing, cause);
     }
+    return existing == null ? null : existing.value;
   }
 
   @Override
-  public final void invalidateAll(Iterable<K> keys) {
-    checkNotNull(keys, "keys");
-    synchronized (lock) {
-      for (K key : keys) {
-        SizedValue existing = delegate.remove(key);
-        if (existing != null) {
-          evictionListener.onEviction(key, existing, EvictionType.EXPLICIT);
-        }
+  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();
     }
   }
 
@@ -221,47 +201,60 @@ public final boolean hasCacheEntry(K key) {
 
   /** Returns shallow copied values in the cache. */
   public final List<V> values() {
-    synchronized (lock) {
-      List<V> list = new ArrayList<>(delegate.size());
-      for (SizedValue value : delegate.values()) {
-        list.add(value.value);
-      }
-      return Collections.unmodifiableList(list);
+    List<V> list = new ArrayList<>(delegate.size());
+    for (SizedValue value : delegate.values()) {
+      list.add(value.value);
     }
+    return Collections.unmodifiableList(list);
   }
 
   /**
-   * Resizes cache. If new size is smaller than current estimated size, it will free up space by
+   * 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
    */
-  public final void resize(int newSizeBytes) {
-    long now = timeProvider.currentTimeNanos();
-    synchronized (lock) {
-      this.estimatedMaxSizeBytes = newSizeBytes;
-      if (estimatedSizeBytes.get() <= newSizeBytes) {
-        // new size is larger no need to do cleanup
-        return;
-      }
-      // cleanup expired entries
-      cleanupExpiredEntries(now);
-
-      // cleanup eldest entry until new size limit
-      Iterator<Map.Entry<K, SizedValue>> lruIter = delegate.entrySet().iterator();
-      while (lruIter.hasNext() && estimatedMaxSizeBytes < this.estimatedSizeBytes.get()) {
-        Map.Entry<K, SizedValue> entry = lruIter.next();
-        lruIter.remove();
-        // eviction listener will update the estimatedSizeBytes
-        evictionListener.onEviction(entry.getKey(), entry.getValue(), EvictionType.SIZE);
+  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() {
-    synchronized (lock) {
-      return delegate.size();
-    }
+    return delegate.size();
+  }
+
+  /** Returns {@code true} if any entries were removed. */
+  public final boolean cleanupExpiredEntries() {
+    return cleanupExpiredEntries(ticker.read());
   }
 
   private boolean cleanupExpiredEntries(long now) {
@@ -272,16 +265,14 @@ private boolean cleanupExpiredEntries(long now) {
   private boolean cleanupExpiredEntries(int maxExpiredEntries, long now) {
     checkArgument(maxExpiredEntries > 0, "maxExpiredEntries must be positive");
     boolean removedAny = false;
-    synchronized (lock) {
-      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();
-          evictionListener.onEviction(entry.getKey(), entry.getValue(), EvictionType.EXPIRED);
-          removedAny = true;
-          maxExpiredEntries--;
-        }
+    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;
@@ -289,68 +280,13 @@ private boolean cleanupExpiredEntries(int maxExpiredEntries, long now) {
 
   @Override
   public final void close() {
-    synchronized (lock) {
-      periodicCleaner.stop();
-      doClose();
-      delegate.clear();
-    }
+    invalidateAll();
   }
 
-  protected void doClose() {}
-
-  /** Periodically cleans up the AsyncRequestCache. */
-  private final class PeriodicCleaner {
-
-    private final ScheduledExecutorService ses;
-    private final int interval;
-    private final TimeUnit intervalUnit;
-    private ScheduledFuture<?> scheduledFuture;
-
-    PeriodicCleaner(ScheduledExecutorService ses, int interval, TimeUnit intervalUnit) {
-      this.ses = checkNotNull(ses, "ses");
-      checkState(interval > 0, "interval must be positive");
-      this.interval = interval;
-      this.intervalUnit = checkNotNull(intervalUnit, "intervalUnit");
-    }
-
-    PeriodicCleaner start() {
-      checkState(scheduledFuture == null, "cleaning task can be started only once");
-      this.scheduledFuture =
-          ses.scheduleAtFixedRate(new CleaningTask(), interval, interval, intervalUnit);
-      return this;
-    }
-
-    void stop() {
-      if (scheduledFuture != null) {
-        scheduledFuture.cancel(false);
-        scheduledFuture = null;
-      }
-    }
-
-    private class CleaningTask implements Runnable {
-
-      @Override
-      public void run() {
-        cleanupExpiredEntries(timeProvider.currentTimeNanos());
-      }
-    }
-  }
-
-  /** A {@link EvictionListener} keeps track of size. */
-  private final class SizeHandlingEvictionListener implements EvictionListener<K, SizedValue> {
-
-    private final EvictionListener<K, V> delegate;
-
-    SizeHandlingEvictionListener(@Nullable EvictionListener<K, V> delegate) {
-      this.delegate = delegate;
-    }
-
-    @Override
-    public void onEviction(K key, SizedValue value, EvictionType cause) {
-      estimatedSizeBytes.addAndGet(-1 * value.size);
-      if (delegate != null) {
-        delegate.onEviction(key, value.value, cause);
-      }
+  private void fireOnEviction(K key, SizedValue value, EvictionType cause) {
+    estimatedSizeBytes -= value.size;
+    if (evictionListener != null) {
+      evictionListener.onEviction(key, value.value, cause);
     }
   }
 
diff --git a/rls/src/main/java/io/grpc/rls/LruCache.java b/rls/src/main/java/io/grpc/rls/LruCache.java
index 6ab5c4bcb46..8fc4ae98472 100644
--- a/rls/src/main/java/io/grpc/rls/LruCache.java
+++ b/rls/src/main/java/io/grpc/rls/LruCache.java
@@ -16,7 +16,7 @@
 
 package io.grpc.rls;
 
-import javax.annotation.CheckReturnValue;
+import com.google.errorprone.annotations.CheckReturnValue;
 import javax.annotation.Nullable;
 
 /** An LruCache is a cache with least recently used eviction. */
@@ -49,10 +49,10 @@ interface LruCache<K, V> {
   V invalidate(K key);
 
   /**
-   * Invalidates cache entries for given keys. This operation will trigger {@link EvictionListener}
+   * Invalidates cache entries for all keys. This operation will trigger {@link EvictionListener}
    * with {@link EvictionType#EXPLICIT}.
    */
-  void invalidateAll(Iterable<K> keys);
+  void invalidateAll();
 
   /** Returns {@code true} if given key is cached. */
   @CheckReturnValue
diff --git a/rls/src/main/java/io/grpc/rls/RlsLoadBalancer.java b/rls/src/main/java/io/grpc/rls/RlsLoadBalancer.java
index 12903044a21..848199f50a8 100644
--- a/rls/src/main/java/io/grpc/rls/RlsLoadBalancer.java
+++ b/rls/src/main/java/io/grpc/rls/RlsLoadBalancer.java
@@ -19,7 +19,6 @@
 import static com.google.common.base.Preconditions.checkNotNull;
 
 import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.MoreObjects;
 import io.grpc.ChannelLogger;
 import io.grpc.ChannelLogger.ChannelLogLevel;
 import io.grpc.ConnectivityState;
@@ -49,16 +48,17 @@ final class RlsLoadBalancer extends LoadBalancer {
   }
 
   @Override
-  public void handleResolvedAddresses(ResolvedAddresses resolvedAddresses) {
-    logger.log(ChannelLogLevel.DEBUG, "Received resolution result: {0}", resolvedAddresses);
+  public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
     LbPolicyConfiguration lbPolicyConfiguration =
         (LbPolicyConfiguration) resolvedAddresses.getLoadBalancingPolicyConfig();
-    checkNotNull(lbPolicyConfiguration, "Missing rls lb config");
+    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().getLookupService().equals(
-          lbPolicyConfiguration.getRouteLookupConfig().getLookupService());
+          || !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();
         }
@@ -78,42 +78,34 @@ public void handleResolvedAddresses(ResolvedAddresses resolvedAddresses) {
       //  not required.
       this.lbPolicyConfiguration = lbPolicyConfiguration;
     }
+    return routeLookupClient.acceptResolvedAddressFactory(
+        new ChildLbResolvedAddressFactory(
+            resolvedAddresses.getAddresses(), resolvedAddresses.getAttributes()));
   }
 
   @Override
   public void requestConnection() {
-    routeLookupClient.requestConnection();
+    if (routeLookupClient != null) {
+      routeLookupClient.requestConnection();
+    }
   }
 
   @Override
   public void handleNameResolutionError(final Status error) {
-    logger.log(ChannelLogLevel.DEBUG, "Received resolution error: {0}", error);
-    class ErrorPicker extends SubchannelPicker {
-      @Override
-      public PickResult pickSubchannel(PickSubchannelArgs args) {
-        return PickResult.withError(error);
-      }
-
-      @Override
-      public String toString() {
-        return MoreObjects.toStringHelper(this)
-            .add("error", error)
-            .toString();
-      }
-    }
-
     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 ErrorPicker());
+    helper.updateBalancingState(
+        ConnectivityState.TRANSIENT_FAILURE, new FixedResultPicker(PickResult.withError(error)));
   }
 
   @Override
   public void shutdown() {
-    logger.log(ChannelLogLevel.DEBUG, "Rls lb shutdown");
     if (routeLookupClient != null) {
+      logger.log(ChannelLogLevel.DEBUG, "closing the routeLookupClient because of RLS LB shutdown");
       routeLookupClient.close();
       routeLookupClient = null;
     }
diff --git a/rls/src/main/java/io/grpc/rls/RlsLoadBalancerProvider.java b/rls/src/main/java/io/grpc/rls/RlsLoadBalancerProvider.java
index ca1ed714e82..d78f2d67fc0 100644
--- a/rls/src/main/java/io/grpc/rls/RlsLoadBalancerProvider.java
+++ b/rls/src/main/java/io/grpc/rls/RlsLoadBalancerProvider.java
@@ -30,9 +30,9 @@
 import java.util.Map;
 
 /**
- * The provider for the "rls-experimental" balancing policy.  This class should not be directly
+ * 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".
+ * io.grpc.LoadBalancerRegistry#getProvider} with the name "rls_experimental".
  */
 @Internal
 public final class RlsLoadBalancerProvider extends LoadBalancerProvider {
@@ -49,7 +49,7 @@ public int getPriority() {
 
   @Override
   public String getPolicyName() {
-    return "rls-experimental";
+    return "rls_experimental";
   }
 
   @Override
@@ -62,31 +62,18 @@ public ConfigOrError parseLoadBalancingPolicyConfig(Map<String, ?> rawLoadBalanc
     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"))));
-      // Checking all valid targets to make sure the config is always valid. This strict check
-      // prevents child policy to handle invalid child policy.
-      for (String validTarget : routeLookupConfig.getValidTargets()) {
-        ConfigOrError childPolicyConfigOrError =
-            lbPolicy
-                .getEffectiveLbProvider()
-                .parseLoadBalancingPolicyConfig(lbPolicy.getEffectiveChildPolicy(validTarget));
-        if (childPolicyConfigOrError.getError() != null) {
-          return
-              ConfigOrError.fromError(
-                  childPolicyConfigOrError
-                      .getError()
-                      .augmentDescription(
-                          "failed to parse childPolicy for validTarget: " + validTarget));
-        }
-      }
-      return ConfigOrError.fromConfig(new LbPolicyConfiguration(routeLookupConfig, lbPolicy));
+      return ConfigOrError.fromConfig(
+          new LbPolicyConfiguration(routeLookupConfig, routeLookupChannelServiceConfig, lbPolicy));
     } catch (Exception e) {
       return ConfigOrError.fromError(
-          Status.INVALID_ARGUMENT
+          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
index baf7fa0dbac..70f9fb4d891 100644
--- a/rls/src/main/java/io/grpc/rls/RlsProtoConverters.java
+++ b/rls/src/main/java/io/grpc/rls/RlsProtoConverters.java
@@ -18,19 +18,28 @@
 
 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.concurrent.TimeUnit;
+import java.util.Set;
 import javax.annotation.Nullable;
 
 /**
@@ -39,6 +48,12 @@
  */
 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}.
@@ -48,22 +63,19 @@ static final class RouteLookupRequestConverter
 
     @Override
     protected RlsProtoData.RouteLookupRequest doForward(RouteLookupRequest routeLookupRequest) {
-      return
-          new RlsProtoData.RouteLookupRequest(
-              /* server= */ routeLookupRequest.getServer(),
-              /* path= */ routeLookupRequest.getPath(),
-              /* targetType= */ routeLookupRequest.getTargetType(),
-              routeLookupRequest.getKeyMapMap());
+      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()
-              .setServer(routeLookupRequest.getServer())
-              .setPath(routeLookupRequest.getPath())
-              .setTargetType(routeLookupRequest.getTargetType())
-              .putAllKeyMap(routeLookupRequest.getKeyMap())
+              .setTargetType("grpc")
+              .setReason(RouteLookupRequest.Reason.valueOf(routeLookupRequest.reason().name()))
+              .putAllKeyMap(routeLookupRequest.keyMap())
               .build();
     }
   }
@@ -78,15 +90,15 @@ static final class RouteLookupResponseConverter
     @Override
     protected RlsProtoData.RouteLookupResponse doForward(RouteLookupResponse routeLookupResponse) {
       return
-          new RlsProtoData.RouteLookupResponse(
-              routeLookupResponse.getTargetsList(),
+          RlsProtoData.RouteLookupResponse.create(
+              ImmutableList.copyOf(routeLookupResponse.getTargetsList()),
               routeLookupResponse.getHeaderData());
     }
 
     @Override
     protected RouteLookupResponse doBackward(RlsProtoData.RouteLookupResponse routeLookupResponse) {
       return RouteLookupResponse.newBuilder()
-          .addAllTargets(routeLookupResponse.getTargets())
+          .addAllTargets(routeLookupResponse.targets())
           .setHeaderData(routeLookupResponse.getHeaderData())
           .build();
     }
@@ -100,33 +112,77 @@ static final class RouteLookupConfigConverter
 
     @Override
     protected RouteLookupConfig doForward(Map<String, ?> json) {
-      List<GrpcKeyBuilder> grpcKeyBuilders =
-          GrpcKeyBuilderConverter
-              .covertAll(JsonUtil.checkObjectList(JsonUtil.getList(json, "grpcKeyBuilders")));
+      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");
-      long timeout =
-          TimeUnit.SECONDS.toMillis(
-              orDefault(
-                  JsonUtil.getNumberAsLong(json, "lookupServiceTimeout"),
-                  0L));
-      Long maxAge =
-          convertTimeIfNotNull(
-              TimeUnit.SECONDS, TimeUnit.MILLISECONDS, JsonUtil.getNumberAsLong(json, "maxAge"));
-      Long staleAge =
-          convertTimeIfNotNull(
-              TimeUnit.SECONDS, TimeUnit.MILLISECONDS, JsonUtil.getNumberAsLong(json, "staleAge"));
-      long cacheSize = orDefault(JsonUtil.getNumberAsLong(json, "cacheSizeBytes"), Long.MAX_VALUE);
-      List<String> validTargets = JsonUtil.checkStringList(JsonUtil.getList(json, "validTargets"));
-      String defaultTarget = JsonUtil.getString(json, "defaultTarget");
-      return new RouteLookupConfig(
-          grpcKeyBuilders,
-          lookupService,
-          /* lookupServiceTimeoutInMillis= */ timeout,
-          /* maxAgeInMillis= */ maxAge,
-          /* staleAgeInMillis= */ staleAge,
-          /* cacheSizeBytes= */ cacheSize,
-          validTargets,
-          defaultTarget);
+      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) {
@@ -136,52 +192,82 @@ private static <T> T orDefault(@Nullable T value, T defaultValue) {
       return value;
     }
 
-    private static Long convertTimeIfNotNull(TimeUnit from, TimeUnit to, Long value) {
-      if (value == null) {
-        return null;
-      }
-      return to.convert(value, from);
-    }
-
     @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 List<GrpcKeyBuilder> covertAll(List<Map<String, ?>> keyBuilders) {
-      List<GrpcKeyBuilder> keyBuilderList = new ArrayList<>();
+    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;
+      return keyBuilderList.build();
     }
 
     @SuppressWarnings("unchecked")
     static GrpcKeyBuilder convert(Map<String, ?> keyBuilder) {
-      List<Map<String, ?>> rawNames =
-          JsonUtil.checkObjectList(JsonUtil.getList(keyBuilder, "names"));
-      List<Name> names = new ArrayList<>();
+      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) {
-        names.add(
-            new Name(
-                JsonUtil.getString(rawName, "service"), JsonUtil.getString(rawName, "method")));
+        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 =
-          JsonUtil.checkObjectList(JsonUtil.getList(keyBuilder, "headers"));
-      List<NameMatcher> nameMatchers = new ArrayList<>();
+          rawRawHeaders == null
+              ? new ArrayList<Map<String, ?>>() : JsonUtil.checkObjectList(rawRawHeaders);
+      ImmutableList.Builder<NameMatcher> nameMatchersBuilder = ImmutableList.builder();
       for (Map<String, ?> rawHeader : rawHeaders) {
-        NameMatcher matcher =
-            new NameMatcher(
-                JsonUtil.getString(rawHeader, "key"),
-                (List<String>) rawHeader.get("names"),
-                (Boolean) rawHeader.get("optional"));
+        Boolean requiredMatch = JsonUtil.getBoolean(rawHeader, "requiredMatch");
         checkArgument(
-            matcher.isOptional(), "NameMatcher for GrpcKeyBuilders shouldn't be required");
-        nameMatchers.add(matcher);
+            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);
       }
-      return new GrpcKeyBuilder(names, nameMatchers);
+      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");
     }
   }
 
diff --git a/rls/src/main/java/io/grpc/rls/RlsProtoData.java b/rls/src/main/java/io/grpc/rls/RlsProtoData.java
index fbcb6feb21c..39c404870f9 100644
--- a/rls/src/main/java/io/grpc/rls/RlsProtoData.java
+++ b/rls/src/main/java/io/grpc/rls/RlsProtoData.java
@@ -16,227 +16,84 @@
 
 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.Objects;
+import com.google.auto.value.AutoValue;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
-import io.grpc.rls.RlsProtoData.GrpcKeyBuilder.Name;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.concurrent.TimeUnit;
 import javax.annotation.Nullable;
 import javax.annotation.concurrent.Immutable;
 
 /** RlsProtoData is a collection of internal representation of RouteLookupService proto messages. */
 final class RlsProtoData {
 
-  /** A request object sent to route lookup service. */
-  @Immutable
-  static final class RouteLookupRequest {
-
-    private final String server;
+  private RlsProtoData() {}
 
-    private final String path;
-
-    private final String targetType;
+  /** A key object for the Rls route lookup data cache. */
+  @AutoValue
+  @Immutable
+  abstract static class RouteLookupRequestKey {
 
-    private final ImmutableMap<String, String> keyMap;
+    /** Returns a map of key values extracted via key builders for the gRPC or HTTP request. */
+    abstract ImmutableMap<String, String> keyMap();
 
-    RouteLookupRequest(
-        String server, String path, String targetType, Map<String, String> keyMap) {
-      this.server = checkNotNull(server, "server");
-      this.path = checkNotNull(path, "path");
-      this.targetType = checkNotNull(targetType, "targetName");
-      this.keyMap = ImmutableMap.copyOf(checkNotNull(keyMap, "keyMap"));
+    static RouteLookupRequestKey create(ImmutableMap<String, String> keyMap) {
+      return new AutoValue_RlsProtoData_RouteLookupRequestKey(keyMap);
     }
+  }
 
-    /**
-     * Returns a full host name of the target server, {@literal e.g.} firestore.googleapis.com. Only
-     * set for gRPC requests; HTTP requests must use key_map explicitly.
-     */
-    String getServer() {
-      return server;
-    }
+  /** A request object sent to route lookup service. */
+  @AutoValue
+  @Immutable
+  abstract static class RouteLookupRequest {
 
-    /**
-     * Returns a full path of the request, {@literal i.e.} "/service/method". Only set for gRPC
-     * requests; HTTP requests must use key_map explicitly.
-     */
-    String getPath() {
-      return path;
+    /** 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;
     }
 
-    /**
-     * Returns the 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, {@literal e.g.} "grpc".
-     */
-    String getTargetType() {
-      return targetType;
-    }
+    /** Reason for making this request. */
+    abstract Reason reason();
 
     /** Returns a map of key values extracted via key builders for the gRPC or HTTP request. */
-    ImmutableMap<String, String> getKeyMap() {
-      return keyMap;
-    }
-
-    @Override
-    public boolean equals(Object o) {
-      if (this == o) {
-        return true;
-      }
-      if (o == null || getClass() != o.getClass()) {
-        return false;
-      }
-      RouteLookupRequest that = (RouteLookupRequest) o;
-      return Objects.equal(server, that.server)
-          && Objects.equal(path, that.path)
-          && Objects.equal(targetType, that.targetType)
-          && Objects.equal(keyMap, that.keyMap);
-    }
+    abstract ImmutableMap<String, String> keyMap();
 
-    @Override
-    public int hashCode() {
-      return Objects.hashCode(server, path, targetType, keyMap);
-    }
-
-    @Override
-    public String toString() {
-      return MoreObjects.toStringHelper(this)
-          .add("server", server)
-          .add("path", path)
-          .add("targetName", targetType)
-          .add("keyMap", keyMap)
-          .toString();
+    static RouteLookupRequest create(ImmutableMap<String, String> keyMap, Reason reason) {
+      return new AutoValue_RlsProtoData_RouteLookupRequest(reason, keyMap);
     }
   }
 
   /** A response from route lookup service. */
+  @AutoValue
   @Immutable
-  static final class RouteLookupResponse {
-
-    private final ImmutableList<String> targets;
-
-    private final String headerData;
-
-    RouteLookupResponse(List<String> targets, String headerData) {
-      checkState(targets != null && !targets.isEmpty(), "targets cannot be empty or null");
-      this.targets = ImmutableList.copyOf(targets);
-      this.headerData = checkNotNull(headerData, "headerData");
-    }
+  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.
      */
-    ImmutableList<String> getTargets() {
-      return targets;
-    }
+    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.
      */
-    String getHeaderData() {
-      return headerData;
-    }
-
-    @Override
-    public boolean equals(Object o) {
-      if (this == o) {
-        return true;
-      }
-      if (o == null || getClass() != o.getClass()) {
-        return false;
-      }
-      RouteLookupResponse that = (RouteLookupResponse) o;
-      return java.util.Objects.equals(targets, that.targets)
-          && java.util.Objects.equals(headerData, that.headerData);
-    }
-
-    @Override
-    public int hashCode() {
-      return java.util.Objects.hash(targets, headerData);
-    }
+    abstract String getHeaderData();
 
-    @Override
-    public String toString() {
-      return MoreObjects.toStringHelper(this)
-          .add("targets", targets)
-          .add("headerData", headerData)
-          .toString();
+    static RouteLookupResponse create(ImmutableList<String> targets, String getHeaderData) {
+      return new AutoValue_RlsProtoData_RouteLookupResponse(targets, getHeaderData);
     }
   }
 
   /** A config object for gRPC RouteLookupService. */
+  @AutoValue
   @Immutable
-  static final class RouteLookupConfig {
-
-    private static final long MAX_AGE_MILLIS = TimeUnit.MINUTES.toMillis(5);
-
-    private final ImmutableList<GrpcKeyBuilder> grpcKeyBuilders;
-
-    private final String lookupService;
-
-    private final long lookupServiceTimeoutInMillis;
-
-    private final long maxAgeInMillis;
-
-    private final long staleAgeInMillis;
-
-    private final long cacheSizeBytes;
-
-    private final ImmutableList<String> validTargets;
-
-    @Nullable
-    private final String defaultTarget;
-
-    RouteLookupConfig(
-        List<GrpcKeyBuilder> grpcKeyBuilders,
-        String lookupService,
-        long lookupServiceTimeoutInMillis,
-        @Nullable Long maxAgeInMillis,
-        @Nullable Long staleAgeInMillis,
-        long cacheSizeBytes,
-        List<String> validTargets,
-        @Nullable
-        String defaultTarget) {
-      checkState(
-          !checkNotNull(grpcKeyBuilders, "grpcKeyBuilders").isEmpty(),
-          "must have at least one GrpcKeyBuilder");
-      checkUniqueName(grpcKeyBuilders);
-      this.grpcKeyBuilders = ImmutableList.copyOf(grpcKeyBuilders);
-      // TODO(creamsoup) also check if it is URI
-      checkState(
-          lookupService != null && !lookupService.isEmpty(), "lookupService must not be empty");
-      this.lookupService = lookupService;
-      checkState(
-          lookupServiceTimeoutInMillis > 0, "lookupServiceTimeoutInMillis should be positive");
-      this.lookupServiceTimeoutInMillis = lookupServiceTimeoutInMillis;
-      if (maxAgeInMillis == null) {
-        checkState(
-            staleAgeInMillis == null, "To specify staleAgeInMillis, must have maxAgeInMillis");
-      }
-      if (maxAgeInMillis == null || maxAgeInMillis == 0) {
-        maxAgeInMillis = MAX_AGE_MILLIS;
-      }
-      if (staleAgeInMillis == null || staleAgeInMillis == 0) {
-        staleAgeInMillis = MAX_AGE_MILLIS;
-      }
-      this.maxAgeInMillis = Math.min(maxAgeInMillis, MAX_AGE_MILLIS);
-      this.staleAgeInMillis = Math.min(staleAgeInMillis, this.maxAgeInMillis);
-      checkArgument(cacheSizeBytes > 0, "cacheSize must be positive");
-      this.cacheSizeBytes = cacheSizeBytes;
-      this.validTargets = ImmutableList.copyOf(checkNotNull(validTargets, "validTargets"));
-      this.defaultTarget = defaultTarget;
-    }
+  abstract static class RouteLookupConfig {
 
     /**
      * Returns unordered specifications for constructing keys for gRPC requests. All GrpcKeyBuilders
@@ -244,36 +101,25 @@ static final class RouteLookupConfig {
      * 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.
      */
-    ImmutableList<GrpcKeyBuilder> getGrpcKeyBuilders() {
-      return grpcKeyBuilders;
-    }
+    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".
      */
-    String getLookupService() {
-      return lookupService;
-    }
+    abstract String lookupService();
 
     /** Returns the timeout value for lookup service requests. */
-    long getLookupServiceTimeoutInMillis() {
-      return lookupServiceTimeoutInMillis;
-    }
-
+    abstract long lookupServiceTimeoutInNanos();
 
     /** Returns the maximum age the result will be cached. */
-    long getMaxAgeInMillis() {
-      return maxAgeInMillis;
-    }
+    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
      */
-    long getStaleAgeInMillis() {
-      return staleAgeInMillis;
-    }
+    abstract long staleAgeInNanos();
 
     /**
      * Returns a rough indicator of amount of memory to use for the client cache. Some of the data
@@ -281,18 +127,7 @@ long getStaleAgeInMillis() {
      * 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.
      */
-    long getCacheSizeBytes() {
-      return cacheSizeBytes;
-    }
-
-    /**
-     * Returns the 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 RPC error from the
-     * RLS.
-     */
-    ImmutableList<String> getValidTargets() {
-      return validTargets;
-    }
+    abstract long cacheSizeBytes();
 
     /**
      * Returns the default target to use if needed.  If nonempty (implies request processing
@@ -300,62 +135,31 @@ ImmutableList<String> getValidTargets() {
      * error.  Note that requests can be routed only to a subdomain of the original target,
      * {@literal e.g.} "us_east_1.cloudbigtable.googleapis.com".
      */
-    String getDefaultTarget() {
-      return defaultTarget;
-    }
+    @Nullable
+    abstract String defaultTarget();
 
-    @Override
-    public boolean equals(Object o) {
-      if (this == o) {
-        return true;
-      }
-      if (o == null || getClass() != o.getClass()) {
-        return false;
-      }
-      RouteLookupConfig that = (RouteLookupConfig) o;
-      return lookupServiceTimeoutInMillis == that.lookupServiceTimeoutInMillis
-          && maxAgeInMillis == that.maxAgeInMillis
-          && staleAgeInMillis == that.staleAgeInMillis
-          && cacheSizeBytes == that.cacheSizeBytes
-          && Objects.equal(grpcKeyBuilders, that.grpcKeyBuilders)
-          && Objects.equal(lookupService, that.lookupService)
-          && Objects.equal(defaultTarget, that.defaultTarget);
+    static Builder builder() {
+      return new AutoValue_RlsProtoData_RouteLookupConfig.Builder();
     }
 
-    @Override
-    public int hashCode() {
-      return Objects.hashCode(
-          grpcKeyBuilders,
-          lookupService,
-          lookupServiceTimeoutInMillis,
-          maxAgeInMillis,
-          staleAgeInMillis,
-          cacheSizeBytes,
-          defaultTarget);
-    }
+    @AutoValue.Builder
+    abstract static class Builder {
 
-    @Override
-    public String toString() {
-      return MoreObjects.toStringHelper(this)
-          .add("grpcKeyBuilders", grpcKeyBuilders)
-          .add("lookupService", lookupService)
-          .add("lookupServiceTimeoutInMillis", lookupServiceTimeoutInMillis)
-          .add("maxAgeInMillis", maxAgeInMillis)
-          .add("staleAgeInMillis", staleAgeInMillis)
-          .add("cacheSize", cacheSizeBytes)
-          .add("defaultTarget", defaultTarget)
-          .toString();
-    }
-  }
+      abstract Builder grpcKeybuilders(ImmutableList<GrpcKeyBuilder> grpcKeybuilders);
 
-  private static void checkUniqueName(List<GrpcKeyBuilder> grpcKeyBuilders) {
-    Set<Name> names = new HashSet<>();
-    for (GrpcKeyBuilder grpcKeyBuilder : grpcKeyBuilders) {
-      int prevSize = names.size();
-      names.addAll(grpcKeyBuilder.getNames());
-      if (names.size() != prevSize + grpcKeyBuilder.getNames().size()) {
-        throw new IllegalStateException("Names in the GrpcKeyBuilders should be unique");
-      }
+      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();
     }
   }
 
@@ -364,87 +168,25 @@ private static void checkUniqueName(List<GrpcKeyBuilder> grpcKeyBuilders) {
    * 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
-  static final class NameMatcher {
-
-    private final String key;
-
-    private final ImmutableList<String> names;
-
-    private final boolean optional;
-
-    NameMatcher(String key, List<String> names, @Nullable Boolean optional) {
-      this.key = checkNotNull(key, "key");
-      this.names = ImmutableList.copyOf(checkNotNull(names, "names"));
-      this.optional = optional != null ? optional : true;
-    }
+  abstract static class NameMatcher {
 
     /** The name that will be used in the RLS key_map to refer to this value. */
-    String getKey() {
-      return key;
-    }
+    abstract String key();
 
     /** Returns ordered list of names; the first non-empty value will be used. */
-    ImmutableList<String> names() {
-      return names;
-    }
-
-    /**
-     * Indicates if this extraction optional. A key builder will still match if no value is found.
-     */
-    boolean isOptional() {
-      return optional;
-    }
-
-    @Override
-    public boolean equals(Object o) {
-      if (this == o) {
-        return true;
-      }
-      if (o == null || getClass() != o.getClass()) {
-        return false;
-      }
-      NameMatcher matcher = (NameMatcher) o;
-      return optional == matcher.optional
-          && java.util.Objects.equals(key, matcher.key)
-          && java.util.Objects.equals(names, matcher.names);
-    }
-
-    @Override
-    public int hashCode() {
-      return java.util.Objects.hash(key, names, optional);
-    }
+    abstract ImmutableList<String> names();
 
-    @Override
-    public String toString() {
-      return MoreObjects.toStringHelper(this)
-          .add("key", key)
-          .add("names", names)
-          .add("optional", optional)
-          .toString();
+    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. */
-  static final class GrpcKeyBuilder {
-
-    private final ImmutableList<Name> names;
-
-    private final ImmutableList<NameMatcher> headers;
-
-    public GrpcKeyBuilder(List<Name> names, List<NameMatcher> headers) {
-      checkState(names != null && !names.isEmpty(), "names cannot be empty");
-      this.names = ImmutableList.copyOf(names);
-      checkUniqueKey(checkNotNull(headers, "headers"));
-      this.headers = ImmutableList.copyOf(headers);
-    }
-
-    private static void checkUniqueKey(List<NameMatcher> headers) {
-      Set<String> names = new HashSet<>();
-      for (NameMatcher header :  headers) {
-        checkState(names.add(header.key), "key in headers must be unique");
-      }
-    }
+  @AutoValue
+  @Immutable
+  abstract static class GrpcKeyBuilder {
 
     /**
      * Returns names. To match, one of the given Name fields must match; the service and method
@@ -452,41 +194,23 @@ private static void checkUniqueKey(List<NameMatcher> headers) {
      * package name. The method name may be omitted, in which case any method on the given service
      * is matched.
      */
-    ImmutableList<Name> getNames() {
-      return names;
-    }
+    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.
      */
-    ImmutableList<NameMatcher> getHeaders() {
-      return headers;
-    }
+    abstract ImmutableList<NameMatcher> headers();
 
-    @Override
-    public boolean equals(Object o) {
-      if (this == o) {
-        return true;
-      }
-      if (o == null || getClass() != o.getClass()) {
-        return false;
-      }
-      GrpcKeyBuilder that = (GrpcKeyBuilder) o;
-      return Objects.equal(names, that.names) && Objects.equal(headers, that.headers);
-    }
+    abstract ExtraKeys extraKeys();
 
-    @Override
-    public int hashCode() {
-      return Objects.hashCode(names, headers);
-    }
+    abstract ImmutableMap<String, String> constantKeys();
 
-    @Override
-    public String toString() {
-      return MoreObjects.toStringHelper(this)
-          .add("names", names)
-          .add("headers", headers)
-          .toString();
+    static GrpcKeyBuilder create(
+        ImmutableList<Name> names,
+        ImmutableList<NameMatcher> headers,
+        ExtraKeys extraKeys, ImmutableMap<String, String> constantKeys) {
+      return new AutoValue_RlsProtoData_GrpcKeyBuilder(names, headers, extraKeys, constantKeys);
     }
 
     /**
@@ -495,57 +219,35 @@ public String toString() {
      * required and includes the proto package name. The method name may be omitted, in which case
      * any method on the given service is matched.
      */
-    static final class Name {
+    @AutoValue
+    @Immutable
+    abstract static class Name {
 
-      private final String service;
+      abstract String service();
 
-      private final String method;
+      @Nullable
+      abstract String method();
 
-      Name(String service) {
-        this(service, "*");
-      }
-
-      Name(String service, String method) {
-        checkState(
-            !checkNotNull(service, "service").isEmpty(),
-            "service must not be empty or null");
-        this.service = service;
-        this.method = method;
+      static Name create(String service, @Nullable String method) {
+        return new AutoValue_RlsProtoData_GrpcKeyBuilder_Name(service, method);
       }
+    }
+  }
 
-      String getService() {
-        return service;
-      }
+  @AutoValue
+  @Immutable
+  abstract static class ExtraKeys {
+    static final ExtraKeys DEFAULT = create(null, null, null);
 
-      String getMethod() {
-        return method;
-      }
+    @Nullable abstract String host();
 
-      @Override
-      public boolean equals(Object o) {
-        if (this == o) {
-          return true;
-        }
-        if (o == null || getClass() != o.getClass()) {
-          return false;
-        }
-        Name name = (Name) o;
-        return Objects.equal(service, name.service)
-            && Objects.equal(method, name.method);
-      }
+    @Nullable abstract String service();
 
-      @Override
-      public int hashCode() {
-        return Objects.hashCode(service, method);
-      }
+    @Nullable abstract String method();
 
-      @Override
-      public String toString() {
-        return MoreObjects.toStringHelper(this)
-            .add("service", service)
-            .add("method", method)
-            .toString();
-      }
+    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
index b9bcb037cf5..1fed78f4df3 100644
--- a/rls/src/main/java/io/grpc/rls/RlsRequestFactory.java
+++ b/rls/src/main/java/io/grpc/rls/RlsRequestFactory.java
@@ -19,31 +19,27 @@
 import static com.google.common.base.Preconditions.checkNotNull;
 
 import com.google.common.base.MoreObjects;
-import com.google.common.collect.HashBasedTable;
-import com.google.common.collect.Table;
+import com.google.common.collect.ImmutableMap;
+import com.google.errorprone.annotations.CheckReturnValue;
 import io.grpc.Metadata;
-import io.grpc.Status;
-import io.grpc.StatusRuntimeException;
+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.RouteLookupRequestKey;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
-import javax.annotation.CheckReturnValue;
 
 /**
- * A RlsRequestFactory creates {@link RouteLookupRequest} using key builder map from {@link
+ * A RlsRequestFactory creates {@link RouteLookupRequestKey} using key builder map from {@link
  * RouteLookupConfig}.
  */
 final class RlsRequestFactory {
 
   private final String target;
-  /**
-   * schema: Path(/serviceName/methodName or /serviceName/*), rls request headerName, header fields.
-   */
-  private final Table<String, String, NameMatcher> keyBuilderTable;
+  private final Map<String, GrpcKeyBuilder> keyBuilderTable;
 
   RlsRequestFactory(RouteLookupConfig rlsConfig, String target) {
     checkNotNull(rlsConfig, "rlsConfig");
@@ -51,43 +47,55 @@ final class RlsRequestFactory {
     this.keyBuilderTable = createKeyBuilderTable(rlsConfig);
   }
 
-  private static Table<String, String, NameMatcher> createKeyBuilderTable(
+  private static Map<String, GrpcKeyBuilder> createKeyBuilderTable(
       RouteLookupConfig config) {
-    Table<String, String, NameMatcher> table = HashBasedTable.create();
-    for (GrpcKeyBuilder grpcKeyBuilder : config.getGrpcKeyBuilders()) {
-      for (NameMatcher nameMatcher : grpcKeyBuilder.getHeaders()) {
-        for (Name name : grpcKeyBuilder.getNames()) {
-          String method =
-              name.getMethod() == null || name.getMethod().isEmpty()
-                  ? "*" : name.getMethod();
-          String path = "/" + name.getService() + "/" + method;
-          table.put(path, nameMatcher.getKey(), nameMatcher);
-        }
+    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 RouteLookupRequest} for given request's metadata. */
+  /** Creates a {@link RouteLookupRequestKey} for the given request lookup metadata. */
   @CheckReturnValue
-  RouteLookupRequest create(String service, String method, Metadata metadata) {
+  RouteLookupRequestKey create(String service, String method, Metadata metadata) {
     checkNotNull(service, "service");
     checkNotNull(method, "method");
     String path = "/" + service + "/" + method;
-    Map<String, NameMatcher> keyBuilder = keyBuilderTable.row(path);
-    // if no matching keyBuilder found, fall back to wildcard match (ServiceName/*)
-    if (keyBuilder.isEmpty()) {
-      keyBuilder = keyBuilderTable.row("/" + service + "/*");
+    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);
     }
-    Map<String, String> rlsRequestHeaders = createRequestHeaders(metadata, keyBuilder);
-    return new RouteLookupRequest(target, path, "grpc", rlsRequestHeaders);
+    rlsRequestHeaders.putAll(constantKeys);
+    return RouteLookupRequestKey.create(rlsRequestHeaders.buildOrThrow());
   }
 
-  private Map<String, String> createRequestHeaders(
-      Metadata metadata, Map<String, NameMatcher> keyBuilder) {
-    Map<String, String> rlsRequestHeaders = new HashMap<>();
-    for (Map.Entry<String, NameMatcher> entry : keyBuilder.entrySet()) {
-      NameMatcher nameMatcher = entry.getValue();
+  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));
@@ -96,11 +104,7 @@ private Map<String, String> createRequestHeaders(
         }
       }
       if (value != null) {
-        rlsRequestHeaders.put(entry.getKey(), value);
-      } else if (!nameMatcher.isOptional()) {
-        throw new StatusRuntimeException(
-            Status.INVALID_ARGUMENT.withDescription(
-                String.format("Missing mandatory metadata(%s) not found", entry.getKey())));
+        rlsRequestHeaders.put(nameMatcher.key(), value);
       }
     }
     return rlsRequestHeaders;
diff --git a/rls/src/main/java/io/grpc/rls/SubchannelStateManager.java b/rls/src/main/java/io/grpc/rls/SubchannelStateManager.java
index f5437eac75a..041d2a817ab 100644
--- a/rls/src/main/java/io/grpc/rls/SubchannelStateManager.java
+++ b/rls/src/main/java/io/grpc/rls/SubchannelStateManager.java
@@ -16,6 +16,7 @@
 
 package io.grpc.rls;
 
+import com.google.common.annotations.VisibleForTesting;
 import io.grpc.ConnectivityState;
 import javax.annotation.Nullable;
 
@@ -35,6 +36,7 @@ interface SubchannelStateManager {
    * {@code null}.
    */
   @Nullable
+  @VisibleForTesting
   ConnectivityState getState(String name);
 
   /** Returns representative subchannel status from all registered subchannels. */
diff --git a/rls/src/main/java/io/grpc/rls/SubchannelStateManagerImpl.java b/rls/src/main/java/io/grpc/rls/SubchannelStateManagerImpl.java
index 6d34e713f00..f2d6d612fd6 100644
--- a/rls/src/main/java/io/grpc/rls/SubchannelStateManagerImpl.java
+++ b/rls/src/main/java/io/grpc/rls/SubchannelStateManagerImpl.java
@@ -30,6 +30,7 @@ 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) {
@@ -56,16 +57,20 @@ public ConnectivityState getState(String name) {
   @Override
   public ConnectivityState getAggregatedState() {
     if (stateMultiset.contains(ConnectivityState.READY)) {
-      return ConnectivityState.READY;
+      currentState = ConnectivityState.READY;
     } else if (stateMultiset.contains(ConnectivityState.CONNECTING)) {
-      return ConnectivityState.CONNECTING;
+      if (currentState != ConnectivityState.TRANSIENT_FAILURE) {
+        currentState = ConnectivityState.CONNECTING;
+      }
     } else if (stateMultiset.contains(ConnectivityState.IDLE)) {
-      return ConnectivityState.IDLE;
+      currentState = ConnectivityState.IDLE;
     } else if (stateMultiset.contains(ConnectivityState.TRANSIENT_FAILURE)) {
-      return ConnectivityState.TRANSIENT_FAILURE;
+      currentState = ConnectivityState.TRANSIENT_FAILURE;
+    } else {
+      // empty or shutdown
+      currentState = ConnectivityState.IDLE;
     }
-    // empty or shutdown
-    return ConnectivityState.IDLE;
+    return currentState;
   }
 
   @Override
diff --git a/rls/src/main/java/io/grpc/rls/Throttler.java b/rls/src/main/java/io/grpc/rls/Throttler.java
index 08f54c2e1b3..96d17e70adf 100644
--- a/rls/src/main/java/io/grpc/rls/Throttler.java
+++ b/rls/src/main/java/io/grpc/rls/Throttler.java
@@ -42,27 +42,4 @@ interface Throttler {
    * @param throttled specifies whether the request was throttled by the backend.
    */
   void registerBackendResponse(boolean throttled);
-
-  /**
-   * A ThrottledException indicates the call is throttled. This exception is meant to be used by
-   * caller of {@link Throttler}, the implementation of Throttler should <strong>not</strong> throw
-   * this exception when {@link #shouldThrottle()} is called.
-   */
-  final class ThrottledException extends RuntimeException {
-
-    static final long serialVersionUID = 1L;
-
-    public ThrottledException() {
-      super();
-    }
-
-    public ThrottledException(String s) {
-      super(s);
-    }
-
-    @Override
-    public synchronized Throwable fillInStackTrace() {
-      return this;
-    }
-  }
 }
diff --git a/rls/src/main/proto/grpc/lookup/v1/rls.proto b/rls/src/main/proto/grpc/lookup/v1/rls.proto
index 0d14e693a6c..7d1735289d5 100644
--- a/rls/src/main/proto/grpc/lookup/v1/rls.proto
+++ b/rls/src/main/proto/grpc/lookup/v1/rls.proto
@@ -22,34 +22,38 @@ option java_package = "io.grpc.lookup.v1";
 option java_outer_classname = "RlsProto";
 
 message RouteLookupRequest {
-  // Full host name of the target server, e.g. firestore.googleapis.com.
-  // Only set for gRPC requests; HTTP requests must use key_map explicitly.
-  string server = 1;
-  // Full path of the request, i.e. "/service/method".
-  // Only set for gRPC requests; HTTP requests must use key_map explicitly.
-  string path = 2;
   // 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 {
-  // Actual addressable entity to use for routing decision, using syntax
-  // requested by the request target_type.
-  // This field is deprecated in favor of the new "targets" field, below.
-  string target = 1 [deprecated=true];
   // 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.
-  // If present, it should be used by proxy/gRPC client code instead of
-  // "target" (which is deprecated).
   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 {
diff --git a/rls/src/main/proto/grpc/lookup/v1/rls_config.proto b/rls/src/main/proto/grpc/lookup/v1/rls_config.proto
index 4c02201329b..9d2b6c54cfb 100644
--- a/rls/src/main/proto/grpc/lookup/v1/rls_config.proto
+++ b/rls/src/main/proto/grpc/lookup/v1/rls_config.proto
@@ -29,6 +29,9 @@ option java_outer_classname = "RlsConfigProto";
 // 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
@@ -52,10 +55,29 @@ message GrpcKeyBuilder {
   }
   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.
@@ -131,6 +153,12 @@ message HttpKeyBuilder {
   // 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 {
@@ -176,40 +204,22 @@ message RouteLookupConfig {
 
   // 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 RPC error from the RLS.
+  // treated the same as an unhealthy target.
   repeated string valid_targets = 8;
 
-  // This value provides a default target to use if needed.  It will be used for
-  // request processing strategy SYNC_LOOKUP_DEFAULT_TARGET_ON_ERROR if RLS
-  // returns an error, or strategy ASYNC_LOOKUP_DEFAULT_TARGET_ON_MISS if RLS
-  // returns an error or there is a cache miss in the client.  It will also be
-  // used if there are no healthy backends for an RLS target.  Note that
-  // requests can be routed only to a subdomain of the original target,
-  // e.g. "us_east_1.cloudbigtable.googleapis.com".
+  // 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;
 
-  // Specify how to process a request when not already in the cache.
-  enum RequestProcessingStrategy {
-    STRATEGY_UNSPECIFIED = 0;
-
-    // Query the RLS and process the request using target returned by the
-    // lookup. The target will then be cached and used for processing
-    // subsequent requests for the same key. Any errors during lookup service
-    // processing will fall back to default target for request processing.
-    SYNC_LOOKUP_DEFAULT_TARGET_ON_ERROR = 1;
-
-    // Query the RLS and process the request using target returned by the
-    // lookup. The target will then be cached and used for processing
-    // subsequent requests for the same key. Any errors during lookup service
-    // processing will return an error back to the client.  Services with
-    // strict regional routing requirements should use this strategy.
-    SYNC_LOOKUP_CLIENT_SEES_ERROR = 2;
-
-    // Query the RLS asynchronously but respond with the default target.  The
-    // target in the lookup response will then be cached and used for
-    // subsequent requests.  Services with strict latency requirements (but not
-    // strict regional routing requirements) should use this strategy.
-    ASYNC_LOOKUP_DEFAULT_TARGET_ON_MISS = 3;
-  }
-  RequestProcessingStrategy request_processing_strategy = 10;
+  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/test/java/io/grpc/rls/AdaptiveThrottlerTest.java b/rls/src/test/java/io/grpc/rls/AdaptiveThrottlerTest.java
index 8da8e9b0210..6852b2479d5 100644
--- a/rls/src/test/java/io/grpc/rls/AdaptiveThrottlerTest.java
+++ b/rls/src/test/java/io/grpc/rls/AdaptiveThrottlerTest.java
@@ -18,8 +18,8 @@
 
 import static com.google.common.truth.Truth.assertThat;
 
+import com.google.common.base.Ticker;
 import io.grpc.internal.FakeClock;
-import io.grpc.internal.TimeProvider;
 import java.util.concurrent.TimeUnit;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -30,21 +30,23 @@ public class AdaptiveThrottlerTest {
   private static final float TOLERANCE = 0.0001f;
 
   private final FakeClock fakeClock = new FakeClock();
-  private final TimeProvider fakeTimeProvider = fakeClock.getTimeProvider();
+  private final Ticker fakeTicker = fakeClock.getTicker();
   private final AdaptiveThrottler throttler =
       new AdaptiveThrottler.Builder()
           .setHistorySeconds(1)
           .setRatioForAccepts(1.0f)
           .setRequestsPadding(1)
-          .setTimeProvider(fakeTimeProvider)
+          .setTicker(fakeTicker)
           .build();
 
   @Test
   public void shouldThrottle() {
+    long startTime = fakeClock.currentTimeMillis();
+
     // initial states
-    assertThat(throttler.requestStat.get(fakeTimeProvider.currentTimeNanos())).isEqualTo(0L);
-    assertThat(throttler.throttledStat.get(fakeTimeProvider.currentTimeNanos())).isEqualTo(0L);
-    assertThat(throttler.getThrottleProbability(fakeTimeProvider.currentTimeNanos()))
+    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.
@@ -52,10 +54,10 @@ public void shouldThrottle() {
     fakeClock.forwardTime(1L, TimeUnit.MILLISECONDS);
     throttler.registerBackendResponse(false);
 
-    assertThat(throttler.requestStat.get(fakeTimeProvider.currentTimeNanos()))
+    assertThat(throttler.requestStat.get(fakeTicker.read()))
         .isEqualTo(1L);
-    assertThat(throttler.throttledStat.get(fakeTimeProvider.currentTimeNanos())).isEqualTo(0L);
-    assertThat(throttler.getThrottleProbability(fakeTimeProvider.currentTimeNanos()))
+    assertThat(throttler.throttledStat.get(fakeTicker.read())).isEqualTo(0L);
+    assertThat(throttler.getThrottleProbability(fakeTicker.read()))
         .isWithin(TOLERANCE).of(0.0f);
 
     // Request 2, throttled by backend
@@ -63,25 +65,26 @@ public void shouldThrottle() {
     fakeClock.forwardTime(1L, TimeUnit.MILLISECONDS);
     throttler.registerBackendResponse(true);
 
-    assertThat(throttler.requestStat.get(fakeTimeProvider.currentTimeNanos()))
+    assertThat(throttler.requestStat.get(fakeTicker.read()))
         .isEqualTo(2L);
-    assertThat(throttler.throttledStat.get(fakeTimeProvider.currentTimeNanos()))
+    assertThat(throttler.throttledStat.get(fakeTicker.read()))
         .isEqualTo(1L);
-    assertThat(throttler.getThrottleProbability(fakeTimeProvider.currentTimeNanos()))
+    assertThat(throttler.getThrottleProbability(fakeTicker.read()))
         .isWithin(TOLERANCE)
         .of(1.0f / 3.0f);
 
-    // Skip half a second (half the duration).
-    fakeClock.forwardTime(500 - fakeClock.currentTimeMillis(), TimeUnit.MILLISECONDS);
+    // 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(fakeTimeProvider.currentTimeNanos())).isEqualTo(3L);
-    assertThat(throttler.throttledStat.get(fakeTimeProvider.currentTimeNanos())).isEqualTo(2L);
-    assertThat(throttler.getThrottleProbability(fakeTimeProvider.currentTimeNanos()))
+    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);
 
@@ -89,19 +92,33 @@ public void shouldThrottle() {
     assertThat(throttler.shouldThrottle(0.4f)).isTrue();
     fakeClock.forwardTime(1L, TimeUnit.MILLISECONDS);
 
-    assertThat(throttler.requestStat.get(fakeTimeProvider.currentTimeNanos())).isEqualTo(4L);
-    assertThat(throttler.throttledStat.get(fakeTimeProvider.currentTimeNanos())).isEqualTo(3L);
-    assertThat(throttler.getThrottleProbability(fakeTimeProvider.currentTimeNanos()))
+    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(), TimeUnit.MILLISECONDS);
+    fakeClock.forwardTime(
+        1250 - (fakeClock.currentTimeMillis() - startTime), TimeUnit.MILLISECONDS);
 
-    assertThat(throttler.requestStat.get(fakeTimeProvider.currentTimeNanos())).isEqualTo(2L);
-    assertThat(throttler.throttledStat.get(fakeTimeProvider.currentTimeNanos())).isEqualTo(2L);
-    assertThat(throttler.getThrottleProbability(fakeTimeProvider.currentTimeNanos()))
+    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
index c2c221800ab..b349aecdbf3 100644
--- a/rls/src/test/java/io/grpc/rls/CachingRlsLbClientTest.java
+++ b/rls/src/test/java/io/grpc/rls/CachingRlsLbClientTest.java
@@ -19,14 +19,19 @@
 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.CALLS_REAL_METHODS;
 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;
@@ -38,33 +43,44 @@
 import io.grpc.ChannelLogger;
 import io.grpc.ConnectivityState;
 import io.grpc.EquivalentAddressGroup;
-import io.grpc.ForwardingChannelBuilder;
+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.DoNotUseDirectScheduledExecutorService.FakeTimeProvider;
 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;
@@ -77,14 +93,20 @@
 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;
@@ -92,8 +114,9 @@
 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;
@@ -112,9 +135,18 @@ public class CachingRlsLbClientTest {
   public final GrpcCleanupRule grpcCleanupRule = new GrpcCleanupRule();
 
   @Mock
-  private EvictionListener<RouteLookupRequest, CacheEntry> evictionListener;
+  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() {
@@ -128,33 +160,26 @@ public void uncaughtException(Thread t, Throwable e) {
       new ChildLbResolvedAddressFactory(
           ImmutableList.of(new EquivalentAddressGroup(socketAddress)), Attributes.EMPTY);
   private final TestLoadBalancerProvider lbProvider = new TestLoadBalancerProvider();
-  private final DoNotUseDirectScheduledExecutorService fakeScheduledExecutorService =
-      mock(DoNotUseDirectScheduledExecutorService.class, CALLS_REAL_METHODS);
-  private final FakeTimeProvider fakeTimeProvider =
-      fakeScheduledExecutorService.getFakeTimeProvider();
+  private final FakeClock fakeClock = new FakeClock();
   private final StaticFixedDelayRlsServerImpl rlsServerImpl =
       new StaticFixedDelayRlsServerImpl(
-          TimeUnit.MILLISECONDS.toNanos(SERVER_LATENCY_MILLIS), fakeScheduledExecutorService);
+          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, AdditionalAnswers.delegatesTo(new FakeHelper()));
+      mock(Helper.class, delegatesTo(fakeHelper));
   private final FakeThrottler fakeThrottler = new FakeThrottler();
   private final LbPolicyConfiguration lbPolicyConfiguration =
-      new LbPolicyConfiguration(ROUTE_LOOKUP_CONFIG, childLbPolicy);
+      new LbPolicyConfiguration(ROUTE_LOOKUP_CONFIG, null, childLbPolicy);
 
   private CachingRlsLbClient rlsLbClient;
-  private boolean existingEnableOobChannelDirectPath;
   private Map<String, ?> rlsChannelServiceConfig;
   private String rlsChannelOverriddenAuthority;
 
-  @Before
-  public void setUp() throws Exception {
-    existingEnableOobChannelDirectPath = CachingRlsLbClient.enableOobChannelDirectPath;
-    CachingRlsLbClient.enableOobChannelDirectPath = false;
-  }
-
   private void setUpRlsLbClient() {
+    fakeThrottler.resetCounts();
     rlsLbClient =
         CachingRlsLbClient.newBuilder()
             .setBackoffProvider(fakeBackoffProvider)
@@ -163,25 +188,34 @@ private void setUpRlsLbClient() {
             .setHelper(helper)
             .setLbPolicyConfig(lbPolicyConfiguration)
             .setThrottler(fakeThrottler)
-            .setTimeProvider(fakeTimeProvider)
+            .setTicker(fakeClock.getTicker())
             .build();
   }
 
+  @Before
+  public void setUpMockMetricRecorder() {
+    when(mockMetricRecorder.registerBatchCallback(any(), any())).thenReturn(mockGaugeRegistration);
+  }
+
   @After
   public void tearDown() throws Exception {
-    rlsLbClient.close();
-    CachingRlsLbClient.enableOobChannelDirectPath = existingEnableOobChannelDirectPath;
+    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 RouteLookupRequest request)
+      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(request));
+        responseSettableFuture.set(rlsLbClient.get(routeLookupRequestKey));
       }
     });
     return responseSettableFuture.get(5, TimeUnit.SECONDS);
@@ -191,185 +225,371 @@ public void run() {
   public void get_noError_lifeCycle() throws Exception {
     setUpRlsLbClient();
     InOrder inOrder = inOrder(evictionListener);
-    RouteLookupRequest routeLookupRequest =
-        new RouteLookupRequest(
-            "bigtable.googleapis.com", "/foo/bar", "grpc", ImmutableMap.<String, String>of());
+    RlsProtoData.RouteLookupRequestKey routeLookupRequestKey =
+        RlsProtoData.RouteLookupRequestKey.create(
+            ImmutableMap.of(
+            "server", "bigtable.googleapis.com", "service-key", "foo", "method-key", "bar"));
     rlsServerImpl.setLookupTable(
         ImmutableMap.of(
-            routeLookupRequest,
-            new RouteLookupResponse(ImmutableList.of("target"), "header")));
+            routeLookupRequestKey,
+            RouteLookupResponse.create(ImmutableList.of("target"), "header")));
 
     // initial request
-    CachedRouteLookupResponse resp = getInSyncContext(routeLookupRequest);
+    CachedRouteLookupResponse resp = getInSyncContext(routeLookupRequestKey);
     assertThat(resp.isPending()).isTrue();
 
     // server response
-    fakeTimeProvider.forwardTime(SERVER_LATENCY_MILLIS, TimeUnit.MILLISECONDS);
+    fakeClock.forwardTime(SERVER_LATENCY_MILLIS, TimeUnit.MILLISECONDS);
 
-    resp = getInSyncContext(routeLookupRequest);
+    resp = getInSyncContext(routeLookupRequestKey);
     assertThat(resp.hasData()).isTrue();
 
     // cache hit for staled entry
-    fakeTimeProvider.forwardTime(ROUTE_LOOKUP_CONFIG.getStaleAgeInMillis(), TimeUnit.MILLISECONDS);
+    fakeClock.forwardTime(ROUTE_LOOKUP_CONFIG.staleAgeInNanos(), TimeUnit.NANOSECONDS);
 
-    resp = getInSyncContext(routeLookupRequest);
+    rlsServerImpl.routeLookupReason = null;
+    resp = getInSyncContext(routeLookupRequestKey);
     assertThat(resp.hasData()).isTrue();
 
     // async refresh finishes
-    fakeTimeProvider.forwardTime(SERVER_LATENCY_MILLIS, TimeUnit.MILLISECONDS);
+    fakeClock.forwardTime(SERVER_LATENCY_MILLIS, TimeUnit.MILLISECONDS);
     inOrder
         .verify(evictionListener)
-        .onEviction(eq(routeLookupRequest), any(CacheEntry.class), eq(EvictionType.REPLACED));
+        .onEviction(eq(routeLookupRequestKey), any(CacheEntry.class), eq(EvictionType.REPLACED));
 
-    resp = getInSyncContext(routeLookupRequest);
+    resp = getInSyncContext(routeLookupRequestKey);
 
+    assertThat(rlsServerImpl.routeLookupReason).isEqualTo(
+        io.grpc.lookup.v1.RouteLookupRequest.Reason.REASON_STALE);
     assertThat(resp.hasData()).isTrue();
 
     // existing cache expired
-    fakeTimeProvider.forwardTime(ROUTE_LOOKUP_CONFIG.getMaxAgeInMillis(), TimeUnit.MILLISECONDS);
+    fakeClock.forwardTime(ROUTE_LOOKUP_CONFIG.maxAgeInNanos(), TimeUnit.NANOSECONDS);
 
-    resp = getInSyncContext(routeLookupRequest);
+    resp = getInSyncContext(routeLookupRequestKey);
 
     assertThat(resp.isPending()).isTrue();
     inOrder
         .verify(evictionListener)
-        .onEviction(eq(routeLookupRequest), any(CacheEntry.class), eq(EvictionType.EXPIRED));
+        .onEviction(eq(routeLookupRequestKey), any(CacheEntry.class), eq(EvictionType.EXPIRED));
 
     inOrder.verifyNoMoreInteractions();
   }
 
   @Test
-  public void rls_overDirectPath() throws Exception {
-    CachingRlsLbClient.enableOobChannelDirectPath = true;
-    setUpRlsLbClient();
-    RouteLookupRequest routeLookupRequest =
-        new RouteLookupRequest(
-            "bigtable.googleapis.com", "/foo/bar", "grpc", ImmutableMap.<String, String>of());
+  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(
-            routeLookupRequest,
-            new RouteLookupResponse(ImmutableList.of("target"), "header")));
+            routeLookupRequestKey,
+            RouteLookupResponse.create(ImmutableList.of("target"), "header")));
 
+    rlsServerImpl.routeLookupReason = null;
     // initial request
-    CachedRouteLookupResponse resp = getInSyncContext(routeLookupRequest);
+    CachedRouteLookupResponse resp = getInSyncContext(routeLookupRequestKey);
     assertThat(resp.isPending()).isTrue();
 
     // server response
-    fakeTimeProvider.forwardTime(SERVER_LATENCY_MILLIS, TimeUnit.MILLISECONDS);
+    fakeClock.forwardTime(SERVER_LATENCY_MILLIS, TimeUnit.MILLISECONDS);
 
-    resp = getInSyncContext(routeLookupRequest);
+    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(
+    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(
-            "loadBalancingConfig",
-            ImmutableList.of(ImmutableMap.of(
-                "grpclb",
-                ImmutableMap.of(
-                    "childPolicy",
-                    ImmutableList.of(ImmutableMap.of("pick_first", ImmutableMap.of())),
-                    "serviceName",
-                    "service1")))));
+            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_throttledAndRecover() throws Exception {
+  public void get_throttledTwice_usesSameBackoffpolicy() throws Exception {
     setUpRlsLbClient();
-    RouteLookupRequest routeLookupRequest =
-        new RouteLookupRequest("server", "/foo/bar", "grpc", ImmutableMap.<String, String>of());
+    RlsProtoData.RouteLookupRequestKey routeLookupRequestKey =
+        RlsProtoData.RouteLookupRequestKey.create(
+            ImmutableMap.of(
+            "server", "bigtable.googleapis.com", "service-key", "foo", "method-key", "bar"));
     rlsServerImpl.setLookupTable(
         ImmutableMap.of(
-            routeLookupRequest,
-            new RouteLookupResponse(ImmutableList.of("target"), "header")));
+            routeLookupRequestKey,
+            RouteLookupResponse.create(ImmutableList.of("target"), "header")));
 
     fakeThrottler.nextResult = true;
     fakeBackoffProvider.nextPolicy = createBackoffPolicy(10, TimeUnit.MILLISECONDS);
 
-    CachedRouteLookupResponse resp = getInSyncContext(routeLookupRequest);
+    CachedRouteLookupResponse resp = getInSyncContext(routeLookupRequestKey);
 
     assertThat(resp.hasError()).isTrue();
 
-    fakeTimeProvider.forwardTime(10, TimeUnit.MILLISECONDS);
-    // initially backed off entry is backed off again
-    verify(evictionListener)
-        .onEviction(eq(routeLookupRequest), any(CacheEntry.class), eq(EvictionType.REPLACED));
-
-    resp = getInSyncContext(routeLookupRequest);
+    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();
 
-    // let it pass throttler
+    fakeClock.forwardTime(10, TimeUnit.MILLISECONDS);
+
+    // Backoff entry's backoff timer has gone off, so next rpc should not be backed off.
     fakeThrottler.nextResult = false;
-    fakeTimeProvider.forwardTime(10, TimeUnit.MILLISECONDS);
+    resp = getInSyncContext(routeLookupRequestKey);
+    assertThat(resp.isPending()).isTrue();
 
-    resp = getInSyncContext(routeLookupRequest);
+    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
-    fakeTimeProvider.forwardTime(SERVER_LATENCY_MILLIS, TimeUnit.MILLISECONDS);
+    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();
 
-    resp = getInSyncContext(routeLookupRequest);
+    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();
 
-    assertThat(resp.hasData()).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);
-    RouteLookupRequest routeLookupRequest =
-        new RouteLookupRequest(
-            "bigtable.googleapis.com", "/foo/bar", "grpc", ImmutableMap.<String, String>of());
+    RlsProtoData.RouteLookupRequestKey routeLookupRequestKey =
+        RlsProtoData.RouteLookupRequestKey.create(
+            ImmutableMap.of(
+            "server", "bigtable.googleapis.com", "service-key", "service1",
+                "method-key", "create"));
     rlsServerImpl.setLookupTable(
         ImmutableMap.of(
-            routeLookupRequest,
-            new RouteLookupResponse(
+            routeLookupRequestKey,
+            RouteLookupResponse.create(
                 ImmutableList.of("primary.cloudbigtable.googleapis.com"),
                 "header-rls-data-value")));
 
     // valid channel
-    CachedRouteLookupResponse resp = getInSyncContext(routeLookupRequest);
+    CachedRouteLookupResponse resp = getInSyncContext(routeLookupRequestKey);
     assertThat(resp.isPending()).isTrue();
-    fakeTimeProvider.forwardTime(SERVER_LATENCY_MILLIS, TimeUnit.MILLISECONDS);
+    fakeClock.forwardTime(SERVER_LATENCY_MILLIS, TimeUnit.MILLISECONDS);
 
-    resp = getInSyncContext(routeLookupRequest);
+    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(2))
+    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.CONNECTING, ConnectivityState.READY);
+        .containsExactly(ConnectivityState.TRANSIENT_FAILURE, ConnectivityState.CONNECTING,
+            ConnectivityState.READY);
     Metadata headers = new Metadata();
-    PickResult pickResult = pickerCaptor.getValue().pickSubchannel(
-        new PickSubchannelArgsImpl(
-            TestMethodDescriptors.voidMethod().toBuilder().setFullMethodName("foo/bar").build(),
-            headers,
-            CallOptions.DEFAULT));
+    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
-    RouteLookupRequest invalidRouteLookupRequest =
-        new RouteLookupRequest(
-            "bigtable.googleapis.com", "/doesn/exists", "grpc", ImmutableMap.<String, String>of());
-    CachedRouteLookupResponse errorResp = getInSyncContext(invalidRouteLookupRequest);
+    RlsProtoData.RouteLookupRequestKey invalidRouteLookupRequestKey =
+        RlsProtoData.RouteLookupRequestKey.create(ImmutableMap.<String, String>of());
+    CachedRouteLookupResponse errorResp = getInSyncContext(invalidRouteLookupRequestKey);
     assertThat(errorResp.isPending()).isTrue();
-    fakeTimeProvider.forwardTime(SERVER_LATENCY_MILLIS, TimeUnit.MILLISECONDS);
+    fakeClock.forwardTime(SERVER_LATENCY_MILLIS, TimeUnit.MILLISECONDS);
 
-    errorResp = getInSyncContext(invalidRouteLookupRequest);
+    errorResp = getInSyncContext(invalidRouteLookupRequestKey);
     assertThat(errorResp.hasError()).isTrue();
 
-    // Channel is still READY because the subchannel for method /foo/bar is still READY.
+    // 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());
@@ -379,61 +599,331 @@ public void get_updatesLbState() throws Exception {
                 .setFullMethodName("doesn/exists")
                 .build(),
             headers,
-            CallOptions.DEFAULT));
+            CallOptions.DEFAULT,
+            new PickDetailsConsumer() {}));
     assertThat(pickResult.getStatus().getCode()).isEqualTo(Code.UNAVAILABLE);
-    assertThat(pickResult.getStatus().getDescription()).isEqualTo("fallback not available");
+    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();
-    RouteLookupRequest routeLookupRequest =
-        new RouteLookupRequest("server", "/foo/bar", "grpc", ImmutableMap.<String, String>of());
-    RouteLookupRequest routeLookupRequest2 =
-        new RouteLookupRequest("server", "/foo/baz", "grpc", ImmutableMap.<String, String>of());
+    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(
-            routeLookupRequest, new RouteLookupResponse(ImmutableList.of("target"), "header"),
-            routeLookupRequest2, new RouteLookupResponse(ImmutableList.of("target"), "header2")));
+            routeLookupRequestKey,
+            RouteLookupResponse.create(ImmutableList.of("target"), "header"),
+            routeLookupRequestKey2,
+            RouteLookupResponse.create(ImmutableList.of("target"), "header2")));
 
-    CachedRouteLookupResponse resp = getInSyncContext(routeLookupRequest);
+    CachedRouteLookupResponse resp = getInSyncContext(routeLookupRequestKey);
     assertThat(resp.isPending()).isTrue();
-    fakeTimeProvider.forwardTime(SERVER_LATENCY_MILLIS, TimeUnit.MILLISECONDS);
+    fakeClock.forwardTime(SERVER_LATENCY_MILLIS, TimeUnit.MILLISECONDS);
 
-    resp = getInSyncContext(routeLookupRequest);
+    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(routeLookupRequest2);
+    CachedRouteLookupResponse resp2 = getInSyncContext(routeLookupRequestKey2);
     assertThat(resp2.isPending()).isTrue();
-    fakeTimeProvider.forwardTime(SERVER_LATENCY_MILLIS, TimeUnit.MILLISECONDS);
+    fakeClock.forwardTime(SERVER_LATENCY_MILLIS, TimeUnit.MILLISECONDS);
 
-    resp2 = getInSyncContext(routeLookupRequest2);
+    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 new RouteLookupConfig(
-        ImmutableList.of(
-            new GrpcKeyBuilder(
-                ImmutableList.of(new Name("service1", "create")),
+    return RouteLookupConfig.builder()
+        .grpcKeybuilders(ImmutableList.of(
+            GrpcKeyBuilder.create(
+                ImmutableList.of(Name.create("service1", "create")),
                 ImmutableList.of(
-                    new NameMatcher("user", ImmutableList.of("User", "Parent"), true),
-                    new NameMatcher("id", ImmutableList.of("X-Google-Id"), true)))),
-        /* lookupService= */ "service1",
-        /* lookupServiceTimeoutInMillis= */ TimeUnit.SECONDS.toMillis(2),
-        /* maxAgeInMillis= */ TimeUnit.SECONDS.toMillis(300),
-        /* staleAgeInMillis= */ TimeUnit.SECONDS.toMillis(240),
-        /* cacheSizeBytes= */ 1000,
-        /* validTargets= */ ImmutableList.of("a valid target"),
-        DEFAULT_TARGET);
+                    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) {
@@ -448,6 +938,21 @@ public long nextBackoffNanos() {
         };
   }
 
+  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);
@@ -463,6 +968,7 @@ public BackoffPolicy get() {
    * immediately fails when using the fallback target.
    */
   private static final class TestLoadBalancerProvider extends LoadBalancerProvider {
+    final Set<LoadBalancer> loadBalancers = new HashSet<>();
 
     @Override
     public boolean isAvailable() {
@@ -487,10 +993,10 @@ public ConfigOrError parseLoadBalancingPolicyConfig(
 
     @Override
     public LoadBalancer newLoadBalancer(final Helper helper) {
-      return new LoadBalancer() {
+      LoadBalancer loadBalancer = new LoadBalancer() {
 
         @Override
-        public void handleResolvedAddresses(ResolvedAddresses resolvedAddresses) {
+        public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
           Map<?, ?> config = (Map<?, ?>) resolvedAddresses.getLoadBalancingPolicyConfig();
           if (DEFAULT_TARGET.equals(config.get("target"))) {
             helper.updateBalancingState(
@@ -499,7 +1005,7 @@ public void handleResolvedAddresses(ResolvedAddresses resolvedAddresses) {
                   @Override
                   public PickResult pickSubchannel(PickSubchannelArgs args) {
                     return PickResult.withError(
-                        Status.UNAVAILABLE.withDescription("fallback not available"));
+                            Status.UNAVAILABLE.withDescription("fallback not available"));
                   }
                 });
           } else {
@@ -508,28 +1014,30 @@ public PickResult pickSubchannel(PickSubchannelArgs args) {
                 new SubchannelPicker() {
                   @Override
                   public PickResult pickSubchannel(PickSubchannelArgs args) {
-                    return PickResult.withSubchannel(mock(Subchannel.class));
+                    return PickResult.withSubchannel(
+                        mock(Subchannel.class, config.get("target").toString()));
                   }
                 });
           }
+
+          return Status.OK;
         }
 
         @Override
         public void handleNameResolutionError(final Status error) {
-          class ErrorPicker extends SubchannelPicker {
-            @Override
-            public PickResult pickSubchannel(PickSubchannelArgs args) {
-              return PickResult.withError(error);
-            }
-          }
-
-          helper.updateBalancingState(ConnectivityState.TRANSIENT_FAILURE, new ErrorPicker());
+          helper.updateBalancingState(
+              ConnectivityState.TRANSIENT_FAILURE,
+              new FixedResultPicker(PickResult.withError(error)));
         }
 
         @Override
         public void shutdown() {
+          loadBalancers.remove(this);
         }
       };
+
+      loadBalancers.add(loadBalancer);
+      return loadBalancer;
     }
   }
 
@@ -544,7 +1052,9 @@ private static final class StaticFixedDelayRlsServerImpl
     private final long responseDelayNano;
     private final ScheduledExecutorService scheduledExecutorService;
 
-    private Map<RouteLookupRequest, RouteLookupResponse> lookupTable = ImmutableMap.of();
+    private Map<RlsProtoData.RouteLookupRequestKey, RouteLookupResponse> lookupTable =
+        ImmutableMap.of();
+    io.grpc.lookup.v1.RouteLookupRequest.Reason routeLookupReason;
 
     public StaticFixedDelayRlsServerImpl(
         long responseDelayNano, ScheduledExecutorService scheduledExecutorService) {
@@ -554,7 +1064,8 @@ public StaticFixedDelayRlsServerImpl(
           checkNotNull(scheduledExecutorService, "scheduledExecutorService");
     }
 
-    private void setLookupTable(Map<RouteLookupRequest, RouteLookupResponse> lookupTable) {
+    private void setLookupTable(Map<RlsProtoData.RouteLookupRequestKey,
+        RouteLookupResponse> lookupTable) {
       this.lookupTable = checkNotNull(lookupTable, "lookupTable");
     }
 
@@ -566,8 +1077,11 @@ public void routeLookup(final io.grpc.lookup.v1.RouteLookupRequest request,
               new Runnable() {
                 @Override
                 public void run() {
+                  routeLookupReason = request.getReason();
                   RouteLookupResponse response =
-                      lookupTable.get(REQUEST_CONVERTER.convert(request));
+                      lookupTable.get(
+                          RlsProtoData.RouteLookupRequestKey.create(
+                              REQUEST_CONVERTER.convert(request).keyMap()));
                   if (response == null) {
                     responseObserver.onError(new RuntimeException("not found"));
                   } else {
@@ -581,23 +1095,30 @@ public void run() {
 
   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 {
-        grpcCleanupRule.register(
-            InProcessServerBuilder.forName(target)
-                .addService(rlsServerImpl)
-                .directExecutor()
-                .build()
-                .start());
+        createServerAndRegister(target);
       } catch (IOException e) {
         throw new RuntimeException("cannot create server: " + target, e);
       }
       final InProcessChannelBuilder builder =
           InProcessChannelBuilder.forName(target).directExecutor();
 
-      class CleaningChannelBuilder extends ForwardingChannelBuilder<CleaningChannelBuilder> {
+      class CleaningChannelBuilder extends ForwardingChannelBuilder2<CleaningChannelBuilder> {
 
         @Override
         protected ManagedChannelBuilder<?> delegate() {
@@ -606,7 +1127,8 @@ protected ManagedChannelBuilder<?> delegate() {
 
         @Override
         public ManagedChannel build() {
-          return grpcCleanupRule.register(super.build());
+          oobChannel = super.build();
+          return grpcCleanupRule.register(oobChannel);
         }
 
         @Override
@@ -635,7 +1157,6 @@ public ManagedChannel createOobChannel(EquivalentAddressGroup eag, String author
     @Override
     public void updateBalancingState(
         @Nonnull ConnectivityState newState, @Nonnull SubchannelPicker newPicker) {
-      // no-op
     }
 
     @Override
@@ -656,7 +1177,7 @@ public ChannelCredentials withoutBearerTokens() {
 
     @Override
     public ScheduledExecutorService getScheduledExecutorService() {
-      return fakeScheduledExecutorService;
+      return fakeClock.getScheduledExecutorService();
     }
 
     @Override
@@ -668,9 +1189,21 @@ public SynchronizationContext getSynchronizationContext() {
     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;
 
@@ -681,7 +1214,24 @@ public boolean shouldThrottle() {
 
     @Override
     public void registerBackendResponse(boolean throttled) {
-      // no-op
+      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/ChildLoadBalancerHelperTest.java b/rls/src/test/java/io/grpc/rls/ChildLoadBalancerHelperTest.java
index 48901da3235..543540f498e 100644
--- a/rls/src/test/java/io/grpc/rls/ChildLoadBalancerHelperTest.java
+++ b/rls/src/test/java/io/grpc/rls/ChildLoadBalancerHelperTest.java
@@ -57,7 +57,7 @@ public void childLoadBalancerHelper_shouldReportsSubchannelState() {
         .isEqualTo(ConnectivityState.TRANSIENT_FAILURE);
 
     childLbHelper2.updateBalancingState(ConnectivityState.CONNECTING, picker2);
-    inOrder.verify(helper).updateBalancingState(ConnectivityState.CONNECTING, picker);
+    inOrder.verify(helper).updateBalancingState(ConnectivityState.TRANSIENT_FAILURE, picker);
     assertThat(subchannelStateManager.getState(target2)).isEqualTo(ConnectivityState.CONNECTING);
 
     childLbHelper1.updateBalancingState(ConnectivityState.READY, picker1);
diff --git a/rls/src/test/java/io/grpc/rls/DoNotUseDirectScheduledExecutorService.java b/rls/src/test/java/io/grpc/rls/DoNotUseDirectScheduledExecutorService.java
deleted file mode 100644
index 9fa06a3a722..00000000000
--- a/rls/src/test/java/io/grpc/rls/DoNotUseDirectScheduledExecutorService.java
+++ /dev/null
@@ -1,239 +0,0 @@
-/*
- * 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 static org.mockito.Mockito.mock;
-
-import com.google.common.base.MoreObjects;
-import io.grpc.internal.TimeProvider;
-import java.util.Comparator;
-import java.util.PriorityQueue;
-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;
-import java.util.concurrent.atomic.AtomicReference;
-
-/**
- * A fake minimal implementation of {@link ScheduledExecutorService} *only* supports
- * {@link ScheduledExecutorService#scheduleAtFixedRate(Runnable, long, long, TimeUnit)} (at most 1
- * task is allowed) and {@link ScheduledExecutorService#schedule(Runnable, long, TimeUnit)}. It is
- * directExecutor equivalent for {@link ScheduledExecutorService}.
- *
- * <p>Example:
- * <pre>
- * import static org.mockito.Mockito.CALLS_REAL_METHODS;
- * import static org.mockito.Mockito.mock;
- *
- * private final DoNotUseDirectScheduledExecutorService fakeScheduledService =
- *     mock(DoNotUseDirectScheduledExecutorService.class, CALLS_REAL_METHODS);
- * </pre>
- *
- * <p>Note: This class is only intended to be used in this test with CALL_REAL_METHODS mock. This
- * implementation is not thread-safe. Not safe to use elsewhere.
- */
-abstract class DoNotUseDirectScheduledExecutorService implements ScheduledExecutorService {
-
-  private long currTimeNanos;
-  private long period;
-  private long nextRun;
-  private AtomicReference<Runnable> repeatedCommand;
-  private PriorityQueue<ScheduledRunnable> scheduledCommands;
-  private boolean initialized;
-
-  private DoNotUseDirectScheduledExecutorService() {
-    throw new UnsupportedOperationException("this class is for mock only");
-  }
-
-  /**
-   * Note: CALLS_REAL_METHODS doesn't initialize instance variables, all the methods need to call
-   * maybeInit if they access instance variables.
-   */
-  private void maybeInit() {
-    if (initialized) {
-      return;
-    }
-
-    initialized = true;
-    repeatedCommand = new AtomicReference<>();
-    scheduledCommands = new PriorityQueue<>(11, new ScheduledRunnableComparator());
-  }
-
-  @Override
-  public final ScheduledFuture<?> scheduleAtFixedRate(
-      Runnable command, long initialDelay, long period, TimeUnit unit) {
-    maybeInit();
-    checkArgument(period > 0, "period should be positive");
-    checkArgument(initialDelay >= 0, "initial delay should be >= 0");
-    checkState(this.repeatedCommand.get() == null, "only can schedule one");
-    if (initialDelay == 0) {
-      initialDelay = period;
-      command.run();
-    }
-    this.repeatedCommand.set(checkNotNull(command, "command"));
-    this.nextRun = checkNotNull(unit, "unit").toNanos(initialDelay) + currTimeNanos;
-    this.period = unit.toNanos(period);
-    return mock(ScheduledFuture.class);
-  }
-
-  @Override
-  public final ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit) {
-    maybeInit();
-    checkNotNull(command, "command");
-    checkNotNull(unit, "unit");
-    checkArgument(delay > 0, "delay must be positive");
-    ScheduledRunnable scheduledRunnable =
-        new ScheduledRunnable(currTimeNanos + TimeUnit.NANOSECONDS.convert(delay, unit), command);
-    scheduledCommands.add(scheduledRunnable);
-    return scheduledRunnable.scheduledFuture;
-  }
-
-  final FakeTimeProvider getFakeTimeProvider() {
-    maybeInit();
-    return new FakeTimeProvider();
-  }
-
-  private void forwardTime(long delta, TimeUnit unit) {
-    maybeInit();
-    checkNotNull(unit, "unit");
-    checkArgument(delta > 0, "delta must be positive");
-    long finalTime = currTimeNanos + unit.toNanos(delta);
-
-    if (repeatedCommand.get() != null) {
-      while (finalTime >= nextRun) {
-        scheduledCommands.add(new ScheduledRunnable(nextRun, repeatedCommand.get()));
-        nextRun += period;
-      }
-    }
-
-    while (!scheduledCommands.isEmpty()
-        && scheduledCommands.peek().scheduledTimeNanos <= finalTime) {
-      ScheduledRunnable scheduledCommand = scheduledCommands.poll();
-      try {
-        // pretend to run at the scheduled time
-        currTimeNanos = scheduledCommand.scheduledTimeNanos;
-        scheduledCommand.run();
-      } catch (Throwable t) {
-        throw new RuntimeException("failed to run scheduled command: " + scheduledCommand, t);
-      }
-    }
-
-    this.currTimeNanos = finalTime;
-  }
-
-  private final class ScheduledRunnable implements Runnable {
-    private final long scheduledTimeNanos;
-    private final Runnable command;
-    private final ScheduledFuture<?> scheduledFuture = new ScheduledRunnable.FakeScheduledFuture();
-    private boolean running = false;
-    private boolean done = false;
-
-    public ScheduledRunnable(long scheduledTimeNanos, Runnable command) {
-      this.scheduledTimeNanos = scheduledTimeNanos;
-      this.command = checkNotNull(command, "command");
-    }
-
-    @Override
-    public void run() {
-      if (!scheduledFuture.isCancelled()) {
-        running = true;
-        command.run();
-        done = true;
-      }
-    }
-
-    @Override
-    public String toString() {
-      return MoreObjects.toStringHelper(this)
-          .add("scheduledTimeNanos", scheduledTimeNanos)
-          .add("command", command)
-          .add("scheduledFuture", scheduledFuture)
-          .add("running", running)
-          .add("done", done)
-          .toString();
-    }
-
-    private final class FakeScheduledFuture implements ScheduledFuture<Object> {
-      boolean cancelled = false;
-
-      @Override
-      public long getDelay(TimeUnit unit) {
-        return unit.convert(scheduledTimeNanos - currTimeNanos, TimeUnit.NANOSECONDS);
-      }
-
-      @Override
-      public int compareTo(Delayed unused) {
-        throw new UnsupportedOperationException();
-      }
-
-      @Override
-      public boolean cancel(boolean mayInterruptIfRunning) {
-        if (running) {
-          return false;
-        }
-        cancelled = true;
-        return true;
-      }
-
-      @Override
-      public boolean isCancelled() {
-        return cancelled;
-      }
-
-      @Override
-      public boolean isDone() {
-        return done;
-      }
-
-      @Override
-      public Object get() throws InterruptedException, ExecutionException {
-        throw new UnsupportedOperationException();
-      }
-
-      @Override
-      public Object get(long timeout, TimeUnit unit)
-          throws InterruptedException, ExecutionException, TimeoutException {
-        throw new UnsupportedOperationException();
-      }
-    }
-  }
-
-  private static final class ScheduledRunnableComparator
-      implements Comparator<ScheduledRunnable> {
-    @Override
-    public int compare(ScheduledRunnable o1, ScheduledRunnable o2) {
-      return Long.compare(o1.scheduledTimeNanos, o2.scheduledTimeNanos);
-    }
-  }
-
-  final class FakeTimeProvider implements TimeProvider {
-
-    @Override
-    public long currentTimeNanos() {
-      return currTimeNanos;
-    }
-
-    void forwardTime(long delta, TimeUnit unit) {
-      DoNotUseDirectScheduledExecutorService.this.forwardTime(delta, unit);
-    }
-  }
-}
diff --git a/rls/src/test/java/io/grpc/rls/LbPolicyConfigurationTest.java b/rls/src/test/java/io/grpc/rls/LbPolicyConfigurationTest.java
index 7c6be039c24..de41d0488fc 100644
--- a/rls/src/test/java/io/grpc/rls/LbPolicyConfigurationTest.java
+++ b/rls/src/test/java/io/grpc/rls/LbPolicyConfigurationTest.java
@@ -18,40 +18,79 @@
 
 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.ChildLbStatusListener;
 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 ChildLbStatusListener childLbStatusListener = mock(ChildLbStatusListener.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 ChildLoadBalancerHelperProvider(helper, subchannelStateManager, picker),
-          childLbStatusListener);
+          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() {
@@ -77,6 +116,13 @@ public void childPolicyWrapper_refCounted() {
     }
   }
 
+  @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);
@@ -132,9 +178,26 @@ public void updateBalancingState_triggersListener() {
 
     childPolicyReportingHelper.updateBalancingState(ConnectivityState.READY, childPicker);
 
-    verify(childLbStatusListener).onStatusChanged(ConnectivityState.READY);
     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
index b7254341f64..23ffe6ec026 100644
--- a/rls/src/test/java/io/grpc/rls/LinkedHashLruCacheTest.java
+++ b/rls/src/test/java/io/grpc/rls/LinkedHashLruCacheTest.java
@@ -19,16 +19,16 @@
 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.CALLS_REAL_METHODS;
-import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
 
-import com.google.common.collect.ImmutableList;
-import io.grpc.rls.DoNotUseDirectScheduledExecutorService.FakeTimeProvider;
+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;
@@ -46,9 +46,8 @@ public class LinkedHashLruCacheTest {
   @Rule
   public final MockitoRule mocks = MockitoJUnit.rule();
 
-  private final DoNotUseDirectScheduledExecutorService fakeScheduledService =
-      mock(DoNotUseDirectScheduledExecutorService.class, CALLS_REAL_METHODS);
-  private final FakeTimeProvider timeProvider = fakeScheduledService.getFakeTimeProvider();
+  private final FakeClock fakeClock = new FakeClock();
+  private final Ticker ticker = fakeClock.getTicker();
 
   @Mock
   private EvictionListener<Integer, Entry> evictionListener;
@@ -59,13 +58,10 @@ public void setUp() {
     this.cache = new LinkedHashLruCache<Integer, Entry>(
         MAX_SIZE,
         evictionListener,
-        10,
-        TimeUnit.NANOSECONDS,
-        fakeScheduledService,
-        timeProvider) {
+        fakeClock.getTicker()) {
       @Override
       protected boolean isExpired(Integer key, Entry value, long nowNanos) {
-        return value.expireTime <= nowNanos;
+        return value.expireTime - nowNanos <= 0;
       }
 
       @Override
@@ -88,8 +84,8 @@ public void eviction_size() {
 
   @Test
   public void size() {
-    Entry entry1 = new Entry("Entry0", timeProvider.currentTimeNanos() + 10);
-    Entry entry2 = new Entry("Entry1", timeProvider.currentTimeNanos() + 20);
+    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);
@@ -103,22 +99,24 @@ public void size() {
 
   @Test
   public void eviction_expire() {
-    Entry toBeEvicted = new Entry("Entry0", timeProvider.currentTimeNanos() + 10);
-    Entry survivor = new Entry("Entry1", timeProvider.currentTimeNanos() + 20);
+    Entry toBeEvicted = new Entry("Entry0", ticker.read() + 10);
+    Entry survivor = new Entry("Entry1", ticker.read() + 20);
     cache.cache(0, toBeEvicted);
     cache.cache(1, survivor);
 
-    timeProvider.forwardTime(10, TimeUnit.NANOSECONDS);
+    fakeClock.forwardTime(10, TimeUnit.NANOSECONDS);
+    cache.cleanupExpiredEntries();
     verify(evictionListener).onEviction(0, toBeEvicted, EvictionType.EXPIRED);
 
-    timeProvider.forwardTime(10, TimeUnit.NANOSECONDS);
+    fakeClock.forwardTime(10, TimeUnit.NANOSECONDS);
+    cache.cleanupExpiredEntries();
     verify(evictionListener).onEviction(1, survivor, EvictionType.EXPIRED);
   }
 
   @Test
   public void eviction_explicit() {
-    Entry toBeEvicted = new Entry("Entry0", timeProvider.currentTimeNanos() + 10);
-    Entry survivor = new Entry("Entry1", timeProvider.currentTimeNanos() + 20);
+    Entry toBeEvicted = new Entry("Entry0", ticker.read() + 10);
+    Entry survivor = new Entry("Entry1", ticker.read() + 20);
     cache.cache(0, toBeEvicted);
     cache.cache(1, survivor);
 
@@ -129,8 +127,8 @@ public void eviction_explicit() {
 
   @Test
   public void eviction_replaced() {
-    Entry toBeEvicted = new Entry("Entry0", timeProvider.currentTimeNanos() + 10);
-    Entry survivor = new Entry("Entry1", timeProvider.currentTimeNanos() + 20);
+    Entry toBeEvicted = new Entry("Entry0", ticker.read() + 10);
+    Entry survivor = new Entry("Entry1", ticker.read() + 20);
     cache.cache(0, toBeEvicted);
     cache.cache(0, survivor);
 
@@ -141,7 +139,7 @@ public void eviction_replaced() {
   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, timeProvider.currentTimeNanos() + MAX_SIZE - i - 1));
+      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));
 
@@ -152,13 +150,17 @@ public void eviction_size_shouldEvictAlreadyExpired() {
   }
 
   @Test
-  public void eviction_get_shouldNotReturnAlreadyExpired() {
+  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, timeProvider.currentTimeNanos() + MAX_SIZE - i));
+      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));
@@ -166,7 +168,7 @@ public void eviction_get_shouldNotReturnAlreadyExpired() {
 
   @Test
   public void updateEntrySize() {
-    Entry entry = new Entry("Entry", timeProvider.currentTimeNanos() + 10);
+    Entry entry = new Entry("Entry", ticker.read() + 10);
 
     cache.cache(1, entry);
 
@@ -185,8 +187,8 @@ public void updateEntrySize() {
 
   @Test
   public void updateEntrySize_multipleEntries() {
-    Entry entry1 = new Entry("Entry", timeProvider.currentTimeNanos() + 10, 2);
-    Entry entry2 = new Entry("Entry2", timeProvider.currentTimeNanos() + 10, 3);
+    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);
@@ -202,24 +204,24 @@ public void updateEntrySize_multipleEntries() {
 
   @Test
   public void invalidateAll() {
-    Entry entry1 = new Entry("Entry", timeProvider.currentTimeNanos() + 10);
-    Entry entry2 = new Entry("Entry2", timeProvider.currentTimeNanos() + 10);
+    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(ImmutableList.of(1, 2));
+    cache.invalidateAll();
 
     assertThat(cache.estimatedSize()).isEqualTo(0);
   }
 
   @Test
   public void resize() {
-    Entry entry1 = new Entry("Entry", timeProvider.currentTimeNanos() + 10);
-    Entry entry2 = new Entry("Entry2", timeProvider.currentTimeNanos() + 10);
-    Entry entry3 = new Entry("Entry3", timeProvider.currentTimeNanos() + 10);
+    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);
@@ -266,4 +268,91 @@ 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
index f3a655289d7..a52390743a6 100644
--- a/rls/src/test/java/io/grpc/rls/RlsLoadBalancerTest.java
+++ b/rls/src/test/java/io/grpc/rls/RlsLoadBalancerTest.java
@@ -18,18 +18,22 @@
 
 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.CALLS_REAL_METHODS;
+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;
@@ -37,10 +41,14 @@
 import io.grpc.ConnectivityState;
 import io.grpc.ConnectivityStateInfo;
 import io.grpc.EquivalentAddressGroup;
-import io.grpc.ForwardingChannelBuilder;
+import io.grpc.ForwardingChannelBuilder2;
+import io.grpc.Grpc;
+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;
@@ -49,31 +57,44 @@
 import io.grpc.ManagedChannelBuilder;
 import io.grpc.Metadata;
 import io.grpc.MethodDescriptor;
-import io.grpc.MethodDescriptor.Marshaller;
 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;
@@ -83,10 +104,10 @@
 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.MockitoAnnotations;
 import org.mockito.junit.MockitoJUnit;
 import org.mockito.junit.MockitoRule;
 
@@ -98,8 +119,7 @@ public class RlsLoadBalancerTest {
   @Rule
   public final MockitoRule mocks = MockitoJUnit.rule();
   private final RlsLoadBalancerProvider provider = new RlsLoadBalancerProvider();
-  private final DoNotUseDirectScheduledExecutorService fakeScheduledExecutorService =
-      mock(DoNotUseDirectScheduledExecutorService.class, CALLS_REAL_METHODS);
+  private final FakeClock fakeClock = new FakeClock();
   private final SynchronizationContext syncContext =
       new SynchronizationContext(new UncaughtExceptionHandler() {
         @Override
@@ -107,110 +127,177 @@ 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(new FakeHelper()));
-  private final FakeRlsServerImpl fakeRlsServerImpl = new FakeRlsServerImpl();
+      mock(Helper.class, AdditionalAnswers.delegatesTo(helperDelegate));
+  private final FakeRlsServerImpl fakeRlsServerImpl = new FakeRlsServerImpl(
+      fakeClock.getScheduledExecutorService());
   private final Deque<FakeSubchannel> subchannels = new LinkedList<>();
-  @Mock
-  private Marshaller<Object> mockMarshaller;
+  private final FakeThrottler fakeThrottler = new FakeThrottler();
+  private final String channelTarget = "channelTarget";
   @Captor
   private ArgumentCaptor<SubchannelPicker> pickerCaptor;
-  private MethodDescriptor<Object, Object> fakeSearchMethod;
-  private MethodDescriptor<Object, Object> fakeRescueMethod;
+  private MethodDescriptor<Void, Void> fakeSearchMethod;
+  private MethodDescriptor<Void, Void> fakeRescueMethod;
   private RlsLoadBalancer rlsLb;
-  private boolean existingEnableOobChannelDirectPath;
   private String defaultTarget = "defaultTarget";
+  private PickSubchannelArgs searchSubchannelArgs;
+  private PickSubchannelArgs rescueSubchannelArgs;
 
   @Before
-  public void setUp() throws Exception {
-    MockitoAnnotations.initMocks(this);
-
-    existingEnableOobChannelDirectPath = CachingRlsLbClient.enableOobChannelDirectPath;
-    CachingRlsLbClient.enableOobChannelDirectPath = false;
-
+  public void setUp() {
     fakeSearchMethod =
-        MethodDescriptor.newBuilder()
+        MethodDescriptor.<Void, Void>newBuilder()
             .setFullMethodName("com.google/Search")
-            .setRequestMarshaller(mockMarshaller)
-            .setResponseMarshaller(mockMarshaller)
+            .setRequestMarshaller(TestMethodDescriptors.voidMarshaller())
+            .setResponseMarshaller(TestMethodDescriptors.voidMarshaller())
             .setType(MethodType.CLIENT_STREAMING)
             .build();
     fakeRescueMethod =
-        MethodDescriptor.newBuilder()
+        MethodDescriptor.<Void, Void>newBuilder()
             .setFullMethodName("com.google/Rescue")
-            .setRequestMarshaller(mockMarshaller)
-            .setResponseMarshaller(mockMarshaller)
+            .setRequestMarshaller(TestMethodDescriptors.voidMarshaller())
+            .setResponseMarshaller(TestMethodDescriptors.voidMarshaller())
             .setType(MethodType.UNARY)
             .build();
     fakeRlsServerImpl.setLookupTable(
         ImmutableMap.of(
-            new RouteLookupRequest(
-                "fake-bigtable.googleapis.com", "/com.google/Search", "grpc",
-                ImmutableMap.<String, String>of()),
-            new RouteLookupResponse(ImmutableList.of("wilderness"), "where are you?"),
-            new RouteLookupRequest(
-                "fake-bigtable.googleapis.com", "/com.google/Rescue", "grpc",
-                ImmutableMap.<String, String>of()),
-            new RouteLookupResponse(ImmutableList.of("civilization"), "you are safe")));
+            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 default throttler which doesn't throttle
-        return CachingRlsLbClient.newBuilder();
+        // 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() throws Exception {
+  public void tearDown() {
     rlsLb.shutdown();
-    CachingRlsLbClient.enableOobChannelDirectPath = existingEnableOobChannelDirectPath;
   }
 
   @Test
-  public void lb_working_withDefaultTarget() throws Exception {
-    deliverResolvedAddresses();
+  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();
-    Metadata headers = new Metadata();
-    PickResult res = picker.pickSubchannel(
-        new PickSubchannelArgsImpl(fakeSearchMethod, headers, CallOptions.DEFAULT));
-    inOrder.verify(helper).createSubchannel(any(CreateSubchannelArgs.class));
+    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(subchannelIsReady(res.getSubchannel())).isFalse();
 
-    assertThat(subchannels).hasSize(1);
+    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().getAddresses()).isEqualTo(searchSubchannel.getAddresses());
-    assertThat(res.getSubchannel().getAttributes()).isEqualTo(searchSubchannel.getAttributes());
+    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(
-        new PickSubchannelArgsImpl(fakeRescueMethod, headers, CallOptions.DEFAULT));
+    res = picker.pickSubchannel(rescueSubchannelArgs);
     inOrder.verify(helper).createSubchannel(any(CreateSubchannelArgs.class));
     // other rls picker itself is ready due to first channel.
-    inOrder.verify(helper)
-        .updateBalancingState(eq(ConnectivityState.READY), pickerCaptor.capture());
-    inOrder.verifyNoMoreInteractions();
     assertThat(res.getStatus().isOk()).isTrue();
     assertThat(subchannelIsReady(res.getSubchannel())).isFalse();
-    assertThat(subchannels).hasSize(2);
+    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.NOT_FOUND));
+    searchSubchannel.updateState(ConnectivityStateInfo.forTransientFailure(Status.UNAVAILABLE));
     inOrder.verify(helper)
         .updateBalancingState(eq(ConnectivityState.CONNECTING), pickerCaptor.capture());
 
@@ -218,40 +305,180 @@ public void lb_working_withDefaultTarget() throws Exception {
     inOrder.verify(helper)
         .updateBalancingState(eq(ConnectivityState.READY), pickerCaptor.capture());
 
-    // search again, use pending fallback because searchSubchannel is in failure mode
-    res = picker.pickSubchannel(
-        new PickSubchannelArgsImpl(fakeSearchMethod, headers, CallOptions.DEFAULT));
-    assertThat(res.getStatus().isOk()).isTrue();
+    // 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");
+  }
 
-    inOrder.verify(helper).createSubchannel(any(CreateSubchannelArgs.class));
-    assertThat(subchannels).hasSize(3);
-    FakeSubchannel fallbackSubchannel = subchannels.getLast();
-    fallbackSubchannel.updateState(ConnectivityStateInfo.forNonError(ConnectivityState.READY));
-    inOrder.verify(helper, times(2))
-        .updateBalancingState(eq(ConnectivityState.READY), pickerCaptor.capture());
-    inOrder.verifyNoMoreInteractions();
+  @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());
 
-    res = picker.pickSubchannel(
-        new PickSubchannelArgsImpl(fakeSearchMethod, headers, CallOptions.DEFAULT));
-    assertThat(subchannelIsReady(res.getSubchannel())).isTrue();
-    assertThat(res.getSubchannel().getAddresses()).isEqualTo(searchSubchannel.getAddresses());
-    assertThat(res.getSubchannel().getAttributes()).isEqualTo(searchSubchannel.getAttributes());
+    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();
+  }
 
-    res = picker.pickSubchannel(
-        new PickSubchannelArgsImpl(fakeRescueMethod, headers, CallOptions.DEFAULT));
-    assertThat(subchannelIsReady(res.getSubchannel())).isTrue();
-    assertThat(res.getSubchannel().getAddresses()).isEqualTo(rescueSubchannel.getAddresses());
-    assertThat(res.getSubchannel().getAttributes()).isEqualTo(rescueSubchannel.getAttributes());
+  @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());
 
-    // all channels are failed
-    rescueSubchannel.updateState(ConnectivityStateInfo.forTransientFailure(Status.NOT_FOUND));
+    StreamRecorder<Void> recorder = StreamRecorder.create();
+    CallOptions callOptions = CallOptions.DEFAULT
+        .withOption(Grpc.CALL_OPTION_CUSTOM_LABEL, "customvalue");
+    StreamObserver<Void> requestObserver = ClientCalls.asyncClientStreamingCall(
+        channel.newCall(fakeSearchMethod, callOptions), 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("customvalue")));
+  }
+
+  @Test
+  public void lb_working_withoutDefaultTarget_noRlsResponse() throws Exception {
+    defaultTarget = "";
+    fakeThrottler.nextResult = true;
+
+    deliverResolvedAddresses();
+    InOrder inOrder = inOrder(helper);
     inOrder.verify(helper)
-        .updateBalancingState(eq(ConnectivityState.READY), pickerCaptor.capture());
-    fallbackSubchannel.updateState(ConnectivityStateInfo.forTransientFailure(Status.NOT_FOUND));
+        .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.TRANSIENT_FAILURE), pickerCaptor.capture());
+        .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
@@ -262,38 +489,40 @@ public void lb_working_withoutDefaultTarget() throws Exception {
     inOrder.verify(helper)
         .updateBalancingState(eq(ConnectivityState.CONNECTING), pickerCaptor.capture());
     SubchannelPicker picker = pickerCaptor.getValue();
-    Metadata headers = new Metadata();
-    PickResult res = picker.pickSubchannel(
-        new PickSubchannelArgsImpl(fakeSearchMethod, headers, CallOptions.DEFAULT));
+    // 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)
+    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 = subchannels.getLast();
-    searchSubchannel.updateState(ConnectivityStateInfo.forNonError(ConnectivityState.READY));
-    inOrder.verify(helper)
-        .updateBalancingState(eq(ConnectivityState.READY), pickerCaptor.capture());
+    FakeSubchannel searchSubchannel =
+        (FakeSubchannel) markReadyAndGetPickResult(inOrder, searchSubchannelArgs).getSubchannel();
+    inOrder.verify(helper).getMetricRecorder();
+    inOrder.verify(helper).getChannelTarget();
     inOrder.verifyNoMoreInteractions();
-    assertThat(subchannelIsReady(res.getSubchannel())).isTrue();
-    assertThat(res.getSubchannel().getAddresses()).isEqualTo(searchSubchannel.getAddresses());
-    assertThat(res.getSubchannel().getAttributes()).isEqualTo(searchSubchannel.getAttributes());
+    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(
-        new PickSubchannelArgsImpl(fakeRescueMethod, headers, CallOptions.DEFAULT));
+    res = picker.pickSubchannel(rescueSubchannelArgs);
     inOrder.verify(helper).createSubchannel(any(CreateSubchannelArgs.class));
     // other rls picker itself is ready due to first channel.
-    inOrder.verify(helper)
-        .updateBalancingState(eq(ConnectivityState.READY), pickerCaptor.capture());
-    inOrder.verifyNoMoreInteractions();
     assertThat(res.getStatus().isOk()).isTrue();
-    assertThat(subchannelIsReady(res.getSubchannel())).isFalse();
     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));
@@ -306,43 +535,45 @@ public void lb_working_withoutDefaultTarget() throws Exception {
 
     // search method will fail because there is no fallback target.
     picker = pickerCaptor.getValue();
-    res = picker.pickSubchannel(
-        new PickSubchannelArgsImpl(fakeSearchMethod, headers, CallOptions.DEFAULT));
+    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(
-        new PickSubchannelArgsImpl(fakeRescueMethod, headers, CallOptions.DEFAULT));
+    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 {
-    deliverResolvedAddresses();
+    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();
-    Metadata headers = new Metadata();
-    PickResult res =
-        picker.pickSubchannel(
-            new PickSubchannelArgsImpl(fakeSearchMethod, headers, CallOptions.DEFAULT));
+    PickResult res = picker.pickSubchannel(newPickSubchannelArgs(fakeSearchMethod));
     assertThat(res.getStatus().isOk()).isTrue();
     assertThat(subchannelIsReady(res.getSubchannel())).isFalse();
 
     inOrder.verify(helper).createSubchannel(any(CreateSubchannelArgs.class));
-    inOrder.verify(helper)
-        .updateBalancingState(eq(ConnectivityState.CONNECTING), pickerCaptor.capture());
-    assertThat(subchannels).hasSize(1);
-    inOrder.verifyNoMoreInteractions();
+    assertThat(subchannels).hasSize(2); // includes fallback sub-channel
 
     FakeSubchannel searchSubchannel = subchannels.getLast();
     searchSubchannel.updateState(ConnectivityStateInfo.forNonError(ConnectivityState.READY));
@@ -351,13 +582,15 @@ public void lb_nameResolutionFailed() throws Exception {
 
     SubchannelPicker picker2 = pickerCaptor.getValue();
     assertThat(picker2).isEqualTo(picker);
-    res = picker2.pickSubchannel(
-        new PickSubchannelArgsImpl(fakeSearchMethod, headers, CallOptions.DEFAULT));
+    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);
@@ -365,17 +598,26 @@ public void lb_nameResolutionFailed() throws Exception {
     verify(helper)
         .updateBalancingState(eq(ConnectivityState.TRANSIENT_FAILURE), pickerCaptor.capture());
     SubchannelPicker failedPicker = pickerCaptor.getValue();
-    res = failedPicker.pickSubchannel(
-        new PickSubchannelArgsImpl(fakeSearchMethod, headers, CallOptions.DEFAULT));
+    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(getServiceConfig());
+        provider.parseLoadBalancingPolicyConfig(parseJson(getLbConfigJsonStr()));
     assertThat(parsedConfigOrError.getConfig()).isNotNull();
-    rlsLb.handleResolvedAddresses(ResolvedAddresses.newBuilder()
+    rlsLb.acceptResolvedAddresses(ResolvedAddresses.newBuilder()
         .setAddresses(ImmutableList.of(new EquivalentAddressGroup(mock(SocketAddress.class))))
         .setLoadBalancingPolicyConfig(parsedConfigOrError.getConfig())
         .build());
@@ -383,18 +625,29 @@ private void deliverResolvedAddresses() throws Exception {
   }
 
   @SuppressWarnings("unchecked")
-  private Map<String, Object> getServiceConfig() throws IOException {
-    String serviceConfig = "{"
+  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\""
         + "}";
-    return (Map<String, Object>) JsonParser.parse(serviceConfig);
   }
 
   private String getRlsConfigJsonStr() {
     return "{\n"
-        + "  \"grpcKeyBuilders\": [\n"
+        + "  \"grpcKeybuilders\": [\n"
         + "    {\n"
         + "      \"names\": [\n"
         + "        {\n"
@@ -408,20 +661,60 @@ private String getRlsConfigJsonStr() {
         + "          \"names\": [\"PermitId\"],\n"
         + "          \"optional\": true\n"
         + "        }\n"
-        + "      ]\n"
+        + "      ],\n"
+        + "      \"extraKeys\": {\n"
+        + "        \"host\": \"server\",\n"
+        + "        \"service\": \"service-key\",\n"
+        + "        \"method\": \"method-key\"\n"
+        + "      }\n"
         + "    }\n"
         + "  ],\n"
         + "  \"lookupService\": \"localhost:8972\",\n"
-        + "  \"lookupServiceTimeout\": 2,\n"
-        + "  \"maxAge\": 300,\n"
-        + "  \"staleAge\": 240,\n"
+        + "  \"lookupServiceTimeout\": \"2s\",\n"
+        + "  \"maxAge\": \"300s\",\n"
+        + "  \"staleAge\": \"240s\",\n"
         + "  \"validTargets\": [\"localhost:9001\", \"localhost:9002\"],"
-        + "  \"cacheSizeBytes\": 1000,\n"
+        + "  \"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
@@ -447,7 +740,7 @@ public ManagedChannelBuilder<?> createResolvingOobChannelBuilder(
       final InProcessChannelBuilder builder =
           InProcessChannelBuilder.forName(target).directExecutor();
 
-      class CleaningChannelBuilder extends ForwardingChannelBuilder<CleaningChannelBuilder> {
+      class CleaningChannelBuilder extends ForwardingChannelBuilder2<CleaningChannelBuilder> {
 
         @Override
         protected ManagedChannelBuilder<?> delegate() {
@@ -474,6 +767,11 @@ public void updateBalancingState(
       // no-op
     }
 
+    @Override
+    public void refreshNameResolution() {
+      // no-op
+    }
+
     @Override
     public String getAuthority() {
       return "fake-bigtable.googleapis.com";
@@ -493,7 +791,7 @@ public ChannelCredentials withoutBearerTokens() {
 
     @Override
     public ScheduledExecutorService getScheduledExecutorService() {
-      return fakeScheduledExecutorService;
+      return fakeClock.getScheduledExecutorService();
     }
 
     @Override
@@ -505,6 +803,16 @@ public SynchronizationContext getSynchronizationContext() {
     public ChannelLogger getChannelLogger() {
       return mock(ChannelLogger.class);
     }
+
+    @Override
+    public MetricRecorder getMetricRecorder() {
+      return mockMetricRecorder;
+    }
+
+    @Override
+    public String getChannelTarget() {
+      return channelTarget;
+    }
   }
 
   private static final class FakeRlsServerImpl
@@ -515,17 +823,41 @@ private static final class FakeRlsServerImpl
     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 {
@@ -539,7 +871,7 @@ private static final class FakeSubchannel extends Subchannel {
     private final Attributes attributes;
     private List<EquivalentAddressGroup> eags;
     private SubchannelStateListener listener;
-    private boolean isReady;
+    private volatile boolean isReady;
 
     public FakeSubchannel(List<EquivalentAddressGroup> eags, Attributes attributes) {
       this.eags = Collections.unmodifiableList(eags);
@@ -583,4 +915,20 @@ public void updateState(ConnectivityStateInfo newState) {
   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
index 2f7d84d6b13..82ad606c50d 100644
--- a/rls/src/test/java/io/grpc/rls/RlsProtoConvertersTest.java
+++ b/rls/src/test/java/io/grpc/rls/RlsProtoConvertersTest.java
@@ -17,6 +17,7 @@
 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;
@@ -27,6 +28,7 @@
 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;
@@ -46,18 +48,12 @@ public void convert_toRequestProto() {
     Converter<RouteLookupRequest, RlsProtoData.RouteLookupRequest> converter =
         new RouteLookupRequestConverter();
     RouteLookupRequest proto = RouteLookupRequest.newBuilder()
-        .setServer("server")
-        .setPath("path")
-        .setTargetType("target")
         .putKeyMap("key1", "val1")
         .build();
 
     RlsProtoData.RouteLookupRequest object = converter.convert(proto);
 
-    assertThat(object.getServer()).isEqualTo("server");
-    assertThat(object.getPath()).isEqualTo("path");
-    assertThat(object.getTargetType()).isEqualTo("target");
-    assertThat(object.getKeyMap()).containsExactly("key1", "val1");
+    assertThat(object.keyMap()).containsExactly("key1", "val1");
   }
 
   @Test
@@ -65,15 +61,14 @@ public void convert_toRequestObject() {
     Converter<RlsProtoData.RouteLookupRequest, RouteLookupRequest> converter =
         new RouteLookupRequestConverter().reverse();
     RlsProtoData.RouteLookupRequest requestObject =
-        new RlsProtoData.RouteLookupRequest(
-            "server", "path", "target", ImmutableMap.of("key1", "val1"));
+        RlsProtoData.RouteLookupRequest.create(ImmutableMap.of("key1", "val1"),
+            RlsProtoData.RouteLookupRequest.Reason.REASON_MISS);
 
     RouteLookupRequest proto = converter.convert(requestObject);
 
-    assertThat(proto.getServer()).isEqualTo("server");
-    assertThat(proto.getPath()).isEqualTo("path");
-    assertThat(proto.getTargetType()).isEqualTo("target");
+    assertThat(proto.getTargetType()).isEqualTo("grpc");
     assertThat(proto.getKeyMapMap()).containsExactly("key1", "val1");
+    assertThat(proto.getReason()).isEqualTo(RouteLookupRequest.Reason.REASON_MISS);
   }
 
   @Test
@@ -87,7 +82,7 @@ public void convert_toResponseProto() {
 
     RlsProtoData.RouteLookupResponse object = converter.convert(proto);
 
-    assertThat(object.getTargets()).containsExactly("target");
+    assertThat(object.targets()).containsExactly("target");
     assertThat(object.getHeaderData()).isEqualTo("some header data");
   }
 
@@ -97,7 +92,7 @@ public void convert_toResponseObject() {
         new RouteLookupResponseConverter().reverse();
 
     RlsProtoData.RouteLookupResponse object =
-        new RlsProtoData.RouteLookupResponse(ImmutableList.of("target"), "some header data");
+        RlsProtoData.RouteLookupResponse.create(ImmutableList.of("target"), "some header data");
 
     RouteLookupResponse proto = converter.convert(object);
 
@@ -108,7 +103,7 @@ public void convert_toResponseObject() {
   @Test
   public void convert_jsonRlsConfig() throws IOException {
     String jsonStr = "{\n"
-        + "  \"grpcKeyBuilders\": [\n"
+        + "  \"grpcKeybuilders\": [\n"
         + "    {\n"
         + "      \"names\": [\n"
         + "        {\n"
@@ -162,42 +157,430 @@ public void convert_jsonRlsConfig() throws IOException {
         + "          \"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"
-        + "  \"lookupServiceTimeout\": 2,\n"
-        + "  \"maxAge\": 300,\n"
-        + "  \"staleAge\": 240,\n"
         + "  \"validTargets\": [\"a valid target\"],"
-        + "  \"cacheSizeBytes\": 1000,\n"
         + "  \"defaultTarget\": \"us_east_1.cloudbigtable.googleapis.com\"\n"
         + "}";
 
     RouteLookupConfig expectedConfig =
-        new RouteLookupConfig(
-            ImmutableList.of(
-                new GrpcKeyBuilder(
-                    ImmutableList.of(new Name("service1", "create")),
+        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(
-                        new NameMatcher("user", ImmutableList.of("User", "Parent"), true),
-                        new NameMatcher("id", ImmutableList.of("X-Google-Id"), true))),
-                new GrpcKeyBuilder(
-                    ImmutableList.of(new Name("service1")),
+                        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(
-                        new NameMatcher("user", ImmutableList.of("User", "Parent"), true),
-                        new NameMatcher("password", ImmutableList.of("Password"), true))),
-                new GrpcKeyBuilder(
-                    ImmutableList.of(new Name("service3")),
+                        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_clampMaxAgeIfStaleAgeMissing() 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" // Exceeds 5m limit
+        + "  \"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(
-                        new NameMatcher("user", ImmutableList.of("User", "Parent"), true)))),
-            /* lookupService= */ "service1",
-            /* lookupServiceTimeoutInMillis= */ TimeUnit.SECONDS.toMillis(2),
-            /* maxAgeInMillis= */ TimeUnit.SECONDS.toMillis(300),
-            /* staleAgeInMillis= */ TimeUnit.SECONDS.toMillis(240),
-            /* cacheSizeBytes= */ 1000,
-            /* validTargets= */ ImmutableList.of("a valid target"),
-            /* defaultTarget= */ "us_east_1.cloudbigtable.googleapis.com");
+                        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))
+            // Should be clamped to 300s (5m) because staleAge is missing
+            .maxAgeInNanos(TimeUnit.MINUTES.toNanos(5))
+            .staleAgeInNanos(TimeUnit.MINUTES.toNanos(5))
+            .cacheSizeBytes(1000)
+            .defaultTarget("us_east_1.cloudbigtable.googleapis.com")
+            .build();
 
     RouteLookupConfigConverter converter = new RouteLookupConfigConverter();
     @SuppressWarnings("unchecked")
@@ -205,4 +588,128 @@ public void convert_jsonRlsConfig() throws IOException {
     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
index 8661e023346..2b900994ed9 100644
--- a/rls/src/test/java/io/grpc/rls/RlsRequestFactoryTest.java
+++ b/rls/src/test/java/io/grpc/rls/RlsRequestFactoryTest.java
@@ -17,17 +17,15 @@
 package io.grpc.rls;
 
 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 io.grpc.Metadata;
-import io.grpc.Status.Code;
-import io.grpc.StatusRuntimeException;
+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 java.util.concurrent.TimeUnit;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -37,34 +35,41 @@
 public class RlsRequestFactoryTest {
 
   private static final RouteLookupConfig RLS_CONFIG =
-      new RouteLookupConfig(
-          ImmutableList.of(
-              new GrpcKeyBuilder(
-                  ImmutableList.of(new Name("com.google.service1", "Create")),
+      RouteLookupConfig.builder()
+          .grpcKeybuilders(ImmutableList.of(
+              GrpcKeyBuilder.create(
+                  ImmutableList.of(Name.create("com.google.service1", "Create")),
                   ImmutableList.of(
-                      new NameMatcher("user", ImmutableList.of("User", "Parent"), true),
-                      new NameMatcher("id", ImmutableList.of("X-Google-Id"), true))),
-              new GrpcKeyBuilder(
-                  ImmutableList.of(new Name("com.google.service1")),
+                      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(
-                      new NameMatcher("user", ImmutableList.of("User", "Parent"), true),
-                      new NameMatcher("password", ImmutableList.of("Password"), true))),
-              new GrpcKeyBuilder(
-                  ImmutableList.of(new Name("com.google.service2")),
+                      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(
-                      new NameMatcher("user", ImmutableList.of("User", "Parent"), false),
-                      new NameMatcher("password", ImmutableList.of("Password"), true))),
-              new GrpcKeyBuilder(
-                  ImmutableList.of(new Name("com.google.service3")),
+                      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(
-                      new NameMatcher("user", ImmutableList.of("User", "Parent"), true)))),
-          /* lookupService= */ "bigtable-rls.googleapis.com",
-          /* lookupServiceTimeoutInMillis= */ TimeUnit.SECONDS.toMillis(2),
-          /* maxAgeInMillis= */ TimeUnit.SECONDS.toMillis(300),
-          /* staleAgeInMillis= */ TimeUnit.SECONDS.toMillis(240),
-          /* cacheSizeBytes= */ 1000,
-          /* validTargets= */ ImmutableList.of("a valid target"),
-          /* defaultTarget= */ "us_east_1.cloudbigtable.googleapis.com");
+                      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");
@@ -76,25 +81,13 @@ public void create_pathMatches() {
     metadata.put(Metadata.Key.of("X-Google-Id", Metadata.ASCII_STRING_MARSHALLER), "123");
     metadata.put(Metadata.Key.of("foo", Metadata.ASCII_STRING_MARSHALLER), "bar");
 
-    RouteLookupRequest request = factory.create("com.google.service1", "Create", metadata);
-    assertThat(request.getTargetType()).isEqualTo("grpc");
-    assertThat(request.getPath()).isEqualTo("/com.google.service1/Create");
-    assertThat(request.getServer()).isEqualTo("bigtable.googleapis.com");
-    assertThat(request.getKeyMap()).containsExactly("user", "test", "id", "123");
-  }
-
-  @Test
-  public void create_missingRequiredHeader() {
-    Metadata metadata = new Metadata();
-
-    try {
-      RouteLookupRequest unused = factory.create("com.google.service2", "Create", metadata);
-      fail();
-    } catch (StatusRuntimeException e) {
-      assertThat(e.getStatus().getCode()).isEqualTo(Code.INVALID_ARGUMENT);
-      assertThat(e.getStatus().getDescription())
-          .isEqualTo("Missing mandatory metadata(user) not found");
-    }
+    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
@@ -104,12 +97,14 @@ public void create_pathFallbackMatches() {
     metadata.put(Metadata.Key.of("Password", Metadata.ASCII_STRING_MARSHALLER), "hunter2");
     metadata.put(Metadata.Key.of("foo", Metadata.ASCII_STRING_MARSHALLER), "bar");
 
-    RouteLookupRequest request = factory.create("com.google.service1" , "Update", metadata);
+    RlsProtoData.RouteLookupRequestKey routeLookupRequestKey =
+        factory.create("com.google.service1" , "Update", metadata);
 
-    assertThat(request.getTargetType()).isEqualTo("grpc");
-    assertThat(request.getPath()).isEqualTo("/com.google.service1/Update");
-    assertThat(request.getServer()).isEqualTo("bigtable.googleapis.com");
-    assertThat(request.getKeyMap()).containsExactly("user", "test", "password", "hunter2");
+    assertThat(routeLookupRequestKey.keyMap()).containsExactly(
+        "user", "test",
+        "password", "hunter2",
+        "service-2", "com.google.service1",
+        "const-key-2", "const-value-2");
   }
 
   @Test
@@ -119,12 +114,13 @@ public void create_pathFallbackMatches_optionalHeaderMissing() {
     metadata.put(Metadata.Key.of("X-Google-Id", Metadata.ASCII_STRING_MARSHALLER), "123");
     metadata.put(Metadata.Key.of("foo", Metadata.ASCII_STRING_MARSHALLER), "bar");
 
-    RouteLookupRequest request = factory.create("com.google.service1", "Update", metadata);
+    RlsProtoData.RouteLookupRequestKey routeLookupRequestKey =
+        factory.create("com.google.service1", "Update", metadata);
 
-    assertThat(request.getTargetType()).isEqualTo("grpc");
-    assertThat(request.getPath()).isEqualTo("/com.google.service1/Update");
-    assertThat(request.getServer()).isEqualTo("bigtable.googleapis.com");
-    assertThat(request.getKeyMap()).containsExactly("user", "test");
+    assertThat(routeLookupRequestKey.keyMap()).containsExactly(
+        "user", "test",
+        "service-2", "com.google.service1",
+        "const-key-2", "const-value-2");
   }
 
   @Test
@@ -134,12 +130,9 @@ public void create_unknownPath() {
     metadata.put(Metadata.Key.of("X-Google-Id", Metadata.ASCII_STRING_MARSHALLER), "123");
     metadata.put(Metadata.Key.of("foo", Metadata.ASCII_STRING_MARSHALLER), "bar");
 
-    RouteLookupRequest request = factory.create("abc.def.service999", "Update", metadata);
-
-    assertThat(request.getTargetType()).isEqualTo("grpc");
-    assertThat(request.getPath()).isEqualTo("/abc.def.service999/Update");
-    assertThat(request.getServer()).isEqualTo("bigtable.googleapis.com");
-    assertThat(request.getKeyMap()).isEmpty();
+    RlsProtoData.RouteLookupRequestKey routeLookupRequestKey =
+        factory.create("abc.def.service999", "Update", metadata);
+    assertThat(routeLookupRequestKey.keyMap()).isEmpty();
   }
 
   @Test
@@ -149,11 +142,10 @@ public void create_noMethodInRlsConfig() {
     metadata.put(Metadata.Key.of("X-Google-Id", Metadata.ASCII_STRING_MARSHALLER), "123");
     metadata.put(Metadata.Key.of("foo", Metadata.ASCII_STRING_MARSHALLER), "bar");
 
-    RouteLookupRequest request = factory.create("com.google.service3", "Update", metadata);
+    RlsProtoData.RouteLookupRequestKey routeLookupRequestKey =
+        factory.create("com.google.service3", "Update", metadata);
 
-    assertThat(request.getTargetType()).isEqualTo("grpc");
-    assertThat(request.getPath()).isEqualTo("/com.google.service3/Update");
-    assertThat(request.getServer()).isEqualTo("bigtable.googleapis.com");
-    assertThat(request.getKeyMap()).containsExactly("user", "test");
+    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
index a6d42e7d2a3..317d49448e5 100644
--- a/rls/src/test/java/io/grpc/rls/SubchannelStateManagerImplTest.java
+++ b/rls/src/test/java/io/grpc/rls/SubchannelStateManagerImplTest.java
@@ -90,5 +90,13 @@ public void getAggregateState_multipleSubchannels() {
 
     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/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..37236f26f4b
--- /dev/null
+++ b/s2a/src/main/java/io/grpc/s2a/internal/handshaker/S2AStub.java
@@ -0,0 +1,245 @@
+/*
+ * 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 long deadlineSeconds = HANDSHAKE_RPC_DEADLINE_SECS;
+  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 newInstanceWithDeadline(
+      S2AServiceGrpc.S2AServiceStub serviceStub, long deadlineSeconds) {
+    checkNotNull(serviceStub);
+    checkArgument(deadlineSeconds > 0);
+    return new S2AStub(serviceStub, deadlineSeconds);
+  }
+
+  @VisibleForTesting
+  static S2AStub newInstanceForTesting(StreamObserver<SessionReq> writer) {
+    checkNotNull(writer);
+    return new S2AStub(writer);
+  }
+
+  private S2AStub(S2AServiceGrpc.S2AServiceStub serviceStub) {
+    this.serviceStub = serviceStub;
+  }
+
+  private S2AStub(S2AServiceGrpc.S2AServiceStub serviceStub, long deadlineSeconds) {
+    this.serviceStub = serviceStub;
+    this.deadlineSeconds = deadlineSeconds;
+  }
+
+  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(deadlineSeconds, 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..2c7a7dd8405
--- /dev/null
+++ b/s2a/src/test/java/io/grpc/s2a/internal/handshaker/S2AStubTest.java
@@ -0,0 +1,285 @@
+/*
+ * 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 {
+    SessionReq req =
+        SessionReq.newBuilder()
+            .setGetTlsConfigurationReq(
+                GetTlsConfigurationReq.newBuilder()
+                    .setConnectionSide(ConnectionSide.CONNECTION_SIDE_CLIENT))
+            .build();
+
+    SessionResp resp = stub.send(req);
+
+    assertThat(resp.hasGetTlsConfigurationResp()).isTrue();
+    assertThat(resp.getGetTlsConfigurationResp().hasClientTlsConfiguration()).isTrue();
+  }
+
+  @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_withUnavailableService_throwsDeadlineExceeded() throws Exception {
+    ObjectPool<Channel> channelPool =
+        SharedResourcePool.forResource(
+            S2AHandshakerServiceChannel.getChannelResource(
+                S2A_ADDRESS, InsecureChannelCredentials.create()));
+    S2AServiceGrpc.S2AServiceStub serviceStub = S2AServiceGrpc.newStub(channelPool.getObject());
+    S2AStub newStub = S2AStub.newInstanceWithDeadline(serviceStub, 1);
+
+    IOException expected =
+        assertThrows(IOException.class, () -> newStub.send(SessionReq.getDefaultInstance()));
+
+    assertThat(expected).hasMessageThat().contains("DEADLINE_EXCEEDED");
+  }
+
+  @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
index 97b5120ccd3..ba9d334a5c9 100644
--- a/services/BUILD.bazel
+++ b/services/BUILD.bazel
@@ -1,44 +1,107 @@
+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/services/BinaryLogProvider.java",
-        "src/main/java/io/grpc/services/BinaryLogProviderImpl.java",
-        "src/main/java/io/grpc/services/BinaryLogSink.java",
-        "src/main/java/io/grpc/services/BinlogHelper.java",
-        "src/main/java/io/grpc/services/InetAddressUtil.java",
-        "src/main/java/io/grpc/services/TempFileSink.java",
+        "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_code_findbugs_jsr305//jar",
-        "@com_google_guava_guava//jar",
         "@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/services/ChannelzProtoUtil.java",
+        "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",
-        "//context",
         "//stub",
-        "@com_google_code_findbugs_jsr305//jar",
-        "@com_google_guava_guava//jar",
         "@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"),
     ],
 )
 
@@ -46,27 +109,29 @@ 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",
-        "//context",
-        "//core:internal",
-        "//core:util",
         "//protobuf",
         "//stub",
-        "@com_google_code_findbugs_jsr305//jar",
-        "@com_google_guava_guava//jar",
         "@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/services/HealthServiceImpl.java",
+        "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 = [
@@ -74,9 +139,31 @@ java_library(
         "//api",
         "//context",
         "//stub",
-        "@com_google_code_findbugs_jsr305//jar",
-        "@com_google_guava_guava//jar",
         "@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"),
     ],
 )
 
@@ -90,6 +177,13 @@ java_grpc_library(
     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"],
diff --git a/services/build.gradle b/services/build.gradle
index f5132515528..c30e1ba53bd 100644
--- a/services/build.gradle
+++ b/services/build.gradle
@@ -8,7 +8,7 @@ plugins {
 
 description = "gRPC: Services"
 
-[compileJava].each() {
+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 += [
@@ -16,42 +16,51 @@ description = "gRPC: Services"
     ]
 }
 
-evaluationDependsOn(project(':grpc-core').path)
+tasks.named("jar").configure {
+    manifest {
+        attributes('Automatic-Module-Name': 'io.grpc.services')
+    }
+}
 
 dependencies {
-    api project(':grpc-protobuf'),
-            project(':grpc-stub'),
-            project(':grpc-core')
-    implementation (libraries.protobuf_util) {
-        // prefer our own versions instead of protobuf-util's dependency
-        exclude group: 'com.google.guava', module: 'guava'
-        exclude group: 'com.google.errorprone', module: 'error_prone_annotations'
-    }
-    guavaDependency 'implementation'
-    runtimeOnly libraries.errorprone
+    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
 
-    compileOnly libraries.javax_annotation
+    runtimeOnly libraries.errorprone.annotations,
+            libraries.gson  // to fix checkUpperBoundDeps error here
     testImplementation project(':grpc-testing'),
-            libraries.netty_epoll, // for DomainSocketAddress
-            project(':grpc-core').sourceSets.test.output  // for FakeClock
-    testCompileOnly libraries.javax_annotation
-    signature "org.codehaus.mojo.signature:java17:1.0@signature"
+            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()
 
-javadoc {
+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/*'
 }
 
-jacocoTestReport {
+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
index 87e302407f8..c4ac4076d22 100644
--- a/services/src/generated/main/grpc/io/grpc/channelz/v1/ChannelzGrpc.java
+++ b/services/src/generated/main/grpc/io/grpc/channelz/v1/ChannelzGrpc.java
@@ -8,14 +8,12 @@
  * information.
  * </pre>
  */
-@javax.annotation.Generated(
-    value = "by gRPC proto compiler",
-    comments = "Source: grpc/channelz/v1/channelz.proto")
+@io.grpc.stub.annotations.GrpcGenerated
 public final class ChannelzGrpc {
 
   private ChannelzGrpc() {}
 
-  public static final String SERVICE_NAME = "grpc.channelz.v1.Channelz";
+  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,
@@ -249,6 +247,21 @@ public ChannelzStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOpt
     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
    */
@@ -285,7 +298,7 @@ public ChannelzFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions c
    * information.
    * </pre>
    */
-  public static abstract class ChannelzImplBase implements io.grpc.BindableService {
+  public interface AsyncService {
 
     /**
      * <pre>
@@ -293,7 +306,7 @@ public static abstract class ChannelzImplBase implements io.grpc.BindableService
      * created). This does not include subchannels nor non-top level channels.
      * </pre>
      */
-    public void getTopChannels(io.grpc.channelz.v1.GetTopChannelsRequest request,
+    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);
     }
@@ -303,7 +316,7 @@ public void getTopChannels(io.grpc.channelz.v1.GetTopChannelsRequest request,
      * Gets all servers that exist in the process.
      * </pre>
      */
-    public void getServers(io.grpc.channelz.v1.GetServersRequest request,
+    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);
     }
@@ -313,7 +326,7 @@ public void getServers(io.grpc.channelz.v1.GetServersRequest request,
      * Returns a single Server, or else a NOT_FOUND code.
      * </pre>
      */
-    public void getServer(io.grpc.channelz.v1.GetServerRequest request,
+    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);
     }
@@ -323,7 +336,7 @@ public void getServer(io.grpc.channelz.v1.GetServerRequest request,
      * Gets all server sockets that exist in the process.
      * </pre>
      */
-    public void getServerSockets(io.grpc.channelz.v1.GetServerSocketsRequest request,
+    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);
     }
@@ -333,7 +346,7 @@ public void getServerSockets(io.grpc.channelz.v1.GetServerSocketsRequest request
      * Returns a single Channel, or else a NOT_FOUND code.
      * </pre>
      */
-    public void getChannel(io.grpc.channelz.v1.GetChannelRequest request,
+    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);
     }
@@ -343,7 +356,7 @@ public void getChannel(io.grpc.channelz.v1.GetChannelRequest request,
      * Returns a single Subchannel, or else a NOT_FOUND code.
      * </pre>
      */
-    public void getSubchannel(io.grpc.channelz.v1.GetSubchannelRequest request,
+    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);
     }
@@ -353,73 +366,36 @@ public void getSubchannel(io.grpc.channelz.v1.GetSubchannelRequest request,
      * Returns a single Socket or else a NOT_FOUND code.
      * </pre>
      */
-    public void getSocket(io.grpc.channelz.v1.GetSocketRequest request,
+    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 io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
-          .addMethod(
-            getGetTopChannelsMethod(),
-            io.grpc.stub.ServerCalls.asyncUnaryCall(
-              new MethodHandlers<
-                io.grpc.channelz.v1.GetTopChannelsRequest,
-                io.grpc.channelz.v1.GetTopChannelsResponse>(
-                  this, METHODID_GET_TOP_CHANNELS)))
-          .addMethod(
-            getGetServersMethod(),
-            io.grpc.stub.ServerCalls.asyncUnaryCall(
-              new MethodHandlers<
-                io.grpc.channelz.v1.GetServersRequest,
-                io.grpc.channelz.v1.GetServersResponse>(
-                  this, METHODID_GET_SERVERS)))
-          .addMethod(
-            getGetServerMethod(),
-            io.grpc.stub.ServerCalls.asyncUnaryCall(
-              new MethodHandlers<
-                io.grpc.channelz.v1.GetServerRequest,
-                io.grpc.channelz.v1.GetServerResponse>(
-                  this, METHODID_GET_SERVER)))
-          .addMethod(
-            getGetServerSocketsMethod(),
-            io.grpc.stub.ServerCalls.asyncUnaryCall(
-              new MethodHandlers<
-                io.grpc.channelz.v1.GetServerSocketsRequest,
-                io.grpc.channelz.v1.GetServerSocketsResponse>(
-                  this, METHODID_GET_SERVER_SOCKETS)))
-          .addMethod(
-            getGetChannelMethod(),
-            io.grpc.stub.ServerCalls.asyncUnaryCall(
-              new MethodHandlers<
-                io.grpc.channelz.v1.GetChannelRequest,
-                io.grpc.channelz.v1.GetChannelResponse>(
-                  this, METHODID_GET_CHANNEL)))
-          .addMethod(
-            getGetSubchannelMethod(),
-            io.grpc.stub.ServerCalls.asyncUnaryCall(
-              new MethodHandlers<
-                io.grpc.channelz.v1.GetSubchannelRequest,
-                io.grpc.channelz.v1.GetSubchannelResponse>(
-                  this, METHODID_GET_SUBCHANNEL)))
-          .addMethod(
-            getGetSocketMethod(),
-            io.grpc.stub.ServerCalls.asyncUnaryCall(
-              new MethodHandlers<
-                io.grpc.channelz.v1.GetSocketRequest,
-                io.grpc.channelz.v1.GetSocketResponse>(
-                  this, METHODID_GET_SOCKET)))
-          .build();
+      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> {
+  public static final class ChannelzStub
+      extends io.grpc.stub.AbstractAsyncStub<ChannelzStub> {
     private ChannelzStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -511,12 +487,106 @@ public void getSocket(io.grpc.channelz.v1.GetSocketRequest request,
   }
 
   /**
+   * 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 ChannelzBlockingStub extends io.grpc.stub.AbstractBlockingStub<ChannelzBlockingStub> {
+  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);
@@ -601,12 +671,14 @@ public io.grpc.channelz.v1.GetSocketResponse getSocket(io.grpc.channelz.v1.GetSo
   }
 
   /**
+   * 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> {
+  public static final class ChannelzFutureStub
+      extends io.grpc.stub.AbstractFutureStub<ChannelzFutureStub> {
     private ChannelzFutureStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -710,10 +782,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 ChannelzImplBase serviceImpl;
+    private final AsyncService serviceImpl;
     private final int methodId;
 
-    MethodHandlers(ChannelzImplBase serviceImpl, int methodId) {
+    MethodHandlers(AsyncService serviceImpl, int methodId) {
       this.serviceImpl = serviceImpl;
       this.methodId = methodId;
     }
@@ -766,6 +838,60 @@ public io.grpc.stub.StreamObserver<Req> invoke(
     }
   }
 
+  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() {}
@@ -789,9 +915,9 @@ private static final class ChannelzFileDescriptorSupplier
   private static final class ChannelzMethodDescriptorSupplier
       extends ChannelzBaseDescriptorSupplier
       implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
-    private final String methodName;
+    private final java.lang.String methodName;
 
-    ChannelzMethodDescriptorSupplier(String methodName) {
+    ChannelzMethodDescriptorSupplier(java.lang.String methodName) {
       this.methodName = methodName;
     }
 
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 52f39ee7816..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
@@ -4,14 +4,12 @@
 
 /**
  */
-@javax.annotation.Generated(
-    value = "by gRPC proto compiler",
-    comments = "Source: grpc/health/v1/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.
   private static volatile io.grpc.MethodDescriptor<io.grpc.health.v1.HealthCheckRequest,
@@ -90,6 +88,21 @@ public HealthStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptio
     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);
+  }
+
   /**
    * Creates a new blocking-style stub that supports unary and streaming output calls on the service
    */
@@ -122,7 +135,7 @@ public HealthFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions cal
 
   /**
    */
-  public static abstract class HealthImplBase implements io.grpc.BindableService {
+  public interface AsyncService {
 
     /**
      * <pre>
@@ -130,7 +143,7 @@ public static abstract class HealthImplBase implements io.grpc.BindableService {
      * 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) {
       io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getCheckMethod(), responseObserver);
     }
@@ -152,34 +165,28 @@ public void check(io.grpc.health.v1.HealthCheckRequest request,
      * clients should retry the call with appropriate exponential backoff.
      * </pre>
      */
-    public void watch(io.grpc.health.v1.HealthCheckRequest request,
+    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 abstract class HealthImplBase
+      implements io.grpc.BindableService, AsyncService {
 
     @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
-      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>(
-                  this, METHODID_CHECK)))
-          .addMethod(
-            getWatchMethod(),
-            io.grpc.stub.ServerCalls.asyncServerStreamingCall(
-              new MethodHandlers<
-                io.grpc.health.v1.HealthCheckRequest,
-                io.grpc.health.v1.HealthCheckResponse>(
-                  this, METHODID_WATCH)))
-          .build();
+      return HealthGrpc.bindService(this);
     }
   }
 
   /**
+   * A stub to allow clients to do asynchronous rpc calls to service Health.
    */
-  public static final class HealthStub extends io.grpc.stub.AbstractAsyncStub<HealthStub> {
+  public static final class HealthStub
+      extends io.grpc.stub.AbstractAsyncStub<HealthStub> {
     private HealthStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -228,8 +235,62 @@ public void watch(io.grpc.health.v1.HealthCheckRequest request,
   }
 
   /**
+   * A stub to allow clients to do synchronous rpc calls to service Health.
+   */
+  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);
+    }
+  }
+
+  /**
+   * 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> {
+  public static final class HealthBlockingStub
+      extends io.grpc.stub.AbstractBlockingStub<HealthBlockingStub> {
     private HealthBlockingStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -277,8 +338,10 @@ public java.util.Iterator<io.grpc.health.v1.HealthCheckResponse> watch(
   }
 
   /**
+   * A stub to allow clients to do ListenableFuture-style rpc calls to service Health.
    */
-  public static final class HealthFutureStub extends io.grpc.stub.AbstractFutureStub<HealthFutureStub> {
+  public static final class HealthFutureStub
+      extends io.grpc.stub.AbstractFutureStub<HealthFutureStub> {
     private HealthFutureStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -311,10 +374,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 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;
     }
@@ -347,6 +410,25 @@ public io.grpc.stub.StreamObserver<Req> invoke(
     }
   }
 
+  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() {}
@@ -370,9 +452,9 @@ private static final class HealthFileDescriptorSupplier
   private static final class HealthMethodDescriptorSupplier
       extends HealthBaseDescriptorSupplier
       implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
-    private final String methodName;
+    private final java.lang.String methodName;
 
-    HealthMethodDescriptorSupplier(String methodName) {
+    HealthMethodDescriptorSupplier(java.lang.String methodName) {
       this.methodName = methodName;
     }
 
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 3dc4142231d..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
@@ -4,14 +4,12 @@
 
 /**
  */
-@javax.annotation.Generated(
-    value = "by gRPC proto compiler",
-    comments = "Source: 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.
   private static volatile io.grpc.MethodDescriptor<io.grpc.reflection.v1alpha.ServerReflectionRequest,
@@ -59,6 +57,21 @@ public ServerReflectionStub newStub(io.grpc.Channel channel, io.grpc.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
    */
@@ -91,7 +104,7 @@ public ServerReflectionFutureStub newStub(io.grpc.Channel channel, io.grpc.CallO
 
   /**
    */
-  public static abstract class ServerReflectionImplBase implements io.grpc.BindableService {
+  public interface AsyncService {
 
     /**
      * <pre>
@@ -99,27 +112,28 @@ 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 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(
-            getServerReflectionInfoMethod(),
-            io.grpc.stub.ServerCalls.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.AbstractAsyncStub<ServerReflectionStub> {
+  public static final class ServerReflectionStub
+      extends io.grpc.stub.AbstractAsyncStub<ServerReflectionStub> {
     private ServerReflectionStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -145,8 +159,40 @@ public io.grpc.stub.StreamObserver<io.grpc.reflection.v1alpha.ServerReflectionRe
   }
 
   /**
+   * 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.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> {
+  public static final class ServerReflectionBlockingStub
+      extends io.grpc.stub.AbstractBlockingStub<ServerReflectionBlockingStub> {
     private ServerReflectionBlockingStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -160,8 +206,10 @@ protected ServerReflectionBlockingStub build(
   }
 
   /**
+   * 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> {
+  public static final class ServerReflectionFutureStub
+      extends io.grpc.stub.AbstractFutureStub<ServerReflectionFutureStub> {
     private ServerReflectionFutureStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -181,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;
     }
@@ -212,6 +260,18 @@ public io.grpc.stub.StreamObserver<Req> invoke(
     }
   }
 
+  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() {}
@@ -235,9 +295,9 @@ private static final class ServerReflectionFileDescriptorSupplier
   private static final class ServerReflectionMethodDescriptorSupplier
       extends ServerReflectionBaseDescriptorSupplier
       implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
-    private final String methodName;
+    private final java.lang.String methodName;
 
-    ServerReflectionMethodDescriptorSupplier(String methodName) {
+    ServerReflectionMethodDescriptorSupplier(java.lang.String methodName) {
       this.methodName = methodName;
     }
 
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 30cd9a62a20..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
@@ -7,14 +7,12 @@
  * AnotherDynamicService
  * </pre>
  */
-@javax.annotation.Generated(
-    value = "by gRPC proto compiler",
-    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.
   private static volatile io.grpc.MethodDescriptor<io.grpc.reflection.testing.DynamicRequest,
@@ -62,6 +60,21 @@ public AnotherDynamicServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOp
     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);
+  }
+
   /**
    * Creates a new blocking-style stub that supports unary and streaming output calls on the service
    */
@@ -97,37 +110,41 @@ public AnotherDynamicServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.
    * 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) {
       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(
-            getMethodMethod(),
-            io.grpc.stub.ServerCalls.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.AbstractAsyncStub<AnotherDynamicServiceStub> {
+  public static final class AnotherDynamicServiceStub
+      extends io.grpc.stub.AbstractAsyncStub<AnotherDynamicServiceStub> {
     private AnotherDynamicServiceStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -152,11 +169,43 @@ public void method(io.grpc.reflection.testing.DynamicRequest request,
   }
 
   /**
+   * A stub to allow clients to do synchronous rpc calls to service AnotherDynamicService.
+   * <pre>
+   * AnotherDynamicService
+   * </pre>
+   */
+  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);
+    }
+
+    /**
+     * <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> {
+  public static final class AnotherDynamicServiceBlockingStub
+      extends io.grpc.stub.AbstractBlockingStub<AnotherDynamicServiceBlockingStub> {
     private AnotherDynamicServiceBlockingStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -180,11 +229,13 @@ public io.grpc.reflection.testing.DynamicReply method(io.grpc.reflection.testing
   }
 
   /**
+   * 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.AbstractFutureStub<AnotherDynamicServiceFutureStub> {
+  public static final class AnotherDynamicServiceFutureStub
+      extends io.grpc.stub.AbstractFutureStub<AnotherDynamicServiceFutureStub> {
     private AnotherDynamicServiceFutureStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -215,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;
     }
@@ -247,6 +298,18 @@ public io.grpc.stub.StreamObserver<Req> invoke(
     }
   }
 
+  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() {}
@@ -270,9 +333,9 @@ private static final class AnotherDynamicServiceFileDescriptorSupplier
   private static final class AnotherDynamicServiceMethodDescriptorSupplier
       extends AnotherDynamicServiceBaseDescriptorSupplier
       implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
-    private final String methodName;
+    private final java.lang.String methodName;
 
-    AnotherDynamicServiceMethodDescriptorSupplier(String methodName) {
+    AnotherDynamicServiceMethodDescriptorSupplier(java.lang.String methodName) {
       this.methodName = methodName;
     }
 
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
index 0d5a7a13722..e688c3d5cca 100644
--- a/services/src/generated/test/grpc/io/grpc/reflection/testing/AnotherReflectableServiceGrpc.java
+++ b/services/src/generated/test/grpc/io/grpc/reflection/testing/AnotherReflectableServiceGrpc.java
@@ -4,14 +4,12 @@
 
 /**
  */
-@javax.annotation.Generated(
-    value = "by gRPC proto compiler",
-    comments = "Source: io/grpc/reflection/testing/reflection_test.proto")
+@io.grpc.stub.annotations.GrpcGenerated
 public final class AnotherReflectableServiceGrpc {
 
   private AnotherReflectableServiceGrpc() {}
 
-  public static final String SERVICE_NAME = "grpc.reflection.testing.AnotherReflectableService";
+  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,
@@ -59,6 +57,21 @@ public AnotherReflectableServiceStub newStub(io.grpc.Channel channel, io.grpc.Ca
     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
    */
@@ -91,31 +104,32 @@ public AnotherReflectableServiceFutureStub newStub(io.grpc.Channel channel, io.g
 
   /**
    */
-  public static abstract class AnotherReflectableServiceImplBase 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) {
       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 io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
-          .addMethod(
-            getMethodMethod(),
-            io.grpc.stub.ServerCalls.asyncUnaryCall(
-              new MethodHandlers<
-                io.grpc.reflection.testing.Request,
-                io.grpc.reflection.testing.Reply>(
-                  this, METHODID_METHOD)))
-          .build();
+      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> {
+  public static final class AnotherReflectableServiceStub
+      extends io.grpc.stub.AbstractAsyncStub<AnotherReflectableServiceStub> {
     private AnotherReflectableServiceStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -137,8 +151,34 @@ public void method(io.grpc.reflection.testing.Request request,
   }
 
   /**
+   * A stub to allow clients to do synchronous rpc calls to service AnotherReflectableService.
    */
-  public static final class AnotherReflectableServiceBlockingStub extends io.grpc.stub.AbstractBlockingStub<AnotherReflectableServiceBlockingStub> {
+  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);
@@ -159,8 +199,10 @@ public io.grpc.reflection.testing.Reply method(io.grpc.reflection.testing.Reques
   }
 
   /**
+   * 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> {
+  public static final class AnotherReflectableServiceFutureStub
+      extends io.grpc.stub.AbstractFutureStub<AnotherReflectableServiceFutureStub> {
     private AnotherReflectableServiceFutureStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -188,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 AnotherReflectableServiceImplBase serviceImpl;
+    private final AsyncService serviceImpl;
     private final int methodId;
 
-    MethodHandlers(AnotherReflectableServiceImplBase serviceImpl, int methodId) {
+    MethodHandlers(AsyncService serviceImpl, int methodId) {
       this.serviceImpl = serviceImpl;
       this.methodId = methodId;
     }
@@ -220,6 +262,18 @@ public io.grpc.stub.StreamObserver<Req> invoke(
     }
   }
 
+  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() {}
@@ -243,9 +297,9 @@ private static final class AnotherReflectableServiceFileDescriptorSupplier
   private static final class AnotherReflectableServiceMethodDescriptorSupplier
       extends AnotherReflectableServiceBaseDescriptorSupplier
       implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
-    private final String methodName;
+    private final java.lang.String methodName;
 
-    AnotherReflectableServiceMethodDescriptorSupplier(String methodName) {
+    AnotherReflectableServiceMethodDescriptorSupplier(java.lang.String methodName) {
       this.methodName = methodName;
     }
 
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 996bf7003b4..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
@@ -7,14 +7,12 @@
  * A DynamicService
  * </pre>
  */
-@javax.annotation.Generated(
-    value = "by gRPC proto compiler",
-    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.
   private static volatile io.grpc.MethodDescriptor<io.grpc.reflection.testing.DynamicRequest,
@@ -62,6 +60,21 @@ public DynamicServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions c
     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);
+  }
+
   /**
    * Creates a new blocking-style stub that supports unary and streaming output calls on the service
    */
@@ -97,37 +110,41 @@ public DynamicServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOpt
    * 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) {
       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(
-            getMethodMethod(),
-            io.grpc.stub.ServerCalls.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.AbstractAsyncStub<DynamicServiceStub> {
+  public static final class DynamicServiceStub
+      extends io.grpc.stub.AbstractAsyncStub<DynamicServiceStub> {
     private DynamicServiceStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -152,11 +169,43 @@ public void method(io.grpc.reflection.testing.DynamicRequest request,
   }
 
   /**
+   * A stub to allow clients to do synchronous rpc calls to service DynamicService.
+   * <pre>
+   * A DynamicService
+   * </pre>
+   */
+  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);
+    }
+
+    /**
+     * <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> {
+  public static final class DynamicServiceBlockingStub
+      extends io.grpc.stub.AbstractBlockingStub<DynamicServiceBlockingStub> {
     private DynamicServiceBlockingStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -180,11 +229,13 @@ public io.grpc.reflection.testing.DynamicReply method(io.grpc.reflection.testing
   }
 
   /**
+   * 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.AbstractFutureStub<DynamicServiceFutureStub> {
+  public static final class DynamicServiceFutureStub
+      extends io.grpc.stub.AbstractFutureStub<DynamicServiceFutureStub> {
     private DynamicServiceFutureStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -215,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;
     }
@@ -247,6 +298,18 @@ public io.grpc.stub.StreamObserver<Req> invoke(
     }
   }
 
+  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() {}
@@ -270,9 +333,9 @@ private static final class DynamicServiceFileDescriptorSupplier
   private static final class DynamicServiceMethodDescriptorSupplier
       extends DynamicServiceBaseDescriptorSupplier
       implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
-    private final String methodName;
+    private final java.lang.String methodName;
 
-    DynamicServiceMethodDescriptorSupplier(String methodName) {
+    DynamicServiceMethodDescriptorSupplier(java.lang.String methodName) {
       this.methodName = methodName;
     }
 
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 80c86c12d30..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
@@ -4,14 +4,12 @@
 
 /**
  */
-@javax.annotation.Generated(
-    value = "by gRPC proto compiler",
-    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.
   private static volatile io.grpc.MethodDescriptor<io.grpc.reflection.testing.Request,
@@ -59,6 +57,21 @@ public ReflectableServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptio
     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);
+  }
+
   /**
    * Creates a new blocking-style stub that supports unary and streaming output calls on the service
    */
@@ -91,31 +104,32 @@ public ReflectableServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.Cal
 
   /**
    */
-  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) {
       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(
-            getMethodMethod(),
-            io.grpc.stub.ServerCalls.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.AbstractAsyncStub<ReflectableServiceStub> {
+  public static final class ReflectableServiceStub
+      extends io.grpc.stub.AbstractAsyncStub<ReflectableServiceStub> {
     private ReflectableServiceStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -137,8 +151,34 @@ public void method(io.grpc.reflection.testing.Request request,
   }
 
   /**
+   * A stub to allow clients to do synchronous rpc calls to service ReflectableService.
    */
-  public static final class ReflectableServiceBlockingStub extends io.grpc.stub.AbstractBlockingStub<ReflectableServiceBlockingStub> {
+  public static final class ReflectableServiceBlockingV2Stub
+      extends io.grpc.stub.AbstractBlockingStub<ReflectableServiceBlockingV2Stub> {
+    private ReflectableServiceBlockingV2Stub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, 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);
@@ -159,8 +199,10 @@ public io.grpc.reflection.testing.Reply method(io.grpc.reflection.testing.Reques
   }
 
   /**
+   * A stub to allow clients to do ListenableFuture-style rpc calls to service ReflectableService.
    */
-  public static final class ReflectableServiceFutureStub extends io.grpc.stub.AbstractFutureStub<ReflectableServiceFutureStub> {
+  public static final class ReflectableServiceFutureStub
+      extends io.grpc.stub.AbstractFutureStub<ReflectableServiceFutureStub> {
     private ReflectableServiceFutureStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -188,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;
     }
@@ -220,6 +262,18 @@ public io.grpc.stub.StreamObserver<Req> invoke(
     }
   }
 
+  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() {}
@@ -243,9 +297,9 @@ private static final class ReflectableServiceFileDescriptorSupplier
   private static final class ReflectableServiceMethodDescriptorSupplier
       extends ReflectableServiceBaseDescriptorSupplier
       implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
-    private final String methodName;
+    private final java.lang.String methodName;
 
-    ReflectableServiceMethodDescriptorSupplier(String methodName) {
+    ReflectableServiceMethodDescriptorSupplier(java.lang.String methodName) {
       this.methodName = methodName;
     }
 
diff --git a/services/src/main/java/io/grpc/services/BinaryLogProvider.java b/services/src/main/java/io/grpc/protobuf/services/BinaryLogProvider.java
similarity index 99%
rename from services/src/main/java/io/grpc/services/BinaryLogProvider.java
rename to services/src/main/java/io/grpc/protobuf/services/BinaryLogProvider.java
index 3ca5de65558..bbbb88ce6e8 100644
--- a/services/src/main/java/io/grpc/services/BinaryLogProvider.java
+++ b/services/src/main/java/io/grpc/protobuf/services/BinaryLogProvider.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.grpc.services;
+package io.grpc.protobuf.services;
 
 import com.google.common.annotations.VisibleForTesting;
 import com.google.common.base.Preconditions;
diff --git a/services/src/main/java/io/grpc/services/BinaryLogProviderImpl.java b/services/src/main/java/io/grpc/protobuf/services/BinaryLogProviderImpl.java
similarity index 96%
rename from services/src/main/java/io/grpc/services/BinaryLogProviderImpl.java
rename to services/src/main/java/io/grpc/protobuf/services/BinaryLogProviderImpl.java
index dee13a924c6..896d92bcd91 100644
--- a/services/src/main/java/io/grpc/services/BinaryLogProviderImpl.java
+++ b/services/src/main/java/io/grpc/protobuf/services/BinaryLogProviderImpl.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.grpc.services;
+package io.grpc.protobuf.services;
 
 import com.google.common.base.Preconditions;
 import io.grpc.CallOptions;
@@ -42,6 +42,7 @@ public BinaryLogProviderImpl() throws IOException {
    * 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"));
   }
diff --git a/services/src/main/java/io/grpc/services/BinaryLogSink.java b/services/src/main/java/io/grpc/protobuf/services/BinaryLogSink.java
similarity index 96%
rename from services/src/main/java/io/grpc/services/BinaryLogSink.java
rename to services/src/main/java/io/grpc/protobuf/services/BinaryLogSink.java
index 1c1c193e4fe..44e4e2cc856 100644
--- a/services/src/main/java/io/grpc/services/BinaryLogSink.java
+++ b/services/src/main/java/io/grpc/protobuf/services/BinaryLogSink.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.grpc.services;
+package io.grpc.protobuf.services;
 
 import com.google.protobuf.MessageLite;
 import io.grpc.ExperimentalApi;
diff --git a/services/src/main/java/io/grpc/services/BinaryLogs.java b/services/src/main/java/io/grpc/protobuf/services/BinaryLogs.java
similarity index 98%
rename from services/src/main/java/io/grpc/services/BinaryLogs.java
rename to services/src/main/java/io/grpc/protobuf/services/BinaryLogs.java
index fc2d8d84ad1..4a7757c8617 100644
--- a/services/src/main/java/io/grpc/services/BinaryLogs.java
+++ b/services/src/main/java/io/grpc/protobuf/services/BinaryLogs.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.grpc.services;
+package io.grpc.protobuf.services;
 
 import io.grpc.BinaryLog;
 import io.grpc.ExperimentalApi;
diff --git a/services/src/main/java/io/grpc/services/BinlogHelper.java b/services/src/main/java/io/grpc/protobuf/services/BinlogHelper.java
similarity index 98%
rename from services/src/main/java/io/grpc/services/BinlogHelper.java
rename to services/src/main/java/io/grpc/protobuf/services/BinlogHelper.java
index d8923160e5c..e810c983beb 100644
--- a/services/src/main/java/io/grpc/services/BinlogHelper.java
+++ b/services/src/main/java/io/grpc/protobuf/services/BinlogHelper.java
@@ -14,15 +14,14 @@
  * limitations under the License.
  */
 
-package io.grpc.services;
+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.services.BinaryLogProvider.BYTEARRAY_MARSHALLER;
+import static io.grpc.protobuf.services.BinaryLogProvider.BYTEARRAY_MARSHALLER;
 
 import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Charsets;
 import com.google.common.base.Preconditions;
 import com.google.common.base.Splitter;
 import com.google.protobuf.ByteString;
@@ -53,11 +52,13 @@
 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;
@@ -840,7 +841,7 @@ static MaybeTruncated<io.grpc.binarylog.v1.Metadata.Builder> createMetadataProto
     if (serialized != null) {
       int curBytes = 0;
       for (int i = 0; i < serialized.length; i += 2) {
-        String key = new String(serialized[i], Charsets.UTF_8);
+        String key = new String(serialized[i], StandardCharsets.UTF_8);
         byte[] value = serialized[i + 1];
         if (NEVER_INCLUDED_METADATA.contains(key)) {
           continue;
@@ -851,9 +852,8 @@ static MaybeTruncated<io.grpc.binarylog.v1.Metadata.Builder> createMetadataProto
           truncated = true;
           continue;
         }
-        metaBuilder.addEntryBuilder()
-            .setKey(key)
-            .setValue(ByteString.copyFrom(value));
+        metaBuilder.addEntry(
+            MetadataEntry.newBuilder().setKey(key).setValue(ByteString.copyFrom(value)));
         if (!forceInclude) {
           // force included keys do not count towards the size limit
           curBytes = bytesAfterAdd;
diff --git a/services/src/main/java/io/grpc/services/ChannelzProtoUtil.java b/services/src/main/java/io/grpc/protobuf/services/ChannelzProtoUtil.java
similarity index 90%
rename from services/src/main/java/io/grpc/services/ChannelzProtoUtil.java
rename to services/src/main/java/io/grpc/protobuf/services/ChannelzProtoUtil.java
index 349995d9f80..74448a8c5bf 100644
--- a/services/src/main/java/io/grpc/services/ChannelzProtoUtil.java
+++ b/services/src/main/java/io/grpc/protobuf/services/ChannelzProtoUtil.java
@@ -14,13 +14,14 @@
  * limitations under the License.
  */
 
-package io.grpc.services;
+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;
@@ -79,6 +80,8 @@
 
 /**
  * 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());
@@ -254,22 +257,20 @@ static SocketOption toSocketOptionLinger(int lingerSeconds) {
     } else {
       lingerOpt = SocketOptionLinger.getDefaultInstance();
     }
-    return SocketOption
-        .newBuilder()
+    return SocketOption.newBuilder()
         .setName(SO_LINGER)
-        .setAdditional(Any.pack(lingerOpt))
+        .setAdditional(packToAny("SocketOptionLinger", lingerOpt))
         .build();
   }
 
   static SocketOption toSocketOptionTimeout(String name, int timeoutMillis) {
     Preconditions.checkNotNull(name);
-    return SocketOption
-        .newBuilder()
+    return SocketOption.newBuilder()
         .setName(name)
         .setAdditional(
-            Any.pack(
-                SocketOptionTimeout
-                    .newBuilder()
+            packToAny(
+                "SocketOptionTimeout",
+                SocketOptionTimeout.newBuilder()
                     .setDuration(Durations.fromMillis(timeoutMillis))
                     .build()))
         .build();
@@ -307,10 +308,9 @@ static SocketOption toSocketOptionTcpInfo(InternalChannelz.TcpInfo i) {
         .setTcpiAdvmss(i.advmss)
         .setTcpiReordering(i.reordering)
         .build();
-    return SocketOption
-        .newBuilder()
+    return SocketOption.newBuilder()
         .setName(TCP_INFO)
-        .setAdditional(Any.pack(tcpInfo))
+        .setAdditional(packToAny("SocketOptionTcpInfo", tcpInfo))
         .build();
   }
 
@@ -380,10 +380,11 @@ private static ChannelTrace toChannelTrace(InternalChannelz.ChannelTrace channel
   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(Severity.valueOf(event.severity.name()))
-          .setTimestamp(Timestamps.fromNanos(event.timestampNanos));
+      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));
       }
@@ -395,14 +396,39 @@ private static List<ChannelTraceEvent> toChannelTraceEvents(List<Event> events)
     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;
     }
-    try {
-      return Enum.valueOf(State.class, state.name());
-    } catch (IllegalArgumentException e) {
-      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;
     }
   }
 
@@ -468,4 +494,12 @@ private static <T> T getFuture(ListenableFuture<T> future) {
       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/services/HealthCheckingLoadBalancerFactory.java b/services/src/main/java/io/grpc/protobuf/services/HealthCheckingLoadBalancerFactory.java
similarity index 82%
rename from services/src/main/java/io/grpc/services/HealthCheckingLoadBalancerFactory.java
rename to services/src/main/java/io/grpc/protobuf/services/HealthCheckingLoadBalancerFactory.java
index e233d94a98a..b9f235d0aff 100644
--- a/services/src/main/java/io/grpc/services/HealthCheckingLoadBalancerFactory.java
+++ b/services/src/main/java/io/grpc/protobuf/services/HealthCheckingLoadBalancerFactory.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.grpc.services;
+package io.grpc.protobuf.services;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 import static com.google.common.base.Preconditions.checkState;
@@ -22,6 +22,7 @@
 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;
@@ -52,6 +53,7 @@
 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;
@@ -100,7 +102,7 @@ private final class HelperImpl extends ForwardingLoadBalancerHelper {
     final HashSet<HealthCheckState> hcStates = new HashSet<>();
 
     HelperImpl(Helper delegate) {
-      this.delegate = checkNotNull(delegate, "delegate");
+      this.delegate = new HealthProducerHelper(checkNotNull(delegate, "delegate"));
       this.syncContext = checkNotNull(delegate.getSynchronizationContext(), "syncContext");
     }
 
@@ -114,11 +116,17 @@ public Subchannel createSubchannel(CreateSubchannelArgs args) {
       // HealthCheckState is not thread-safe, we are requiring the original LoadBalancer calls
       // createSubchannel() from the SynchronizationContext.
       syncContext.throwIfNotInThisSynchronizationContext();
-      Subchannel originalSubchannel = super.createSubchannel(args);
+      LoadBalancer.SubchannelStateListener healthConsumerListener =
+          args.getOption(HEALTH_CONSUMER_LISTENER_ARG_KEY);
       HealthCheckState hcState = new HealthCheckState(
-          this, originalSubchannel, syncContext, delegate.getScheduledExecutorService());
+          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(originalSubchannel, hcState);
+      Subchannel subchannel = new SubchannelImpl(delegate, hcState);
       if (healthCheckedService != null) {
         hcState.setServiceName(healthCheckedService);
       }
@@ -136,6 +144,30 @@ void setHealthCheckedService(@Nullable String service) {
     public String toString() {
       return MoreObjects.toStringHelper(this).add("delegate", delegate()).toString();
     }
+
+    @Override
+    public void updateBalancingState(
+        io.grpc.ConnectivityState newState, LoadBalancer.SubchannelPicker newPicker) {
+      delegate().updateBalancingState(newState, new HealthCheckPicker(newPicker));
+    }
+
+    private final class HealthCheckPicker extends LoadBalancer.SubchannelPicker {
+      private final LoadBalancer.SubchannelPicker delegate;
+
+      HealthCheckPicker(LoadBalancer.SubchannelPicker delegate) {
+        this.delegate = delegate;
+      }
+
+      @Override
+      public LoadBalancer.PickResult pickSubchannel(LoadBalancer.PickSubchannelArgs args) {
+        LoadBalancer.PickResult result = delegate.pickSubchannel(args);
+        LoadBalancer.Subchannel subchannel = result.getSubchannel();
+        if (subchannel instanceof SubchannelImpl) {
+          return result.copyWithSubchannel(((SubchannelImpl) subchannel).delegate());
+        }
+        return result;
+      }
+    }
   }
 
   @VisibleForTesting
@@ -155,21 +187,21 @@ protected Subchannel delegate() {
 
     @Override
     public void start(final SubchannelStateListener listener) {
-      hcState.init(listener);
-      delegate().start(hcState);
+      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;
-    final SynchronizationContext syncContext;
-    final ScheduledExecutorService timerService;
 
     HealthCheckingLoadBalancer(HelperImpl helper, LoadBalancer delegate) {
       this.helper = checkNotNull(helper, "helper");
-      this.syncContext = checkNotNull(helper.getSynchronizationContext(), "syncContext");
-      this.timerService = checkNotNull(helper.getScheduledExecutorService(), "timerService");
       this.delegate = checkNotNull(delegate, "delegate");
     }
 
@@ -186,7 +218,18 @@ public void handleResolvedAddresses(ResolvedAddresses resolvedAddresses) {
               .get(LoadBalancer.ATTR_HEALTH_CHECKING_CONFIG);
       String serviceName = ServiceConfigUtil.getHealthCheckedServiceName(healthCheckingConfig);
       helper.setHealthCheckedService(serviceName);
-      super.handleResolvedAddresses(resolvedAddresses);
+      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
@@ -208,8 +251,10 @@ public void run() {
     private final SynchronizationContext syncContext;
     private final ScheduledExecutorService timerService;
     private final HelperImpl helperImpl;
-    private final Subchannel subchannel;
-    private final ChannelLogger subchannelLogger;
+    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.
@@ -231,16 +276,21 @@ public void run() {
     private ScheduledHandle retryTimer;
 
     HealthCheckState(
-        HelperImpl helperImpl,
-        Subchannel subchannel, SynchronizationContext syncContext,
-        ScheduledExecutorService timerService) {
+        HelperImpl helperImpl, SynchronizationContext syncContext,
+        ScheduledExecutorService timerService,
+        @Nullable SubchannelStateListener healthListener) {
       this.helperImpl = checkNotNull(helperImpl, "helperImpl");
-      this.subchannel = checkNotNull(subchannel, "subchannel");
-      this.subchannelLogger = checkNotNull(subchannel.getChannelLogger(), "subchannelLogger");
       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");
@@ -404,11 +454,10 @@ void handleResponse(HealthCheckResponse response) {
         } else {
           subchannelLogger.log(
               ChannelLogLevel.INFO, "TRANSIENT_FAILURE: health-check responded {0}", status);
-          gotoState(
-              ConnectivityStateInfo.forTransientFailure(
-                  Status.UNAVAILABLE.withDescription(
-                      "Health-check service responded "
-                      + status + " for '" + callServiceName + "'")));
+          String errorDescription =  "Health-check service responded "
+              + status + " for '" + callServiceName + "'";
+          gotoState(ConnectivityStateInfo.forTransientFailure(
+              Status.UNAVAILABLE.withDescription(errorDescription)));
         }
         call.request(1);
       }
@@ -427,11 +476,10 @@ void handleStreamClosed(Status status) {
         long delayNanos = 0;
         subchannelLogger.log(
             ChannelLogLevel.INFO, "TRANSIENT_FAILURE: health-check stream closed with {0}", status);
-        gotoState(
-            ConnectivityStateInfo.forTransientFailure(
-                Status.UNAVAILABLE.withDescription(
-                    "Health-check stream unexpectedly closed with "
-                    + status + " for '" + callServiceName + "'")));
+        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) {
diff --git a/services/src/main/java/io/grpc/services/HealthCheckingLoadBalancerUtil.java b/services/src/main/java/io/grpc/protobuf/services/HealthCheckingLoadBalancerUtil.java
similarity index 98%
rename from services/src/main/java/io/grpc/services/HealthCheckingLoadBalancerUtil.java
rename to services/src/main/java/io/grpc/protobuf/services/HealthCheckingLoadBalancerUtil.java
index c22716f46cf..7988ed8ff9e 100644
--- a/services/src/main/java/io/grpc/services/HealthCheckingLoadBalancerUtil.java
+++ b/services/src/main/java/io/grpc/protobuf/services/HealthCheckingLoadBalancerUtil.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.grpc.services;
+package io.grpc.protobuf.services;
 
 import io.grpc.ExperimentalApi;
 import io.grpc.LoadBalancer;
diff --git a/services/src/main/java/io/grpc/services/HealthServiceImpl.java b/services/src/main/java/io/grpc/protobuf/services/HealthServiceImpl.java
similarity index 88%
rename from services/src/main/java/io/grpc/services/HealthServiceImpl.java
rename to services/src/main/java/io/grpc/protobuf/services/HealthServiceImpl.java
index 906f5250d36..5cd294b4fbe 100644
--- a/services/src/main/java/io/grpc/services/HealthServiceImpl.java
+++ b/services/src/main/java/io/grpc/protobuf/services/HealthServiceImpl.java
@@ -14,18 +14,20 @@
  * limitations under the License.
  */
 
-package io.grpc.services;
+package io.grpc.protobuf.services;
 
 import com.google.common.annotations.VisibleForTesting;
 import com.google.common.util.concurrent.MoreExecutors;
-import io.grpc.Context.CancellationListener;
+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;
@@ -34,7 +36,6 @@
 import java.util.logging.Level;
 import java.util.logging.Logger;
 import javax.annotation.Nullable;
-import javax.annotation.concurrent.GuardedBy;
 
 final class HealthServiceImpl extends HealthGrpc.HealthImplBase {
 
@@ -83,6 +84,11 @@ 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 =
@@ -98,21 +104,25 @@ public void watch(HealthCheckRequest request,
           @Override
           // Called when the client has closed the stream
           public void cancelled(Context context) {
-            synchronized (watchLock) {
-              IdentityHashMap<StreamObserver<HealthCheckResponse>, Boolean> serviceWatchers =
-                  watchers.get(service);
-              if (serviceWatchers != null) {
-                serviceWatchers.remove(responseObserver);
-                if (serviceWatchers.isEmpty()) {
-                  watchers.remove(service);
-                }
-              }
-            }
+            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) {
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
index 4a7840a3ad9..07008b682c3 100644
--- a/services/src/main/java/io/grpc/protobuf/services/ProtoReflectionService.java
+++ b/services/src/main/java/io/grpc/protobuf/services/ProtoReflectionService.java
@@ -16,43 +16,15 @@
 
 package io.grpc.protobuf.services;
 
-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.InternalServer;
-import io.grpc.Server;
+import io.grpc.MethodDescriptor;
+import io.grpc.ServerCallHandler;
 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.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;
-import javax.annotation.concurrent.GuardedBy;
+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).
@@ -60,480 +32,56 @@
  * <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 extends ServerReflectionGrpc.ServerReflectionImplBase {
-
-  private final Object lock = new Object();
-
-  @GuardedBy("lock")
-  private final Map<Server, ServerReflectionIndex> serverReflectionIndexes = new WeakHashMap<>();
+public final class ProtoReflectionService implements BindableService {
 
-  private ProtoReflectionService() {}
+  private ProtoReflectionService() {
+  }
 
-  /**
-   * Creates a instance of {@link ProtoReflectionService}.
-   */
+  @Deprecated
   public static BindableService newInstance() {
     return new ProtoReflectionService();
   }
 
-  /**
-   * 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;
+  @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();
   }
 
-  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);
-    }
+  @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/services/TempFileSink.java b/services/src/main/java/io/grpc/protobuf/services/TempFileSink.java
similarity index 98%
rename from services/src/main/java/io/grpc/services/TempFileSink.java
rename to services/src/main/java/io/grpc/protobuf/services/TempFileSink.java
index c28339d1bd6..0ab91f54329 100644
--- a/services/src/main/java/io/grpc/services/TempFileSink.java
+++ b/services/src/main/java/io/grpc/protobuf/services/TempFileSink.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.grpc.services;
+package io.grpc.protobuf.services;
 
 import com.google.protobuf.MessageLite;
 import java.io.BufferedOutputStream;
diff --git a/services/src/main/java/io/grpc/services/internal/HealthCheckingRoundRobinLoadBalancerProvider.java b/services/src/main/java/io/grpc/protobuf/services/internal/HealthCheckingRoundRobinLoadBalancerProvider.java
similarity index 95%
rename from services/src/main/java/io/grpc/services/internal/HealthCheckingRoundRobinLoadBalancerProvider.java
rename to services/src/main/java/io/grpc/protobuf/services/internal/HealthCheckingRoundRobinLoadBalancerProvider.java
index c2c6357b68e..68d67dbeb28 100644
--- a/services/src/main/java/io/grpc/services/internal/HealthCheckingRoundRobinLoadBalancerProvider.java
+++ b/services/src/main/java/io/grpc/protobuf/services/internal/HealthCheckingRoundRobinLoadBalancerProvider.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.grpc.services.internal;
+package io.grpc.protobuf.services.internal;
 
 import com.google.common.annotations.VisibleForTesting;
 import com.google.common.base.Throwables;
@@ -23,7 +23,7 @@
 import io.grpc.LoadBalancer.Helper;
 import io.grpc.LoadBalancerProvider;
 import io.grpc.NameResolver.ConfigOrError;
-import io.grpc.services.HealthCheckingLoadBalancerUtil;
+import io.grpc.protobuf.services.HealthCheckingLoadBalancerUtil;
 import java.util.Map;
 
 /**
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
index f9b6a71a4b8..d480f0f4c3b 100644
--- a/services/src/main/java/io/grpc/services/CallMetricRecorder.java
+++ b/services/src/main/java/io/grpc/services/CallMetricRecorder.java
@@ -17,6 +17,7 @@
 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;
@@ -36,13 +37,19 @@ public final class CallMetricRecorder {
   static final Context.Key<CallMetricRecorder> CONTEXT_KEY =
       Context.key("io.grpc.services.CallMetricRecorder");
 
-  private final AtomicReference<ConcurrentHashMap<String, Double>> metrics =
+  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;
 
-  CallMetricRecorder() {
-  }
-
   /**
    * Returns the call metric recorder attached to the current {@link Context}.  If there is none,
    * returns a no-op recorder.
@@ -62,41 +69,209 @@ public static CallMetricRecorder getCurrent() {
   }
 
   /**
-   * Records a call metric measurement.  If RPC has already finished, this method is no-op.
+   * 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 (metrics.get() == null) {
+    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.
-      metrics.compareAndSet(null, new ConcurrentHashMap<String, Double>());
+      requestCostMetrics.compareAndSet(null, new ConcurrentHashMap<String, Double>());
     }
-    metrics.get().put(name, value);
+    requestCostMetrics.get().put(name, value);
     return this;
   }
 
   /**
-   * 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.
+   * 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 = metrics.get();
+    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;
diff --git a/services/src/main/java/io/grpc/services/ChannelzService.java b/services/src/main/java/io/grpc/services/ChannelzService.java
index 8032d0ad222..e8ef2bb8a9a 100644
--- a/services/src/main/java/io/grpc/services/ChannelzService.java
+++ b/services/src/main/java/io/grpc/services/ChannelzService.java
@@ -16,17 +16,7 @@
 
 package io.grpc.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;
@@ -46,189 +36,70 @@
 
 /**
  * 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 InternalChannelz channelz;
-  private final int maxPageSize;
+  private final io.grpc.protobuf.services.ChannelzService delegate;
 
   /**
    * Creates an instance.
    */
   public static ChannelzService newInstance(int maxPageSize) {
-    return new ChannelzService(InternalChannelz.instance(), maxPageSize);
+    return new ChannelzService(maxPageSize);
   }
 
-  @VisibleForTesting
-  ChannelzService(InternalChannelz channelz, int maxPageSize) {
-    this.channelz = channelz;
-    this.maxPageSize = 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) {
-    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();
+    delegate.getTopChannels(request, responseObserver);
   }
 
   /** 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();
+    delegate.getChannel(request, responseObserver);
   }
 
   /** 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();
+    delegate.getServers(request, responseObserver);
   }
 
   /** 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();
+    delegate.getServer(request, responseObserver);
   }
 
   /** 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();
+    delegate.getSubchannel(request, responseObserver);
   }
 
   /** 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();
+    delegate.getSocket(request, responseObserver);
   }
 
   @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();
+    delegate.getServerSockets(request, responseObserver);
   }
 }
diff --git a/services/src/main/java/io/grpc/services/HealthStatusManager.java b/services/src/main/java/io/grpc/services/HealthStatusManager.java
index 1edcb53c77f..7bcaf52da52 100644
--- a/services/src/main/java/io/grpc/services/HealthStatusManager.java
+++ b/services/src/main/java/io/grpc/services/HealthStatusManager.java
@@ -16,8 +16,6 @@
 
 package io.grpc.services;
 
-import static com.google.common.base.Preconditions.checkNotNull;
-
 import io.grpc.BindableService;
 import io.grpc.health.v1.HealthCheckResponse.ServingStatus;
 
@@ -29,29 +27,33 @@
  *
  * <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.
  */
+@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 = "";
+  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 BindableService getHealthService() {
-    return healthService;
+    return delegate.getHealthService();
   }
 
   /**
@@ -63,8 +65,7 @@ public BindableService 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);
   }
 
   /**
@@ -75,7 +76,7 @@ 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);
   }
 
   /**
@@ -84,6 +85,6 @@ public void clearStatus(String service) {
    * shutdown as a way to indicate that clients should redirect their traffic elsewhere.
    */
   public void enterTerminalState() {
-    healthService.enterTerminalState();
+    delegate.enterTerminalState();
   }
 }
diff --git a/services/src/main/java/io/grpc/services/InetAddressUtil.java b/services/src/main/java/io/grpc/services/InetAddressUtil.java
deleted file mode 100644
index 057a8ccb5e6..00000000000
--- a/services/src/main/java/io/grpc/services/InetAddressUtil.java
+++ /dev/null
@@ -1,94 +0,0 @@
-/*
- * 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 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();
-  }
-}
\ No newline at end of file
diff --git a/services/src/main/java/io/grpc/services/InternalCallMetricRecorder.java b/services/src/main/java/io/grpc/services/InternalCallMetricRecorder.java
index c68759e8b38..a7ff1e5c32e 100644
--- a/services/src/main/java/io/grpc/services/InternalCallMetricRecorder.java
+++ b/services/src/main/java/io/grpc/services/InternalCallMetricRecorder.java
@@ -40,4 +40,16 @@ public static CallMetricRecorder newCallMetricRecorder() {
   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 3b5b639361c..7e21ae519bb 100644
--- a/services/src/main/java/io/grpc/services/package-info.java
+++ b/services/src/main/java/io/grpc/services/package-info.java
@@ -14,6 +14,8 @@
  * 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
index 9ed1733e2d8..b18bd88ddc9 100644
--- a/services/src/main/proto/grpc/binlog/v1/binarylog.proto
+++ b/services/src/main/proto/grpc/binlog/v1/binarylog.proto
@@ -120,7 +120,7 @@ message ClientHeader {
 
   // A single process may be used to run multiple virtual
   // servers with different identities.
-  // The authority is the name of such a server identitiy.
+  // 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;
diff --git a/services/src/main/proto/grpc/channelz/v1/channelz.proto b/services/src/main/proto/grpc/channelz/v1/channelz.proto
index f0b3b10837e..d0781094ea8 100644
--- a/services/src/main/proto/grpc/channelz/v1/channelz.proto
+++ b/services/src/main/proto/grpc/channelz/v1/channelz.proto
@@ -35,7 +35,7 @@ option java_outer_classname = "ChannelzProto";
 
 // Channel is a logical grouping of channels, subchannels, and sockets.
 message Channel {
-  // The identifier for this channel. This should bet set.
+  // The identifier for this channel. This should be set.
   ChannelRef ref = 1;
   // Data specific to this channel.
   ChannelData data = 2;
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
index 8c5e06fe148..a3984b55c2d 100644
--- a/services/src/main/proto/grpc/reflection/v1alpha/reflection.proto
+++ b/services/src/main/proto/grpc/reflection/v1alpha/reflection.proto
@@ -80,7 +80,7 @@ message ExtensionRequest {
 message ServerReflectionResponse {
   string valid_host = 1;
   ServerReflectionRequest original_request = 2;
-  // The server set one of the following fields accroding to the message_request
+  // 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,
@@ -91,7 +91,7 @@ message ServerReflectionResponse {
     // 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.
+    // 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.
diff --git a/services/src/main/resources/META-INF/services/io.grpc.LoadBalancerProvider b/services/src/main/resources/META-INF/services/io.grpc.LoadBalancerProvider
index bbc2a4902df..d3e5f85ffbb 100644
--- a/services/src/main/resources/META-INF/services/io.grpc.LoadBalancerProvider
+++ b/services/src/main/resources/META-INF/services/io.grpc.LoadBalancerProvider
@@ -1 +1 @@
-io.grpc.services.internal.HealthCheckingRoundRobinLoadBalancerProvider
+io.grpc.protobuf.services.internal.HealthCheckingRoundRobinLoadBalancerProvider
diff --git a/services/src/test/java/io/grpc/services/BinaryLogProviderImplTest.java b/services/src/test/java/io/grpc/protobuf/services/BinaryLogProviderImplTest.java
similarity index 98%
rename from services/src/test/java/io/grpc/services/BinaryLogProviderImplTest.java
rename to services/src/test/java/io/grpc/protobuf/services/BinaryLogProviderImplTest.java
index 238f5fbc0ef..cab7dcf05e5 100644
--- a/services/src/test/java/io/grpc/services/BinaryLogProviderImplTest.java
+++ b/services/src/test/java/io/grpc/protobuf/services/BinaryLogProviderImplTest.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.grpc.services;
+package io.grpc.protobuf.services;
 
 import static org.junit.Assert.assertNull;
 import static org.mockito.Mockito.mock;
diff --git a/services/src/test/java/io/grpc/services/BinaryLogProviderTest.java b/services/src/test/java/io/grpc/protobuf/services/BinaryLogProviderTest.java
similarity index 99%
rename from services/src/test/java/io/grpc/services/BinaryLogProviderTest.java
rename to services/src/test/java/io/grpc/protobuf/services/BinaryLogProviderTest.java
index 6905cbb603d..67b187e9d7a 100644
--- a/services/src/test/java/io/grpc/services/BinaryLogProviderTest.java
+++ b/services/src/test/java/io/grpc/protobuf/services/BinaryLogProviderTest.java
@@ -14,10 +14,10 @@
  * limitations under the License.
  */
 
-package io.grpc.services;
+package io.grpc.protobuf.services;
 
-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.assertSame;
 import static org.junit.Assert.assertTrue;
@@ -35,12 +35,12 @@
 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 io.grpc.internal.NoopClientCall;
-import io.grpc.internal.NoopServerCall;
 import java.io.ByteArrayInputStream;
 import java.io.IOException;
 import java.io.InputStream;
diff --git a/services/src/test/java/io/grpc/services/BinlogHelperTest.java b/services/src/test/java/io/grpc/protobuf/services/BinlogHelperTest.java
similarity index 95%
rename from services/src/test/java/io/grpc/services/BinlogHelperTest.java
rename to services/src/test/java/io/grpc/protobuf/services/BinlogHelperTest.java
index f7d0d40726c..ca42c1691b1 100644
--- a/services/src/test/java/io/grpc/services/BinlogHelperTest.java
+++ b/services/src/test/java/io/grpc/protobuf/services/BinlogHelperTest.java
@@ -14,12 +14,12 @@
  * limitations under the License.
  */
 
-package io.grpc.services;
+package io.grpc.protobuf.services;
 
 import static com.google.common.truth.Truth.assertThat;
-import static io.grpc.services.BinaryLogProvider.BYTEARRAY_MARSHALLER;
-import static io.grpc.services.BinlogHelper.createMetadataProto;
-import static io.grpc.services.BinlogHelper.getPeerSocket;
+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;
@@ -54,6 +54,8 @@
 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;
@@ -67,14 +69,12 @@
 import io.grpc.binarylog.v1.MetadataEntry;
 import io.grpc.binarylog.v1.ServerHeader;
 import io.grpc.binarylog.v1.Trailer;
-import io.grpc.internal.NoopClientCall;
-import io.grpc.internal.NoopServerCall;
 import io.grpc.protobuf.StatusProto;
-import io.grpc.services.BinlogHelper.FactoryImpl;
-import io.grpc.services.BinlogHelper.MaybeTruncated;
-import io.grpc.services.BinlogHelper.SinkWriter;
-import io.grpc.services.BinlogHelper.SinkWriterImpl;
-import io.grpc.services.BinlogHelper.TimeProvider;
+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;
@@ -92,6 +92,7 @@
 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");
@@ -887,7 +888,7 @@ public void logRpcMessage() throws Exception {
       verify(sink).write(base);
     }
 
-    // server messsage
+    // server message
     {
       sinkWriterImpl.logRpcMessage(
           seq,
@@ -928,11 +929,6 @@ public void getPeerSocketTest() {
 
   @Test
   public void serverDeadlineLogged() {
-    final AtomicReference<ServerCall<byte[], byte[]>> interceptedCall =
-        new AtomicReference<>();
-    @SuppressWarnings("unchecked")
-    final ServerCall.Listener<byte[]> mockListener = mock(ServerCall.Listener.class);
-
     final MethodDescriptor<byte[], byte[]> method =
         MethodDescriptor.<byte[], byte[]>newBuilder()
             .setType(MethodType.UNKNOWN)
@@ -940,6 +936,25 @@ public void serverDeadlineLogged() {
             .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()
@@ -950,23 +965,7 @@ public void run() {
             ServerCall.Listener<byte[]> unused =
                 new BinlogHelper(mockSinkWriter)
                     .getServerInterceptor(CALL_ID)
-                    .interceptCall(
-                        new NoopServerCall<byte[], byte[]>() {
-                          @Override
-                          public MethodDescriptor<byte[], byte[]> getMethodDescriptor() {
-                            return method;
-                          }
-                        },
-                        new Metadata(),
-                        new ServerCallHandler<byte[], byte[]>() {
-                          @Override
-                          public ServerCall.Listener<byte[]> startCall(
-                              ServerCall<byte[], byte[]> call,
-                              Metadata headers) {
-                            interceptedCall.set(call);
-                            return mockListener;
-                          }
-                        });
+                    .interceptCall(noopServerCall, new Metadata(), noopHandler);
           }
         });
     ArgumentCaptor<Duration> timeoutCaptor = ArgumentCaptor.forClass(Duration.class);
@@ -981,7 +980,7 @@ public ServerCall.Listener<byte[]> startCall(
         ArgumentMatchers.<SocketAddress>isNull());
     verifyNoMoreInteractions(mockSinkWriter);
     Duration timeout = timeoutCaptor.getValue();
-    assertThat(TimeUnit.SECONDS.toNanos(1) - Durations.toNanos(timeout))
+    assertThat(Math.abs(TimeUnit.SECONDS.toNanos(1) - Durations.toNanos(timeout)))
         .isAtMost(TimeUnit.MILLISECONDS.toNanos(250));
   }
 
@@ -1002,7 +1001,7 @@ public void clientDeadlineLogged_deadlineSetViaCallOption() {
             .getClientInterceptor(CALL_ID)
             .interceptCall(
                 method,
-                CallOptions.DEFAULT.withDeadlineAfter(1, TimeUnit.SECONDS),
+                CallOptions.DEFAULT.withDeadlineAfter(2, TimeUnit.SECONDS),
                 new Channel() {
                   @Override
                   public <RequestT, ResponseT> ClientCall<RequestT, ResponseT> newCall(
@@ -1030,17 +1029,18 @@ public String authority() {
             AdditionalMatchers.or(ArgumentMatchers.<SocketAddress>isNull(),
                 ArgumentMatchers.<SocketAddress>any()));
     Duration timeout = callOptTimeoutCaptor.getValue();
-    assertThat(TimeUnit.SECONDS.toNanos(1) - Durations.toNanos(timeout))
-        .isAtMost(TimeUnit.MILLISECONDS.toNanos(250));
+    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(
-            Deadline.after(1, TimeUnit.SECONDS), Executors.newSingleThreadScheduledExecutor())
+            expectedDeadline, Executors.newSingleThreadScheduledExecutor())
         .run(new Runnable() {
           @Override
           public void run() {
@@ -1056,7 +1056,7 @@ public void run() {
                 .getClientInterceptor(CALL_ID)
                 .interceptCall(
                     method,
-                    CallOptions.DEFAULT.withDeadlineAfter(1, TimeUnit.SECONDS),
+                    CallOptions.DEFAULT.withDeadlineAfter(10, TimeUnit.SECONDS),
                     new Channel() {
                       @Override
                       public <RequestT, ResponseT> ClientCall<RequestT, ResponseT> newCall(
@@ -1087,9 +1087,10 @@ public String authority() {
             anyLong(),
             AdditionalMatchers.or(ArgumentMatchers.<SocketAddress>isNull(),
                 ArgumentMatchers.<SocketAddress>any()));
-    Duration timeout = callOptTimeoutCaptor.getValue();
-    assertThat(TimeUnit.SECONDS.toNanos(1) - Durations.toNanos(timeout))
-        .isAtMost(TimeUnit.MILLISECONDS.toNanos(250));
+    long expectedTimeRemaining = expectedDeadline.timeRemaining(TimeUnit.NANOSECONDS);
+    long timeout = Durations.toNanos(callOptTimeoutCaptor.getValue());
+    assertThat(Math.abs(expectedTimeRemaining - timeout))
+        .isAtMost(TimeUnit.MILLISECONDS.toNanos(750));
   }
 
   @Test
@@ -1432,16 +1433,16 @@ public ServerCall.Listener<byte[]> startCall(
 
     // send server header
     {
-      Metadata serverInital = new Metadata();
-      interceptedCall.get().sendHeaders(serverInital);
+      Metadata serverInitial = new Metadata();
+      interceptedCall.get().sendHeaders(serverInitial);
       verify(mockSinkWriter).logServerHeader(
           /*seq=*/ eq(2L),
-          same(serverInital),
+          same(serverInitial),
           eq(Logger.LOGGER_SERVER),
           eq(CALL_ID),
           ArgumentMatchers.<SocketAddress>isNull());
       verifyNoMoreInteractions(mockSinkWriter);
-      assertSame(serverInital, actualServerInitial.get());
+      assertSame(serverInitial, actualServerInitial.get());
     }
 
     // receive client msg
diff --git a/services/src/test/java/io/grpc/services/ChannelzProtoUtilTest.java b/services/src/test/java/io/grpc/protobuf/services/ChannelzProtoUtilTest.java
similarity index 86%
rename from services/src/test/java/io/grpc/services/ChannelzProtoUtilTest.java
rename to services/src/test/java/io/grpc/protobuf/services/ChannelzProtoUtilTest.java
index 45dd8056ddf..598a8625e58 100644
--- a/services/src/test/java/io/grpc/services/ChannelzProtoUtilTest.java
+++ b/services/src/test/java/io/grpc/protobuf/services/ChannelzProtoUtilTest.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.grpc.services;
+package io.grpc.protobuf.services;
 
 import static com.google.common.truth.Truth.assertThat;
 import static io.grpc.InternalChannelz.id;
@@ -22,13 +22,12 @@
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 
-import com.google.common.base.Charsets;
 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.Message;
+import com.google.protobuf.MessageLite;
 import com.google.protobuf.util.Durations;
 import com.google.protobuf.util.Timestamps;
 import io.grpc.ConnectivityState;
@@ -74,14 +73,15 @@
 import io.grpc.channelz.v1.SocketRef;
 import io.grpc.channelz.v1.Subchannel;
 import io.grpc.channelz.v1.SubchannelRef;
-import io.grpc.services.ChannelzTestHelper.TestChannel;
-import io.grpc.services.ChannelzTestHelper.TestListenSocket;
-import io.grpc.services.ChannelzTestHelper.TestServer;
-import io.grpc.services.ChannelzTestHelper.TestSocket;
+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;
@@ -154,33 +154,44 @@ public final class ChannelzProtoUtilTest {
       .setData(serverData)
       .build();
 
-  private final SocketOption sockOptLingerDisabled = SocketOption
-      .newBuilder()
-      .setName("SO_LINGER")
-      .setAdditional(
-          Any.pack(SocketOptionLinger.getDefaultInstance()))
-      .build();
-
-  private final SocketOption sockOptlinger10s = SocketOption
-      .newBuilder()
-      .setName("SO_LINGER")
-      .setAdditional(
-          Any.pack(SocketOptionLinger
-              .newBuilder()
-              .setActive(true)
-              .setDuration(Durations.fromSeconds(10))
-              .build()))
-      .build();
-
-  private final SocketOption sockOptTimeout200ms = SocketOption
-      .newBuilder()
-      .setName("SO_TIMEOUT")
-      .setAdditional(
-          Any.pack(SocketOptionTimeout
-          .newBuilder()
-          .setDuration(Durations.fromMillis(200))
-          .build())
-      ).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()
@@ -221,43 +232,46 @@ public final class ChannelzProtoUtilTest {
       .setReordering(728)
       .build();
 
-  private final SocketOption socketOptionTcpInfo = SocketOption
-      .newBuilder()
-      .setName("TCP_INFO")
-      .setAdditional(
-          Any.pack(
-              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()))
-      .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
@@ -336,6 +350,16 @@ 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));
@@ -346,7 +370,7 @@ public void toState() {
     for (ConnectivityState connectivityState : ConnectivityState.values()) {
       assertEquals(
           connectivityState.name(),
-          ChannelzProtoUtil.toState(connectivityState).getValueDescriptor().getName());
+          ChannelzProtoUtil.toState(connectivityState).name()); // OK because test isn't proguarded.
     }
     assertEquals(State.UNKNOWN, ChannelzProtoUtil.toState(null));
   }
@@ -437,8 +461,8 @@ public void toSocketData() throws Exception {
   public void socketSecurityTls() throws Exception {
     Certificate local = mock(Certificate.class);
     Certificate remote = mock(Certificate.class);
-    when(local.getEncoded()).thenReturn("localcert".getBytes(Charsets.UTF_8));
-    when(remote.getEncoded()).thenReturn("remotecert".getBytes(Charsets.UTF_8));
+    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));
@@ -446,8 +470,8 @@ public void socketSecurityTls() throws Exception {
         Security.newBuilder().setTls(
             Tls.newBuilder()
             .setStandardName("TLS_NULL_WITH_NULL_NULL")
-            .setLocalCertificate(ByteString.copyFrom("localcert", Charsets.UTF_8))
-            .setRemoteCertificate(ByteString.copyFrom("remotecert", Charsets.UTF_8)))
+            .setLocalCertificate(ByteString.copyFrom("localcert", StandardCharsets.UTF_8))
+            .setRemoteCertificate(ByteString.copyFrom("remotecert", StandardCharsets.UTF_8)))
         .build(),
         ChannelzProtoUtil.toSocket(socket).getSecurity());
 
@@ -457,7 +481,7 @@ public void socketSecurityTls() throws Exception {
         Security.newBuilder().setTls(
             Tls.newBuilder()
             .setStandardName("TLS_NULL_WITH_NULL_NULL")
-            .setRemoteCertificate(ByteString.copyFrom("remotecert", Charsets.UTF_8)))
+            .setRemoteCertificate(ByteString.copyFrom("remotecert", StandardCharsets.UTF_8)))
         .build(),
         ChannelzProtoUtil.toSocket(socket).getSecurity());
 
@@ -467,7 +491,7 @@ public void socketSecurityTls() throws Exception {
         Security.newBuilder().setTls(
             Tls.newBuilder()
                 .setStandardName("TLS_NULL_WITH_NULL_NULL")
-                .setLocalCertificate(ByteString.copyFrom("localcert", Charsets.UTF_8)))
+                .setLocalCertificate(ByteString.copyFrom("localcert", StandardCharsets.UTF_8)))
             .build(),
             ChannelzProtoUtil.toSocket(socket).getSecurity());
   }
@@ -475,8 +499,12 @@ public void socketSecurityTls() throws Exception {
   @Test
   public void socketSecurityOther() throws Exception {
     // what is packed here is not important, just pick some proto message
-    Message contents = GetChannelRequest.newBuilder().setChannelId(1).build();
-    Any packed = Any.pack(contents);
+    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));
diff --git a/services/src/test/java/io/grpc/services/ChannelzServiceTest.java b/services/src/test/java/io/grpc/protobuf/services/ChannelzServiceTest.java
similarity index 97%
rename from services/src/test/java/io/grpc/services/ChannelzServiceTest.java
rename to services/src/test/java/io/grpc/protobuf/services/ChannelzServiceTest.java
index 54d84358bdd..bb520a16dec 100644
--- a/services/src/test/java/io/grpc/services/ChannelzServiceTest.java
+++ b/services/src/test/java/io/grpc/protobuf/services/ChannelzServiceTest.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.grpc.services;
+package io.grpc.protobuf.services;
 
 import static com.google.common.truth.Truth.assertWithMessage;
 import static org.junit.Assert.assertEquals;
@@ -35,9 +35,9 @@
 import io.grpc.channelz.v1.GetSubchannelResponse;
 import io.grpc.channelz.v1.GetTopChannelsRequest;
 import io.grpc.channelz.v1.GetTopChannelsResponse;
-import io.grpc.services.ChannelzTestHelper.TestChannel;
-import io.grpc.services.ChannelzTestHelper.TestServer;
-import io.grpc.services.ChannelzTestHelper.TestSocket;
+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;
diff --git a/services/src/test/java/io/grpc/services/ChannelzTestHelper.java b/services/src/test/java/io/grpc/protobuf/services/ChannelzTestHelper.java
similarity index 99%
rename from services/src/test/java/io/grpc/services/ChannelzTestHelper.java
rename to services/src/test/java/io/grpc/protobuf/services/ChannelzTestHelper.java
index 6bd8e8bceb5..0b93a8d9271 100644
--- a/services/src/test/java/io/grpc/services/ChannelzTestHelper.java
+++ b/services/src/test/java/io/grpc/protobuf/services/ChannelzTestHelper.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.grpc.services;
+package io.grpc.protobuf.services;
 
 import com.google.common.base.MoreObjects;
 import com.google.common.util.concurrent.ListenableFuture;
diff --git a/services/src/test/java/io/grpc/services/HealthCheckingLoadBalancerFactoryTest.java b/services/src/test/java/io/grpc/protobuf/services/HealthCheckingLoadBalancerFactoryTest.java
similarity index 77%
rename from services/src/test/java/io/grpc/services/HealthCheckingLoadBalancerFactoryTest.java
rename to services/src/test/java/io/grpc/protobuf/services/HealthCheckingLoadBalancerFactoryTest.java
index fc9b3f62ecf..a49c426f7e1 100644
--- a/services/src/test/java/io/grpc/services/HealthCheckingLoadBalancerFactoryTest.java
+++ b/services/src/test/java/io/grpc/protobuf/services/HealthCheckingLoadBalancerFactoryTest.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.grpc.services;
+package io.grpc.protobuf.services;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 import static com.google.common.base.Preconditions.checkState;
@@ -57,7 +57,6 @@
 import io.grpc.ManagedChannel;
 import io.grpc.Server;
 import io.grpc.Status;
-import io.grpc.Status.Code;
 import io.grpc.SynchronizationContext;
 import io.grpc.health.v1.HealthCheckRequest;
 import io.grpc.health.v1.HealthCheckResponse;
@@ -68,7 +67,7 @@
 import io.grpc.internal.BackoffPolicy;
 import io.grpc.internal.FakeClock;
 import io.grpc.internal.ServiceConfigUtil;
-import io.grpc.services.HealthCheckingLoadBalancerFactory.SubchannelImpl;
+import io.grpc.protobuf.services.HealthCheckingLoadBalancerFactory.SubchannelImpl;
 import io.grpc.stub.StreamObserver;
 import java.net.SocketAddress;
 import java.text.MessageFormat;
@@ -84,21 +83,35 @@
 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.junit.runners.Parameterized;
 import org.mockito.ArgumentCaptor;
 import org.mockito.Captor;
 import org.mockito.InOrder;
 import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
 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}. */
-@RunWith(JUnit4.class)
+/** 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");
 
@@ -112,12 +125,13 @@ public class HealthCheckingLoadBalancerFactoryTest {
   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
@@ -157,8 +171,6 @@ public LoadBalancer newLoadBalancer(Helper helper) {
   @Before
   @SuppressWarnings("unchecked")
   public void setup() throws Exception {
-    MockitoAnnotations.initMocks(this);
-
     for (int i = 0; i < NUM_SUBCHANNELS; i++) {
       HealthImpl healthImpl = new HealthImpl();
       healthImpls[i] = healthImpl;
@@ -176,6 +188,7 @@ public void setup() throws Exception {
       List<EquivalentAddressGroup> eagList = Arrays.asList(eag);
       eagLists[i] = eagList;
       mockStateListeners[i] = mock(SubchannelStateListener.class);
+      mockHealthListeners[i] = mock(SubchannelStateListener.class);
     }
     resolvedAddressList = Arrays.asList(eags);
 
@@ -193,15 +206,16 @@ public void setup() throws Exception {
         boolean shutdown;
 
         @Override
-        public void handleResolvedAddresses(final ResolvedAddresses resolvedAddresses) {
+        public Status acceptResolvedAddresses(final ResolvedAddresses resolvedAddresses) {
           syncContext.execute(new Runnable() {
               @Override
               public void run() {
                 if (!shutdown) {
-                  hcLb.handleResolvedAddresses(resolvedAddresses);
+                  hcLb.acceptResolvedAddresses(resolvedAddresses);
                 }
               }
             });
+          return Status.OK;
         }
 
         @Override
@@ -251,22 +265,23 @@ public void typicalWorkflow() {
         .setAddresses(resolvedAddressList)
         .setAttributes(resolutionAttrs)
         .build();
-    hcLbEventDelivery.handleResolvedAddresses(result);
+    hcLbEventDelivery.acceptResolvedAddresses(result);
 
-    verify(origLb).handleResolvedAddresses(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 orignal LB creates 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);
+      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]);
@@ -279,30 +294,47 @@ public void typicalWorkflow() {
       FakeSubchannel subchannel = subchannels[i];
       HealthImpl healthImpl = healthImpls[i];
       SubchannelStateListener mockStateListener = mockStateListeners[i];
-      InOrder inOrder = inOrder(mockStateListener);
+      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"));
 
-      // Starting the health check will make the Subchannel appear CONNECTING to the origLb.
-      inOrder.verify(mockStateListener).onSubchannelState(
-          eq(ConnectivityStateInfo.forNonError(CONNECTING)));
-      verifyNoMoreInteractions(mockStateListener);
+      verifyNoMoreInteractions(mockStateListener, mockHealthListener);
 
       assertThat(subchannel.logs).containsExactly(
           "INFO: CONNECTING: Starting health-check for \"FooService\"");
@@ -316,19 +348,20 @@ public void typicalWorkflow() {
         serverCall.responseObserver.onNext(makeResponse(servingStatus));
         // SERVING is mapped to READY, while other statuses are mapped to TRANSIENT_FAILURE
         if (servingStatus == ServingStatus.SERVING) {
-          inOrder.verify(mockStateListener).onSubchannelState(
-              eq(ConnectivityStateInfo.forNonError(READY)));
+          inOrder.verify(hasHealthConsumer ? mockHealthListener : mockStateListener)
+              .onSubchannelState(eq(ConnectivityStateInfo.forNonError(READY)));
           assertThat(subchannel.logs).containsExactly(
               "INFO: READY: health-check responded SERVING");
         } else {
-          inOrder.verify(mockStateListener).onSubchannelState(
+          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(mockStateListener);
+        verifyNoMoreInteractions(hasHealthConsumer ? mockHealthListener : mockStateListener);
       }
     }
 
@@ -372,23 +405,28 @@ public void healthCheckDisabledWhenServiceNotImplemented() {
         .setAddresses(resolvedAddressList)
         .setAttributes(resolutionAttrs)
         .build();
-    hcLbEventDelivery.handleResolvedAddresses(result);
+    hcLbEventDelivery.acceptResolvedAddresses(result);
 
-    verify(origLb).handleResolvedAddresses(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);
+      createSubchannel(i, Attributes.EMPTY, hasHealthConsumer ? mockHealthListeners[i] : null);
     }
 
-    InOrder inOrder = inOrder(mockStateListeners[0], mockStateListeners[1]);
+    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);
-      inOrder.verify(mockStateListeners[i]).onSubchannelState(
-          eq(ConnectivityStateInfo.forNonError(CONNECTING)));
+      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();
@@ -400,15 +438,16 @@ public void healthCheckDisabledWhenServiceNotImplemented() {
     // 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(mockStateListeners[0]).onSubchannelState(
-        eq(ConnectivityStateInfo.forNonError(READY)));
+    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(mockStateListeners[1]).onSubchannelState(
+    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
@@ -416,21 +455,31 @@ public void healthCheckDisabledWhenServiceNotImplemented() {
     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(mockStateListeners[0]).onSubchannelState(
-        eq(ConnectivityStateInfo.forNonError(CONNECTING)));
+    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(mockStateListeners[0]).onSubchannelState(
-        unavailableStateWithMsg("Health-check service responded SERVICE_UNKNOWN for 'BarService'"));
+    inOrder.verify(hasHealthConsumer ? mockHealthListeners[0] : mockStateListeners[0])
+        .onSubchannelState(unavailableStateWithMsg(
+            "Health-check service responded SERVICE_UNKNOWN for 'BarService'"));
 
-    verifyNoMoreInteractions(origLb, mockStateListeners[0], mockStateListeners[1]);
+    verifyNoMoreInteractions(origLb, mockStateListeners[0], mockStateListeners[1],
+        mockHealthListeners[0], mockHealthListeners[1]);
     verifyNoInteractions(backoffPolicyProvider);
   }
 
@@ -441,18 +490,25 @@ public void backoffRetriesWhenServerErroneouslyClosesRpcBeforeAnyResponse() {
         .setAddresses(resolvedAddressList)
         .setAttributes(resolutionAttrs)
         .build();
-    hcLbEventDelivery.handleResolvedAddresses(result);
+    hcLbEventDelivery.acceptResolvedAddresses(result);
 
-    verify(origLb).handleResolvedAddresses(result);
+    verify(origLb).acceptResolvedAddresses(result);
     verifyNoMoreInteractions(origLb);
 
-    FakeSubchannel subchannel = unwrap(createSubchannel(0, Attributes.EMPTY));
+    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, backoffPolicyProvider, backoffPolicy1, backoffPolicy2);
+    InOrder inOrder = inOrder(mockListener, mockHealthListener, backoffPolicyProvider,
+        backoffPolicy1, backoffPolicy2);
 
     deliverSubchannelState(0, ConnectivityStateInfo.forNonError(READY));
-    inOrder.verify(mockListener).onSubchannelState(
+    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);
@@ -463,7 +519,7 @@ public void backoffRetriesWhenServerErroneouslyClosesRpcBeforeAnyResponse() {
     healthImpl.calls.poll().responseObserver.onCompleted();
 
     // which results in TRANSIENT_FAILURE
-    inOrder.verify(mockListener).onSubchannelState(
+    inOrder.verify(getMockListener()).onSubchannelState(
         unavailableStateWithMsg(
             "Health-check stream unexpectedly closed with " + Status.OK + " for 'TeeService'"));
     assertThat(subchannel.logs).containsExactly(
@@ -475,7 +531,7 @@ public void backoffRetriesWhenServerErroneouslyClosesRpcBeforeAnyResponse() {
     inOrder.verify(backoffPolicy1).nextBackoffNanos();
     assertThat(clock.getPendingTasks()).hasSize(1);
 
-    verifyRetryAfterNanos(inOrder, mockListener, healthImpl, 11);
+    verifyRetryAfterNanos(inOrder, getMockListener(), healthImpl, 11);
     assertThat(clock.getPendingTasks()).isEmpty();
 
     subchannel.logs.clear();
@@ -483,10 +539,10 @@ public void backoffRetriesWhenServerErroneouslyClosesRpcBeforeAnyResponse() {
     healthImpl.calls.poll().responseObserver.onError(Status.CANCELLED.asException());
 
     // which also results in TRANSIENT_FAILURE, with a different description
-    inOrder.verify(mockListener).onSubchannelState(
+    inOrder.verify(getMockListener()).onSubchannelState(
         unavailableStateWithMsg(
             "Health-check stream unexpectedly closed with "
-            + Status.CANCELLED + " for 'TeeService'"));
+                + 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();
@@ -494,15 +550,15 @@ public void backoffRetriesWhenServerErroneouslyClosesRpcBeforeAnyResponse() {
     // Retry with backoff
     inOrder.verify(backoffPolicy1).nextBackoffNanos();
 
-    verifyRetryAfterNanos(inOrder, mockListener, healthImpl, 21);
+    verifyRetryAfterNanos(inOrder, getMockListener(), healthImpl, 21);
 
     // Server responds this time
     healthImpl.calls.poll().responseObserver.onNext(makeResponse(ServingStatus.SERVING));
 
-    inOrder.verify(mockListener).onSubchannelState(
+    inOrder.verify(getMockListener()).onSubchannelState(
         eq(ConnectivityStateInfo.forNonError(READY)));
 
-    verifyNoMoreInteractions(origLb, mockListener, backoffPolicyProvider, backoffPolicy1);
+    verifyNoMoreInteractions(origLb, getMockListener(), backoffPolicyProvider, backoffPolicy1);
   }
 
   @Test
@@ -512,19 +568,26 @@ public void serverRespondResetsBackoff() {
         .setAddresses(resolvedAddressList)
         .setAttributes(resolutionAttrs)
         .build();
-    hcLbEventDelivery.handleResolvedAddresses(result);
+    hcLbEventDelivery.acceptResolvedAddresses(result);
 
-    verify(origLb).handleResolvedAddresses(result);
+    verify(origLb).acceptResolvedAddresses(result);
     verifyNoMoreInteractions(origLb);
 
     SubchannelStateListener mockStateListener = mockStateListeners[0];
-    Subchannel subchannel = createSubchannel(0, Attributes.EMPTY);
+    SubchannelStateListener mockHealthListener = mockHealthListeners[0];
+    Subchannel subchannel = createSubchannel(0, Attributes.EMPTY, maybeGetMockListener());
+
     assertThat(unwrap(subchannel)).isSameInstanceAs(subchannels[0]);
     InOrder inOrder =
-        inOrder(mockStateListener, backoffPolicyProvider, backoffPolicy1, backoffPolicy2);
+        inOrder(mockStateListener, mockHealthListener,
+            backoffPolicyProvider, backoffPolicy1, backoffPolicy2);
 
     deliverSubchannelState(0, ConnectivityStateInfo.forNonError(READY));
-    inOrder.verify(mockStateListener).onSubchannelState(
+    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);
@@ -534,37 +597,37 @@ public void serverRespondResetsBackoff() {
     healthImpl.calls.poll().responseObserver.onError(Status.CANCELLED.asException());
 
     // which results in TRANSIENT_FAILURE
-    inOrder.verify(mockStateListener).onSubchannelState(
+    inOrder.verify(getMockListener()).onSubchannelState(
         unavailableStateWithMsg(
             "Health-check stream unexpectedly closed with "
-            + Status.CANCELLED + " for 'TeeService'"));
+                + Status.CANCELLED + " for 'TeeService'"));
 
     // Retry with backoff is scheduled
     inOrder.verify(backoffPolicyProvider).get();
     inOrder.verify(backoffPolicy1).nextBackoffNanos();
     assertThat(clock.getPendingTasks()).hasSize(1);
 
-    verifyRetryAfterNanos(inOrder, mockStateListener, healthImpl, 11);
+    verifyRetryAfterNanos(inOrder, getMockListener(), healthImpl, 11);
     assertThat(clock.getPendingTasks()).isEmpty();
 
     // Server responds
     healthImpl.calls.peek().responseObserver.onNext(makeResponse(ServingStatus.SERVING));
-    inOrder.verify(mockStateListener).onSubchannelState(
+    inOrder.verify(getMockListener()).onSubchannelState(
         eq(ConnectivityStateInfo.forNonError(READY)));
 
     verifyNoMoreInteractions(mockStateListener);
 
     // then closes the stream
     healthImpl.calls.poll().responseObserver.onError(Status.UNAVAILABLE.asException());
-    inOrder.verify(mockStateListener).onSubchannelState(
+    inOrder.verify(getMockListener()).onSubchannelState(
         unavailableStateWithMsg(
             "Health-check stream unexpectedly closed with "
-            + Status.UNAVAILABLE + " for 'TeeService'"));
+                + 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(mockStateListener).onSubchannelState(
+    inOrder.verify(getMockListener()).onSubchannelState(
         eq(ConnectivityStateInfo.forNonError(CONNECTING)));
     assertThat(healthImpl.calls).hasSize(1);
     assertThat(clock.getPendingTasks()).isEmpty();
@@ -572,17 +635,17 @@ public void serverRespondResetsBackoff() {
 
     // then closes the stream for this retry
     healthImpl.calls.poll().responseObserver.onError(Status.UNAVAILABLE.asException());
-    inOrder.verify(mockStateListener).onSubchannelState(
+    inOrder.verify(getMockListener()).onSubchannelState(
         unavailableStateWithMsg(
             "Health-check stream unexpectedly closed with "
-            + Status.UNAVAILABLE + " for 'TeeService'"));
+                + 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, mockStateListener, healthImpl, 12);
+    verifyRetryAfterNanos(inOrder, getMockListener(), healthImpl, 12);
   }
 
   private void verifyRetryAfterNanos(
@@ -605,9 +668,9 @@ public void serviceConfigHasNoHealthCheckingInitiallyButDoesLater() {
         .setAddresses(resolvedAddressList)
         .setAttributes(Attributes.EMPTY)
         .build();
-    hcLbEventDelivery.handleResolvedAddresses(result1);
+    hcLbEventDelivery.acceptResolvedAddresses(result1);
 
-    verify(origLb).handleResolvedAddresses(result1);
+    verify(origLb).acceptResolvedAddresses(result1);
     verifyNoMoreInteractions(origLb);
 
     // First, create Subchannels 0
@@ -626,8 +689,8 @@ public void serviceConfigHasNoHealthCheckingInitiallyButDoesLater() {
         .setAddresses(resolvedAddressList)
         .setAttributes(resolutionAttrs)
         .build();
-    hcLbEventDelivery.handleResolvedAddresses(result2);
-    verify(origLb).handleResolvedAddresses(result2);
+    hcLbEventDelivery.acceptResolvedAddresses(result2);
+    verify(origLb).acceptResolvedAddresses(result2);
 
     // Health check started on existing Subchannel
     assertThat(healthImpls[0].calls).hasSize(1);
@@ -649,17 +712,21 @@ public void serviceConfigDisablesHealthCheckWhenRpcActive() {
         .setAddresses(resolvedAddressList)
         .setAttributes(resolutionAttrs)
         .build();
-    hcLbEventDelivery.handleResolvedAddresses(result1);
+    hcLbEventDelivery.acceptResolvedAddresses(result1);
 
-    verify(origLb).handleResolvedAddresses(result1);
+    verify(origLb).acceptResolvedAddresses(result1);
     verifyNoMoreInteractions(origLb);
 
-    Subchannel subchannel = createSubchannel(0, Attributes.EMPTY);
+    Subchannel subchannel = createSubchannel(0, Attributes.EMPTY, maybeGetMockListener());
     assertThat(unwrap(subchannel)).isSameInstanceAs(subchannels[0]);
-    InOrder inOrder = inOrder(origLb, mockStateListeners[0]);
+    InOrder inOrder = inOrder(origLb, mockStateListeners[0], mockHealthListeners[0]);
 
     deliverSubchannelState(0, ConnectivityStateInfo.forNonError(READY));
-    inOrder.verify(mockStateListeners[0]).onSubchannelState(
+    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];
@@ -672,15 +739,15 @@ public void serviceConfigDisablesHealthCheckWhenRpcActive() {
         .setAddresses(resolvedAddressList)
         .setAttributes(Attributes.EMPTY)
         .build();
-    hcLbEventDelivery.handleResolvedAddresses(result2);
+    hcLbEventDelivery.acceptResolvedAddresses(result2);
 
     // Health check RPC cancelled.
     assertThat(serverCall.cancelled).isTrue();
     // Subchannel uses original state
-    inOrder.verify(mockStateListeners[0]).onSubchannelState(
+    inOrder.verify(getMockListener()).onSubchannelState(
         eq(ConnectivityStateInfo.forNonError(READY)));
 
-    inOrder.verify(origLb).handleResolvedAddresses(result2);
+    inOrder.verify(origLb).acceptResolvedAddresses(result2);
 
     verifyNoMoreInteractions(origLb, mockStateListeners[0]);
     assertThat(healthImpl.calls).isEmpty();
@@ -693,17 +760,22 @@ public void serviceConfigDisablesHealthCheckWhenRetryPending() {
         .setAddresses(resolvedAddressList)
         .setAttributes(resolutionAttrs)
         .build();
-    hcLbEventDelivery.handleResolvedAddresses(result);
+    hcLbEventDelivery.acceptResolvedAddresses(result);
 
-    verify(origLb).handleResolvedAddresses(result);
+    verify(origLb).acceptResolvedAddresses(result);
     verifyNoMoreInteractions(origLb);
 
-    Subchannel subchannel = createSubchannel(0, Attributes.EMPTY);
+    SubchannelStateListener mockHealthListener = mockHealthListeners[0];
+    Subchannel subchannel = createSubchannel(0, Attributes.EMPTY, maybeGetMockListener());
     assertThat(unwrap(subchannel)).isSameInstanceAs(subchannels[0]);
-    InOrder inOrder = inOrder(origLb, mockStateListeners[0]);
+    InOrder inOrder = inOrder(origLb, mockStateListeners[0], mockHealthListener);
 
     deliverSubchannelState(0, ConnectivityStateInfo.forNonError(READY));
-    inOrder.verify(mockStateListeners[0]).onSubchannelState(
+    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];
@@ -713,7 +785,7 @@ public void serviceConfigDisablesHealthCheckWhenRetryPending() {
     assertThat(clock.getPendingTasks()).isEmpty();
     healthImpl.calls.poll().responseObserver.onCompleted();
     assertThat(clock.getPendingTasks()).hasSize(1);
-    inOrder.verify(mockStateListeners[0]).onSubchannelState(
+    inOrder.verify(getMockListener()).onSubchannelState(
         unavailableStateWithMsg(
             "Health-check stream unexpectedly closed with " + Status.OK + " for 'TeeService'"));
 
@@ -722,7 +794,7 @@ public void serviceConfigDisablesHealthCheckWhenRetryPending() {
         .setAddresses(resolvedAddressList)
         .setAttributes(Attributes.EMPTY)
         .build();
-    hcLbEventDelivery.handleResolvedAddresses(result2);
+    hcLbEventDelivery.acceptResolvedAddresses(result2);
 
     // Retry timer is cancelled
     assertThat(clock.getPendingTasks()).isEmpty();
@@ -730,11 +802,11 @@ public void serviceConfigDisablesHealthCheckWhenRetryPending() {
     // No retry was attempted
     assertThat(healthImpl.calls).isEmpty();
 
-    // Subchannel uses original state
-    inOrder.verify(mockStateListeners[0]).onSubchannelState(
+    // Subchannel uses raw state as health state
+    inOrder.verify(getMockListener()).onSubchannelState(
         eq(ConnectivityStateInfo.forNonError(READY)));
 
-    inOrder.verify(origLb).handleResolvedAddresses(result2);
+    inOrder.verify(origLb).acceptResolvedAddresses(result2);
 
     verifyNoMoreInteractions(origLb, mockStateListeners[0]);
   }
@@ -746,21 +818,24 @@ public void serviceConfigDisablesHealthCheckWhenRpcInactive() {
         .setAddresses(resolvedAddressList)
         .setAttributes(resolutionAttrs)
         .build();
-    hcLbEventDelivery.handleResolvedAddresses(result1);
+    hcLbEventDelivery.acceptResolvedAddresses(result1);
 
-    verify(origLb).handleResolvedAddresses(result1);
+    verify(origLb).acceptResolvedAddresses(result1);
     verifyNoMoreInteractions(origLb);
 
-    Subchannel subchannel = createSubchannel(0, Attributes.EMPTY);
+    Subchannel subchannel = createSubchannel(0, Attributes.EMPTY, maybeGetMockListener());
     assertThat(unwrap(subchannel)).isSameInstanceAs(subchannels[0]);
-    InOrder inOrder = inOrder(origLb, mockStateListeners[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);
-    inOrder.verify(mockStateListeners[0]).onSubchannelState(same(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
@@ -768,15 +843,19 @@ public void serviceConfigDisablesHealthCheckWhenRpcInactive() {
         .setAddresses(resolvedAddressList)
         .setAttributes(Attributes.EMPTY)
         .build();
-    hcLbEventDelivery.handleResolvedAddresses(result2);
+    hcLbEventDelivery.acceptResolvedAddresses(result2);
 
-    inOrder.verify(origLb).handleResolvedAddresses(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.
-    inOrder.verify(mockStateListeners[0]).onSubchannelState(
+    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.
@@ -792,18 +871,22 @@ public void serviceConfigChangesServiceNameWhenRpcActive() {
         .setAddresses(resolvedAddressList)
         .setAttributes(resolutionAttrs)
         .build();
-    hcLbEventDelivery.handleResolvedAddresses(result1);
+    hcLbEventDelivery.acceptResolvedAddresses(result1);
 
-    verify(origLb).handleResolvedAddresses(result1);
+    verify(origLb).acceptResolvedAddresses(result1);
     verifyNoMoreInteractions(origLb);
 
-    Subchannel subchannel = createSubchannel(0, Attributes.EMPTY);
+    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);
+    InOrder inOrder = inOrder(origLb, mockListener, mockHealthListener);
 
     deliverSubchannelState(0, ConnectivityStateInfo.forNonError(READY));
-    inOrder.verify(mockListener).onSubchannelState(
+    if (hasHealthConsumer) {
+      inOrder.verify(mockListener).onSubchannelState(eq(ConnectivityStateInfo.forNonError(READY)));
+    }
+    inOrder.verify(getMockListener()).onSubchannelState(
         eq(ConnectivityStateInfo.forNonError(CONNECTING)));
 
     HealthImpl healthImpl = healthImpls[0];
@@ -814,13 +897,13 @@ public void serviceConfigChangesServiceNameWhenRpcActive() {
 
     // Health check responded
     serverCall.responseObserver.onNext(makeResponse(ServingStatus.SERVING));
-    inOrder.verify(mockListener).onSubchannelState(
+    inOrder.verify(getMockListener()).onSubchannelState(
         eq(ConnectivityStateInfo.forNonError(READY)));
 
     // Service config returns with the same health check name.
-    hcLbEventDelivery.handleResolvedAddresses(result1);
+    hcLbEventDelivery.acceptResolvedAddresses(result1);
     // It's delivered to origLb, but nothing else happens
-    inOrder.verify(origLb).handleResolvedAddresses(result1);
+    inOrder.verify(origLb).acceptResolvedAddresses(result1);
     verifyNoMoreInteractions(origLb, mockListener);
 
     // Service config returns a different health check name.
@@ -829,8 +912,8 @@ public void serviceConfigChangesServiceNameWhenRpcActive() {
         .setAddresses(resolvedAddressList)
         .setAttributes(resolutionAttrs)
         .build();
-    hcLbEventDelivery.handleResolvedAddresses(result2);
-    inOrder.verify(origLb).handleResolvedAddresses(result2);
+    hcLbEventDelivery.acceptResolvedAddresses(result2);
+    inOrder.verify(origLb).acceptResolvedAddresses(result2);
 
     // Current health check RPC cancelled.
     assertThat(serverCall.cancelled).isTrue();
@@ -842,7 +925,7 @@ public void serviceConfigChangesServiceNameWhenRpcActive() {
     assertThat(serverCall.request).isEqualTo(makeRequest("FooService"));
 
     // State stays in READY, instead of switching to CONNECTING.
-    verifyNoMoreInteractions(origLb, mockListener);
+    verifyNoMoreInteractions(origLb, mockListener, mockHealthListener);
   }
 
   @Test
@@ -852,18 +935,22 @@ public void serviceConfigChangesServiceNameWhenRetryPending() {
         .setAddresses(resolvedAddressList)
         .setAttributes(resolutionAttrs)
         .build();
-    hcLbEventDelivery.handleResolvedAddresses(result1);
+    hcLbEventDelivery.acceptResolvedAddresses(result1);
 
-    verify(origLb).handleResolvedAddresses(result1);
+    verify(origLb).acceptResolvedAddresses(result1);
     verifyNoMoreInteractions(origLb);
 
-    Subchannel subchannel = createSubchannel(0, Attributes.EMPTY);
+    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);
+    InOrder inOrder = inOrder(origLb, mockListener, mockHealthListener);
 
     deliverSubchannelState(0, ConnectivityStateInfo.forNonError(READY));
-    inOrder.verify(mockListener).onSubchannelState(
+    if (hasHealthConsumer) {
+      inOrder.verify(mockListener).onSubchannelState(eq(ConnectivityStateInfo.forNonError(READY)));
+    }
+    inOrder.verify(getMockListener()).onSubchannelState(
         eq(ConnectivityStateInfo.forNonError(CONNECTING)));
 
     HealthImpl healthImpl = healthImpls[0];
@@ -877,15 +964,15 @@ public void serviceConfigChangesServiceNameWhenRetryPending() {
     serverCall.responseObserver.onCompleted();
     assertThat(clock.getPendingTasks()).hasSize(1);
     assertThat(healthImpl.calls).isEmpty();
-    inOrder.verify(mockListener).onSubchannelState(
+    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.handleResolvedAddresses(result1);
+    hcLbEventDelivery.acceptResolvedAddresses(result1);
     // It's delivered to origLb, but nothing else happens
-    inOrder.verify(origLb).handleResolvedAddresses(result1);
+    inOrder.verify(origLb).acceptResolvedAddresses(result1);
     verifyNoMoreInteractions(origLb, mockListener);
     assertThat(clock.getPendingTasks()).hasSize(1);
     assertThat(healthImpl.calls).isEmpty();
@@ -896,13 +983,12 @@ public void serviceConfigChangesServiceNameWhenRetryPending() {
         .setAddresses(resolvedAddressList)
         .setAttributes(resolutionAttrs)
         .build();
-    hcLbEventDelivery.handleResolvedAddresses(result2);
-
+    hcLbEventDelivery.acceptResolvedAddresses(result2);
     // Concluded CONNECTING state
-    inOrder.verify(mockListener).onSubchannelState(
+    inOrder.verify(getMockListener()).onSubchannelState(
         eq(ConnectivityStateInfo.forNonError(CONNECTING)));
 
-    inOrder.verify(origLb).handleResolvedAddresses(result2);
+    inOrder.verify(origLb).acceptResolvedAddresses(result2);
 
     // Current retry timer cancelled
     assertThat(clock.getPendingTasks()).isEmpty();
@@ -913,7 +999,7 @@ public void serviceConfigChangesServiceNameWhenRetryPending() {
     // with the new service name
     assertThat(serverCall.request).isEqualTo(makeRequest("FooService"));
 
-    verifyNoMoreInteractions(origLb, mockListener);
+    verifyNoMoreInteractions(origLb, mockListener, mockHealthListener);
   }
 
   @Test
@@ -923,15 +1009,15 @@ public void serviceConfigChangesServiceNameWhenRpcInactive() {
         .setAddresses(resolvedAddressList)
         .setAttributes(resolutionAttrs)
         .build();
-    hcLbEventDelivery.handleResolvedAddresses(result1);
+    hcLbEventDelivery.acceptResolvedAddresses(result1);
 
-    verify(origLb).handleResolvedAddresses(result1);
+    verify(origLb).acceptResolvedAddresses(result1);
     verifyNoMoreInteractions(origLb);
 
-    Subchannel subchannel = createSubchannel(0, Attributes.EMPTY);
+    Subchannel subchannel = createSubchannel(0, Attributes.EMPTY, maybeGetMockListener());
     SubchannelStateListener mockListener = mockStateListeners[0];
     assertThat(unwrap(subchannel)).isSameInstanceAs(subchannels[0]);
-    InOrder inOrder = inOrder(origLb, mockListener);
+    InOrder inOrder = inOrder(origLb, mockListener, mockHealthListeners[0]);
     HealthImpl healthImpl = healthImpls[0];
 
     // Underlying subchannel is not READY initially
@@ -939,13 +1025,16 @@ public void serviceConfigChangesServiceNameWhenRpcInactive() {
         ConnectivityStateInfo.forTransientFailure(
             Status.UNAVAILABLE.withDescription("connection refused"));
     deliverSubchannelState(0, underlyingErrorState);
-    inOrder.verify(mockListener).onSubchannelState(same(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.handleResolvedAddresses(result1);
+    hcLbEventDelivery.acceptResolvedAddresses(result1);
     // It's delivered to origLb, but nothing else happens
-    inOrder.verify(origLb).handleResolvedAddresses(result1);
+    inOrder.verify(origLb).acceptResolvedAddresses(result1);
     assertThat(healthImpl.calls).isEmpty();
     verifyNoMoreInteractions(origLb);
 
@@ -955,15 +1044,19 @@ public void serviceConfigChangesServiceNameWhenRpcInactive() {
         .setAddresses(resolvedAddressList)
         .setAttributes(resolutionAttrs)
         .build();
-    hcLbEventDelivery.handleResolvedAddresses(result2);
+    hcLbEventDelivery.acceptResolvedAddresses(result2);
 
-    inOrder.verify(origLb).handleResolvedAddresses(result2);
+    inOrder.verify(origLb).acceptResolvedAddresses(result2);
 
     // Underlying subchannel is now ready
     deliverSubchannelState(0, ConnectivityStateInfo.forNonError(READY));
 
     // Concluded CONNECTING state
-    inOrder.verify(mockListener).onSubchannelState(
+    if (hasHealthConsumer) {
+      inOrder.verify(mockListener).onSubchannelState(
+          eq(ConnectivityStateInfo.forNonError(READY)));
+    }
+    inOrder.verify(getMockListener()).onSubchannelState(
         eq(ConnectivityStateInfo.forNonError(CONNECTING)));
 
     // Health check RPC is started
@@ -1000,18 +1093,20 @@ public void balancerShutdown() {
         .setAddresses(resolvedAddressList)
         .setAttributes(resolutionAttrs)
         .build();
-    hcLbEventDelivery.handleResolvedAddresses(result);
+    hcLbEventDelivery.acceptResolvedAddresses(result);
 
-    verify(origLb).handleResolvedAddresses(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);
+      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
@@ -1022,7 +1117,11 @@ public void balancerShutdown() {
       serverCalls[i] = healthImpl.calls.poll();
       assertThat(serverCalls[i].cancelled).isFalse();
 
-      verify(mockListener).onSubchannelState(
+      if (hasHealthConsumer) {
+        verify(mockListener).onSubchannelState(
+            eq(ConnectivityStateInfo.forNonError(READY)));
+      }
+      verify(hasHealthConsumer ? mockHealthListener : mockListener).onSubchannelState(
           eq(ConnectivityStateInfo.forNonError(CONNECTING)));
     }
 
@@ -1074,8 +1173,8 @@ public LoadBalancer newLoadBalancer(Helper helper) {
         .setAddresses(resolvedAddressList)
         .setAttributes(resolutionAttrs)
         .build();
-    hcLbEventDelivery.handleResolvedAddresses(result);
-    verify(origLb).handleResolvedAddresses(result);
+    hcLbEventDelivery.acceptResolvedAddresses(result);
+    verify(origLb).acceptResolvedAddresses(result);
     createSubchannel(0, Attributes.EMPTY);
     assertThat(healthImpls[0].calls).isEmpty();
     deliverSubchannelState(0, ConnectivityStateInfo.forNonError(READY));
@@ -1111,7 +1210,7 @@ public boolean matches(Object item) {
               return false;
             }
             Status error = info.getStatus();
-            if (!error.getCode().equals(Code.UNAVAILABLE)) {
+            if (!error.getCode().equals(Status.Code.UNAVAILABLE)) {
               return false;
             }
             if (!error.getDescription().equals(expectedMsg)) {
@@ -1127,6 +1226,14 @@ public void describeTo(org.hamcrest.Description desc) {
         });
   }
 
+  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<>();
@@ -1192,6 +1299,11 @@ public void log(ChannelLogLevel level, String template, Object... args) {
       this.channel = checkNotNull(channel);
     }
 
+    @Override
+    public Object getInternalSubchannel() {
+      return this;
+    }
+
     @Override
     public void start(SubchannelStateListener listener) {
       checkState(this.listener == null);
@@ -1288,15 +1400,24 @@ public String toString() {
 
   // 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(CreateSubchannelArgs.newBuilder()
-              .setAddresses(eagLists[index])
-              .setAttributes(attrs)
-              .build());
+          Subchannel s = wrappedHelper.createSubchannel(subchannelArgsBuilder.build());
           s.start(mockStateListeners[index]);
           returnedSubchannel.set(s);
         }
@@ -1313,7 +1434,8 @@ public void run() {
       });
   }
 
-  private static FakeSubchannel unwrap(Subchannel s) {
-    return (FakeSubchannel) ((SubchannelImpl) s).delegate();
+  private FakeSubchannel unwrap(Subchannel s) {
+    Subchannel s1 = ((SubchannelImpl) s).delegate();
+    return (FakeSubchannel) s1.getInternalSubchannel();
   }
 }
diff --git a/services/src/test/java/io/grpc/services/HealthStatusManagerTest.java b/services/src/test/java/io/grpc/protobuf/services/HealthStatusManagerTest.java
similarity index 93%
rename from services/src/test/java/io/grpc/services/HealthStatusManagerTest.java
rename to services/src/test/java/io/grpc/protobuf/services/HealthStatusManagerTest.java
index fe04419656f..b2652e92771 100644
--- a/services/src/test/java/io/grpc/services/HealthStatusManagerTest.java
+++ b/services/src/test/java/io/grpc/protobuf/services/HealthStatusManagerTest.java
@@ -14,20 +14,26 @@
  * limitations under the License.
  */
 
-package io.grpc.services;
+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.CancellableContext;
 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;
@@ -109,6 +115,18 @@ public void enterTerminalState_watch() throws Exception {
     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);
diff --git a/services/src/test/java/io/grpc/protobuf/services/ProtoReflectionServiceTest.java b/services/src/test/java/io/grpc/protobuf/services/ProtoReflectionServiceTest.java
index c9dd1014141..115dd11b0f1 100644
--- a/services/src/test/java/io/grpc/protobuf/services/ProtoReflectionServiceTest.java
+++ b/services/src/test/java/io/grpc/protobuf/services/ProtoReflectionServiceTest.java
@@ -71,7 +71,8 @@ public class ProtoReflectionServiceTest {
 
   private static final String TEST_HOST = "localhost";
   private MutableHandlerRegistry handlerRegistry = new MutableHandlerRegistry();
-  private BindableService reflectionService;
+  @SuppressWarnings("deprecation")
+  private BindableService reflectionService = ProtoReflectionService.newInstance();
   private ServerServiceDefinition dynamicService =
       new DynamicServiceGrpc.DynamicServiceImplBase() {}.bindService();
   private ServerServiceDefinition anotherDynamicService =
@@ -80,7 +81,6 @@ public class ProtoReflectionServiceTest {
 
   @Before
   public void setUp() throws Exception {
-    reflectionService = ProtoReflectionService.newInstance();
     Server server =
         InProcessServerBuilder.forName("proto-reflection-test")
             .directExecutor()
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/services/TempFileSinkTest.java b/services/src/test/java/io/grpc/protobuf/services/TempFileSinkTest.java
similarity index 94%
rename from services/src/test/java/io/grpc/services/TempFileSinkTest.java
rename to services/src/test/java/io/grpc/protobuf/services/TempFileSinkTest.java
index f47f10569d6..e3b662a8588 100644
--- a/services/src/test/java/io/grpc/services/TempFileSinkTest.java
+++ b/services/src/test/java/io/grpc/protobuf/services/TempFileSinkTest.java
@@ -14,11 +14,12 @@
  * limitations under the License.
  */
 
-package io.grpc.services;
+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;
@@ -27,7 +28,7 @@
 import org.junit.runners.JUnit4;
 
 /**
- * Tests for {@link io.grpc.services.TempFileSink}.
+ * Tests for {@link TempFileSink}.
  */
 @RunWith(JUnit4.class)
 public class TempFileSinkTest {
diff --git a/services/src/test/java/io/grpc/services/internal/HealthCheckingRoundRobinLoadBalancerProviderTest.java b/services/src/test/java/io/grpc/protobuf/services/internal/HealthCheckingRoundRobinLoadBalancerProviderTest.java
similarity index 94%
rename from services/src/test/java/io/grpc/services/internal/HealthCheckingRoundRobinLoadBalancerProviderTest.java
rename to services/src/test/java/io/grpc/protobuf/services/internal/HealthCheckingRoundRobinLoadBalancerProviderTest.java
index 1c122967d9a..470670f2060 100644
--- a/services/src/test/java/io/grpc/services/internal/HealthCheckingRoundRobinLoadBalancerProviderTest.java
+++ b/services/src/test/java/io/grpc/protobuf/services/internal/HealthCheckingRoundRobinLoadBalancerProviderTest.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.grpc.services.internal;
+package io.grpc.protobuf.services.internal;
 
 import static com.google.common.truth.Truth.assertThat;
 
@@ -25,7 +25,7 @@
 import org.junit.runners.JUnit4;
 
 /**
- * Tests for {@link InternalHealthCheckingRoundRobinLoadBalancerProvider}.
+ * Tests for {@link HealthCheckingRoundRobinLoadBalancerProvider}.
  */
 @RunWith(JUnit4.class)
 public class HealthCheckingRoundRobinLoadBalancerProviderTest {
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
index db6b294bf3a..f60446b1a3a 100644
--- a/services/src/test/java/io/grpc/services/CallMetricRecorderTest.java
+++ b/services/src/test/java/io/grpc/services/CallMetricRecorderTest.java
@@ -18,13 +18,14 @@
 
 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 BinlogHelper}. */
+/** Tests for {@link CallMetricRecorder}. */
 @RunWith(JUnit4.class)
 public class CallMetricRecorderTest {
 
@@ -37,32 +38,118 @@ public void dumpGivesEmptyResultWhenNoSavedMetricValues() {
 
   @Test
   public void dumpDumpsAllSavedMetricValues() {
-    recorder.recordCallMetric("cost1", 154353.423);
-    recorder.recordCallMetric("cost2", 0.1367);
-    recorder.recordCallMetric("cost3", 1437.34);
+    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);
 
-    Map<String, Double> dump = recorder.finalizeAndDump();
-    assertThat(dump)
-        .containsExactly("cost1", 154353.423, "cost2", 0.1367, "cost3", 1437.34);
+    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.recordCallMetric("cost", 154353.423);
+    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.recordCallMetric("cost1", 3412.5435);
-    recorder.recordCallMetric("cost2", 6441.341);
-    recorder.recordCallMetric("cost1", 6441.341);
-    recorder.recordCallMetric("cost1", 4654.67);
-    recorder.recordCallMetric("cost2", 75.83);
-    Map<String, Double> dump = recorder.finalizeAndDump();
-    assertThat(dump)
+    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
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..5cd213949f4
--- /dev/null
+++ b/servlet/jakarta/build.gradle
@@ -0,0 +1,163 @@
+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
+    }
+    tasks.named("jacocoTestReport").configure {
+        // Must use executionData(Task...) override. The executionData(Object...) override doesn't
+        // find execution data correctly for tasks.
+        executionData jetty11Test.get()
+    }
+}
+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
+    }
+    tasks.named("jacocoTestReport").configure {
+        // Must use executionData(Task...) override. The executionData(Object...) override doesn't
+        // find execution data correctly for tasks.
+        executionData tomcat10Test.get(), undertowTest.get()
+    }
+}
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..5bea4c6e03b
--- /dev/null
+++ b/servlet/src/main/java/io/grpc/servlet/ServletServerBuilder.java
@@ -0,0 +1,294 @@
+/*
+ * 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(
+        (streamTracerFactories, metricRecorder) -> 
+            buildTransportServers(streamTracerFactories));
+  }
+
+  /**
+   * 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..b2891b6e47e
--- /dev/null
+++ b/servlet/src/threadingTest/java/io/grpc/servlet/AsyncServletOutputStreamWriterConcurrencyTest.java
@@ -0,0 +1,182 @@
+/*
+ * 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.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.
+ */
+@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 70dfca8e37a..51c4bdc0d3d 100644
--- a/settings.gradle
+++ b/settings.gradle
@@ -1,22 +1,53 @@
 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 {
-        id "com.android.application" version "3.5.0"
-        id "com.android.library" version "3.5.0"
-        id "com.github.johnrengelman.shadow" version "6.1.0"
-        id "com.github.kt3k.coveralls" version "2.10.2"
-        id "com.google.osdetector" version "1.6.2"
-        id "com.google.protobuf" version "0.8.15"
-        id "digital.wup.android-maven-publish" version "3.6.2"
-        id "me.champeau.gradle.japicmp" version "0.2.5"
-        id "me.champeau.gradle.jmh" version "0.5.2"
-        id "net.ltgt.errorprone" version "1.3.0"
-        id "ru.vyarus.animalsniffer" version "1.5.2"
+        // 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 {
@@ -37,6 +68,7 @@ include ":grpc-protobuf"
 include ":grpc-protobuf-lite"
 include ":grpc-netty"
 include ":grpc-netty-shaded"
+include ":grpc-googleapis"
 include ":grpc-grpclb"
 include ":grpc-testing"
 include ":grpc-testing-proto"
@@ -46,9 +78,21 @@ include ":grpc-all"
 include ":grpc-alts"
 include ":grpc-benchmarks"
 include ":grpc-services"
+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
@@ -61,6 +105,7 @@ project(':grpc-protobuf').projectDir = "$rootDir/protobuf" as File
 project(':grpc-protobuf-lite').projectDir = "$rootDir/protobuf-lite" 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
@@ -70,9 +115,21 @@ 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-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'
@@ -91,4 +148,6 @@ if (settings.hasProperty('skipAndroid') && skipAndroid.toBoolean()) {
     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
index 181ffe0485d..f9188c27272 100644
--- a/stub/BUILD.bazel
+++ b/stub/BUILD.bazel
@@ -1,3 +1,6 @@
+load("@rules_java//java:defs.bzl", "java_library")
+load("@rules_jvm_external//:defs.bzl", "artifact")
+
 java_library(
     name = "stub",
     srcs = glob([
@@ -7,17 +10,9 @@ java_library(
     deps = [
         "//api",
         "//context",
-        "@com_google_code_findbugs_jsr305//jar",
-        "@com_google_guava_guava//jar",
-        "@com_google_j2objc_j2objc_annotations//jar",
+        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"),
     ],
 )
-
-# javax.annotation.Generated is not included in the default root modules in 9,
-# see: http://openjdk.java.net/jeps/320.
-java_library(
-    name = "javax_annotation",
-    neverlink = 1,  # @Generated is source-retention
-    visibility = ["//visibility:public"],
-    exports = ["@org_apache_tomcat_annotations_api//jar"],
-)
diff --git a/stub/build.gradle b/stub/build.gradle
index ce1e742ab38..2dabd9e6202 100644
--- a/stub/build.gradle
+++ b/stub/build.gradle
@@ -7,15 +7,34 @@ plugins {
 }
 
 description = "gRPC: Stub"
+
+tasks.named("jar").configure {
+    manifest {
+        attributes('Automatic-Module-Name': 'io.grpc.stub')
+    }
+}
+
 dependencies {
-    api project(':grpc-api')
-    guavaDependency 'api'
+    api project(':grpc-api'),
+        libraries.animalsniffer.annotations,
+        libraries.guava
+    implementation libraries.errorprone.annotations
     testImplementation libraries.truth,
-            project(':grpc-testing')
-    signature "org.codehaus.mojo.signature:java17:1.0@signature"
-    signature "net.sf.androidscents.signature:android-api-level-14:4.0_r4@signature"
+            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 {
+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
index 3c090357473..f369eeaf87f 100644
--- a/stub/src/main/java/io/grpc/stub/AbstractAsyncStub.java
+++ b/stub/src/main/java/io/grpc/stub/AbstractAsyncStub.java
@@ -16,10 +16,10 @@
 
 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.CheckReturnValue;
 import javax.annotation.concurrent.ThreadSafe;
 
 /**
@@ -35,7 +35,7 @@
 public abstract class AbstractAsyncStub<S extends AbstractAsyncStub<S>> extends AbstractStub<S> {
 
   protected AbstractAsyncStub(Channel channel, CallOptions callOptions) {
-      super(channel, callOptions);
+    super(channel, callOptions);
   }
 
   /**
diff --git a/stub/src/main/java/io/grpc/stub/AbstractBlockingStub.java b/stub/src/main/java/io/grpc/stub/AbstractBlockingStub.java
index 1cb919e67b0..4bdb3c0bb94 100644
--- a/stub/src/main/java/io/grpc/stub/AbstractBlockingStub.java
+++ b/stub/src/main/java/io/grpc/stub/AbstractBlockingStub.java
@@ -16,10 +16,10 @@
 
 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.CheckReturnValue;
 import javax.annotation.concurrent.ThreadSafe;
 
 /**
diff --git a/stub/src/main/java/io/grpc/stub/AbstractFutureStub.java b/stub/src/main/java/io/grpc/stub/AbstractFutureStub.java
index 66570bcd6ff..5e37b1e4915 100644
--- a/stub/src/main/java/io/grpc/stub/AbstractFutureStub.java
+++ b/stub/src/main/java/io/grpc/stub/AbstractFutureStub.java
@@ -16,10 +16,10 @@
 
 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.CheckReturnValue;
 import javax.annotation.concurrent.ThreadSafe;
 
 /**
diff --git a/stub/src/main/java/io/grpc/stub/AbstractStub.java b/stub/src/main/java/io/grpc/stub/AbstractStub.java
index 2a74aa24692..697107760db 100644
--- a/stub/src/main/java/io/grpc/stub/AbstractStub.java
+++ b/stub/src/main/java/io/grpc/stub/AbstractStub.java
@@ -17,7 +17,9 @@
 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;
@@ -26,11 +28,12 @@
 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.CheckReturnValue;
 import javax.annotation.Nullable;
 import javax.annotation.concurrent.ThreadSafe;
+import org.codehaus.mojo.animal_sniffer.IgnoreJRERequirement;
 
 /**
  * Common base type for stub implementations. Stub configuration is immutable; changing the
@@ -149,6 +152,12 @@ 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
@@ -163,14 +172,11 @@ public final S withExecutor(Executor 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));
   }
@@ -255,6 +261,16 @@ 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.
    *
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 7b3d4e55b3e..52dd046831d 100644
--- a/stub/src/main/java/io/grpc/stub/CallStreamObserver.java
+++ b/stub/src/main/java/io/grpc/stub/CallStreamObserver.java
@@ -49,8 +49,10 @@
  *
  * <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> {
 
   /**
diff --git a/stub/src/main/java/io/grpc/stub/ClientCallStreamObserver.java b/stub/src/main/java/io/grpc/stub/ClientCallStreamObserver.java
index e18d19fc376..8f420fa77e4 100644
--- a/stub/src/main/java/io/grpc/stub/ClientCallStreamObserver.java
+++ b/stub/src/main/java/io/grpc/stub/ClientCallStreamObserver.java
@@ -16,13 +16,12 @@
 
 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.
@@ -30,8 +29,7 @@
  * <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
@@ -57,10 +55,58 @@ public abstract class ClientCallStreamObserver<V> extends CallStreamObserver<V>
    *
    * <p>This method may only be called during {@link ClientResponseObserver#beforeStart
    * ClientResponseObserver.beforeStart()}.
-   *
-   * <p>This API is still a work in-progress and may change in the future.
    */
   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 0266cb7d9af..ff2804a0a1f 100644
--- a/stub/src/main/java/io/grpc/stub/ClientCalls.java
+++ b/stub/src/main/java/io/grpc/stub/ClientCalls.java
@@ -19,13 +19,17 @@
 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;
@@ -39,9 +43,15 @@
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.Executor;
 import java.util.concurrent.Future;
+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;
 
 /**
@@ -53,6 +63,11 @@ public final class ClientCalls {
 
   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() {}
 
@@ -65,6 +80,7 @@ private ClientCalls() {}
    */
   public static <ReqT, RespT> void asyncUnaryCall(
       ClientCall<ReqT, RespT> call, ReqT req, StreamObserver<RespT> responseObserver) {
+    checkNotNull(responseObserver, "responseObserver");
     asyncUnaryRequestCall(call, req, responseObserver, false);
   }
 
@@ -78,6 +94,7 @@ public static <ReqT, RespT> void asyncUnaryCall(
    */
   public static <ReqT, RespT> void asyncServerStreamingCall(
       ClientCall<ReqT, RespT> call, ReqT req, StreamObserver<RespT> responseObserver) {
+    checkNotNull(responseObserver, "responseObserver");
     asyncUnaryRequestCall(call, req, responseObserver, true);
   }
 
@@ -94,6 +111,7 @@ public static <ReqT, RespT> void asyncServerStreamingCall(
   public static <ReqT, RespT> StreamObserver<ReqT> asyncClientStreamingCall(
       ClientCall<ReqT, RespT> call,
       StreamObserver<RespT> responseObserver) {
+    checkNotNull(responseObserver, "responseObserver");
     return asyncStreamingRequestCall(call, responseObserver, false);
   }
 
@@ -108,6 +126,7 @@ public static <ReqT, RespT> StreamObserver<ReqT> asyncClientStreamingCall(
    */
   public static <ReqT, RespT> StreamObserver<ReqT> asyncBidiStreamingCall(
       ClientCall<ReqT, RespT> call, StreamObserver<RespT> responseObserver) {
+    checkNotNull(responseObserver, "responseObserver");
     return asyncStreamingRequestCall(call, responseObserver, true);
   }
 
@@ -121,9 +140,7 @@ public static <ReqT, RespT> StreamObserver<ReqT> asyncBidiStreamingCall(
   public static <ReqT, RespT> RespT blockingUnaryCall(ClientCall<ReqT, RespT> call, ReqT req) {
     try {
       return getUnchecked(futureUnaryCall(call, req));
-    } catch (RuntimeException e) {
-      throw cancelThrow(call, e);
-    } catch (Error e) {
+    } catch (RuntimeException | Error e) {
       throw cancelThrow(call, e);
     }
   }
@@ -153,11 +170,9 @@ public static <ReqT, RespT> RespT blockingUnaryCall(
           // Now wait for onClose() to be called, so interceptors can clean up
         }
       }
+      executor.shutdown();
       return getUnchecked(responseFuture);
-    } catch (RuntimeException e) {
-      // Something very bad happened. All bets are off; it may be dangerous to wait for onClose().
-      throw cancelThrow(call, e);
-    } catch (Error e) {
+    } 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 {
@@ -167,6 +182,23 @@ public static <ReqT, RespT> RespT blockingUnaryCall(
     }
   }
 
+  /**
+   * 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.  The {@code call} should not be already started.  After calling this method,
@@ -176,7 +208,6 @@ public static <ReqT, RespT> RespT blockingUnaryCall(
    *
    * @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 req) {
     BlockingResponseStream<RespT> result = new BlockingResponseStream<>(call);
@@ -186,25 +217,100 @@ public static <ReqT, RespT> Iterator<RespT> blockingServerStreamingCall(
 
   /**
    * Executes a server-streaming call returning a blocking {@link Iterator} over the
-   * response stream.  The {@code call} should not be already started.  After calling this method,
-   * {@code call} should no longer be used.
+   * 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 req) {
-    ThreadlessExecutor executor = new ThreadlessExecutor();
     ClientCall<ReqT, RespT> call = channel.newCall(method,
-        callOptions.withOption(ClientCalls.STUB_TYPE_OPTION, StubType.BLOCKING)
-            .withExecutor(executor));
-    BlockingResponseStream<RespT> result = new BlockingResponseStream<>(call, executor);
+        callOptions.withOption(ClientCalls.STUB_TYPE_OPTION, StubType.BLOCKING));
+
+    BlockingResponseStream<RespT> result = new BlockingResponseStream<>(call);
     asyncUnaryRequestCall(call, req, result.listener());
     return result;
   }
 
+  /**
+   * 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
@@ -275,8 +381,7 @@ private static StatusRuntimeException toStatusRuntimeException(Throwable t) {
   private static RuntimeException cancelThrow(ClientCall<?, ?> call, Throwable t) {
     try {
       call.cancel(null, t);
-    } catch (Throwable e) {
-      assert e instanceof RuntimeException || e instanceof Error;
+    } catch (RuntimeException | Error e) {
       logger.log(Level.SEVERE, "RuntimeException encountered while closing call", e);
     }
     if (t instanceof RuntimeException) {
@@ -307,9 +412,7 @@ private static <ReqT, RespT> void asyncUnaryRequestCall(
     try {
       call.sendMessage(req);
       call.halfClose();
-    } catch (RuntimeException e) {
-      throw cancelThrow(call, e);
-    } catch (Error e) {
+    } catch (RuntimeException | Error e) {
       throw cancelThrow(call, e);
     }
   }
@@ -337,9 +440,10 @@ private abstract static class StartableListener<T> extends ClientCall.Listener<T
     abstract void onStart();
   }
 
-  private static final class CallToStreamObserverAdapter<T> extends ClientCallStreamObserver<T> {
+  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 int initialRequest = 1;
@@ -348,7 +452,7 @@ private static final class CallToStreamObserverAdapter<T> extends ClientCallStre
     private boolean completed = false;
 
     // Non private to avoid synthetic class
-    CallToStreamObserverAdapter(ClientCall<T, ?> call, boolean streamingResponse) {
+    CallToStreamObserverAdapter(ClientCall<ReqT, ?> call, boolean streamingResponse) {
       this.call = call;
       this.streamingResponse = streamingResponse;
     }
@@ -358,7 +462,7 @@ 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);
@@ -390,7 +494,6 @@ public void setOnReadyHandler(Runnable onReadyHandler) {
       this.onReadyHandler = onReadyHandler;
     }
 
-    @Deprecated
     @Override
     public void disableAutoInboundFlowControl() {
       disableAutoRequestWithInitial(1);
@@ -411,7 +514,7 @@ public void disableAutoRequestWithInitial(int request) {
     public void request(int count) {
       if (!streamingResponse && count == 1) {
         // 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.
+        // sends more than one response, we can catch it and fail it in the listener.
         call.request(2);
       } else {
         call.request(count);
@@ -500,6 +603,7 @@ void onStart() {
   private static final class UnaryStreamToFuture<RespT> extends StartableListener<RespT> {
     private final GrpcFuture<RespT> responseFuture;
     private RespT value;
+    private boolean isValueReceived = false;
 
     // Non private to avoid synthetic class
     UnaryStreamToFuture(GrpcFuture<RespT> responseFuture) {
@@ -512,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")
@@ -582,20 +687,12 @@ private static final class BlockingResponseStream<T> implements Iterator<T> {
     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;
 
     // Non private to avoid synthetic class
     BlockingResponseStream(ClientCall<?, T> call) {
-      this(call, null);
-    }
-
-    // Non private to avoid synthetic class
-    BlockingResponseStream(ClientCall<?, T> call, ThreadlessExecutor threadless) {
       this.call = call;
-      this.threadless = threadless;
     }
 
     StartableListener<T> listener() {
@@ -605,28 +702,14 @@ StartableListener<T> listener() {
     private Object waitForNext() {
       boolean interrupt = false;
       try {
-        if (threadless == null) {
-          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
-            }
-          }
-        } else {
-          Object next;
-          while ((next = buffer.poll()) == null) {
-            try {
-              threadless.waitAndDrain();
-            } catch (InterruptedException ie) {
-              interrupt = true;
-              call.cancel("Thread interrupted", ie);
-              // Now wait for onClose() to be called, so interceptors can clean up
-            }
+        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
           }
-          return next;
         }
       } finally {
         if (interrupt) {
@@ -654,7 +737,7 @@ public boolean hasNext() {
     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 recieved, every other message can be delivered instantly. This
+      // 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);
@@ -712,7 +795,10 @@ private static final class ThreadlessExecutor extends ConcurrentLinkedQueue<Runn
       implements Executor {
     private static final Logger log = Logger.getLogger(ThreadlessExecutor.class.getName());
 
-    private volatile Thread waiter;
+    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() {}
@@ -736,11 +822,7 @@ public void waitAndDrain() throws InterruptedException {
         }
       }
       do {
-        try {
-          runnable.run();
-        } catch (Throwable t) {
-          log.log(Level.WARNING, "Runnable threw exception", t);
-        }
+        runQuietly(runnable);
       } while ((runnable = poll()) != null);
     }
 
@@ -750,10 +832,156 @@ private static void throwIfInterrupted() throws 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);
-      LockSupport.unpark(waiter); // no-op if null
+      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 {
+          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();
+        }
+
+        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) {
+      waiterLock.lock();
+      try {
+        add(runnable);
+        waiterCondition.signalAll(); // If anything is waiting let it wake up and process this task
+      } finally {
+        waiterLock.unlock();
+      }
     }
   }
 
diff --git a/stub/src/main/java/io/grpc/stub/ClientResponseObserver.java b/stub/src/main/java/io/grpc/stub/ClientResponseObserver.java
index 5f5510f6d3c..b6155f1cbc2 100644
--- a/stub/src/main/java/io/grpc/stub/ClientResponseObserver.java
+++ b/stub/src/main/java/io/grpc/stub/ClientResponseObserver.java
@@ -16,16 +16,13 @@
 
 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("https://github.com/grpc/grpc-java/issues/4693")
 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.
    *
diff --git a/stub/src/main/java/io/grpc/stub/MetadataUtils.java b/stub/src/main/java/io/grpc/stub/MetadataUtils.java
index 0fedf3711f7..4208d3ca652 100644
--- a/stub/src/main/java/io/grpc/stub/MetadataUtils.java
+++ b/stub/src/main/java/io/grpc/stub/MetadataUtils.java
@@ -25,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;
 
@@ -37,18 +41,6 @@ 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, Metadata extraHeaders) {
-    return stub.withInterceptors(newAttachHeadersInterceptor(extraHeaders));
-  }
-
   /**
    * Returns a client interceptor that attaches a set of headers to requests.
    *
@@ -90,24 +82,6 @@ public void start(Listener<RespT> responseListener, Metadata headers) {
     }
   }
 
-  /**
-   * Captures the last received metadata for a stub. 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}.
-   */
-  @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));
-  }
-
   /**
    * Captures the last received metadata on a channel. Useful for testing.
    *
@@ -174,4 +148,63 @@ public void onClose(Status status, Metadata trailers) {
       }
     }
   }
+
+  /**
+   * Returns a ServerInterceptor that adds the specified Metadata to every response stream, one way
+   * or another.
+   *
+   * <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.
+   */
+  @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 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 7a538b0e5d8..6ffea3500cc 100644
--- a/stub/src/main/java/io/grpc/stub/ServerCallStreamObserver.java
+++ b/stub/src/main/java/io/grpc/stub/ServerCallStreamObserver.java
@@ -16,11 +16,14 @@
 
 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.
@@ -28,8 +31,7 @@
  * <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> {
 
   /**
    * Returns {@code true} when the call is cancelled and the server is encouraged to abort
@@ -56,12 +58,29 @@ public abstract class ServerCallStreamObserver<V> extends CallStreamObserver<V>
    * service returns its {@code StreamObserver}.
    *
    * <p>Setting the onCancelHandler will suppress the on-cancel exception thrown by
-   * {@link #onNext}.
+   * {@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. Default gRPC servers support the "gzip" compressor.
@@ -89,10 +108,84 @@ public abstract class ServerCallStreamObserver<V> extends CallStreamObserver<V>
    *   <li>{@link io.grpc.MethodDescriptor.MethodType#SERVER_STREAMING} operations.</li>
    * </ul>
    * </p>
-   *
-   * <p>This API is still a work in-progress and may change in the future.
    */
   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 ba08139b716..9f0063713cc 100644
--- a/stub/src/main/java/io/grpc/stub/ServerCalls.java
+++ b/stub/src/main/java/io/grpc/stub/ServerCalls.java
@@ -206,6 +206,13 @@ public void onReady() {
           responseObserver.onReadyHandler.run();
         }
       }
+
+      @Override
+      public void onComplete() {
+        if (responseObserver.onCloseHandler != null) {
+          responseObserver.onCloseHandler.run();
+        }
+      }
     }
   }
 
@@ -291,6 +298,13 @@ public void onReady() {
           responseObserver.onReadyHandler.run();
         }
       }
+
+      @Override
+      public void onComplete() {
+        if (responseObserver.onCloseHandler != null) {
+          responseObserver.onCloseHandler.run();
+        }
+      }
     }
   }
 
@@ -320,6 +334,7 @@ private static final class ServerCallStreamObserverImpl<ReqT, RespT>
     private Runnable onCancelHandler;
     private boolean aborted = false;
     private boolean completed = false;
+    private Runnable onCloseHandler;
 
     // Non private to avoid synthetic class
     ServerCallStreamObserverImpl(ServerCall<ReqT, RespT> call, boolean serverStreamingOrBidi) {
@@ -367,9 +382,10 @@ 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;
@@ -380,7 +396,7 @@ public void onCompleted() {
       call.close(Status.OK, new Metadata());
       completed = true;
     }
-
+    
     @Override
     public boolean isReady() {
       return call.isReady();
@@ -407,7 +423,14 @@ public void setOnCancelHandler(Runnable onCancelHandler) {
       this.onCancelHandler = onCancelHandler;
     }
 
-    @Deprecated
+    @Override
+    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);
+    }
+
     @Override
     public void disableAutoInboundFlowControl() {
       disableAutoRequest();
@@ -423,6 +446,14 @@ public void disableAutoRequest() {
     public void request(int count) {
       call.request(count);
     }
+
+    @Override
+    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;
+    }
   }
 
   /**
@@ -447,7 +478,7 @@ public static void asyncUnimplementedUnaryCall(
    * @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.
diff --git a/stub/src/main/java/io/grpc/stub/StreamObserver.java b/stub/src/main/java/io/grpc/stub/StreamObserver.java
index 92040d9bc58..3a5c756e73e 100644
--- a/stub/src/main/java/io/grpc/stub/StreamObserver.java
+++ b/stub/src/main/java/io/grpc/stub/StreamObserver.java
@@ -26,11 +26,21 @@
  * {@code StreamObserver} and passes it to the GRPC library for receiving.
  *
  * <p>Implementations are not required to be thread-safe (but should be
- * <a href="http://www.ibm.com/developerworks/library/j-jtp09263/">thread-compatible</a>).
- * Separate {@code StreamObserver}s do
+ * <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 0355696a365..a421d3eca2f 100644
--- a/stub/src/main/java/io/grpc/stub/StreamObservers.java
+++ b/stub/src/main/java/io/grpc/stub/StreamObservers.java
@@ -24,8 +24,20 @@
  * Utility functions for working with {@link StreamObserver} and it's common subclasses like
  * {@link CallStreamObserver}.
  */
-@ExperimentalApi("https://github.com/grpc/grpc-java/issues/4694")
 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.  After calling this method, {@code target} should no
@@ -37,7 +49,10 @@ 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");
@@ -77,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
index fbf46baed87..3615eddfa79 100644
--- a/stub/src/main/java/io/grpc/stub/annotations/RpcMethod.java
+++ b/stub/src/main/java/io/grpc/stub/annotations/RpcMethod.java
@@ -25,7 +25,7 @@
 /**
  * {@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>
+ * Java Annotation Processors</a>.
  *
  * <p>
  *   This annotation is used by the gRPC stub compiler to annotate {@link MethodDescriptor}
diff --git a/stub/src/test/java/io/grpc/stub/AbstractStubTest.java b/stub/src/test/java/io/grpc/stub/AbstractStubTest.java
index 9006b8679e4..352a2fb7fe2 100644
--- a/stub/src/test/java/io/grpc/stub/AbstractStubTest.java
+++ b/stub/src/test/java/io/grpc/stub/AbstractStubTest.java
@@ -16,12 +16,19 @@
 
 package io.grpc.stub;
 
+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 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;
@@ -47,8 +54,23 @@ public NoopStub newStub(Channel channel, CallOptions callOptions) {
         .isNull();
   }
 
-  class NoopStub extends AbstractStub<NoopStub> {
+  @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);
 
+    assertAbout(deadline()).that(actual).isWithin(10, MILLISECONDS).of(expected);
+  }
+
+  class NoopStub extends AbstractStub<NoopStub> {
     NoopStub(Channel channel, CallOptions options) {
       super(channel, options);
     }
diff --git a/stub/src/test/java/io/grpc/stub/BaseAbstractStubTest.java b/stub/src/test/java/io/grpc/stub/BaseAbstractStubTest.java
index b197c78aca2..9f7f10d8298 100644
--- a/stub/src/test/java/io/grpc/stub/BaseAbstractStubTest.java
+++ b/stub/src/test/java/io/grpc/stub/BaseAbstractStubTest.java
@@ -16,6 +16,7 @@
 
 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;
@@ -27,22 +28,19 @@
 import io.grpc.Channel;
 import java.util.concurrent.Executor;
 import javax.annotation.Nullable;
-import org.junit.Before;
+import org.junit.Rule;
 import org.junit.Test;
 import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
+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;
 
-  @Before
-  public void setup() {
-    MockitoAnnotations.initMocks(this);
-  }
-
   T create(Channel channel) {
     return create(channel, CallOptions.DEFAULT);
   }
@@ -93,4 +91,16 @@ public void withExecutor() {
 
     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 6b54ba1f62d..b711b2a23b5 100644
--- a/stub/src/test/java/io/grpc/stub/ClientCallsTest.java
+++ b/stub/src/test/java/io/grpc/stub/ClientCallsTest.java
@@ -19,6 +19,7 @@
 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;
@@ -38,6 +39,7 @@
 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;
@@ -45,7 +47,6 @@
 import io.grpc.StatusRuntimeException;
 import io.grpc.inprocess.InProcessChannelBuilder;
 import io.grpc.inprocess.InProcessServerBuilder;
-import io.grpc.internal.NoopClientCall;
 import io.grpc.stub.ClientCalls.StubType;
 import io.grpc.stub.ServerCalls.NoopStreamObserver;
 import io.grpc.stub.ServerCalls.ServerStreamingMethod;
@@ -58,11 +59,14 @@
 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;
@@ -70,13 +74,16 @@
 import org.mockito.ArgumentMatchers;
 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 ClientCalls}.
  */
 @RunWith(JUnit4.class)
 public class ClientCallsTest {
+  @Rule public final MockitoRule mocks = MockitoJUnit.rule();
+
   private static final MethodDescriptor<Integer, Integer> UNARY_METHOD =
       MethodDescriptor.<Integer, Integer>newBuilder()
           .setType(MethodDescriptor.MethodType.UNARY)
@@ -97,10 +104,11 @@ public class ClientCallsTest {
   private ArgumentCaptor<MethodDescriptor<?, ?>> methodDescriptorCaptor;
   @Captor
   private ArgumentCaptor<CallOptions> callOptionsCaptor;
+  private boolean originalRejectRunnableOnExecutor;
 
   @Before
   public void setUp() {
-    MockitoAnnotations.initMocks(this);
+    originalRejectRunnableOnExecutor = ClientCalls.rejectRunnableOnExecutor;
   }
 
   @After
@@ -111,6 +119,7 @@ public void tearDown() {
     if (channel != null) {
       channel.shutdownNow();
     }
+    ClientCalls.rejectRunnableOnExecutor = originalRejectRunnableOnExecutor;
   }
 
   @Test
@@ -217,6 +226,49 @@ class NoopUnaryMethod implements UnaryMethod<Integer, Integer> {
     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>() {
@@ -347,7 +399,7 @@ public void cancel(String message, Throwable cause) {
       future.get();
       fail("Should fail");
     } catch (CancellationException e) {
-      // Exepcted
+      // Expected
     }
   }
 
@@ -390,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
@@ -454,6 +506,50 @@ public void onCompleted() {
     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 {
@@ -858,6 +954,7 @@ class NoopServerStreamingMethod implements ServerStreamingMethod<Integer, Intege
   // 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(
@@ -867,14 +964,15 @@ public <ReqT,RespT> ClientCall<ReqT, RespT> interceptCall(
           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() {
-          Thread.currentThread().interrupt();
           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 f9ceb82166d..6f458facc5e 100644
--- a/stub/src/test/java/io/grpc/stub/ServerCallsTest.java
+++ b/stub/src/test/java/io/grpc/stub/ServerCallsTest.java
@@ -199,6 +199,53 @@ public StreamObserver<Integer> invoke(StreamObserver<Integer> responseObserver)
     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 =
@@ -255,6 +302,31 @@ public void run() {
     }
   }
 
+  @Test
+  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 =
@@ -288,7 +360,7 @@ public void disablingInboundAutoFlowControlSuppressesRequestsForMoreMessages() t
               public StreamObserver<Integer> invoke(StreamObserver<Integer> responseObserver) {
                 ServerCallStreamObserver<Integer> serverCallObserver =
                     (ServerCallStreamObserver<Integer>) responseObserver;
-                serverCallObserver.disableAutoInboundFlowControl();
+                serverCallObserver.disableAutoRequest();
                 return new ServerCalls.NoopStreamObserver<>();
               }
             });
@@ -379,6 +451,31 @@ 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);
@@ -458,6 +555,35 @@ public void invoke(Integer req, StreamObserver<Integer> responseObserver) {
     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);
@@ -554,6 +680,8 @@ private static class ServerCallRecorder extends ServerCall<Integer, Integer> {
     private Status status;
     private boolean isCancelled;
     private boolean isReady;
+    private int onReadyThreshold;
+    private Metadata trailers;
 
     public ServerCallRecorder(MethodDescriptor<Integer, Integer> methodDescriptor) {
       this.methodDescriptor = methodDescriptor;
@@ -576,6 +704,7 @@ public void sendMessage(Integer message) {
     @Override
     public void close(Status status, Metadata trailers) {
       this.status = status;
+      this.trailers = trailers;
     }
 
     @Override
@@ -588,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 f12fe9250cc..ee602bc5135 100644
--- a/testing-proto/build.gradle
+++ b/testing-proto/build.gradle
@@ -3,16 +3,26 @@ plugins {
     id "maven-publish"
 
     id "com.google.protobuf"
+    id "ru.vyarus.animalsniffer"
 }
 
 description = "gRPC: Testing Protos"
 
+tasks.named("jar").configure {
+    manifest {
+        attributes('Automatic-Module-Name': 'io.grpc.testing.protobuf')
+    }
+}
+
 dependencies {
     api project(':grpc-protobuf'),
             project(':grpc-stub')
-    compileOnly libraries.javax_annotation
     testImplementation libraries.truth
-    testRuntimeOnly libraries.javax_annotation
+    signature (libraries.signature.java) {
+        artifact {
+            extension = "signature"
+        }
+    }
 }
 
 configureProtoCompilation()
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
index 925a5c92956..e242fd0f513 100644
--- 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
@@ -7,14 +7,12 @@
  * A simple service for test.
  * </pre>
  */
-@javax.annotation.Generated(
-    value = "by gRPC proto compiler",
-    comments = "Source: io/grpc/testing/protobuf/simpleservice.proto")
+@io.grpc.stub.annotations.GrpcGenerated
 public final class SimpleServiceGrpc {
 
   private SimpleServiceGrpc() {}
 
-  public static final String SERVICE_NAME = "grpc.testing.SimpleService";
+  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,
@@ -155,6 +153,21 @@ public SimpleServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions ca
     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
    */
@@ -190,14 +203,14 @@ public SimpleServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOpti
    * A simple service for test.
    * </pre>
    */
-  public static abstract class SimpleServiceImplBase implements io.grpc.BindableService {
+  public interface AsyncService {
 
     /**
      * <pre>
      * Simple unary RPC.
      * </pre>
      */
-    public void unaryRpc(io.grpc.testing.protobuf.SimpleRequest request,
+    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);
     }
@@ -207,7 +220,7 @@ public void unaryRpc(io.grpc.testing.protobuf.SimpleRequest request,
      * Simple client-to-server streaming RPC.
      * </pre>
      */
-    public io.grpc.stub.StreamObserver<io.grpc.testing.protobuf.SimpleRequest> clientStreamingRpc(
+    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);
     }
@@ -217,7 +230,7 @@ public io.grpc.stub.StreamObserver<io.grpc.testing.protobuf.SimpleRequest> clien
      * Simple server-to-client streaming RPC.
      * </pre>
      */
-    public void serverStreamingRpc(io.grpc.testing.protobuf.SimpleRequest request,
+    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);
     }
@@ -227,51 +240,34 @@ public void serverStreamingRpc(io.grpc.testing.protobuf.SimpleRequest request,
      * Simple bidirectional streaming RPC.
      * </pre>
      */
-    public io.grpc.stub.StreamObserver<io.grpc.testing.protobuf.SimpleRequest> bidiStreamingRpc(
+    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 io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
-          .addMethod(
-            getUnaryRpcMethod(),
-            io.grpc.stub.ServerCalls.asyncUnaryCall(
-              new MethodHandlers<
-                io.grpc.testing.protobuf.SimpleRequest,
-                io.grpc.testing.protobuf.SimpleResponse>(
-                  this, METHODID_UNARY_RPC)))
-          .addMethod(
-            getClientStreamingRpcMethod(),
-            io.grpc.stub.ServerCalls.asyncClientStreamingCall(
-              new MethodHandlers<
-                io.grpc.testing.protobuf.SimpleRequest,
-                io.grpc.testing.protobuf.SimpleResponse>(
-                  this, METHODID_CLIENT_STREAMING_RPC)))
-          .addMethod(
-            getServerStreamingRpcMethod(),
-            io.grpc.stub.ServerCalls.asyncServerStreamingCall(
-              new MethodHandlers<
-                io.grpc.testing.protobuf.SimpleRequest,
-                io.grpc.testing.protobuf.SimpleResponse>(
-                  this, METHODID_SERVER_STREAMING_RPC)))
-          .addMethod(
-            getBidiStreamingRpcMethod(),
-            io.grpc.stub.ServerCalls.asyncBidiStreamingCall(
-              new MethodHandlers<
-                io.grpc.testing.protobuf.SimpleRequest,
-                io.grpc.testing.protobuf.SimpleResponse>(
-                  this, METHODID_BIDI_STREAMING_RPC)))
-          .build();
+      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> {
+  public static final class SimpleServiceStub
+      extends io.grpc.stub.AbstractAsyncStub<SimpleServiceStub> {
     private SimpleServiceStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -329,11 +325,79 @@ public io.grpc.stub.StreamObserver<io.grpc.testing.protobuf.SimpleRequest> bidiS
   }
 
   /**
+   * A stub to allow clients to do synchronous rpc calls to service SimpleService.
    * <pre>
    * A simple service for test.
    * </pre>
    */
-  public static final class SimpleServiceBlockingStub extends io.grpc.stub.AbstractBlockingStub<SimpleServiceBlockingStub> {
+  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);
@@ -368,11 +432,13 @@ public java.util.Iterator<io.grpc.testing.protobuf.SimpleResponse> serverStreami
   }
 
   /**
+   * 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> {
+  public static final class SimpleServiceFutureStub
+      extends io.grpc.stub.AbstractFutureStub<SimpleServiceFutureStub> {
     private SimpleServiceFutureStub(
         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
@@ -406,10 +472,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 SimpleServiceImplBase serviceImpl;
+    private final AsyncService serviceImpl;
     private final int methodId;
 
-    MethodHandlers(SimpleServiceImplBase serviceImpl, int methodId) {
+    MethodHandlers(AsyncService serviceImpl, int methodId) {
       this.serviceImpl = serviceImpl;
       this.methodId = methodId;
     }
@@ -448,6 +514,39 @@ public io.grpc.stub.StreamObserver<Req> invoke(
     }
   }
 
+  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() {}
@@ -471,9 +570,9 @@ private static final class SimpleServiceFileDescriptorSupplier
   private static final class SimpleServiceMethodDescriptorSupplier
       extends SimpleServiceBaseDescriptorSupplier
       implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
-    private final String methodName;
+    private final java.lang.String methodName;
 
-    SimpleServiceMethodDescriptorSupplier(String methodName) {
+    SimpleServiceMethodDescriptorSupplier(java.lang.String methodName) {
       this.methodName = methodName;
     }
 
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
index 89208c700a5..fdc658399df 100644
--- a/testing-proto/src/test/java/io/grpc/testing/protobuf/SimpleServiceTest.java
+++ b/testing-proto/src/test/java/io/grpc/testing/protobuf/SimpleServiceTest.java
@@ -32,6 +32,7 @@
 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;
@@ -79,6 +80,11 @@ 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());
diff --git a/testing/BUILD.bazel b/testing/BUILD.bazel
index f1e9a5743ed..d280ab97ee1 100644
--- a/testing/BUILD.bazel
+++ b/testing/BUILD.bazel
@@ -1,3 +1,6 @@
+load("@rules_java//java:defs.bzl", "java_library")
+load("@rules_jvm_external//:defs.bzl", "artifact")
+
 java_library(
     name = "testing",
     testonly = 1,
@@ -11,26 +14,12 @@ java_library(
     deps = [
         "//api",
         "//context",
-        "//core:inprocess",
-        "//core:util",
+        "//inprocess",
         "//stub",
-        "@com_google_code_findbugs_jsr305//jar",
-        "@com_google_guava_guava//jar",
-        "@com_google_j2objc_j2objc_annotations//jar",
-        "@com_google_truth_truth//jar",
-        "@junit_junit//jar",
-    ],
-)
-
-java_library(
-    name = "internal",
-    srcs = glob([
-        "src/main/java/io/grpc/internal/*.java",
-    ]),
-    visibility = ["//:__subpackages__"],
-    deps = [
-        "//api",
-        "//core:internal",
-        "@io_opencensus_opencensus_api//jar",
+        "//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 dc619913b6b..b92e39279c6 100644
--- a/testing/build.gradle
+++ b/testing/build.gradle
@@ -3,31 +3,42 @@ plugins {
     id "maven-publish"
 
     id "me.champeau.gradle.japicmp"
+    id "ru.vyarus.animalsniffer"
 }
 
 description = "gRPC: Testing"
 
-evaluationDependsOn(project(':grpc-core').path)
-
 dependencies {
-    api project(':grpc-core'),
+    api project(':grpc-util'),
             project(':grpc-stub'),
             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
 
-    censusApiDependency 'implementation'
-
-    testImplementation (libraries.mockito) {
-        // prefer our own versions instead of mockito's dependency
-        exclude group: 'org.hamcrest', module: 'hamcrest-core'
-    }
+    testImplementation libraries.mockito.core
 
     testImplementation project(':grpc-testing-proto'),
-            project(':grpc-core').sourceSets.test.output
+            testFixtures(project(':grpc-core'))
+
+    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/**' }
 
-jacocoTestReport {
+tasks.named("jacocoTestReport").configure {
     classDirectories.from = sourceSets.main.output.collect {
         fileTree(dir: it,
         exclude: [
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 cd525eeeeb9..a15559ed5cb 100644
--- a/testing/src/main/java/io/grpc/internal/testing/StatsTestUtils.java
+++ b/testing/src/main/java/io/grpc/internal/testing/StatsTestUtils.java
@@ -16,8 +16,8 @@
 
 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;
diff --git a/testing/src/main/java/io/grpc/internal/testing/TestStreamTracer.java b/testing/src/main/java/io/grpc/internal/testing/TestStreamTracer.java
index 444537962e8..1d0061f6120 100644
--- a/testing/src/main/java/io/grpc/internal/testing/TestStreamTracer.java
+++ b/testing/src/main/java/io/grpc/internal/testing/TestStreamTracer.java
@@ -18,6 +18,7 @@
 
 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;
@@ -180,6 +181,7 @@ public void outboundMessageSent(
         int seqNo, long optionalWireSize, long optionalUncompressedSize) {
       outboundEvents.add(
           String.format(
+              Locale.US,
               "outboundMessageSent(%d, %d, %d)",
               seqNo, optionalWireSize, optionalUncompressedSize));
     }
@@ -189,6 +191,7 @@ public void inboundMessageRead(
         int seqNo, long optionalWireSize, long optionalUncompressedSize) {
       inboundEvents.add(
           String.format(
+              Locale.US,
               "inboundMessageRead(%d, %d, %d)", seqNo, optionalWireSize, optionalUncompressedSize));
     }
 
diff --git a/testing/src/main/java/io/grpc/internal/testing/TestUtils.java b/testing/src/main/java/io/grpc/internal/testing/TestUtils.java
index a21c9940136..01b0105c45e 100644
--- a/testing/src/main/java/io/grpc/internal/testing/TestUtils.java
+++ b/testing/src/main/java/io/grpc/internal/testing/TestUtils.java
@@ -18,6 +18,7 @@
 
 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;
@@ -30,14 +31,12 @@
 import java.net.InetSocketAddress;
 import java.net.UnknownHostException;
 import java.security.KeyStore;
-import java.security.NoSuchAlgorithmException;
 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.Collections;
 import java.util.List;
 import javax.net.ssl.SSLContext;
 import javax.net.ssl.SSLSocketFactory;
@@ -95,29 +94,6 @@ public static List<InetSocketAddress> testServerAddresses(InetSocketAddress... o
     }
   }
 
-  /**
-   * 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.
-   */
-  public static List<String> preferredTestCiphers() {
-    String[] ciphers;
-    try {
-      ciphers = SSLContext.getDefault().getDefaultSSLParameters().getCipherSuites();
-    } catch (NoSuchAlgorithmException ex) {
-      throw new RuntimeException(ex);
-    }
-    List<String> ciphersMinusGcm = new ArrayList<>();
-    for (String cipher : ciphers) {
-      // The GCM implementation in Java is _very_ slow (~1 MB/s)
-      if (cipher.contains("_GCM_")) {
-        continue;
-      }
-      ciphersMinusGcm.add(cipher);
-    }
-    return Collections.unmodifiableList(ciphersMinusGcm);
-  }
-
   /**
    * Saves a file from the classpath resources in src/main/resources/certs as a file on the
    * filesystem.
@@ -125,8 +101,7 @@ public static List<String> preferredTestCiphers() {
    * @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));
+    InputStream in = new BufferedInputStream(TlsTesting.loadCert(name));
     File tmpFile = File.createTempFile(name, "");
     tmpFile.deleteOnExit();
 
@@ -154,7 +129,7 @@ public static X509Certificate loadX509Cert(String fileName)
       throws CertificateException, IOException {
     CertificateFactory cf = CertificateFactory.getInstance("X.509");
 
-    InputStream in = TestUtils.class.getResourceAsStream("/certs/" + fileName);
+    InputStream in = TlsTesting.loadCert(fileName);
     try {
       return (X509Certificate) cf.generateCertificate(in);
     } finally {
diff --git a/testing/src/main/java/io/grpc/testing/GrpcCleanupRule.java b/testing/src/main/java/io/grpc/testing/GrpcCleanupRule.java
index cd0d43010ee..55188e57149 100644
--- a/testing/src/main/java/io/grpc/testing/GrpcCleanupRule.java
+++ b/testing/src/main/java/io/grpc/testing/GrpcCleanupRule.java
@@ -22,36 +22,61 @@
 import com.google.common.annotations.VisibleForTesting;
 import com.google.common.base.Stopwatch;
 import com.google.common.base.Ticker;
-import io.grpc.ExperimentalApi;
+import com.google.common.collect.Lists;
 import io.grpc.ManagedChannel;
 import io.grpc.Server;
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.List;
 import java.util.concurrent.TimeUnit;
 import javax.annotation.Nonnull;
 import javax.annotation.concurrent.NotThreadSafe;
-import org.junit.rules.TestRule;
+import org.junit.rules.ExternalResource;
 import org.junit.runner.Description;
-import org.junit.runners.model.MultipleFailureException;
 import org.junit.runners.model.Statement;
 
 /**
- * A JUnit {@link TestRule} 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.
+ * 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
  */
-@ExperimentalApi("https://github.com/grpc/grpc-java/issues/2488")
 @NotThreadSafe
-public final class GrpcCleanupRule implements TestRule {
+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 Throwable firstException;
+  private boolean abruptShutdown;
 
   /**
    * Sets a positive total time limit for the automatic resource cleanup. If any of the resources
@@ -116,69 +141,70 @@ 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 new Statement() {
+    return super.apply(new Statement() {
       @Override
       public void evaluate() throws Throwable {
+        abruptShutdown = false;
         try {
           base.evaluate();
         } catch (Throwable t) {
-          firstException = t;
-
-          try {
-            teardown();
-          } catch (Throwable t2) {
-            throw new MultipleFailureException(Arrays.asList(t, t2));
-          }
-
+          abruptShutdown = true;
           throw t;
         }
-
-        teardown();
-        if (firstException != null) {
-          throw firstException;
-        }
       }
-    };
+    }, description);
   }
 
   /**
    * Releases all the registered resources.
    */
-  private void teardown() {
+  @Override
+  protected void after() {
+    stopwatch.reset();
     stopwatch.start();
 
-    if (firstException == null) {
+    InterruptedException interrupted = null;
+    if (!abruptShutdown) {
+      for (Resource resource : Lists.reverse(resources)) {
+        resource.cleanUp();
+      }
+
       for (int i = resources.size() - 1; i >= 0; i--) {
-        resources.get(i).cleanUp();
+        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;
+        }
       }
     }
 
-    for (int i = resources.size() - 1; i >= 0; i--) {
-      if (firstException != null) {
-        resources.get(i).forceCleanUp();
-        continue;
+    if (!resources.isEmpty()) {
+      for (Resource resource : Lists.reverse(resources)) {
+        resource.forceCleanUp();
       }
 
       try {
-        boolean released = resources.get(i).awaitReleased(
-            timeoutNanos - stopwatch.elapsed(TimeUnit.NANOSECONDS), TimeUnit.NANOSECONDS);
-        if (!released) {
-          firstException = new AssertionError(
-              "Resource " + resources.get(i) + " can not be released in time at the end of test");
+        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);
         }
-      } catch (InterruptedException e) {
-        Thread.currentThread().interrupt();
-        firstException = e;
-      }
-
-      if (firstException != null) {
-        resources.get(i).forceCleanUp();
+      } finally {
+        resources.clear();
       }
     }
-
-    resources.clear();
   }
 
   @VisibleForTesting
diff --git a/testing/src/main/java/io/grpc/testing/GrpcServerRule.java b/testing/src/main/java/io/grpc/testing/GrpcServerRule.java
index dffe7bd1c7f..641c9927d91 100644
--- a/testing/src/main/java/io/grpc/testing/GrpcServerRule.java
+++ b/testing/src/main/java/io/grpc/testing/GrpcServerRule.java
@@ -19,7 +19,6 @@
 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;
@@ -34,19 +33,20 @@
 
 /**
  * {@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. However, due to
- * it's limitation that {@code GrpcServerRule} does not support useful features such as transport
+ * 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}. So in general it is more favorable to use the more flexible {@code TestRule}
- * {@link GrpcCleanupRule} than {@code GrpcServerRule} in unit tests.
+ * 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 final class GrpcServerRule extends ExternalResource {
 
   private ManagedChannel channel;
diff --git a/testing/src/main/java/io/grpc/testing/TestMethodDescriptors.java b/testing/src/main/java/io/grpc/testing/TestMethodDescriptors.java
index b83c323cd5c..5ffc60e369b 100644
--- a/testing/src/main/java/io/grpc/testing/TestMethodDescriptors.java
+++ b/testing/src/main/java/io/grpc/testing/TestMethodDescriptors.java
@@ -16,7 +16,6 @@
 
 package io.grpc.testing;
 
-import io.grpc.ExperimentalApi;
 import io.grpc.MethodDescriptor;
 import io.grpc.MethodDescriptor.MethodType;
 import java.io.ByteArrayInputStream;
@@ -28,7 +27,6 @@
  *
  * @since 1.1.0
  */
-@ExperimentalApi("https://github.com/grpc/grpc-java/issues/2600")
 public final class TestMethodDescriptors {
   private TestMethodDescriptors() {}
 
@@ -38,7 +36,6 @@ private TestMethodDescriptors() {}
    *
    * @since 1.1.0
    */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/2600")
   public static MethodDescriptor<Void, Void> voidMethod() {
     return MethodDescriptor.<Void, Void>newBuilder()
         .setType(MethodType.UNARY)
@@ -53,7 +50,6 @@ public static MethodDescriptor<Void, Void> voidMethod() {
    *
    * @since 1.1.0
    */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/2600")
   public static MethodDescriptor.Marshaller<Void> voidMarshaller() {
     return new NoopMarshaller();
   }
diff --git a/testing/src/main/resources/certs/README b/testing/src/main/resources/certs/README
index ab0d851a18b..13e375784c5 100644
--- a/testing/src/main/resources/certs/README
+++ b/testing/src/main/resources/certs/README
@@ -62,6 +62,40 @@ common name which is set to *.test.google.com.
 $ 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
 
+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
+
+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
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/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-----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+-----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
index 3be53ae8b8b..8eb3edd3825 100644
--- a/testing/src/test/java/io/grpc/testing/GrpcCleanupRuleTest.java
+++ b/testing/src/test/java/io/grpc/testing/GrpcCleanupRuleTest.java
@@ -18,6 +18,7 @@
 
 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;
@@ -35,9 +36,7 @@
 import io.grpc.internal.FakeClock;
 import io.grpc.testing.GrpcCleanupRule.Resource;
 import java.util.concurrent.TimeUnit;
-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.junit.runners.model.MultipleFailureException;
@@ -51,10 +50,6 @@
 public class GrpcCleanupRuleTest {
   public static final FakeClock fakeClock = new FakeClock();
 
-  @SuppressWarnings("deprecation") // https://github.com/grpc/grpc-java/issues/7467
-  @Rule
-  public ExpectedException thrown = ExpectedException.none();
-
   @Test
   public void registerChannelReturnSameChannel() {
     ManagedChannel channel = mock(ManagedChannel.class);
@@ -72,10 +67,9 @@ public void registerNullChannelThrowsNpe() {
     ManagedChannel channel = null;
     GrpcCleanupRule grpcCleanup = new GrpcCleanupRule();
 
-    thrown.expect(NullPointerException.class);
-    thrown.expectMessage("channel");
-
-    grpcCleanup.register(channel);
+    NullPointerException e = assertThrows(NullPointerException.class,
+        () -> grpcCleanup.register(channel));
+    assertThat(e).hasMessageThat().isEqualTo("channel");
   }
 
   @Test
@@ -83,10 +77,9 @@ public void registerNullServerThrowsNpe() {
     Server server = null;
     GrpcCleanupRule grpcCleanup = new GrpcCleanupRule();
 
-    thrown.expect(NullPointerException.class);
-    thrown.expectMessage("server");
-
-    grpcCleanup.register(server);
+    NullPointerException e = assertThrows(NullPointerException.class,
+        () -> grpcCleanup.register(server));
+    assertThat(e).hasMessageThat().isEqualTo("server");
   }
 
   @Test
@@ -248,13 +241,13 @@ public void multiResource_awaitReleasedFails() throws Throwable {
 
     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.verify(resource1).forceCleanUp();
 
     inOrder.verifyNoMoreInteractions();
 
     verify(resource3, never()).forceCleanUp();
-    verify(resource1, never()).awaitReleased(anyLong(), any(TimeUnit.class));
+    verify(resource1, never()).forceCleanUp();
   }
 
   @Test
@@ -280,7 +273,7 @@ public void multiResource_awaitReleasedInterrupted() throws Throwable {
     boolean cleanupFailed = false;
     try {
       grpcCleanup.apply(statement, null /* description*/).evaluate();
-    } catch (InterruptedException e) {
+    } catch (Throwable e) {
       cleanupFailed = true;
     }
 
@@ -381,7 +374,8 @@ public void multiResource_timeoutCalculation_customTimeout() throws Throwable {
   @Test
   public void baseTestFailsThenCleanupFails() throws Throwable {
     // setup
-    Exception baseTestFailure = new Exception();
+    Exception baseTestFailure = new Exception("base test failure");
+    Exception cleanupFailure = new RuntimeException("force cleanup failed");
 
     Statement statement = mock(Statement.class);
     doThrow(baseTestFailure).when(statement).evaluate();
@@ -389,7 +383,7 @@ public void baseTestFailsThenCleanupFails() throws Throwable {
     Resource resource1 = mock(Resource.class);
     Resource resource2 = mock(Resource.class);
     Resource resource3 = mock(Resource.class);
-    doThrow(new RuntimeException()).when(resource2).forceCleanUp();
+    doThrow(cleanupFailure).when(resource2).forceCleanUp();
 
     InOrder inOrder = inOrder(statement, resource1, resource2, resource3);
     GrpcCleanupRule grpcCleanup = new GrpcCleanupRule();
@@ -407,8 +401,14 @@ public void baseTestFailsThenCleanupFails() throws Throwable {
     }
 
     // verify
-    assertThat(failure).isInstanceOf(MultipleFailureException.class);
-    assertSame(baseTestFailure, ((MultipleFailureException) failure).getFailures().get(0));
+    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();
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/core/src/jmh/java/io/grpc/util/HandlerRegistryBenchmark.java b/util/src/jmh/java/io/grpc/util/HandlerRegistryBenchmark.java
similarity index 100%
rename from core/src/jmh/java/io/grpc/util/HandlerRegistryBenchmark.java
rename to util/src/jmh/java/io/grpc/util/HandlerRegistryBenchmark.java
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..eea664f2ad4
--- /dev/null
+++ b/util/src/main/java/io/grpc/util/AdvancedTlsX509KeyManager.java
@@ -0,0 +1,353 @@
+/*
+ * 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.concurrent.atomic.AtomicInteger;
+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.
+ *
+ * <p>The alias increments on every credential load (e.g. {@code "key-1"}, {@code "key-2"}, ...),
+ * so the same alias always maps to the same key material. The previous alias is retained for one
+ * rotation to allow in-progress handshakes to complete, ensuring alias-to-key-material consistency
+ * across credential reloads.
+ */
+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;
+  // Prefix for the key material alias; revision counter appended on each credential load.
+  static final String ALIAS_PREFIX = "key-";
+
+  private final AtomicInteger revision = new AtomicInteger(0);
+  // Snapshot of current and previous KeyInfo; previous is retained for in-progress handshakes
+  // after one rotation.
+  private volatile KeyInfoSnapshot snapshot = new KeyInfoSnapshot(null, null);
+
+  public AdvancedTlsX509KeyManager() {}
+
+  private String alias() {
+    KeyInfo curr = this.snapshot.current;
+    return curr != null ? curr.alias : null;
+  }
+
+  @Override
+  public PrivateKey getPrivateKey(String alias) {
+    KeyInfoSnapshot snap = this.snapshot;
+    if (snap.current != null && snap.current.alias.equals(alias)) {
+      return snap.current.key;
+    }
+    if (snap.previous != null && snap.previous.alias.equals(alias)) {
+      return snap.previous.key;
+    }
+    return null;
+  }
+
+  @Override
+  public X509Certificate[] getCertificateChain(String alias) {
+    KeyInfoSnapshot snap = this.snapshot;
+    if (snap.current != null && snap.current.alias.equals(alias)) {
+      return Arrays.copyOf(snap.current.certs, snap.current.certs.length);
+    }
+    if (snap.previous != null && snap.previous.alias.equals(alias)) {
+      return Arrays.copyOf(snap.previous.certs, snap.previous.certs.length);
+    }
+    return null;
+  }
+
+  @Override
+  public String[] getClientAliases(String keyType, Principal[] issuers) {
+    String alias = alias();
+    return alias != null ? new String[] {alias} : null;
+  }
+
+  @Override
+  public String chooseClientAlias(String[] keyType, Principal[] issuers, Socket socket) {
+    return alias();
+  }
+
+  @Override
+  public String chooseEngineClientAlias(String[] keyType, Principal[] issuers, SSLEngine engine) {
+    return alias();
+  }
+
+  @Override
+  public String[] getServerAliases(String keyType, Principal[] issuers) {
+    String alias = alias();
+    return alias != null ? new String[] {alias} : null;
+  }
+
+  @Override
+  public String chooseServerAlias(String keyType, Principal[] issuers, Socket socket) {
+    return alias();
+  }
+
+  @Override
+  public String chooseEngineServerAlias(String keyType, Principal[] issuers,
+      SSLEngine engine) {
+    return alias();
+  }
+
+  /**
+   * 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) {
+    KeyInfo newInfo = new KeyInfo(checkNotNull(certs, "certs"), checkNotNull(key, "key"),
+        ALIAS_PREFIX + revision.incrementAndGet());
+    this.snapshot = new KeyInfoSnapshot(newInfo, this.snapshot.current);
+  }
+
+  /**
+   * 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;
+    final String alias;
+
+    public KeyInfo(X509Certificate[] certs, PrivateKey key, String alias) {
+      this.certs = certs;
+      this.key = key;
+      this.alias = alias;
+    }
+  }
+
+  private static class KeyInfoSnapshot {
+    final KeyInfo current;
+    final KeyInfo previous;
+
+    KeyInfoSnapshot(KeyInfo current, KeyInfo previous) {
+      this.current = current;
+      this.previous = previous;
+    }
+  }
+
+  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/core/src/main/java/io/grpc/util/ForwardingLoadBalancer.java b/util/src/main/java/io/grpc/util/ForwardingLoadBalancer.java
similarity index 84%
rename from core/src/main/java/io/grpc/util/ForwardingLoadBalancer.java
rename to util/src/main/java/io/grpc/util/ForwardingLoadBalancer.java
index 628eda3b71b..d52ff42e652 100644
--- a/core/src/main/java/io/grpc/util/ForwardingLoadBalancer.java
+++ b/util/src/main/java/io/grpc/util/ForwardingLoadBalancer.java
@@ -17,14 +17,10 @@
 package io.grpc.util;
 
 import com.google.common.base.MoreObjects;
-import io.grpc.Attributes;
 import io.grpc.ConnectivityStateInfo;
-import io.grpc.EquivalentAddressGroup;
 import io.grpc.ExperimentalApi;
 import io.grpc.LoadBalancer;
-import io.grpc.NameResolver;
 import io.grpc.Status;
-import java.util.List;
 
 @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1771")
 public abstract class ForwardingLoadBalancer extends LoadBalancer {
@@ -33,14 +29,7 @@ public abstract class ForwardingLoadBalancer extends LoadBalancer {
    */
   protected abstract LoadBalancer delegate();
 
-  @Override
   @Deprecated
-  public void handleResolvedAddressGroups(
-        List<EquivalentAddressGroup> servers,
-        @NameResolver.ResolutionResultAttr Attributes attributes) {
-    delegate().handleResolvedAddressGroups(servers, attributes);
-  }
-
   @Override
   public void handleResolvedAddresses(ResolvedAddresses resolvedAddresses) {
     delegate().handleResolvedAddresses(resolvedAddresses);
@@ -64,6 +53,8 @@ public void shutdown() {
   }
 
   @Override
+  @Deprecated
+  @SuppressWarnings("InlineMeSuggester")
   public boolean canHandleEmptyAddressListFromNameResolution() {
     return delegate().canHandleEmptyAddressListFromNameResolution();
   }
diff --git a/core/src/main/java/io/grpc/util/ForwardingLoadBalancerHelper.java b/util/src/main/java/io/grpc/util/ForwardingLoadBalancerHelper.java
similarity index 83%
rename from core/src/main/java/io/grpc/util/ForwardingLoadBalancerHelper.java
rename to util/src/main/java/io/grpc/util/ForwardingLoadBalancerHelper.java
index 033524fa816..338903fc5fc 100644
--- a/core/src/main/java/io/grpc/util/ForwardingLoadBalancerHelper.java
+++ b/util/src/main/java/io/grpc/util/ForwardingLoadBalancerHelper.java
@@ -22,15 +22,17 @@
 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.LoadBalancer;
 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")
@@ -50,11 +52,21 @@ public  ManagedChannel createOobChannel(EquivalentAddressGroup eag, String autho
     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) {
@@ -83,11 +95,22 @@ 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();
@@ -123,6 +146,11 @@ 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/core/src/main/java/io/grpc/util/ForwardingSubchannel.java b/util/src/main/java/io/grpc/util/ForwardingSubchannel.java
similarity index 94%
rename from core/src/main/java/io/grpc/util/ForwardingSubchannel.java
rename to util/src/main/java/io/grpc/util/ForwardingSubchannel.java
index 51f2583186e..416be378162 100644
--- a/core/src/main/java/io/grpc/util/ForwardingSubchannel.java
+++ b/util/src/main/java/io/grpc/util/ForwardingSubchannel.java
@@ -74,11 +74,17 @@ 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..27dc080c71b
--- /dev/null
+++ b/util/src/main/java/io/grpc/util/GracefulSwitchLoadBalancer.java
@@ -0,0 +1,274 @@
+/*
+ * 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");
+  }
+
+  @Deprecated
+  @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..d871911d203
--- /dev/null
+++ b/util/src/main/java/io/grpc/util/HealthProducerHelper.java
@@ -0,0 +1,148 @@
+/*
+ * 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.ConnectivityState;
+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;
+  }
+
+  @Override
+  public void updateBalancingState(
+      ConnectivityState newState, LoadBalancer.SubchannelPicker newPicker) {
+    delegate.updateBalancingState(newState, new HealthProducerPicker(newPicker));
+  }
+
+  private static final class HealthProducerPicker extends LoadBalancer.SubchannelPicker {
+    private final LoadBalancer.SubchannelPicker delegate;
+
+    HealthProducerPicker(LoadBalancer.SubchannelPicker delegate) {
+      this.delegate = delegate;
+    }
+
+    @Override
+    public LoadBalancer.PickResult pickSubchannel(LoadBalancer.PickSubchannelArgs args) {
+      LoadBalancer.PickResult result = delegate.pickSubchannel(args);
+      LoadBalancer.Subchannel subchannel = result.getSubchannel();
+      if (subchannel instanceof HealthProducerSubchannel) {
+        return result.copyWithSubchannel(
+            ((HealthProducerSubchannel) subchannel).delegate());
+      }
+      return result;
+    }
+  }
+
+  // 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/core/src/main/java/io/grpc/util/MutableHandlerRegistry.java b/util/src/main/java/io/grpc/util/MutableHandlerRegistry.java
similarity index 95%
rename from core/src/main/java/io/grpc/util/MutableHandlerRegistry.java
rename to util/src/main/java/io/grpc/util/MutableHandlerRegistry.java
index 1e923418923..307142b642c 100644
--- a/core/src/main/java/io/grpc/util/MutableHandlerRegistry.java
+++ b/util/src/main/java/io/grpc/util/MutableHandlerRegistry.java
@@ -31,13 +31,12 @@
 import javax.annotation.concurrent.ThreadSafe;
 
 /**
- * Default implementation of {@link MutableHandlerRegistry}.
+ * Default implementation of {@link HandlerRegistry}.
  *
  * <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<>();
@@ -65,7 +64,7 @@ public ServerServiceDefinition addService(BindableService bindableService) {
   }
 
   /**
-   * Removes a registered service
+   * Removes a registered service.
    *
    * @return true if the service was found to be removed.
    */
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..dc61441bccd
--- /dev/null
+++ b/util/src/main/java/io/grpc/util/OutlierDetectionLoadBalancer.java
@@ -0,0 +1,1165 @@
+/*
+ * 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) {
+        EndpointTracker tracker = subchannel.getAttributes().get(ENDPOINT_TRACKER_KEY);
+        if (subchannel instanceof OutlierDetectionSubchannel) {
+          subchannel = ((OutlierDetectionSubchannel) subchannel).delegate();
+        }
+        return pickResult.copyWithSubchannel(subchannel)
+            .copyWithStreamTracerFactory(new ResultCountingClientStreamTracerFactory(
+                tracker,
+                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/core/src/main/java/io/grpc/util/SecretRoundRobinLoadBalancerProvider.java b/util/src/main/java/io/grpc/util/SecretRoundRobinLoadBalancerProvider.java
similarity index 100%
rename from core/src/main/java/io/grpc/util/SecretRoundRobinLoadBalancerProvider.java
rename to util/src/main/java/io/grpc/util/SecretRoundRobinLoadBalancerProvider.java
diff --git a/core/src/main/java/io/grpc/util/TransmitStatusRuntimeExceptionInterceptor.java b/util/src/main/java/io/grpc/util/TransmitStatusRuntimeExceptionInterceptor.java
similarity index 96%
rename from core/src/main/java/io/grpc/util/TransmitStatusRuntimeExceptionInterceptor.java
rename to util/src/main/java/io/grpc/util/TransmitStatusRuntimeExceptionInterceptor.java
index bead2be4e9e..b477ae1fdfb 100644
--- a/core/src/main/java/io/grpc/util/TransmitStatusRuntimeExceptionInterceptor.java
+++ b/util/src/main/java/io/grpc/util/TransmitStatusRuntimeExceptionInterceptor.java
@@ -219,6 +219,17 @@ public void run() {
       });
     }
 
+    @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() {
diff --git a/core/src/main/java/io/grpc/util/package-info.java b/util/src/main/java/io/grpc/util/package-info.java
similarity index 100%
rename from core/src/main/java/io/grpc/util/package-info.java
rename to util/src/main/java/io/grpc/util/package-info.java
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..b8431d4f991
--- /dev/null
+++ b/util/src/test/java/io/grpc/util/AdvancedTlsX509KeyManagerTest.java
@@ -0,0 +1,209 @@
+/*
+ * 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.assertNull;
+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 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);
+    String alias1 = serverKeyManager.chooseEngineServerAlias(null, null, null);
+    assertEquals(AdvancedTlsX509KeyManager.ALIAS_PREFIX + "1", alias1);
+    assertEquals(serverKey0, serverKeyManager.getPrivateKey(alias1));
+    assertArrayEquals(serverCert0, serverKeyManager.getCertificateChain(alias1));
+
+    serverKeyManager.updateIdentityCredentials(clientCert0File, clientKey0File);
+    String alias2 = serverKeyManager.chooseEngineServerAlias(null, null, null);
+    assertEquals(AdvancedTlsX509KeyManager.ALIAS_PREFIX + "2", alias2);
+    assertEquals(clientKey0, serverKeyManager.getPrivateKey(alias2));
+    assertArrayEquals(clientCert0, serverKeyManager.getCertificateChain(alias2));
+    // Previous alias still resolves — retained to allow in-progress handshakes to complete.
+    assertEquals(serverKey0, serverKeyManager.getPrivateKey(alias1));
+    assertArrayEquals(serverCert0, serverKeyManager.getCertificateChain(alias1));
+
+    serverKeyManager.updateIdentityCredentials(serverCert0File, serverKey0File, 1,
+        TimeUnit.MINUTES, executor);
+    String alias3 = serverKeyManager.chooseEngineServerAlias(null, null, null);
+    assertEquals(serverKey0, serverKeyManager.getPrivateKey(alias3));
+    assertArrayEquals(serverCert0, serverKeyManager.getCertificateChain(alias3));
+    // alias1 is now two rotations back — no longer retained.
+    assertNull(serverKeyManager.getPrivateKey(alias1));
+
+    serverKeyManager.updateIdentityCredentials(serverCert0, serverKey0);
+    String alias4 = serverKeyManager.chooseEngineServerAlias(null, null, null);
+    assertEquals(serverKey0, serverKeyManager.getPrivateKey(alias4));
+    assertArrayEquals(serverCert0, serverKeyManager.getCertificateChain(alias4));
+  }
+
+  @Test
+  public void allAliasMethods_returnNullBeforeCredentialsLoaded() {
+    AdvancedTlsX509KeyManager keyManager = new AdvancedTlsX509KeyManager();
+
+    assertNull(keyManager.chooseClientAlias(null, null, null));
+    assertNull(keyManager.chooseServerAlias(null, null, null));
+    assertNull(keyManager.chooseEngineClientAlias(null, null, null));
+    assertNull(keyManager.chooseEngineServerAlias(null, null, null));
+    assertNull(keyManager.getClientAliases(null, null));
+    assertNull(keyManager.getServerAliases(null, null));
+    assertNull(keyManager.getPrivateKey("key-1"));
+    assertNull(keyManager.getCertificateChain("key-1"));
+  }
+
+  @Test
+  public void allAliasMethods_agreeAfterCredentialLoad() throws Exception {
+    AdvancedTlsX509KeyManager keyManager = new AdvancedTlsX509KeyManager();
+    keyManager.updateIdentityCredentials(serverCert0, serverKey0);
+
+    String expectedAlias = AdvancedTlsX509KeyManager.ALIAS_PREFIX + "1";
+    assertEquals(expectedAlias, keyManager.chooseClientAlias(null, null, null));
+    assertEquals(expectedAlias, keyManager.chooseServerAlias(null, null, null));
+    assertEquals(expectedAlias, keyManager.chooseEngineClientAlias(null, null, null));
+    assertEquals(expectedAlias, keyManager.chooseEngineServerAlias(null, null, null));
+    assertArrayEquals(new String[]{expectedAlias}, keyManager.getClientAliases(null, null));
+    assertArrayEquals(new String[]{expectedAlias}, keyManager.getServerAliases(null, null));
+  }
+
+  @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/core/src/test/java/io/grpc/util/ForwardingLoadBalancerHelperTest.java b/util/src/test/java/io/grpc/util/ForwardingLoadBalancerHelperTest.java
similarity index 100%
rename from core/src/test/java/io/grpc/util/ForwardingLoadBalancerHelperTest.java
rename to util/src/test/java/io/grpc/util/ForwardingLoadBalancerHelperTest.java
diff --git a/core/src/test/java/io/grpc/util/ForwardingLoadBalancerTest.java b/util/src/test/java/io/grpc/util/ForwardingLoadBalancerTest.java
similarity index 87%
rename from core/src/test/java/io/grpc/util/ForwardingLoadBalancerTest.java
rename to util/src/test/java/io/grpc/util/ForwardingLoadBalancerTest.java
index 01226466845..f9b53400cea 100644
--- a/core/src/test/java/io/grpc/util/ForwardingLoadBalancerTest.java
+++ b/util/src/test/java/io/grpc/util/ForwardingLoadBalancerTest.java
@@ -20,8 +20,8 @@
 
 import io.grpc.ForwardingTestUtil;
 import io.grpc.LoadBalancer;
-import java.lang.reflect.Method;
-import java.util.Collections;
+import io.grpc.LoadBalancer.ResolvedAddresses;
+import java.util.Arrays;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
@@ -44,6 +44,7 @@ public void allMethodsForwarded() throws Exception {
         LoadBalancer.class,
         mockDelegate,
         new TestBalancer(),
-        Collections.<Method>emptyList());
+        Arrays.asList(
+            LoadBalancer.class.getMethod("acceptResolvedAddresses", ResolvedAddresses.class)));
   }
 }
diff --git a/core/src/test/java/io/grpc/util/ForwardingSubchannelTest.java b/util/src/test/java/io/grpc/util/ForwardingSubchannelTest.java
similarity index 100%
rename from core/src/test/java/io/grpc/util/ForwardingSubchannelTest.java
rename to util/src/test/java/io/grpc/util/ForwardingSubchannelTest.java
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..0467f9526f6
--- /dev/null
+++ b/util/src/test/java/io/grpc/util/GracefulSwitchLoadBalancerTest.java
@@ -0,0 +1,746 @@
+/*
+ * 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
+  @Deprecated
+  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();
+  }
+
+  @Deprecated
+  @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 98%
rename from core/src/test/java/io/grpc/util/MutableHandlerRegistryTest.java
rename to util/src/test/java/io/grpc/util/MutableHandlerRegistryTest.java
index d499528cf05..a9095fcf105 100644
--- a/core/src/test/java/io/grpc/util/MutableHandlerRegistryTest.java
+++ b/util/src/test/java/io/grpc/util/MutableHandlerRegistryTest.java
@@ -33,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
@@ -68,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")
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..39f5b5fb7d6
--- /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 = pickResult.getSubchannel();
+    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/core/src/test/java/io/grpc/util/UtilServerInterceptorsTest.java b/util/src/test/java/io/grpc/util/UtilServerInterceptorsTest.java
similarity index 98%
rename from core/src/test/java/io/grpc/util/UtilServerInterceptorsTest.java
rename to util/src/test/java/io/grpc/util/UtilServerInterceptorsTest.java
index 8f941073943..a4691d8bdec 100644
--- a/core/src/test/java/io/grpc/util/UtilServerInterceptorsTest.java
+++ b/util/src/test/java/io/grpc/util/UtilServerInterceptorsTest.java
@@ -21,6 +21,7 @@
 
 import io.grpc.Metadata;
 import io.grpc.MethodDescriptor;
+import io.grpc.NoopServerCall;
 import io.grpc.ServerCall;
 import io.grpc.ServerCallHandler;
 import io.grpc.ServerInterceptors;
@@ -29,7 +30,6 @@
 import io.grpc.ServiceDescriptor;
 import io.grpc.Status;
 import io.grpc.StatusRuntimeException;
-import io.grpc.internal.NoopServerCall;
 import io.grpc.testing.TestMethodDescriptors;
 import java.util.Arrays;
 import org.junit.Test;
@@ -43,7 +43,7 @@
 @RunWith(JUnit4.class)
 public class UtilServerInterceptorsTest {
   private static class VoidCallListener extends ServerCall.Listener<Void> {
-    public void onCall(ServerCall<Void, Void> call, Metadata headers) { }
+    public void onCall(ServerCall<Void, Void> unused, Metadata unused2) { }
   }
 
   private MethodDescriptor<Void, Void> flowMethod = TestMethodDescriptors.voidMethod();
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..9a650485c6c
--- /dev/null
+++ b/xds/BUILD.bazel
@@ -0,0 +1,365 @@
+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",
+        "//api:test_fixtures",
+        "//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
index d8462c0de54..8394fe12f6b 100644
--- a/xds/build.gradle
+++ b/xds/build.gradle
@@ -1,114 +1,176 @@
-import java.util.jar.JarFile
+import io.grpc.gradle.CheckPackageLeakageTask;
 
 plugins {
     id "java"
     id "maven-publish"
 
-    id "com.github.johnrengelman.shadow"
     id "com.google.protobuf"
+    id "com.gradleup.shadow"
     id "ru.vyarus.animalsniffer"
 }
 
 description = "gRPC: XDS plugin"
 
-[compileJava].each() {
-    it.options.compilerArgs += [
-        // valueOf(int) in RoutingPriority has been deprecated
-        "-Xlint:-deprecation",
-        // only has AutoValue annotation processor
-        "-Xlint:-processing",
-    ]
-    appendToProperty(
-            it.options.errorprone.excludedPaths,
-            ".*/build/generated/sources/annotationProcessor/java/.*",
-            "|")
+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"
+        }
+    }
 }
 
-evaluationDependsOn(project(':grpc-core').path)
+configurations {
+    pomDeps {
+        extendsFrom configurations.thirdpartyRuntimeClasspath, configurations.shadow
+    }
+}
 
 dependencies {
-    implementation project(':grpc-protobuf'),
-            project(':grpc-stub'),
+    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.bouncycastle,
-            libraries.autovalue_annotation
+            libraries.auto.value.annotations,
+            libraries.protobuf.java.util
     def nettyDependency = implementation project(':grpc-netty')
 
-    implementation (libraries.opencensus_proto) {
-        // prefer our own versions instead of opencensus_proto's
-        exclude group: 'com.google.protobuf', module: 'protobuf-java'
-        exclude group: 'io.grpc', module: 'grpc-protobuf'
-        exclude group: 'io.grpc', module: 'grpc-stub'
-    }
-    implementation (libraries.protobuf_util) {
-        // prefer our own versions instead of protobuf-util's dependency
-        exclude group: 'com.google.guava', module: 'guava'
-        exclude group: 'com.google.errorprone', module: 'error_prone_annotations'
-    }
-
-    testImplementation project(':grpc-core').sourceSets.test.output
+    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.autovalue
-    compileOnly libraries.javax_annotation,
-            // At runtime use the epoll included in grpc-netty-shaded
-            libraries.netty_epoll
+    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'),
-            libraries.netty_epoll
-    testImplementation (libraries.guava_testlib) {
-        exclude group: 'junit', module: 'junit'
+            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 "org.codehaus.mojo.signature:java17:1.0@signature"
-    testRuntimeOnly libraries.netty_tcnative
-}
-
-sourceSets {
-    main {
-        java {
-            srcDir "${projectDir}/third_party/zero-allocation-hashing/main/java"
+    signature (libraries.signature.java) {
+        artifact {
+            extension = "signature"
         }
-        proto {
-            srcDir 'third_party/envoy/src/main/proto'
-            srcDir 'third_party/protoc-gen-validate/src/main/proto'
-            srcDir 'third_party/udpa/src/main/proto'
-            srcDir 'third_party/googleapis/src/main/proto'
-            srcDir 'third_party/istio/src/main/proto'
+    }
+    testRuntimeOnly libraries.netty.tcnative,
+            libraries.netty.tcnative.classes
+    testRuntimeOnly (libraries.netty.tcnative) {
+        artifact {
+            classifier = "linux-x86_64"
         }
     }
-    test {
-        java {
-            srcDir "${projectDir}/third_party/zero-allocation-hashing/test/java"
+    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()
 
-jar {
-    classifier = 'original'
+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
 }
 
-javadoc {
+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/XdsClientWrapperForServerSds.java'
+    exclude 'io/grpc/xds/XdsCredentialsProvider.java'
     exclude 'io/grpc/xds/XdsInitializationException.java'
     exclude 'io/grpc/xds/XdsNameResolverProvider.java'
     exclude 'io/grpc/xds/internal/**'
@@ -116,62 +178,51 @@ javadoc {
 }
 
 def prefixName = 'io.grpc.xds'
-shadowJar {
-    classifier = null
+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"
 }
 
-task checkPackageLeakage(dependsOn: shadowJar) {
-    doLast {
-        def jarEntryPrefixName = prefixName.replaceAll('\\.', '/')
-        shadowJar.outputs.getFiles().each { jar ->
-            def package_leak_detected = false
-            JarFile jf = new JarFile(jar)
-            jf.entries().each { entry ->
-                if (entry.name.endsWith(".class") && !entry.name.startsWith(
-                        jarEntryPrefixName)) {
-                    package_leak_detected = true
-                    println "WARNING: package leaked, may need relocation: " +
-                            entry.name
-                }
-            }
-            jf.close()
-            if (package_leak_detected) {
-                throw new TaskExecutionException(shadowJar,
-                        new IllegalStateException("Resource leakage detected!"))
-            }
-        }
-    }
+def checkPackageLeakage = tasks.register("checkPackageLeakage", CheckPackageLeakageTask) {
+    files.from tasks.named('shadowJar')
+    prefix = prefixName
 }
 
-test {
+tasks.named("test").configure {
     dependsOn checkPackageLeakage
 }
 
-jacocoTestReport {
+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/**',
         ])
     }
 }
@@ -185,12 +236,11 @@ publishing {
 
             pom.withXml {
                 def dependenciesNode = new Node(null, 'dependencies')
-                project.configurations.shadow.allDependencies.each { dep ->
+                project.configurations.pomDeps.allDependencies.each { dep ->
                     def dependencyNode = dependenciesNode.appendNode('dependency')
                     dependencyNode.appendNode('groupId', dep.group)
                     dependencyNode.appendNode('artifactId', dep.name)
-                    def version = (dep.name == 'grpc-netty-shaded') ? '[' + dep.version + ']' : dep.version
-                    dependencyNode.appendNode('version', version)
+                    dependencyNode.appendNode('version', dep.version)
                     dependencyNode.appendNode('scope', 'compile')
                 }
                 asNode().dependencies[0].replaceNode(dependenciesNode)
diff --git a/xds/src/generated/main/grpc/com/github/udpa/udpa/service/orca/v1/OpenRcaServiceGrpc.java b/xds/src/generated/main/grpc/com/github/udpa/udpa/service/orca/v1/OpenRcaServiceGrpc.java
deleted file mode 100644
index 38d8fbed736..00000000000
--- a/xds/src/generated/main/grpc/com/github/udpa/udpa/service/orca/v1/OpenRcaServiceGrpc.java
+++ /dev/null
@@ -1,318 +0,0 @@
-package com.github.udpa.udpa.service.orca.v1;
-
-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>
- */
-@javax.annotation.Generated(
-    value = "by gRPC proto compiler",
-    comments = "Source: udpa/service/orca/v1/orca.proto")
-public final class OpenRcaServiceGrpc {
-
-  private OpenRcaServiceGrpc() {}
-
-  public static final String SERVICE_NAME = "udpa.service.orca.v1.OpenRcaService";
-
-  // Static method descriptors that strictly reflect the proto.
-  private static volatile io.grpc.MethodDescriptor<com.github.udpa.udpa.service.orca.v1.OrcaLoadReportRequest,
-      com.github.udpa.udpa.data.orca.v1.OrcaLoadReport> getStreamCoreMetricsMethod;
-
-  @io.grpc.stub.annotations.RpcMethod(
-      fullMethodName = SERVICE_NAME + '/' + "StreamCoreMetrics",
-      requestType = com.github.udpa.udpa.service.orca.v1.OrcaLoadReportRequest.class,
-      responseType = com.github.udpa.udpa.data.orca.v1.OrcaLoadReport.class,
-      methodType = io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING)
-  public static io.grpc.MethodDescriptor<com.github.udpa.udpa.service.orca.v1.OrcaLoadReportRequest,
-      com.github.udpa.udpa.data.orca.v1.OrcaLoadReport> getStreamCoreMetricsMethod() {
-    io.grpc.MethodDescriptor<com.github.udpa.udpa.service.orca.v1.OrcaLoadReportRequest, com.github.udpa.udpa.data.orca.v1.OrcaLoadReport> getStreamCoreMetricsMethod;
-    if ((getStreamCoreMetricsMethod = OpenRcaServiceGrpc.getStreamCoreMetricsMethod) == null) {
-      synchronized (OpenRcaServiceGrpc.class) {
-        if ((getStreamCoreMetricsMethod = OpenRcaServiceGrpc.getStreamCoreMetricsMethod) == null) {
-          OpenRcaServiceGrpc.getStreamCoreMetricsMethod = getStreamCoreMetricsMethod =
-              io.grpc.MethodDescriptor.<com.github.udpa.udpa.service.orca.v1.OrcaLoadReportRequest, com.github.udpa.udpa.data.orca.v1.OrcaLoadReport>newBuilder()
-              .setType(io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING)
-              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "StreamCoreMetrics"))
-              .setSampledToLocalTracing(true)
-              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
-                  com.github.udpa.udpa.service.orca.v1.OrcaLoadReportRequest.getDefaultInstance()))
-              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
-                  com.github.udpa.udpa.data.orca.v1.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 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 static abstract class OpenRcaServiceImplBase implements io.grpc.BindableService {
-
-    /**
-     */
-    public void streamCoreMetrics(com.github.udpa.udpa.service.orca.v1.OrcaLoadReportRequest request,
-        io.grpc.stub.StreamObserver<com.github.udpa.udpa.data.orca.v1.OrcaLoadReport> responseObserver) {
-      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getStreamCoreMetricsMethod(), responseObserver);
-    }
-
-    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
-      return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
-          .addMethod(
-            getStreamCoreMetricsMethod(),
-            io.grpc.stub.ServerCalls.asyncServerStreamingCall(
-              new MethodHandlers<
-                com.github.udpa.udpa.service.orca.v1.OrcaLoadReportRequest,
-                com.github.udpa.udpa.data.orca.v1.OrcaLoadReport>(
-                  this, METHODID_STREAM_CORE_METRICS)))
-          .build();
-    }
-  }
-
-  /**
-   * <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.udpa.udpa.service.orca.v1.OrcaLoadReportRequest request,
-        io.grpc.stub.StreamObserver<com.github.udpa.udpa.data.orca.v1.OrcaLoadReport> responseObserver) {
-      io.grpc.stub.ClientCalls.asyncServerStreamingCall(
-          getChannel().newCall(getStreamCoreMetricsMethod(), getCallOptions()), request, responseObserver);
-    }
-  }
-
-  /**
-   * <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.udpa.udpa.data.orca.v1.OrcaLoadReport> streamCoreMetrics(
-        com.github.udpa.udpa.service.orca.v1.OrcaLoadReportRequest request) {
-      return io.grpc.stub.ClientCalls.blockingServerStreamingCall(
-          getChannel(), getStreamCoreMetricsMethod(), getCallOptions(), request);
-    }
-  }
-
-  /**
-   * <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 OpenRcaServiceImplBase serviceImpl;
-    private final int methodId;
-
-    MethodHandlers(OpenRcaServiceImplBase 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.udpa.udpa.service.orca.v1.OrcaLoadReportRequest) request,
-              (io.grpc.stub.StreamObserver<com.github.udpa.udpa.data.orca.v1.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();
-      }
-    }
-  }
-
-  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.udpa.udpa.service.orca.v1.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 String methodName;
-
-    OpenRcaServiceMethodDescriptorSupplier(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/main/grpc/com/google/security/meshca/v1/MeshCertificateServiceGrpc.java b/xds/src/generated/main/grpc/com/google/security/meshca/v1/MeshCertificateServiceGrpc.java
deleted file mode 100644
index f8379cbe2c0..00000000000
--- a/xds/src/generated/main/grpc/com/google/security/meshca/v1/MeshCertificateServiceGrpc.java
+++ /dev/null
@@ -1,306 +0,0 @@
-package com.google.security.meshca.v1;
-
-import static io.grpc.MethodDescriptor.generateFullMethodName;
-
-/**
- * <pre>
- * Service for managing certificates issued by the CSM CA.
- * </pre>
- */
-@javax.annotation.Generated(
-    value = "by gRPC proto compiler",
-    comments = "Source: security/proto/providers/google/meshca.proto")
-public final class MeshCertificateServiceGrpc {
-
-  private MeshCertificateServiceGrpc() {}
-
-  public static final String SERVICE_NAME = "google.security.meshca.v1.MeshCertificateService";
-
-  // Static method descriptors that strictly reflect the proto.
-  private static volatile io.grpc.MethodDescriptor<com.google.security.meshca.v1.MeshCertificateRequest,
-      com.google.security.meshca.v1.MeshCertificateResponse> getCreateCertificateMethod;
-
-  @io.grpc.stub.annotations.RpcMethod(
-      fullMethodName = SERVICE_NAME + '/' + "CreateCertificate",
-      requestType = com.google.security.meshca.v1.MeshCertificateRequest.class,
-      responseType = com.google.security.meshca.v1.MeshCertificateResponse.class,
-      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
-  public static io.grpc.MethodDescriptor<com.google.security.meshca.v1.MeshCertificateRequest,
-      com.google.security.meshca.v1.MeshCertificateResponse> getCreateCertificateMethod() {
-    io.grpc.MethodDescriptor<com.google.security.meshca.v1.MeshCertificateRequest, com.google.security.meshca.v1.MeshCertificateResponse> getCreateCertificateMethod;
-    if ((getCreateCertificateMethod = MeshCertificateServiceGrpc.getCreateCertificateMethod) == null) {
-      synchronized (MeshCertificateServiceGrpc.class) {
-        if ((getCreateCertificateMethod = MeshCertificateServiceGrpc.getCreateCertificateMethod) == null) {
-          MeshCertificateServiceGrpc.getCreateCertificateMethod = getCreateCertificateMethod =
-              io.grpc.MethodDescriptor.<com.google.security.meshca.v1.MeshCertificateRequest, com.google.security.meshca.v1.MeshCertificateResponse>newBuilder()
-              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
-              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "CreateCertificate"))
-              .setSampledToLocalTracing(true)
-              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
-                  com.google.security.meshca.v1.MeshCertificateRequest.getDefaultInstance()))
-              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
-                  com.google.security.meshca.v1.MeshCertificateResponse.getDefaultInstance()))
-              .setSchemaDescriptor(new MeshCertificateServiceMethodDescriptorSupplier("CreateCertificate"))
-              .build();
-        }
-      }
-    }
-    return getCreateCertificateMethod;
-  }
-
-  /**
-   * Creates a new async stub that supports all call types for the service
-   */
-  public static MeshCertificateServiceStub newStub(io.grpc.Channel channel) {
-    io.grpc.stub.AbstractStub.StubFactory<MeshCertificateServiceStub> factory =
-      new io.grpc.stub.AbstractStub.StubFactory<MeshCertificateServiceStub>() {
-        @java.lang.Override
-        public MeshCertificateServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
-          return new MeshCertificateServiceStub(channel, callOptions);
-        }
-      };
-    return MeshCertificateServiceStub.newStub(factory, channel);
-  }
-
-  /**
-   * Creates a new blocking-style stub that supports unary and streaming output calls on the service
-   */
-  public static MeshCertificateServiceBlockingStub newBlockingStub(
-      io.grpc.Channel channel) {
-    io.grpc.stub.AbstractStub.StubFactory<MeshCertificateServiceBlockingStub> factory =
-      new io.grpc.stub.AbstractStub.StubFactory<MeshCertificateServiceBlockingStub>() {
-        @java.lang.Override
-        public MeshCertificateServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
-          return new MeshCertificateServiceBlockingStub(channel, callOptions);
-        }
-      };
-    return MeshCertificateServiceBlockingStub.newStub(factory, channel);
-  }
-
-  /**
-   * Creates a new ListenableFuture-style stub that supports unary calls on the service
-   */
-  public static MeshCertificateServiceFutureStub newFutureStub(
-      io.grpc.Channel channel) {
-    io.grpc.stub.AbstractStub.StubFactory<MeshCertificateServiceFutureStub> factory =
-      new io.grpc.stub.AbstractStub.StubFactory<MeshCertificateServiceFutureStub>() {
-        @java.lang.Override
-        public MeshCertificateServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
-          return new MeshCertificateServiceFutureStub(channel, callOptions);
-        }
-      };
-    return MeshCertificateServiceFutureStub.newStub(factory, channel);
-  }
-
-  /**
-   * <pre>
-   * Service for managing certificates issued by the CSM CA.
-   * </pre>
-   */
-  public static abstract class MeshCertificateServiceImplBase implements io.grpc.BindableService {
-
-    /**
-     * <pre>
-     * Using provided CSR, returns a signed certificate that represents a GCP
-     * service account identity.
-     * </pre>
-     */
-    public void createCertificate(com.google.security.meshca.v1.MeshCertificateRequest request,
-        io.grpc.stub.StreamObserver<com.google.security.meshca.v1.MeshCertificateResponse> responseObserver) {
-      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getCreateCertificateMethod(), responseObserver);
-    }
-
-    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
-      return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
-          .addMethod(
-            getCreateCertificateMethod(),
-            io.grpc.stub.ServerCalls.asyncUnaryCall(
-              new MethodHandlers<
-                com.google.security.meshca.v1.MeshCertificateRequest,
-                com.google.security.meshca.v1.MeshCertificateResponse>(
-                  this, METHODID_CREATE_CERTIFICATE)))
-          .build();
-    }
-  }
-
-  /**
-   * <pre>
-   * Service for managing certificates issued by the CSM CA.
-   * </pre>
-   */
-  public static final class MeshCertificateServiceStub extends io.grpc.stub.AbstractAsyncStub<MeshCertificateServiceStub> {
-    private MeshCertificateServiceStub(
-        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
-      super(channel, callOptions);
-    }
-
-    @java.lang.Override
-    protected MeshCertificateServiceStub build(
-        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
-      return new MeshCertificateServiceStub(channel, callOptions);
-    }
-
-    /**
-     * <pre>
-     * Using provided CSR, returns a signed certificate that represents a GCP
-     * service account identity.
-     * </pre>
-     */
-    public void createCertificate(com.google.security.meshca.v1.MeshCertificateRequest request,
-        io.grpc.stub.StreamObserver<com.google.security.meshca.v1.MeshCertificateResponse> responseObserver) {
-      io.grpc.stub.ClientCalls.asyncUnaryCall(
-          getChannel().newCall(getCreateCertificateMethod(), getCallOptions()), request, responseObserver);
-    }
-  }
-
-  /**
-   * <pre>
-   * Service for managing certificates issued by the CSM CA.
-   * </pre>
-   */
-  public static final class MeshCertificateServiceBlockingStub extends io.grpc.stub.AbstractBlockingStub<MeshCertificateServiceBlockingStub> {
-    private MeshCertificateServiceBlockingStub(
-        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
-      super(channel, callOptions);
-    }
-
-    @java.lang.Override
-    protected MeshCertificateServiceBlockingStub build(
-        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
-      return new MeshCertificateServiceBlockingStub(channel, callOptions);
-    }
-
-    /**
-     * <pre>
-     * Using provided CSR, returns a signed certificate that represents a GCP
-     * service account identity.
-     * </pre>
-     */
-    public com.google.security.meshca.v1.MeshCertificateResponse createCertificate(com.google.security.meshca.v1.MeshCertificateRequest request) {
-      return io.grpc.stub.ClientCalls.blockingUnaryCall(
-          getChannel(), getCreateCertificateMethod(), getCallOptions(), request);
-    }
-  }
-
-  /**
-   * <pre>
-   * Service for managing certificates issued by the CSM CA.
-   * </pre>
-   */
-  public static final class MeshCertificateServiceFutureStub extends io.grpc.stub.AbstractFutureStub<MeshCertificateServiceFutureStub> {
-    private MeshCertificateServiceFutureStub(
-        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
-      super(channel, callOptions);
-    }
-
-    @java.lang.Override
-    protected MeshCertificateServiceFutureStub build(
-        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
-      return new MeshCertificateServiceFutureStub(channel, callOptions);
-    }
-
-    /**
-     * <pre>
-     * Using provided CSR, returns a signed certificate that represents a GCP
-     * service account identity.
-     * </pre>
-     */
-    public com.google.common.util.concurrent.ListenableFuture<com.google.security.meshca.v1.MeshCertificateResponse> createCertificate(
-        com.google.security.meshca.v1.MeshCertificateRequest request) {
-      return io.grpc.stub.ClientCalls.futureUnaryCall(
-          getChannel().newCall(getCreateCertificateMethod(), getCallOptions()), request);
-    }
-  }
-
-  private static final int METHODID_CREATE_CERTIFICATE = 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 MeshCertificateServiceImplBase serviceImpl;
-    private final int methodId;
-
-    MethodHandlers(MeshCertificateServiceImplBase 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_CREATE_CERTIFICATE:
-          serviceImpl.createCertificate((com.google.security.meshca.v1.MeshCertificateRequest) request,
-              (io.grpc.stub.StreamObserver<com.google.security.meshca.v1.MeshCertificateResponse>) 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 abstract class MeshCertificateServiceBaseDescriptorSupplier
-      implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier {
-    MeshCertificateServiceBaseDescriptorSupplier() {}
-
-    @java.lang.Override
-    public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
-      return com.google.security.meshca.v1.MeshCaProto.getDescriptor();
-    }
-
-    @java.lang.Override
-    public com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() {
-      return getFileDescriptor().findServiceByName("MeshCertificateService");
-    }
-  }
-
-  private static final class MeshCertificateServiceFileDescriptorSupplier
-      extends MeshCertificateServiceBaseDescriptorSupplier {
-    MeshCertificateServiceFileDescriptorSupplier() {}
-  }
-
-  private static final class MeshCertificateServiceMethodDescriptorSupplier
-      extends MeshCertificateServiceBaseDescriptorSupplier
-      implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
-    private final String methodName;
-
-    MeshCertificateServiceMethodDescriptorSupplier(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 (MeshCertificateServiceGrpc.class) {
-        result = serviceDescriptor;
-        if (result == null) {
-          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
-              .setSchemaDescriptor(new MeshCertificateServiceFileDescriptorSupplier())
-              .addMethod(getCreateCertificateMethod())
-              .build();
-        }
-      }
-    }
-    return result;
-  }
-}
diff --git a/xds/src/generated/main/grpc/io/envoyproxy/envoy/api/v2/ClusterDiscoveryServiceGrpc.java b/xds/src/generated/main/grpc/io/envoyproxy/envoy/api/v2/ClusterDiscoveryServiceGrpc.java
deleted file mode 100644
index ad34486c8f2..00000000000
--- a/xds/src/generated/main/grpc/io/envoyproxy/envoy/api/v2/ClusterDiscoveryServiceGrpc.java
+++ /dev/null
@@ -1,406 +0,0 @@
-package io.envoyproxy.envoy.api.v2;
-
-import static io.grpc.MethodDescriptor.generateFullMethodName;
-
-/**
- * <pre>
- * Return list of all clusters this proxy will load balance to.
- * </pre>
- */
-@javax.annotation.Generated(
-    value = "by gRPC proto compiler",
-    comments = "Source: envoy/api/v2/cds.proto")
-public final class ClusterDiscoveryServiceGrpc {
-
-  private ClusterDiscoveryServiceGrpc() {}
-
-  public static final String SERVICE_NAME = "envoy.api.v2.ClusterDiscoveryService";
-
-  // Static method descriptors that strictly reflect the proto.
-  private static volatile io.grpc.MethodDescriptor<io.envoyproxy.envoy.api.v2.DiscoveryRequest,
-      io.envoyproxy.envoy.api.v2.DiscoveryResponse> getStreamClustersMethod;
-
-  @io.grpc.stub.annotations.RpcMethod(
-      fullMethodName = SERVICE_NAME + '/' + "StreamClusters",
-      requestType = io.envoyproxy.envoy.api.v2.DiscoveryRequest.class,
-      responseType = io.envoyproxy.envoy.api.v2.DiscoveryResponse.class,
-      methodType = io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
-  public static io.grpc.MethodDescriptor<io.envoyproxy.envoy.api.v2.DiscoveryRequest,
-      io.envoyproxy.envoy.api.v2.DiscoveryResponse> getStreamClustersMethod() {
-    io.grpc.MethodDescriptor<io.envoyproxy.envoy.api.v2.DiscoveryRequest, io.envoyproxy.envoy.api.v2.DiscoveryResponse> getStreamClustersMethod;
-    if ((getStreamClustersMethod = ClusterDiscoveryServiceGrpc.getStreamClustersMethod) == null) {
-      synchronized (ClusterDiscoveryServiceGrpc.class) {
-        if ((getStreamClustersMethod = ClusterDiscoveryServiceGrpc.getStreamClustersMethod) == null) {
-          ClusterDiscoveryServiceGrpc.getStreamClustersMethod = getStreamClustersMethod =
-              io.grpc.MethodDescriptor.<io.envoyproxy.envoy.api.v2.DiscoveryRequest, io.envoyproxy.envoy.api.v2.DiscoveryResponse>newBuilder()
-              .setType(io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
-              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "StreamClusters"))
-              .setSampledToLocalTracing(true)
-              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
-                  io.envoyproxy.envoy.api.v2.DiscoveryRequest.getDefaultInstance()))
-              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
-                  io.envoyproxy.envoy.api.v2.DiscoveryResponse.getDefaultInstance()))
-              .setSchemaDescriptor(new ClusterDiscoveryServiceMethodDescriptorSupplier("StreamClusters"))
-              .build();
-        }
-      }
-    }
-    return getStreamClustersMethod;
-  }
-
-  private static volatile io.grpc.MethodDescriptor<io.envoyproxy.envoy.api.v2.DeltaDiscoveryRequest,
-      io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse> getDeltaClustersMethod;
-
-  @io.grpc.stub.annotations.RpcMethod(
-      fullMethodName = SERVICE_NAME + '/' + "DeltaClusters",
-      requestType = io.envoyproxy.envoy.api.v2.DeltaDiscoveryRequest.class,
-      responseType = io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse.class,
-      methodType = io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
-  public static io.grpc.MethodDescriptor<io.envoyproxy.envoy.api.v2.DeltaDiscoveryRequest,
-      io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse> getDeltaClustersMethod() {
-    io.grpc.MethodDescriptor<io.envoyproxy.envoy.api.v2.DeltaDiscoveryRequest, io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse> getDeltaClustersMethod;
-    if ((getDeltaClustersMethod = ClusterDiscoveryServiceGrpc.getDeltaClustersMethod) == null) {
-      synchronized (ClusterDiscoveryServiceGrpc.class) {
-        if ((getDeltaClustersMethod = ClusterDiscoveryServiceGrpc.getDeltaClustersMethod) == null) {
-          ClusterDiscoveryServiceGrpc.getDeltaClustersMethod = getDeltaClustersMethod =
-              io.grpc.MethodDescriptor.<io.envoyproxy.envoy.api.v2.DeltaDiscoveryRequest, io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse>newBuilder()
-              .setType(io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
-              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "DeltaClusters"))
-              .setSampledToLocalTracing(true)
-              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
-                  io.envoyproxy.envoy.api.v2.DeltaDiscoveryRequest.getDefaultInstance()))
-              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
-                  io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse.getDefaultInstance()))
-              .setSchemaDescriptor(new ClusterDiscoveryServiceMethodDescriptorSupplier("DeltaClusters"))
-              .build();
-        }
-      }
-    }
-    return getDeltaClustersMethod;
-  }
-
-  private static volatile io.grpc.MethodDescriptor<io.envoyproxy.envoy.api.v2.DiscoveryRequest,
-      io.envoyproxy.envoy.api.v2.DiscoveryResponse> getFetchClustersMethod;
-
-  @io.grpc.stub.annotations.RpcMethod(
-      fullMethodName = SERVICE_NAME + '/' + "FetchClusters",
-      requestType = io.envoyproxy.envoy.api.v2.DiscoveryRequest.class,
-      responseType = io.envoyproxy.envoy.api.v2.DiscoveryResponse.class,
-      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
-  public static io.grpc.MethodDescriptor<io.envoyproxy.envoy.api.v2.DiscoveryRequest,
-      io.envoyproxy.envoy.api.v2.DiscoveryResponse> getFetchClustersMethod() {
-    io.grpc.MethodDescriptor<io.envoyproxy.envoy.api.v2.DiscoveryRequest, io.envoyproxy.envoy.api.v2.DiscoveryResponse> getFetchClustersMethod;
-    if ((getFetchClustersMethod = ClusterDiscoveryServiceGrpc.getFetchClustersMethod) == null) {
-      synchronized (ClusterDiscoveryServiceGrpc.class) {
-        if ((getFetchClustersMethod = ClusterDiscoveryServiceGrpc.getFetchClustersMethod) == null) {
-          ClusterDiscoveryServiceGrpc.getFetchClustersMethod = getFetchClustersMethod =
-              io.grpc.MethodDescriptor.<io.envoyproxy.envoy.api.v2.DiscoveryRequest, io.envoyproxy.envoy.api.v2.DiscoveryResponse>newBuilder()
-              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
-              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "FetchClusters"))
-              .setSampledToLocalTracing(true)
-              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
-                  io.envoyproxy.envoy.api.v2.DiscoveryRequest.getDefaultInstance()))
-              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
-                  io.envoyproxy.envoy.api.v2.DiscoveryResponse.getDefaultInstance()))
-              .setSchemaDescriptor(new ClusterDiscoveryServiceMethodDescriptorSupplier("FetchClusters"))
-              .build();
-        }
-      }
-    }
-    return getFetchClustersMethod;
-  }
-
-  /**
-   * Creates a new async stub that supports all call types for the service
-   */
-  public static ClusterDiscoveryServiceStub newStub(io.grpc.Channel channel) {
-    io.grpc.stub.AbstractStub.StubFactory<ClusterDiscoveryServiceStub> factory =
-      new io.grpc.stub.AbstractStub.StubFactory<ClusterDiscoveryServiceStub>() {
-        @java.lang.Override
-        public ClusterDiscoveryServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
-          return new ClusterDiscoveryServiceStub(channel, callOptions);
-        }
-      };
-    return ClusterDiscoveryServiceStub.newStub(factory, channel);
-  }
-
-  /**
-   * Creates a new blocking-style stub that supports unary and streaming output calls on the service
-   */
-  public static ClusterDiscoveryServiceBlockingStub newBlockingStub(
-      io.grpc.Channel channel) {
-    io.grpc.stub.AbstractStub.StubFactory<ClusterDiscoveryServiceBlockingStub> factory =
-      new io.grpc.stub.AbstractStub.StubFactory<ClusterDiscoveryServiceBlockingStub>() {
-        @java.lang.Override
-        public ClusterDiscoveryServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
-          return new ClusterDiscoveryServiceBlockingStub(channel, callOptions);
-        }
-      };
-    return ClusterDiscoveryServiceBlockingStub.newStub(factory, channel);
-  }
-
-  /**
-   * Creates a new ListenableFuture-style stub that supports unary calls on the service
-   */
-  public static ClusterDiscoveryServiceFutureStub newFutureStub(
-      io.grpc.Channel channel) {
-    io.grpc.stub.AbstractStub.StubFactory<ClusterDiscoveryServiceFutureStub> factory =
-      new io.grpc.stub.AbstractStub.StubFactory<ClusterDiscoveryServiceFutureStub>() {
-        @java.lang.Override
-        public ClusterDiscoveryServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
-          return new ClusterDiscoveryServiceFutureStub(channel, callOptions);
-        }
-      };
-    return ClusterDiscoveryServiceFutureStub.newStub(factory, channel);
-  }
-
-  /**
-   * <pre>
-   * Return list of all clusters this proxy will load balance to.
-   * </pre>
-   */
-  public static abstract class ClusterDiscoveryServiceImplBase implements io.grpc.BindableService {
-
-    /**
-     */
-    public io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DiscoveryRequest> streamClusters(
-        io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DiscoveryResponse> responseObserver) {
-      return io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall(getStreamClustersMethod(), responseObserver);
-    }
-
-    /**
-     */
-    public io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DeltaDiscoveryRequest> deltaClusters(
-        io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse> responseObserver) {
-      return io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall(getDeltaClustersMethod(), responseObserver);
-    }
-
-    /**
-     */
-    public void fetchClusters(io.envoyproxy.envoy.api.v2.DiscoveryRequest request,
-        io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DiscoveryResponse> responseObserver) {
-      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getFetchClustersMethod(), responseObserver);
-    }
-
-    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
-      return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
-          .addMethod(
-            getStreamClustersMethod(),
-            io.grpc.stub.ServerCalls.asyncBidiStreamingCall(
-              new MethodHandlers<
-                io.envoyproxy.envoy.api.v2.DiscoveryRequest,
-                io.envoyproxy.envoy.api.v2.DiscoveryResponse>(
-                  this, METHODID_STREAM_CLUSTERS)))
-          .addMethod(
-            getDeltaClustersMethod(),
-            io.grpc.stub.ServerCalls.asyncBidiStreamingCall(
-              new MethodHandlers<
-                io.envoyproxy.envoy.api.v2.DeltaDiscoveryRequest,
-                io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse>(
-                  this, METHODID_DELTA_CLUSTERS)))
-          .addMethod(
-            getFetchClustersMethod(),
-            io.grpc.stub.ServerCalls.asyncUnaryCall(
-              new MethodHandlers<
-                io.envoyproxy.envoy.api.v2.DiscoveryRequest,
-                io.envoyproxy.envoy.api.v2.DiscoveryResponse>(
-                  this, METHODID_FETCH_CLUSTERS)))
-          .build();
-    }
-  }
-
-  /**
-   * <pre>
-   * Return list of all clusters this proxy will load balance to.
-   * </pre>
-   */
-  public static final class ClusterDiscoveryServiceStub extends io.grpc.stub.AbstractAsyncStub<ClusterDiscoveryServiceStub> {
-    private ClusterDiscoveryServiceStub(
-        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
-      super(channel, callOptions);
-    }
-
-    @java.lang.Override
-    protected ClusterDiscoveryServiceStub build(
-        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
-      return new ClusterDiscoveryServiceStub(channel, callOptions);
-    }
-
-    /**
-     */
-    public io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DiscoveryRequest> streamClusters(
-        io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DiscoveryResponse> responseObserver) {
-      return io.grpc.stub.ClientCalls.asyncBidiStreamingCall(
-          getChannel().newCall(getStreamClustersMethod(), getCallOptions()), responseObserver);
-    }
-
-    /**
-     */
-    public io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DeltaDiscoveryRequest> deltaClusters(
-        io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse> responseObserver) {
-      return io.grpc.stub.ClientCalls.asyncBidiStreamingCall(
-          getChannel().newCall(getDeltaClustersMethod(), getCallOptions()), responseObserver);
-    }
-
-    /**
-     */
-    public void fetchClusters(io.envoyproxy.envoy.api.v2.DiscoveryRequest request,
-        io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DiscoveryResponse> responseObserver) {
-      io.grpc.stub.ClientCalls.asyncUnaryCall(
-          getChannel().newCall(getFetchClustersMethod(), getCallOptions()), request, responseObserver);
-    }
-  }
-
-  /**
-   * <pre>
-   * Return list of all clusters this proxy will load balance to.
-   * </pre>
-   */
-  public static final class ClusterDiscoveryServiceBlockingStub extends io.grpc.stub.AbstractBlockingStub<ClusterDiscoveryServiceBlockingStub> {
-    private ClusterDiscoveryServiceBlockingStub(
-        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
-      super(channel, callOptions);
-    }
-
-    @java.lang.Override
-    protected ClusterDiscoveryServiceBlockingStub build(
-        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
-      return new ClusterDiscoveryServiceBlockingStub(channel, callOptions);
-    }
-
-    /**
-     */
-    public io.envoyproxy.envoy.api.v2.DiscoveryResponse fetchClusters(io.envoyproxy.envoy.api.v2.DiscoveryRequest request) {
-      return io.grpc.stub.ClientCalls.blockingUnaryCall(
-          getChannel(), getFetchClustersMethod(), getCallOptions(), request);
-    }
-  }
-
-  /**
-   * <pre>
-   * Return list of all clusters this proxy will load balance to.
-   * </pre>
-   */
-  public static final class ClusterDiscoveryServiceFutureStub extends io.grpc.stub.AbstractFutureStub<ClusterDiscoveryServiceFutureStub> {
-    private ClusterDiscoveryServiceFutureStub(
-        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
-      super(channel, callOptions);
-    }
-
-    @java.lang.Override
-    protected ClusterDiscoveryServiceFutureStub build(
-        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
-      return new ClusterDiscoveryServiceFutureStub(channel, callOptions);
-    }
-
-    /**
-     */
-    public com.google.common.util.concurrent.ListenableFuture<io.envoyproxy.envoy.api.v2.DiscoveryResponse> fetchClusters(
-        io.envoyproxy.envoy.api.v2.DiscoveryRequest request) {
-      return io.grpc.stub.ClientCalls.futureUnaryCall(
-          getChannel().newCall(getFetchClustersMethod(), getCallOptions()), request);
-    }
-  }
-
-  private static final int METHODID_FETCH_CLUSTERS = 0;
-  private static final int METHODID_STREAM_CLUSTERS = 1;
-  private static final int METHODID_DELTA_CLUSTERS = 2;
-
-  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 ClusterDiscoveryServiceImplBase serviceImpl;
-    private final int methodId;
-
-    MethodHandlers(ClusterDiscoveryServiceImplBase 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_CLUSTERS:
-          serviceImpl.fetchClusters((io.envoyproxy.envoy.api.v2.DiscoveryRequest) request,
-              (io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DiscoveryResponse>) 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_CLUSTERS:
-          return (io.grpc.stub.StreamObserver<Req>) serviceImpl.streamClusters(
-              (io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DiscoveryResponse>) responseObserver);
-        case METHODID_DELTA_CLUSTERS:
-          return (io.grpc.stub.StreamObserver<Req>) serviceImpl.deltaClusters(
-              (io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse>) responseObserver);
-        default:
-          throw new AssertionError();
-      }
-    }
-  }
-
-  private static abstract class ClusterDiscoveryServiceBaseDescriptorSupplier
-      implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier {
-    ClusterDiscoveryServiceBaseDescriptorSupplier() {}
-
-    @java.lang.Override
-    public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
-      return io.envoyproxy.envoy.api.v2.CdsProto.getDescriptor();
-    }
-
-    @java.lang.Override
-    public com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() {
-      return getFileDescriptor().findServiceByName("ClusterDiscoveryService");
-    }
-  }
-
-  private static final class ClusterDiscoveryServiceFileDescriptorSupplier
-      extends ClusterDiscoveryServiceBaseDescriptorSupplier {
-    ClusterDiscoveryServiceFileDescriptorSupplier() {}
-  }
-
-  private static final class ClusterDiscoveryServiceMethodDescriptorSupplier
-      extends ClusterDiscoveryServiceBaseDescriptorSupplier
-      implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
-    private final String methodName;
-
-    ClusterDiscoveryServiceMethodDescriptorSupplier(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 (ClusterDiscoveryServiceGrpc.class) {
-        result = serviceDescriptor;
-        if (result == null) {
-          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
-              .setSchemaDescriptor(new ClusterDiscoveryServiceFileDescriptorSupplier())
-              .addMethod(getStreamClustersMethod())
-              .addMethod(getDeltaClustersMethod())
-              .addMethod(getFetchClustersMethod())
-              .build();
-        }
-      }
-    }
-    return result;
-  }
-}
diff --git a/xds/src/generated/main/grpc/io/envoyproxy/envoy/api/v2/EndpointDiscoveryServiceGrpc.java b/xds/src/generated/main/grpc/io/envoyproxy/envoy/api/v2/EndpointDiscoveryServiceGrpc.java
deleted file mode 100644
index c149d5a1dc7..00000000000
--- a/xds/src/generated/main/grpc/io/envoyproxy/envoy/api/v2/EndpointDiscoveryServiceGrpc.java
+++ /dev/null
@@ -1,399 +0,0 @@
-package io.envoyproxy.envoy.api.v2;
-
-import static io.grpc.MethodDescriptor.generateFullMethodName;
-
-/**
- */
-@javax.annotation.Generated(
-    value = "by gRPC proto compiler",
-    comments = "Source: envoy/api/v2/eds.proto")
-public final class EndpointDiscoveryServiceGrpc {
-
-  private EndpointDiscoveryServiceGrpc() {}
-
-  public static final String SERVICE_NAME = "envoy.api.v2.EndpointDiscoveryService";
-
-  // Static method descriptors that strictly reflect the proto.
-  private static volatile io.grpc.MethodDescriptor<io.envoyproxy.envoy.api.v2.DiscoveryRequest,
-      io.envoyproxy.envoy.api.v2.DiscoveryResponse> getStreamEndpointsMethod;
-
-  @io.grpc.stub.annotations.RpcMethod(
-      fullMethodName = SERVICE_NAME + '/' + "StreamEndpoints",
-      requestType = io.envoyproxy.envoy.api.v2.DiscoveryRequest.class,
-      responseType = io.envoyproxy.envoy.api.v2.DiscoveryResponse.class,
-      methodType = io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
-  public static io.grpc.MethodDescriptor<io.envoyproxy.envoy.api.v2.DiscoveryRequest,
-      io.envoyproxy.envoy.api.v2.DiscoveryResponse> getStreamEndpointsMethod() {
-    io.grpc.MethodDescriptor<io.envoyproxy.envoy.api.v2.DiscoveryRequest, io.envoyproxy.envoy.api.v2.DiscoveryResponse> getStreamEndpointsMethod;
-    if ((getStreamEndpointsMethod = EndpointDiscoveryServiceGrpc.getStreamEndpointsMethod) == null) {
-      synchronized (EndpointDiscoveryServiceGrpc.class) {
-        if ((getStreamEndpointsMethod = EndpointDiscoveryServiceGrpc.getStreamEndpointsMethod) == null) {
-          EndpointDiscoveryServiceGrpc.getStreamEndpointsMethod = getStreamEndpointsMethod =
-              io.grpc.MethodDescriptor.<io.envoyproxy.envoy.api.v2.DiscoveryRequest, io.envoyproxy.envoy.api.v2.DiscoveryResponse>newBuilder()
-              .setType(io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
-              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "StreamEndpoints"))
-              .setSampledToLocalTracing(true)
-              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
-                  io.envoyproxy.envoy.api.v2.DiscoveryRequest.getDefaultInstance()))
-              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
-                  io.envoyproxy.envoy.api.v2.DiscoveryResponse.getDefaultInstance()))
-              .setSchemaDescriptor(new EndpointDiscoveryServiceMethodDescriptorSupplier("StreamEndpoints"))
-              .build();
-        }
-      }
-    }
-    return getStreamEndpointsMethod;
-  }
-
-  private static volatile io.grpc.MethodDescriptor<io.envoyproxy.envoy.api.v2.DeltaDiscoveryRequest,
-      io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse> getDeltaEndpointsMethod;
-
-  @io.grpc.stub.annotations.RpcMethod(
-      fullMethodName = SERVICE_NAME + '/' + "DeltaEndpoints",
-      requestType = io.envoyproxy.envoy.api.v2.DeltaDiscoveryRequest.class,
-      responseType = io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse.class,
-      methodType = io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
-  public static io.grpc.MethodDescriptor<io.envoyproxy.envoy.api.v2.DeltaDiscoveryRequest,
-      io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse> getDeltaEndpointsMethod() {
-    io.grpc.MethodDescriptor<io.envoyproxy.envoy.api.v2.DeltaDiscoveryRequest, io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse> getDeltaEndpointsMethod;
-    if ((getDeltaEndpointsMethod = EndpointDiscoveryServiceGrpc.getDeltaEndpointsMethod) == null) {
-      synchronized (EndpointDiscoveryServiceGrpc.class) {
-        if ((getDeltaEndpointsMethod = EndpointDiscoveryServiceGrpc.getDeltaEndpointsMethod) == null) {
-          EndpointDiscoveryServiceGrpc.getDeltaEndpointsMethod = getDeltaEndpointsMethod =
-              io.grpc.MethodDescriptor.<io.envoyproxy.envoy.api.v2.DeltaDiscoveryRequest, io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse>newBuilder()
-              .setType(io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
-              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "DeltaEndpoints"))
-              .setSampledToLocalTracing(true)
-              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
-                  io.envoyproxy.envoy.api.v2.DeltaDiscoveryRequest.getDefaultInstance()))
-              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
-                  io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse.getDefaultInstance()))
-              .setSchemaDescriptor(new EndpointDiscoveryServiceMethodDescriptorSupplier("DeltaEndpoints"))
-              .build();
-        }
-      }
-    }
-    return getDeltaEndpointsMethod;
-  }
-
-  private static volatile io.grpc.MethodDescriptor<io.envoyproxy.envoy.api.v2.DiscoveryRequest,
-      io.envoyproxy.envoy.api.v2.DiscoveryResponse> getFetchEndpointsMethod;
-
-  @io.grpc.stub.annotations.RpcMethod(
-      fullMethodName = SERVICE_NAME + '/' + "FetchEndpoints",
-      requestType = io.envoyproxy.envoy.api.v2.DiscoveryRequest.class,
-      responseType = io.envoyproxy.envoy.api.v2.DiscoveryResponse.class,
-      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
-  public static io.grpc.MethodDescriptor<io.envoyproxy.envoy.api.v2.DiscoveryRequest,
-      io.envoyproxy.envoy.api.v2.DiscoveryResponse> getFetchEndpointsMethod() {
-    io.grpc.MethodDescriptor<io.envoyproxy.envoy.api.v2.DiscoveryRequest, io.envoyproxy.envoy.api.v2.DiscoveryResponse> getFetchEndpointsMethod;
-    if ((getFetchEndpointsMethod = EndpointDiscoveryServiceGrpc.getFetchEndpointsMethod) == null) {
-      synchronized (EndpointDiscoveryServiceGrpc.class) {
-        if ((getFetchEndpointsMethod = EndpointDiscoveryServiceGrpc.getFetchEndpointsMethod) == null) {
-          EndpointDiscoveryServiceGrpc.getFetchEndpointsMethod = getFetchEndpointsMethod =
-              io.grpc.MethodDescriptor.<io.envoyproxy.envoy.api.v2.DiscoveryRequest, io.envoyproxy.envoy.api.v2.DiscoveryResponse>newBuilder()
-              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
-              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "FetchEndpoints"))
-              .setSampledToLocalTracing(true)
-              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
-                  io.envoyproxy.envoy.api.v2.DiscoveryRequest.getDefaultInstance()))
-              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
-                  io.envoyproxy.envoy.api.v2.DiscoveryResponse.getDefaultInstance()))
-              .setSchemaDescriptor(new EndpointDiscoveryServiceMethodDescriptorSupplier("FetchEndpoints"))
-              .build();
-        }
-      }
-    }
-    return getFetchEndpointsMethod;
-  }
-
-  /**
-   * Creates a new async stub that supports all call types for the service
-   */
-  public static EndpointDiscoveryServiceStub newStub(io.grpc.Channel channel) {
-    io.grpc.stub.AbstractStub.StubFactory<EndpointDiscoveryServiceStub> factory =
-      new io.grpc.stub.AbstractStub.StubFactory<EndpointDiscoveryServiceStub>() {
-        @java.lang.Override
-        public EndpointDiscoveryServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
-          return new EndpointDiscoveryServiceStub(channel, callOptions);
-        }
-      };
-    return EndpointDiscoveryServiceStub.newStub(factory, channel);
-  }
-
-  /**
-   * Creates a new blocking-style stub that supports unary and streaming output calls on the service
-   */
-  public static EndpointDiscoveryServiceBlockingStub newBlockingStub(
-      io.grpc.Channel channel) {
-    io.grpc.stub.AbstractStub.StubFactory<EndpointDiscoveryServiceBlockingStub> factory =
-      new io.grpc.stub.AbstractStub.StubFactory<EndpointDiscoveryServiceBlockingStub>() {
-        @java.lang.Override
-        public EndpointDiscoveryServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
-          return new EndpointDiscoveryServiceBlockingStub(channel, callOptions);
-        }
-      };
-    return EndpointDiscoveryServiceBlockingStub.newStub(factory, channel);
-  }
-
-  /**
-   * Creates a new ListenableFuture-style stub that supports unary calls on the service
-   */
-  public static EndpointDiscoveryServiceFutureStub newFutureStub(
-      io.grpc.Channel channel) {
-    io.grpc.stub.AbstractStub.StubFactory<EndpointDiscoveryServiceFutureStub> factory =
-      new io.grpc.stub.AbstractStub.StubFactory<EndpointDiscoveryServiceFutureStub>() {
-        @java.lang.Override
-        public EndpointDiscoveryServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
-          return new EndpointDiscoveryServiceFutureStub(channel, callOptions);
-        }
-      };
-    return EndpointDiscoveryServiceFutureStub.newStub(factory, channel);
-  }
-
-  /**
-   */
-  public static abstract class EndpointDiscoveryServiceImplBase implements io.grpc.BindableService {
-
-    /**
-     * <pre>
-     * The resource_names field in DiscoveryRequest specifies a list of clusters
-     * to subscribe to updates for.
-     * </pre>
-     */
-    public io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DiscoveryRequest> streamEndpoints(
-        io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DiscoveryResponse> responseObserver) {
-      return io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall(getStreamEndpointsMethod(), responseObserver);
-    }
-
-    /**
-     */
-    public io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DeltaDiscoveryRequest> deltaEndpoints(
-        io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse> responseObserver) {
-      return io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall(getDeltaEndpointsMethod(), responseObserver);
-    }
-
-    /**
-     */
-    public void fetchEndpoints(io.envoyproxy.envoy.api.v2.DiscoveryRequest request,
-        io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DiscoveryResponse> responseObserver) {
-      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getFetchEndpointsMethod(), responseObserver);
-    }
-
-    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
-      return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
-          .addMethod(
-            getStreamEndpointsMethod(),
-            io.grpc.stub.ServerCalls.asyncBidiStreamingCall(
-              new MethodHandlers<
-                io.envoyproxy.envoy.api.v2.DiscoveryRequest,
-                io.envoyproxy.envoy.api.v2.DiscoveryResponse>(
-                  this, METHODID_STREAM_ENDPOINTS)))
-          .addMethod(
-            getDeltaEndpointsMethod(),
-            io.grpc.stub.ServerCalls.asyncBidiStreamingCall(
-              new MethodHandlers<
-                io.envoyproxy.envoy.api.v2.DeltaDiscoveryRequest,
-                io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse>(
-                  this, METHODID_DELTA_ENDPOINTS)))
-          .addMethod(
-            getFetchEndpointsMethod(),
-            io.grpc.stub.ServerCalls.asyncUnaryCall(
-              new MethodHandlers<
-                io.envoyproxy.envoy.api.v2.DiscoveryRequest,
-                io.envoyproxy.envoy.api.v2.DiscoveryResponse>(
-                  this, METHODID_FETCH_ENDPOINTS)))
-          .build();
-    }
-  }
-
-  /**
-   */
-  public static final class EndpointDiscoveryServiceStub extends io.grpc.stub.AbstractAsyncStub<EndpointDiscoveryServiceStub> {
-    private EndpointDiscoveryServiceStub(
-        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
-      super(channel, callOptions);
-    }
-
-    @java.lang.Override
-    protected EndpointDiscoveryServiceStub build(
-        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
-      return new EndpointDiscoveryServiceStub(channel, callOptions);
-    }
-
-    /**
-     * <pre>
-     * The resource_names field in DiscoveryRequest specifies a list of clusters
-     * to subscribe to updates for.
-     * </pre>
-     */
-    public io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DiscoveryRequest> streamEndpoints(
-        io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DiscoveryResponse> responseObserver) {
-      return io.grpc.stub.ClientCalls.asyncBidiStreamingCall(
-          getChannel().newCall(getStreamEndpointsMethod(), getCallOptions()), responseObserver);
-    }
-
-    /**
-     */
-    public io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DeltaDiscoveryRequest> deltaEndpoints(
-        io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse> responseObserver) {
-      return io.grpc.stub.ClientCalls.asyncBidiStreamingCall(
-          getChannel().newCall(getDeltaEndpointsMethod(), getCallOptions()), responseObserver);
-    }
-
-    /**
-     */
-    public void fetchEndpoints(io.envoyproxy.envoy.api.v2.DiscoveryRequest request,
-        io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DiscoveryResponse> responseObserver) {
-      io.grpc.stub.ClientCalls.asyncUnaryCall(
-          getChannel().newCall(getFetchEndpointsMethod(), getCallOptions()), request, responseObserver);
-    }
-  }
-
-  /**
-   */
-  public static final class EndpointDiscoveryServiceBlockingStub extends io.grpc.stub.AbstractBlockingStub<EndpointDiscoveryServiceBlockingStub> {
-    private EndpointDiscoveryServiceBlockingStub(
-        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
-      super(channel, callOptions);
-    }
-
-    @java.lang.Override
-    protected EndpointDiscoveryServiceBlockingStub build(
-        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
-      return new EndpointDiscoveryServiceBlockingStub(channel, callOptions);
-    }
-
-    /**
-     */
-    public io.envoyproxy.envoy.api.v2.DiscoveryResponse fetchEndpoints(io.envoyproxy.envoy.api.v2.DiscoveryRequest request) {
-      return io.grpc.stub.ClientCalls.blockingUnaryCall(
-          getChannel(), getFetchEndpointsMethod(), getCallOptions(), request);
-    }
-  }
-
-  /**
-   */
-  public static final class EndpointDiscoveryServiceFutureStub extends io.grpc.stub.AbstractFutureStub<EndpointDiscoveryServiceFutureStub> {
-    private EndpointDiscoveryServiceFutureStub(
-        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
-      super(channel, callOptions);
-    }
-
-    @java.lang.Override
-    protected EndpointDiscoveryServiceFutureStub build(
-        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
-      return new EndpointDiscoveryServiceFutureStub(channel, callOptions);
-    }
-
-    /**
-     */
-    public com.google.common.util.concurrent.ListenableFuture<io.envoyproxy.envoy.api.v2.DiscoveryResponse> fetchEndpoints(
-        io.envoyproxy.envoy.api.v2.DiscoveryRequest request) {
-      return io.grpc.stub.ClientCalls.futureUnaryCall(
-          getChannel().newCall(getFetchEndpointsMethod(), getCallOptions()), request);
-    }
-  }
-
-  private static final int METHODID_FETCH_ENDPOINTS = 0;
-  private static final int METHODID_STREAM_ENDPOINTS = 1;
-  private static final int METHODID_DELTA_ENDPOINTS = 2;
-
-  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 EndpointDiscoveryServiceImplBase serviceImpl;
-    private final int methodId;
-
-    MethodHandlers(EndpointDiscoveryServiceImplBase 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_ENDPOINTS:
-          serviceImpl.fetchEndpoints((io.envoyproxy.envoy.api.v2.DiscoveryRequest) request,
-              (io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DiscoveryResponse>) 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_ENDPOINTS:
-          return (io.grpc.stub.StreamObserver<Req>) serviceImpl.streamEndpoints(
-              (io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DiscoveryResponse>) responseObserver);
-        case METHODID_DELTA_ENDPOINTS:
-          return (io.grpc.stub.StreamObserver<Req>) serviceImpl.deltaEndpoints(
-              (io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse>) responseObserver);
-        default:
-          throw new AssertionError();
-      }
-    }
-  }
-
-  private static abstract class EndpointDiscoveryServiceBaseDescriptorSupplier
-      implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier {
-    EndpointDiscoveryServiceBaseDescriptorSupplier() {}
-
-    @java.lang.Override
-    public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
-      return io.envoyproxy.envoy.api.v2.EdsProto.getDescriptor();
-    }
-
-    @java.lang.Override
-    public com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() {
-      return getFileDescriptor().findServiceByName("EndpointDiscoveryService");
-    }
-  }
-
-  private static final class EndpointDiscoveryServiceFileDescriptorSupplier
-      extends EndpointDiscoveryServiceBaseDescriptorSupplier {
-    EndpointDiscoveryServiceFileDescriptorSupplier() {}
-  }
-
-  private static final class EndpointDiscoveryServiceMethodDescriptorSupplier
-      extends EndpointDiscoveryServiceBaseDescriptorSupplier
-      implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
-    private final String methodName;
-
-    EndpointDiscoveryServiceMethodDescriptorSupplier(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 (EndpointDiscoveryServiceGrpc.class) {
-        result = serviceDescriptor;
-        if (result == null) {
-          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
-              .setSchemaDescriptor(new EndpointDiscoveryServiceFileDescriptorSupplier())
-              .addMethod(getStreamEndpointsMethod())
-              .addMethod(getDeltaEndpointsMethod())
-              .addMethod(getFetchEndpointsMethod())
-              .build();
-        }
-      }
-    }
-    return result;
-  }
-}
diff --git a/xds/src/generated/main/grpc/io/envoyproxy/envoy/api/v2/ListenerDiscoveryServiceGrpc.java b/xds/src/generated/main/grpc/io/envoyproxy/envoy/api/v2/ListenerDiscoveryServiceGrpc.java
deleted file mode 100644
index 9f195cc03ef..00000000000
--- a/xds/src/generated/main/grpc/io/envoyproxy/envoy/api/v2/ListenerDiscoveryServiceGrpc.java
+++ /dev/null
@@ -1,421 +0,0 @@
-package io.envoyproxy.envoy.api.v2;
-
-import static io.grpc.MethodDescriptor.generateFullMethodName;
-
-/**
- * <pre>
- * The Envoy instance initiates an RPC at startup to discover a list of
- * listeners. Updates are delivered via streaming from the LDS server and
- * consist of a complete update of all listeners. Existing connections will be
- * allowed to drain from listeners that are no longer present.
- * </pre>
- */
-@javax.annotation.Generated(
-    value = "by gRPC proto compiler",
-    comments = "Source: envoy/api/v2/lds.proto")
-public final class ListenerDiscoveryServiceGrpc {
-
-  private ListenerDiscoveryServiceGrpc() {}
-
-  public static final String SERVICE_NAME = "envoy.api.v2.ListenerDiscoveryService";
-
-  // Static method descriptors that strictly reflect the proto.
-  private static volatile io.grpc.MethodDescriptor<io.envoyproxy.envoy.api.v2.DeltaDiscoveryRequest,
-      io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse> getDeltaListenersMethod;
-
-  @io.grpc.stub.annotations.RpcMethod(
-      fullMethodName = SERVICE_NAME + '/' + "DeltaListeners",
-      requestType = io.envoyproxy.envoy.api.v2.DeltaDiscoveryRequest.class,
-      responseType = io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse.class,
-      methodType = io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
-  public static io.grpc.MethodDescriptor<io.envoyproxy.envoy.api.v2.DeltaDiscoveryRequest,
-      io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse> getDeltaListenersMethod() {
-    io.grpc.MethodDescriptor<io.envoyproxy.envoy.api.v2.DeltaDiscoveryRequest, io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse> getDeltaListenersMethod;
-    if ((getDeltaListenersMethod = ListenerDiscoveryServiceGrpc.getDeltaListenersMethod) == null) {
-      synchronized (ListenerDiscoveryServiceGrpc.class) {
-        if ((getDeltaListenersMethod = ListenerDiscoveryServiceGrpc.getDeltaListenersMethod) == null) {
-          ListenerDiscoveryServiceGrpc.getDeltaListenersMethod = getDeltaListenersMethod =
-              io.grpc.MethodDescriptor.<io.envoyproxy.envoy.api.v2.DeltaDiscoveryRequest, io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse>newBuilder()
-              .setType(io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
-              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "DeltaListeners"))
-              .setSampledToLocalTracing(true)
-              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
-                  io.envoyproxy.envoy.api.v2.DeltaDiscoveryRequest.getDefaultInstance()))
-              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
-                  io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse.getDefaultInstance()))
-              .setSchemaDescriptor(new ListenerDiscoveryServiceMethodDescriptorSupplier("DeltaListeners"))
-              .build();
-        }
-      }
-    }
-    return getDeltaListenersMethod;
-  }
-
-  private static volatile io.grpc.MethodDescriptor<io.envoyproxy.envoy.api.v2.DiscoveryRequest,
-      io.envoyproxy.envoy.api.v2.DiscoveryResponse> getStreamListenersMethod;
-
-  @io.grpc.stub.annotations.RpcMethod(
-      fullMethodName = SERVICE_NAME + '/' + "StreamListeners",
-      requestType = io.envoyproxy.envoy.api.v2.DiscoveryRequest.class,
-      responseType = io.envoyproxy.envoy.api.v2.DiscoveryResponse.class,
-      methodType = io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
-  public static io.grpc.MethodDescriptor<io.envoyproxy.envoy.api.v2.DiscoveryRequest,
-      io.envoyproxy.envoy.api.v2.DiscoveryResponse> getStreamListenersMethod() {
-    io.grpc.MethodDescriptor<io.envoyproxy.envoy.api.v2.DiscoveryRequest, io.envoyproxy.envoy.api.v2.DiscoveryResponse> getStreamListenersMethod;
-    if ((getStreamListenersMethod = ListenerDiscoveryServiceGrpc.getStreamListenersMethod) == null) {
-      synchronized (ListenerDiscoveryServiceGrpc.class) {
-        if ((getStreamListenersMethod = ListenerDiscoveryServiceGrpc.getStreamListenersMethod) == null) {
-          ListenerDiscoveryServiceGrpc.getStreamListenersMethod = getStreamListenersMethod =
-              io.grpc.MethodDescriptor.<io.envoyproxy.envoy.api.v2.DiscoveryRequest, io.envoyproxy.envoy.api.v2.DiscoveryResponse>newBuilder()
-              .setType(io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
-              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "StreamListeners"))
-              .setSampledToLocalTracing(true)
-              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
-                  io.envoyproxy.envoy.api.v2.DiscoveryRequest.getDefaultInstance()))
-              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
-                  io.envoyproxy.envoy.api.v2.DiscoveryResponse.getDefaultInstance()))
-              .setSchemaDescriptor(new ListenerDiscoveryServiceMethodDescriptorSupplier("StreamListeners"))
-              .build();
-        }
-      }
-    }
-    return getStreamListenersMethod;
-  }
-
-  private static volatile io.grpc.MethodDescriptor<io.envoyproxy.envoy.api.v2.DiscoveryRequest,
-      io.envoyproxy.envoy.api.v2.DiscoveryResponse> getFetchListenersMethod;
-
-  @io.grpc.stub.annotations.RpcMethod(
-      fullMethodName = SERVICE_NAME + '/' + "FetchListeners",
-      requestType = io.envoyproxy.envoy.api.v2.DiscoveryRequest.class,
-      responseType = io.envoyproxy.envoy.api.v2.DiscoveryResponse.class,
-      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
-  public static io.grpc.MethodDescriptor<io.envoyproxy.envoy.api.v2.DiscoveryRequest,
-      io.envoyproxy.envoy.api.v2.DiscoveryResponse> getFetchListenersMethod() {
-    io.grpc.MethodDescriptor<io.envoyproxy.envoy.api.v2.DiscoveryRequest, io.envoyproxy.envoy.api.v2.DiscoveryResponse> getFetchListenersMethod;
-    if ((getFetchListenersMethod = ListenerDiscoveryServiceGrpc.getFetchListenersMethod) == null) {
-      synchronized (ListenerDiscoveryServiceGrpc.class) {
-        if ((getFetchListenersMethod = ListenerDiscoveryServiceGrpc.getFetchListenersMethod) == null) {
-          ListenerDiscoveryServiceGrpc.getFetchListenersMethod = getFetchListenersMethod =
-              io.grpc.MethodDescriptor.<io.envoyproxy.envoy.api.v2.DiscoveryRequest, io.envoyproxy.envoy.api.v2.DiscoveryResponse>newBuilder()
-              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
-              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "FetchListeners"))
-              .setSampledToLocalTracing(true)
-              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
-                  io.envoyproxy.envoy.api.v2.DiscoveryRequest.getDefaultInstance()))
-              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
-                  io.envoyproxy.envoy.api.v2.DiscoveryResponse.getDefaultInstance()))
-              .setSchemaDescriptor(new ListenerDiscoveryServiceMethodDescriptorSupplier("FetchListeners"))
-              .build();
-        }
-      }
-    }
-    return getFetchListenersMethod;
-  }
-
-  /**
-   * Creates a new async stub that supports all call types for the service
-   */
-  public static ListenerDiscoveryServiceStub newStub(io.grpc.Channel channel) {
-    io.grpc.stub.AbstractStub.StubFactory<ListenerDiscoveryServiceStub> factory =
-      new io.grpc.stub.AbstractStub.StubFactory<ListenerDiscoveryServiceStub>() {
-        @java.lang.Override
-        public ListenerDiscoveryServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
-          return new ListenerDiscoveryServiceStub(channel, callOptions);
-        }
-      };
-    return ListenerDiscoveryServiceStub.newStub(factory, channel);
-  }
-
-  /**
-   * Creates a new blocking-style stub that supports unary and streaming output calls on the service
-   */
-  public static ListenerDiscoveryServiceBlockingStub newBlockingStub(
-      io.grpc.Channel channel) {
-    io.grpc.stub.AbstractStub.StubFactory<ListenerDiscoveryServiceBlockingStub> factory =
-      new io.grpc.stub.AbstractStub.StubFactory<ListenerDiscoveryServiceBlockingStub>() {
-        @java.lang.Override
-        public ListenerDiscoveryServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
-          return new ListenerDiscoveryServiceBlockingStub(channel, callOptions);
-        }
-      };
-    return ListenerDiscoveryServiceBlockingStub.newStub(factory, channel);
-  }
-
-  /**
-   * Creates a new ListenableFuture-style stub that supports unary calls on the service
-   */
-  public static ListenerDiscoveryServiceFutureStub newFutureStub(
-      io.grpc.Channel channel) {
-    io.grpc.stub.AbstractStub.StubFactory<ListenerDiscoveryServiceFutureStub> factory =
-      new io.grpc.stub.AbstractStub.StubFactory<ListenerDiscoveryServiceFutureStub>() {
-        @java.lang.Override
-        public ListenerDiscoveryServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
-          return new ListenerDiscoveryServiceFutureStub(channel, callOptions);
-        }
-      };
-    return ListenerDiscoveryServiceFutureStub.newStub(factory, channel);
-  }
-
-  /**
-   * <pre>
-   * The Envoy instance initiates an RPC at startup to discover a list of
-   * listeners. Updates are delivered via streaming from the LDS server and
-   * consist of a complete update of all listeners. Existing connections will be
-   * allowed to drain from listeners that are no longer present.
-   * </pre>
-   */
-  public static abstract class ListenerDiscoveryServiceImplBase implements io.grpc.BindableService {
-
-    /**
-     */
-    public io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DeltaDiscoveryRequest> deltaListeners(
-        io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse> responseObserver) {
-      return io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall(getDeltaListenersMethod(), responseObserver);
-    }
-
-    /**
-     */
-    public io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DiscoveryRequest> streamListeners(
-        io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DiscoveryResponse> responseObserver) {
-      return io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall(getStreamListenersMethod(), responseObserver);
-    }
-
-    /**
-     */
-    public void fetchListeners(io.envoyproxy.envoy.api.v2.DiscoveryRequest request,
-        io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DiscoveryResponse> responseObserver) {
-      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getFetchListenersMethod(), responseObserver);
-    }
-
-    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
-      return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
-          .addMethod(
-            getDeltaListenersMethod(),
-            io.grpc.stub.ServerCalls.asyncBidiStreamingCall(
-              new MethodHandlers<
-                io.envoyproxy.envoy.api.v2.DeltaDiscoveryRequest,
-                io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse>(
-                  this, METHODID_DELTA_LISTENERS)))
-          .addMethod(
-            getStreamListenersMethod(),
-            io.grpc.stub.ServerCalls.asyncBidiStreamingCall(
-              new MethodHandlers<
-                io.envoyproxy.envoy.api.v2.DiscoveryRequest,
-                io.envoyproxy.envoy.api.v2.DiscoveryResponse>(
-                  this, METHODID_STREAM_LISTENERS)))
-          .addMethod(
-            getFetchListenersMethod(),
-            io.grpc.stub.ServerCalls.asyncUnaryCall(
-              new MethodHandlers<
-                io.envoyproxy.envoy.api.v2.DiscoveryRequest,
-                io.envoyproxy.envoy.api.v2.DiscoveryResponse>(
-                  this, METHODID_FETCH_LISTENERS)))
-          .build();
-    }
-  }
-
-  /**
-   * <pre>
-   * The Envoy instance initiates an RPC at startup to discover a list of
-   * listeners. Updates are delivered via streaming from the LDS server and
-   * consist of a complete update of all listeners. Existing connections will be
-   * allowed to drain from listeners that are no longer present.
-   * </pre>
-   */
-  public static final class ListenerDiscoveryServiceStub extends io.grpc.stub.AbstractAsyncStub<ListenerDiscoveryServiceStub> {
-    private ListenerDiscoveryServiceStub(
-        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
-      super(channel, callOptions);
-    }
-
-    @java.lang.Override
-    protected ListenerDiscoveryServiceStub build(
-        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
-      return new ListenerDiscoveryServiceStub(channel, callOptions);
-    }
-
-    /**
-     */
-    public io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DeltaDiscoveryRequest> deltaListeners(
-        io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse> responseObserver) {
-      return io.grpc.stub.ClientCalls.asyncBidiStreamingCall(
-          getChannel().newCall(getDeltaListenersMethod(), getCallOptions()), responseObserver);
-    }
-
-    /**
-     */
-    public io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DiscoveryRequest> streamListeners(
-        io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DiscoveryResponse> responseObserver) {
-      return io.grpc.stub.ClientCalls.asyncBidiStreamingCall(
-          getChannel().newCall(getStreamListenersMethod(), getCallOptions()), responseObserver);
-    }
-
-    /**
-     */
-    public void fetchListeners(io.envoyproxy.envoy.api.v2.DiscoveryRequest request,
-        io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DiscoveryResponse> responseObserver) {
-      io.grpc.stub.ClientCalls.asyncUnaryCall(
-          getChannel().newCall(getFetchListenersMethod(), getCallOptions()), request, responseObserver);
-    }
-  }
-
-  /**
-   * <pre>
-   * The Envoy instance initiates an RPC at startup to discover a list of
-   * listeners. Updates are delivered via streaming from the LDS server and
-   * consist of a complete update of all listeners. Existing connections will be
-   * allowed to drain from listeners that are no longer present.
-   * </pre>
-   */
-  public static final class ListenerDiscoveryServiceBlockingStub extends io.grpc.stub.AbstractBlockingStub<ListenerDiscoveryServiceBlockingStub> {
-    private ListenerDiscoveryServiceBlockingStub(
-        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
-      super(channel, callOptions);
-    }
-
-    @java.lang.Override
-    protected ListenerDiscoveryServiceBlockingStub build(
-        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
-      return new ListenerDiscoveryServiceBlockingStub(channel, callOptions);
-    }
-
-    /**
-     */
-    public io.envoyproxy.envoy.api.v2.DiscoveryResponse fetchListeners(io.envoyproxy.envoy.api.v2.DiscoveryRequest request) {
-      return io.grpc.stub.ClientCalls.blockingUnaryCall(
-          getChannel(), getFetchListenersMethod(), getCallOptions(), request);
-    }
-  }
-
-  /**
-   * <pre>
-   * The Envoy instance initiates an RPC at startup to discover a list of
-   * listeners. Updates are delivered via streaming from the LDS server and
-   * consist of a complete update of all listeners. Existing connections will be
-   * allowed to drain from listeners that are no longer present.
-   * </pre>
-   */
-  public static final class ListenerDiscoveryServiceFutureStub extends io.grpc.stub.AbstractFutureStub<ListenerDiscoveryServiceFutureStub> {
-    private ListenerDiscoveryServiceFutureStub(
-        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
-      super(channel, callOptions);
-    }
-
-    @java.lang.Override
-    protected ListenerDiscoveryServiceFutureStub build(
-        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
-      return new ListenerDiscoveryServiceFutureStub(channel, callOptions);
-    }
-
-    /**
-     */
-    public com.google.common.util.concurrent.ListenableFuture<io.envoyproxy.envoy.api.v2.DiscoveryResponse> fetchListeners(
-        io.envoyproxy.envoy.api.v2.DiscoveryRequest request) {
-      return io.grpc.stub.ClientCalls.futureUnaryCall(
-          getChannel().newCall(getFetchListenersMethod(), getCallOptions()), request);
-    }
-  }
-
-  private static final int METHODID_FETCH_LISTENERS = 0;
-  private static final int METHODID_DELTA_LISTENERS = 1;
-  private static final int METHODID_STREAM_LISTENERS = 2;
-
-  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 ListenerDiscoveryServiceImplBase serviceImpl;
-    private final int methodId;
-
-    MethodHandlers(ListenerDiscoveryServiceImplBase 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_LISTENERS:
-          serviceImpl.fetchListeners((io.envoyproxy.envoy.api.v2.DiscoveryRequest) request,
-              (io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DiscoveryResponse>) 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_DELTA_LISTENERS:
-          return (io.grpc.stub.StreamObserver<Req>) serviceImpl.deltaListeners(
-              (io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse>) responseObserver);
-        case METHODID_STREAM_LISTENERS:
-          return (io.grpc.stub.StreamObserver<Req>) serviceImpl.streamListeners(
-              (io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DiscoveryResponse>) responseObserver);
-        default:
-          throw new AssertionError();
-      }
-    }
-  }
-
-  private static abstract class ListenerDiscoveryServiceBaseDescriptorSupplier
-      implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier {
-    ListenerDiscoveryServiceBaseDescriptorSupplier() {}
-
-    @java.lang.Override
-    public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
-      return io.envoyproxy.envoy.api.v2.LdsProto.getDescriptor();
-    }
-
-    @java.lang.Override
-    public com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() {
-      return getFileDescriptor().findServiceByName("ListenerDiscoveryService");
-    }
-  }
-
-  private static final class ListenerDiscoveryServiceFileDescriptorSupplier
-      extends ListenerDiscoveryServiceBaseDescriptorSupplier {
-    ListenerDiscoveryServiceFileDescriptorSupplier() {}
-  }
-
-  private static final class ListenerDiscoveryServiceMethodDescriptorSupplier
-      extends ListenerDiscoveryServiceBaseDescriptorSupplier
-      implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
-    private final String methodName;
-
-    ListenerDiscoveryServiceMethodDescriptorSupplier(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 (ListenerDiscoveryServiceGrpc.class) {
-        result = serviceDescriptor;
-        if (result == null) {
-          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
-              .setSchemaDescriptor(new ListenerDiscoveryServiceFileDescriptorSupplier())
-              .addMethod(getDeltaListenersMethod())
-              .addMethod(getStreamListenersMethod())
-              .addMethod(getFetchListenersMethod())
-              .build();
-        }
-      }
-    }
-    return result;
-  }
-}
diff --git a/xds/src/generated/main/grpc/io/envoyproxy/envoy/api/v2/RouteDiscoveryServiceGrpc.java b/xds/src/generated/main/grpc/io/envoyproxy/envoy/api/v2/RouteDiscoveryServiceGrpc.java
deleted file mode 100644
index fcaba379af5..00000000000
--- a/xds/src/generated/main/grpc/io/envoyproxy/envoy/api/v2/RouteDiscoveryServiceGrpc.java
+++ /dev/null
@@ -1,426 +0,0 @@
-package io.envoyproxy.envoy.api.v2;
-
-import static io.grpc.MethodDescriptor.generateFullMethodName;
-
-/**
- * <pre>
- * The resource_names field in DiscoveryRequest specifies a route configuration.
- * This allows an Envoy configuration with multiple HTTP listeners (and
- * associated HTTP connection manager filters) to use different route
- * configurations. Each listener will bind its HTTP connection manager filter to
- * a route table via this identifier.
- * </pre>
- */
-@javax.annotation.Generated(
-    value = "by gRPC proto compiler",
-    comments = "Source: envoy/api/v2/rds.proto")
-public final class RouteDiscoveryServiceGrpc {
-
-  private RouteDiscoveryServiceGrpc() {}
-
-  public static final String SERVICE_NAME = "envoy.api.v2.RouteDiscoveryService";
-
-  // Static method descriptors that strictly reflect the proto.
-  private static volatile io.grpc.MethodDescriptor<io.envoyproxy.envoy.api.v2.DiscoveryRequest,
-      io.envoyproxy.envoy.api.v2.DiscoveryResponse> getStreamRoutesMethod;
-
-  @io.grpc.stub.annotations.RpcMethod(
-      fullMethodName = SERVICE_NAME + '/' + "StreamRoutes",
-      requestType = io.envoyproxy.envoy.api.v2.DiscoveryRequest.class,
-      responseType = io.envoyproxy.envoy.api.v2.DiscoveryResponse.class,
-      methodType = io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
-  public static io.grpc.MethodDescriptor<io.envoyproxy.envoy.api.v2.DiscoveryRequest,
-      io.envoyproxy.envoy.api.v2.DiscoveryResponse> getStreamRoutesMethod() {
-    io.grpc.MethodDescriptor<io.envoyproxy.envoy.api.v2.DiscoveryRequest, io.envoyproxy.envoy.api.v2.DiscoveryResponse> getStreamRoutesMethod;
-    if ((getStreamRoutesMethod = RouteDiscoveryServiceGrpc.getStreamRoutesMethod) == null) {
-      synchronized (RouteDiscoveryServiceGrpc.class) {
-        if ((getStreamRoutesMethod = RouteDiscoveryServiceGrpc.getStreamRoutesMethod) == null) {
-          RouteDiscoveryServiceGrpc.getStreamRoutesMethod = getStreamRoutesMethod =
-              io.grpc.MethodDescriptor.<io.envoyproxy.envoy.api.v2.DiscoveryRequest, io.envoyproxy.envoy.api.v2.DiscoveryResponse>newBuilder()
-              .setType(io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
-              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "StreamRoutes"))
-              .setSampledToLocalTracing(true)
-              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
-                  io.envoyproxy.envoy.api.v2.DiscoveryRequest.getDefaultInstance()))
-              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
-                  io.envoyproxy.envoy.api.v2.DiscoveryResponse.getDefaultInstance()))
-              .setSchemaDescriptor(new RouteDiscoveryServiceMethodDescriptorSupplier("StreamRoutes"))
-              .build();
-        }
-      }
-    }
-    return getStreamRoutesMethod;
-  }
-
-  private static volatile io.grpc.MethodDescriptor<io.envoyproxy.envoy.api.v2.DeltaDiscoveryRequest,
-      io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse> getDeltaRoutesMethod;
-
-  @io.grpc.stub.annotations.RpcMethod(
-      fullMethodName = SERVICE_NAME + '/' + "DeltaRoutes",
-      requestType = io.envoyproxy.envoy.api.v2.DeltaDiscoveryRequest.class,
-      responseType = io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse.class,
-      methodType = io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
-  public static io.grpc.MethodDescriptor<io.envoyproxy.envoy.api.v2.DeltaDiscoveryRequest,
-      io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse> getDeltaRoutesMethod() {
-    io.grpc.MethodDescriptor<io.envoyproxy.envoy.api.v2.DeltaDiscoveryRequest, io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse> getDeltaRoutesMethod;
-    if ((getDeltaRoutesMethod = RouteDiscoveryServiceGrpc.getDeltaRoutesMethod) == null) {
-      synchronized (RouteDiscoveryServiceGrpc.class) {
-        if ((getDeltaRoutesMethod = RouteDiscoveryServiceGrpc.getDeltaRoutesMethod) == null) {
-          RouteDiscoveryServiceGrpc.getDeltaRoutesMethod = getDeltaRoutesMethod =
-              io.grpc.MethodDescriptor.<io.envoyproxy.envoy.api.v2.DeltaDiscoveryRequest, io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse>newBuilder()
-              .setType(io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
-              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "DeltaRoutes"))
-              .setSampledToLocalTracing(true)
-              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
-                  io.envoyproxy.envoy.api.v2.DeltaDiscoveryRequest.getDefaultInstance()))
-              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
-                  io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse.getDefaultInstance()))
-              .setSchemaDescriptor(new RouteDiscoveryServiceMethodDescriptorSupplier("DeltaRoutes"))
-              .build();
-        }
-      }
-    }
-    return getDeltaRoutesMethod;
-  }
-
-  private static volatile io.grpc.MethodDescriptor<io.envoyproxy.envoy.api.v2.DiscoveryRequest,
-      io.envoyproxy.envoy.api.v2.DiscoveryResponse> getFetchRoutesMethod;
-
-  @io.grpc.stub.annotations.RpcMethod(
-      fullMethodName = SERVICE_NAME + '/' + "FetchRoutes",
-      requestType = io.envoyproxy.envoy.api.v2.DiscoveryRequest.class,
-      responseType = io.envoyproxy.envoy.api.v2.DiscoveryResponse.class,
-      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
-  public static io.grpc.MethodDescriptor<io.envoyproxy.envoy.api.v2.DiscoveryRequest,
-      io.envoyproxy.envoy.api.v2.DiscoveryResponse> getFetchRoutesMethod() {
-    io.grpc.MethodDescriptor<io.envoyproxy.envoy.api.v2.DiscoveryRequest, io.envoyproxy.envoy.api.v2.DiscoveryResponse> getFetchRoutesMethod;
-    if ((getFetchRoutesMethod = RouteDiscoveryServiceGrpc.getFetchRoutesMethod) == null) {
-      synchronized (RouteDiscoveryServiceGrpc.class) {
-        if ((getFetchRoutesMethod = RouteDiscoveryServiceGrpc.getFetchRoutesMethod) == null) {
-          RouteDiscoveryServiceGrpc.getFetchRoutesMethod = getFetchRoutesMethod =
-              io.grpc.MethodDescriptor.<io.envoyproxy.envoy.api.v2.DiscoveryRequest, io.envoyproxy.envoy.api.v2.DiscoveryResponse>newBuilder()
-              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
-              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "FetchRoutes"))
-              .setSampledToLocalTracing(true)
-              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
-                  io.envoyproxy.envoy.api.v2.DiscoveryRequest.getDefaultInstance()))
-              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
-                  io.envoyproxy.envoy.api.v2.DiscoveryResponse.getDefaultInstance()))
-              .setSchemaDescriptor(new RouteDiscoveryServiceMethodDescriptorSupplier("FetchRoutes"))
-              .build();
-        }
-      }
-    }
-    return getFetchRoutesMethod;
-  }
-
-  /**
-   * Creates a new async stub that supports all call types for the service
-   */
-  public static RouteDiscoveryServiceStub newStub(io.grpc.Channel channel) {
-    io.grpc.stub.AbstractStub.StubFactory<RouteDiscoveryServiceStub> factory =
-      new io.grpc.stub.AbstractStub.StubFactory<RouteDiscoveryServiceStub>() {
-        @java.lang.Override
-        public RouteDiscoveryServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
-          return new RouteDiscoveryServiceStub(channel, callOptions);
-        }
-      };
-    return RouteDiscoveryServiceStub.newStub(factory, channel);
-  }
-
-  /**
-   * Creates a new blocking-style stub that supports unary and streaming output calls on the service
-   */
-  public static RouteDiscoveryServiceBlockingStub newBlockingStub(
-      io.grpc.Channel channel) {
-    io.grpc.stub.AbstractStub.StubFactory<RouteDiscoveryServiceBlockingStub> factory =
-      new io.grpc.stub.AbstractStub.StubFactory<RouteDiscoveryServiceBlockingStub>() {
-        @java.lang.Override
-        public RouteDiscoveryServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
-          return new RouteDiscoveryServiceBlockingStub(channel, callOptions);
-        }
-      };
-    return RouteDiscoveryServiceBlockingStub.newStub(factory, channel);
-  }
-
-  /**
-   * Creates a new ListenableFuture-style stub that supports unary calls on the service
-   */
-  public static RouteDiscoveryServiceFutureStub newFutureStub(
-      io.grpc.Channel channel) {
-    io.grpc.stub.AbstractStub.StubFactory<RouteDiscoveryServiceFutureStub> factory =
-      new io.grpc.stub.AbstractStub.StubFactory<RouteDiscoveryServiceFutureStub>() {
-        @java.lang.Override
-        public RouteDiscoveryServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
-          return new RouteDiscoveryServiceFutureStub(channel, callOptions);
-        }
-      };
-    return RouteDiscoveryServiceFutureStub.newStub(factory, channel);
-  }
-
-  /**
-   * <pre>
-   * The resource_names field in DiscoveryRequest specifies a route configuration.
-   * This allows an Envoy configuration with multiple HTTP listeners (and
-   * associated HTTP connection manager filters) to use different route
-   * configurations. Each listener will bind its HTTP connection manager filter to
-   * a route table via this identifier.
-   * </pre>
-   */
-  public static abstract class RouteDiscoveryServiceImplBase implements io.grpc.BindableService {
-
-    /**
-     */
-    public io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DiscoveryRequest> streamRoutes(
-        io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DiscoveryResponse> responseObserver) {
-      return io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall(getStreamRoutesMethod(), responseObserver);
-    }
-
-    /**
-     */
-    public io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DeltaDiscoveryRequest> deltaRoutes(
-        io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse> responseObserver) {
-      return io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall(getDeltaRoutesMethod(), responseObserver);
-    }
-
-    /**
-     */
-    public void fetchRoutes(io.envoyproxy.envoy.api.v2.DiscoveryRequest request,
-        io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DiscoveryResponse> responseObserver) {
-      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getFetchRoutesMethod(), responseObserver);
-    }
-
-    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
-      return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
-          .addMethod(
-            getStreamRoutesMethod(),
-            io.grpc.stub.ServerCalls.asyncBidiStreamingCall(
-              new MethodHandlers<
-                io.envoyproxy.envoy.api.v2.DiscoveryRequest,
-                io.envoyproxy.envoy.api.v2.DiscoveryResponse>(
-                  this, METHODID_STREAM_ROUTES)))
-          .addMethod(
-            getDeltaRoutesMethod(),
-            io.grpc.stub.ServerCalls.asyncBidiStreamingCall(
-              new MethodHandlers<
-                io.envoyproxy.envoy.api.v2.DeltaDiscoveryRequest,
-                io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse>(
-                  this, METHODID_DELTA_ROUTES)))
-          .addMethod(
-            getFetchRoutesMethod(),
-            io.grpc.stub.ServerCalls.asyncUnaryCall(
-              new MethodHandlers<
-                io.envoyproxy.envoy.api.v2.DiscoveryRequest,
-                io.envoyproxy.envoy.api.v2.DiscoveryResponse>(
-                  this, METHODID_FETCH_ROUTES)))
-          .build();
-    }
-  }
-
-  /**
-   * <pre>
-   * The resource_names field in DiscoveryRequest specifies a route configuration.
-   * This allows an Envoy configuration with multiple HTTP listeners (and
-   * associated HTTP connection manager filters) to use different route
-   * configurations. Each listener will bind its HTTP connection manager filter to
-   * a route table via this identifier.
-   * </pre>
-   */
-  public static final class RouteDiscoveryServiceStub extends io.grpc.stub.AbstractAsyncStub<RouteDiscoveryServiceStub> {
-    private RouteDiscoveryServiceStub(
-        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
-      super(channel, callOptions);
-    }
-
-    @java.lang.Override
-    protected RouteDiscoveryServiceStub build(
-        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
-      return new RouteDiscoveryServiceStub(channel, callOptions);
-    }
-
-    /**
-     */
-    public io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DiscoveryRequest> streamRoutes(
-        io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DiscoveryResponse> responseObserver) {
-      return io.grpc.stub.ClientCalls.asyncBidiStreamingCall(
-          getChannel().newCall(getStreamRoutesMethod(), getCallOptions()), responseObserver);
-    }
-
-    /**
-     */
-    public io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DeltaDiscoveryRequest> deltaRoutes(
-        io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse> responseObserver) {
-      return io.grpc.stub.ClientCalls.asyncBidiStreamingCall(
-          getChannel().newCall(getDeltaRoutesMethod(), getCallOptions()), responseObserver);
-    }
-
-    /**
-     */
-    public void fetchRoutes(io.envoyproxy.envoy.api.v2.DiscoveryRequest request,
-        io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DiscoveryResponse> responseObserver) {
-      io.grpc.stub.ClientCalls.asyncUnaryCall(
-          getChannel().newCall(getFetchRoutesMethod(), getCallOptions()), request, responseObserver);
-    }
-  }
-
-  /**
-   * <pre>
-   * The resource_names field in DiscoveryRequest specifies a route configuration.
-   * This allows an Envoy configuration with multiple HTTP listeners (and
-   * associated HTTP connection manager filters) to use different route
-   * configurations. Each listener will bind its HTTP connection manager filter to
-   * a route table via this identifier.
-   * </pre>
-   */
-  public static final class RouteDiscoveryServiceBlockingStub extends io.grpc.stub.AbstractBlockingStub<RouteDiscoveryServiceBlockingStub> {
-    private RouteDiscoveryServiceBlockingStub(
-        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
-      super(channel, callOptions);
-    }
-
-    @java.lang.Override
-    protected RouteDiscoveryServiceBlockingStub build(
-        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
-      return new RouteDiscoveryServiceBlockingStub(channel, callOptions);
-    }
-
-    /**
-     */
-    public io.envoyproxy.envoy.api.v2.DiscoveryResponse fetchRoutes(io.envoyproxy.envoy.api.v2.DiscoveryRequest request) {
-      return io.grpc.stub.ClientCalls.blockingUnaryCall(
-          getChannel(), getFetchRoutesMethod(), getCallOptions(), request);
-    }
-  }
-
-  /**
-   * <pre>
-   * The resource_names field in DiscoveryRequest specifies a route configuration.
-   * This allows an Envoy configuration with multiple HTTP listeners (and
-   * associated HTTP connection manager filters) to use different route
-   * configurations. Each listener will bind its HTTP connection manager filter to
-   * a route table via this identifier.
-   * </pre>
-   */
-  public static final class RouteDiscoveryServiceFutureStub extends io.grpc.stub.AbstractFutureStub<RouteDiscoveryServiceFutureStub> {
-    private RouteDiscoveryServiceFutureStub(
-        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
-      super(channel, callOptions);
-    }
-
-    @java.lang.Override
-    protected RouteDiscoveryServiceFutureStub build(
-        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
-      return new RouteDiscoveryServiceFutureStub(channel, callOptions);
-    }
-
-    /**
-     */
-    public com.google.common.util.concurrent.ListenableFuture<io.envoyproxy.envoy.api.v2.DiscoveryResponse> fetchRoutes(
-        io.envoyproxy.envoy.api.v2.DiscoveryRequest request) {
-      return io.grpc.stub.ClientCalls.futureUnaryCall(
-          getChannel().newCall(getFetchRoutesMethod(), getCallOptions()), request);
-    }
-  }
-
-  private static final int METHODID_FETCH_ROUTES = 0;
-  private static final int METHODID_STREAM_ROUTES = 1;
-  private static final int METHODID_DELTA_ROUTES = 2;
-
-  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 RouteDiscoveryServiceImplBase serviceImpl;
-    private final int methodId;
-
-    MethodHandlers(RouteDiscoveryServiceImplBase 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_ROUTES:
-          serviceImpl.fetchRoutes((io.envoyproxy.envoy.api.v2.DiscoveryRequest) request,
-              (io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DiscoveryResponse>) 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_ROUTES:
-          return (io.grpc.stub.StreamObserver<Req>) serviceImpl.streamRoutes(
-              (io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DiscoveryResponse>) responseObserver);
-        case METHODID_DELTA_ROUTES:
-          return (io.grpc.stub.StreamObserver<Req>) serviceImpl.deltaRoutes(
-              (io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse>) responseObserver);
-        default:
-          throw new AssertionError();
-      }
-    }
-  }
-
-  private static abstract class RouteDiscoveryServiceBaseDescriptorSupplier
-      implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier {
-    RouteDiscoveryServiceBaseDescriptorSupplier() {}
-
-    @java.lang.Override
-    public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
-      return io.envoyproxy.envoy.api.v2.RdsProto.getDescriptor();
-    }
-
-    @java.lang.Override
-    public com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() {
-      return getFileDescriptor().findServiceByName("RouteDiscoveryService");
-    }
-  }
-
-  private static final class RouteDiscoveryServiceFileDescriptorSupplier
-      extends RouteDiscoveryServiceBaseDescriptorSupplier {
-    RouteDiscoveryServiceFileDescriptorSupplier() {}
-  }
-
-  private static final class RouteDiscoveryServiceMethodDescriptorSupplier
-      extends RouteDiscoveryServiceBaseDescriptorSupplier
-      implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
-    private final String methodName;
-
-    RouteDiscoveryServiceMethodDescriptorSupplier(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 (RouteDiscoveryServiceGrpc.class) {
-        result = serviceDescriptor;
-        if (result == null) {
-          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
-              .setSchemaDescriptor(new RouteDiscoveryServiceFileDescriptorSupplier())
-              .addMethod(getStreamRoutesMethod())
-              .addMethod(getDeltaRoutesMethod())
-              .addMethod(getFetchRoutesMethod())
-              .build();
-        }
-      }
-    }
-    return result;
-  }
-}
diff --git a/xds/src/generated/main/grpc/io/envoyproxy/envoy/api/v2/ScopedRoutesDiscoveryServiceGrpc.java b/xds/src/generated/main/grpc/io/envoyproxy/envoy/api/v2/ScopedRoutesDiscoveryServiceGrpc.java
deleted file mode 100644
index b2617c4a166..00000000000
--- a/xds/src/generated/main/grpc/io/envoyproxy/envoy/api/v2/ScopedRoutesDiscoveryServiceGrpc.java
+++ /dev/null
@@ -1,436 +0,0 @@
-package io.envoyproxy.envoy.api.v2;
-
-import static io.grpc.MethodDescriptor.generateFullMethodName;
-
-/**
- * <pre>
- * The Scoped Routes Discovery Service (SRDS) API distributes
- * :ref:`ScopedRouteConfiguration&lt;envoy_api_msg.ScopedRouteConfiguration&gt;`
- * resources. Each ScopedRouteConfiguration resource represents a "routing
- * scope" containing a mapping that allows the HTTP connection manager to
- * dynamically assign a routing table (specified via a
- * :ref:`RouteConfiguration&lt;envoy_api_msg_RouteConfiguration&gt;` message) to each
- * HTTP request.
- * </pre>
- */
-@javax.annotation.Generated(
-    value = "by gRPC proto compiler",
-    comments = "Source: envoy/api/v2/srds.proto")
-public final class ScopedRoutesDiscoveryServiceGrpc {
-
-  private ScopedRoutesDiscoveryServiceGrpc() {}
-
-  public static final String SERVICE_NAME = "envoy.api.v2.ScopedRoutesDiscoveryService";
-
-  // Static method descriptors that strictly reflect the proto.
-  private static volatile io.grpc.MethodDescriptor<io.envoyproxy.envoy.api.v2.DiscoveryRequest,
-      io.envoyproxy.envoy.api.v2.DiscoveryResponse> getStreamScopedRoutesMethod;
-
-  @io.grpc.stub.annotations.RpcMethod(
-      fullMethodName = SERVICE_NAME + '/' + "StreamScopedRoutes",
-      requestType = io.envoyproxy.envoy.api.v2.DiscoveryRequest.class,
-      responseType = io.envoyproxy.envoy.api.v2.DiscoveryResponse.class,
-      methodType = io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
-  public static io.grpc.MethodDescriptor<io.envoyproxy.envoy.api.v2.DiscoveryRequest,
-      io.envoyproxy.envoy.api.v2.DiscoveryResponse> getStreamScopedRoutesMethod() {
-    io.grpc.MethodDescriptor<io.envoyproxy.envoy.api.v2.DiscoveryRequest, io.envoyproxy.envoy.api.v2.DiscoveryResponse> getStreamScopedRoutesMethod;
-    if ((getStreamScopedRoutesMethod = ScopedRoutesDiscoveryServiceGrpc.getStreamScopedRoutesMethod) == null) {
-      synchronized (ScopedRoutesDiscoveryServiceGrpc.class) {
-        if ((getStreamScopedRoutesMethod = ScopedRoutesDiscoveryServiceGrpc.getStreamScopedRoutesMethod) == null) {
-          ScopedRoutesDiscoveryServiceGrpc.getStreamScopedRoutesMethod = getStreamScopedRoutesMethod =
-              io.grpc.MethodDescriptor.<io.envoyproxy.envoy.api.v2.DiscoveryRequest, io.envoyproxy.envoy.api.v2.DiscoveryResponse>newBuilder()
-              .setType(io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
-              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "StreamScopedRoutes"))
-              .setSampledToLocalTracing(true)
-              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
-                  io.envoyproxy.envoy.api.v2.DiscoveryRequest.getDefaultInstance()))
-              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
-                  io.envoyproxy.envoy.api.v2.DiscoveryResponse.getDefaultInstance()))
-              .setSchemaDescriptor(new ScopedRoutesDiscoveryServiceMethodDescriptorSupplier("StreamScopedRoutes"))
-              .build();
-        }
-      }
-    }
-    return getStreamScopedRoutesMethod;
-  }
-
-  private static volatile io.grpc.MethodDescriptor<io.envoyproxy.envoy.api.v2.DeltaDiscoveryRequest,
-      io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse> getDeltaScopedRoutesMethod;
-
-  @io.grpc.stub.annotations.RpcMethod(
-      fullMethodName = SERVICE_NAME + '/' + "DeltaScopedRoutes",
-      requestType = io.envoyproxy.envoy.api.v2.DeltaDiscoveryRequest.class,
-      responseType = io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse.class,
-      methodType = io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
-  public static io.grpc.MethodDescriptor<io.envoyproxy.envoy.api.v2.DeltaDiscoveryRequest,
-      io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse> getDeltaScopedRoutesMethod() {
-    io.grpc.MethodDescriptor<io.envoyproxy.envoy.api.v2.DeltaDiscoveryRequest, io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse> getDeltaScopedRoutesMethod;
-    if ((getDeltaScopedRoutesMethod = ScopedRoutesDiscoveryServiceGrpc.getDeltaScopedRoutesMethod) == null) {
-      synchronized (ScopedRoutesDiscoveryServiceGrpc.class) {
-        if ((getDeltaScopedRoutesMethod = ScopedRoutesDiscoveryServiceGrpc.getDeltaScopedRoutesMethod) == null) {
-          ScopedRoutesDiscoveryServiceGrpc.getDeltaScopedRoutesMethod = getDeltaScopedRoutesMethod =
-              io.grpc.MethodDescriptor.<io.envoyproxy.envoy.api.v2.DeltaDiscoveryRequest, io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse>newBuilder()
-              .setType(io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
-              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "DeltaScopedRoutes"))
-              .setSampledToLocalTracing(true)
-              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
-                  io.envoyproxy.envoy.api.v2.DeltaDiscoveryRequest.getDefaultInstance()))
-              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
-                  io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse.getDefaultInstance()))
-              .setSchemaDescriptor(new ScopedRoutesDiscoveryServiceMethodDescriptorSupplier("DeltaScopedRoutes"))
-              .build();
-        }
-      }
-    }
-    return getDeltaScopedRoutesMethod;
-  }
-
-  private static volatile io.grpc.MethodDescriptor<io.envoyproxy.envoy.api.v2.DiscoveryRequest,
-      io.envoyproxy.envoy.api.v2.DiscoveryResponse> getFetchScopedRoutesMethod;
-
-  @io.grpc.stub.annotations.RpcMethod(
-      fullMethodName = SERVICE_NAME + '/' + "FetchScopedRoutes",
-      requestType = io.envoyproxy.envoy.api.v2.DiscoveryRequest.class,
-      responseType = io.envoyproxy.envoy.api.v2.DiscoveryResponse.class,
-      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
-  public static io.grpc.MethodDescriptor<io.envoyproxy.envoy.api.v2.DiscoveryRequest,
-      io.envoyproxy.envoy.api.v2.DiscoveryResponse> getFetchScopedRoutesMethod() {
-    io.grpc.MethodDescriptor<io.envoyproxy.envoy.api.v2.DiscoveryRequest, io.envoyproxy.envoy.api.v2.DiscoveryResponse> getFetchScopedRoutesMethod;
-    if ((getFetchScopedRoutesMethod = ScopedRoutesDiscoveryServiceGrpc.getFetchScopedRoutesMethod) == null) {
-      synchronized (ScopedRoutesDiscoveryServiceGrpc.class) {
-        if ((getFetchScopedRoutesMethod = ScopedRoutesDiscoveryServiceGrpc.getFetchScopedRoutesMethod) == null) {
-          ScopedRoutesDiscoveryServiceGrpc.getFetchScopedRoutesMethod = getFetchScopedRoutesMethod =
-              io.grpc.MethodDescriptor.<io.envoyproxy.envoy.api.v2.DiscoveryRequest, io.envoyproxy.envoy.api.v2.DiscoveryResponse>newBuilder()
-              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
-              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "FetchScopedRoutes"))
-              .setSampledToLocalTracing(true)
-              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
-                  io.envoyproxy.envoy.api.v2.DiscoveryRequest.getDefaultInstance()))
-              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
-                  io.envoyproxy.envoy.api.v2.DiscoveryResponse.getDefaultInstance()))
-              .setSchemaDescriptor(new ScopedRoutesDiscoveryServiceMethodDescriptorSupplier("FetchScopedRoutes"))
-              .build();
-        }
-      }
-    }
-    return getFetchScopedRoutesMethod;
-  }
-
-  /**
-   * Creates a new async stub that supports all call types for the service
-   */
-  public static ScopedRoutesDiscoveryServiceStub newStub(io.grpc.Channel channel) {
-    io.grpc.stub.AbstractStub.StubFactory<ScopedRoutesDiscoveryServiceStub> factory =
-      new io.grpc.stub.AbstractStub.StubFactory<ScopedRoutesDiscoveryServiceStub>() {
-        @java.lang.Override
-        public ScopedRoutesDiscoveryServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
-          return new ScopedRoutesDiscoveryServiceStub(channel, callOptions);
-        }
-      };
-    return ScopedRoutesDiscoveryServiceStub.newStub(factory, channel);
-  }
-
-  /**
-   * Creates a new blocking-style stub that supports unary and streaming output calls on the service
-   */
-  public static ScopedRoutesDiscoveryServiceBlockingStub newBlockingStub(
-      io.grpc.Channel channel) {
-    io.grpc.stub.AbstractStub.StubFactory<ScopedRoutesDiscoveryServiceBlockingStub> factory =
-      new io.grpc.stub.AbstractStub.StubFactory<ScopedRoutesDiscoveryServiceBlockingStub>() {
-        @java.lang.Override
-        public ScopedRoutesDiscoveryServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
-          return new ScopedRoutesDiscoveryServiceBlockingStub(channel, callOptions);
-        }
-      };
-    return ScopedRoutesDiscoveryServiceBlockingStub.newStub(factory, channel);
-  }
-
-  /**
-   * Creates a new ListenableFuture-style stub that supports unary calls on the service
-   */
-  public static ScopedRoutesDiscoveryServiceFutureStub newFutureStub(
-      io.grpc.Channel channel) {
-    io.grpc.stub.AbstractStub.StubFactory<ScopedRoutesDiscoveryServiceFutureStub> factory =
-      new io.grpc.stub.AbstractStub.StubFactory<ScopedRoutesDiscoveryServiceFutureStub>() {
-        @java.lang.Override
-        public ScopedRoutesDiscoveryServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
-          return new ScopedRoutesDiscoveryServiceFutureStub(channel, callOptions);
-        }
-      };
-    return ScopedRoutesDiscoveryServiceFutureStub.newStub(factory, channel);
-  }
-
-  /**
-   * <pre>
-   * The Scoped Routes Discovery Service (SRDS) API distributes
-   * :ref:`ScopedRouteConfiguration&lt;envoy_api_msg.ScopedRouteConfiguration&gt;`
-   * resources. Each ScopedRouteConfiguration resource represents a "routing
-   * scope" containing a mapping that allows the HTTP connection manager to
-   * dynamically assign a routing table (specified via a
-   * :ref:`RouteConfiguration&lt;envoy_api_msg_RouteConfiguration&gt;` message) to each
-   * HTTP request.
-   * </pre>
-   */
-  public static abstract class ScopedRoutesDiscoveryServiceImplBase implements io.grpc.BindableService {
-
-    /**
-     */
-    public io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DiscoveryRequest> streamScopedRoutes(
-        io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DiscoveryResponse> responseObserver) {
-      return io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall(getStreamScopedRoutesMethod(), responseObserver);
-    }
-
-    /**
-     */
-    public io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DeltaDiscoveryRequest> deltaScopedRoutes(
-        io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse> responseObserver) {
-      return io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall(getDeltaScopedRoutesMethod(), responseObserver);
-    }
-
-    /**
-     */
-    public void fetchScopedRoutes(io.envoyproxy.envoy.api.v2.DiscoveryRequest request,
-        io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DiscoveryResponse> responseObserver) {
-      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getFetchScopedRoutesMethod(), responseObserver);
-    }
-
-    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
-      return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
-          .addMethod(
-            getStreamScopedRoutesMethod(),
-            io.grpc.stub.ServerCalls.asyncBidiStreamingCall(
-              new MethodHandlers<
-                io.envoyproxy.envoy.api.v2.DiscoveryRequest,
-                io.envoyproxy.envoy.api.v2.DiscoveryResponse>(
-                  this, METHODID_STREAM_SCOPED_ROUTES)))
-          .addMethod(
-            getDeltaScopedRoutesMethod(),
-            io.grpc.stub.ServerCalls.asyncBidiStreamingCall(
-              new MethodHandlers<
-                io.envoyproxy.envoy.api.v2.DeltaDiscoveryRequest,
-                io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse>(
-                  this, METHODID_DELTA_SCOPED_ROUTES)))
-          .addMethod(
-            getFetchScopedRoutesMethod(),
-            io.grpc.stub.ServerCalls.asyncUnaryCall(
-              new MethodHandlers<
-                io.envoyproxy.envoy.api.v2.DiscoveryRequest,
-                io.envoyproxy.envoy.api.v2.DiscoveryResponse>(
-                  this, METHODID_FETCH_SCOPED_ROUTES)))
-          .build();
-    }
-  }
-
-  /**
-   * <pre>
-   * The Scoped Routes Discovery Service (SRDS) API distributes
-   * :ref:`ScopedRouteConfiguration&lt;envoy_api_msg.ScopedRouteConfiguration&gt;`
-   * resources. Each ScopedRouteConfiguration resource represents a "routing
-   * scope" containing a mapping that allows the HTTP connection manager to
-   * dynamically assign a routing table (specified via a
-   * :ref:`RouteConfiguration&lt;envoy_api_msg_RouteConfiguration&gt;` message) to each
-   * HTTP request.
-   * </pre>
-   */
-  public static final class ScopedRoutesDiscoveryServiceStub extends io.grpc.stub.AbstractAsyncStub<ScopedRoutesDiscoveryServiceStub> {
-    private ScopedRoutesDiscoveryServiceStub(
-        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
-      super(channel, callOptions);
-    }
-
-    @java.lang.Override
-    protected ScopedRoutesDiscoveryServiceStub build(
-        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
-      return new ScopedRoutesDiscoveryServiceStub(channel, callOptions);
-    }
-
-    /**
-     */
-    public io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DiscoveryRequest> streamScopedRoutes(
-        io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DiscoveryResponse> responseObserver) {
-      return io.grpc.stub.ClientCalls.asyncBidiStreamingCall(
-          getChannel().newCall(getStreamScopedRoutesMethod(), getCallOptions()), responseObserver);
-    }
-
-    /**
-     */
-    public io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DeltaDiscoveryRequest> deltaScopedRoutes(
-        io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse> responseObserver) {
-      return io.grpc.stub.ClientCalls.asyncBidiStreamingCall(
-          getChannel().newCall(getDeltaScopedRoutesMethod(), getCallOptions()), responseObserver);
-    }
-
-    /**
-     */
-    public void fetchScopedRoutes(io.envoyproxy.envoy.api.v2.DiscoveryRequest request,
-        io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DiscoveryResponse> responseObserver) {
-      io.grpc.stub.ClientCalls.asyncUnaryCall(
-          getChannel().newCall(getFetchScopedRoutesMethod(), getCallOptions()), request, responseObserver);
-    }
-  }
-
-  /**
-   * <pre>
-   * The Scoped Routes Discovery Service (SRDS) API distributes
-   * :ref:`ScopedRouteConfiguration&lt;envoy_api_msg.ScopedRouteConfiguration&gt;`
-   * resources. Each ScopedRouteConfiguration resource represents a "routing
-   * scope" containing a mapping that allows the HTTP connection manager to
-   * dynamically assign a routing table (specified via a
-   * :ref:`RouteConfiguration&lt;envoy_api_msg_RouteConfiguration&gt;` message) to each
-   * HTTP request.
-   * </pre>
-   */
-  public static final class ScopedRoutesDiscoveryServiceBlockingStub extends io.grpc.stub.AbstractBlockingStub<ScopedRoutesDiscoveryServiceBlockingStub> {
-    private ScopedRoutesDiscoveryServiceBlockingStub(
-        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
-      super(channel, callOptions);
-    }
-
-    @java.lang.Override
-    protected ScopedRoutesDiscoveryServiceBlockingStub build(
-        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
-      return new ScopedRoutesDiscoveryServiceBlockingStub(channel, callOptions);
-    }
-
-    /**
-     */
-    public io.envoyproxy.envoy.api.v2.DiscoveryResponse fetchScopedRoutes(io.envoyproxy.envoy.api.v2.DiscoveryRequest request) {
-      return io.grpc.stub.ClientCalls.blockingUnaryCall(
-          getChannel(), getFetchScopedRoutesMethod(), getCallOptions(), request);
-    }
-  }
-
-  /**
-   * <pre>
-   * The Scoped Routes Discovery Service (SRDS) API distributes
-   * :ref:`ScopedRouteConfiguration&lt;envoy_api_msg.ScopedRouteConfiguration&gt;`
-   * resources. Each ScopedRouteConfiguration resource represents a "routing
-   * scope" containing a mapping that allows the HTTP connection manager to
-   * dynamically assign a routing table (specified via a
-   * :ref:`RouteConfiguration&lt;envoy_api_msg_RouteConfiguration&gt;` message) to each
-   * HTTP request.
-   * </pre>
-   */
-  public static final class ScopedRoutesDiscoveryServiceFutureStub extends io.grpc.stub.AbstractFutureStub<ScopedRoutesDiscoveryServiceFutureStub> {
-    private ScopedRoutesDiscoveryServiceFutureStub(
-        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
-      super(channel, callOptions);
-    }
-
-    @java.lang.Override
-    protected ScopedRoutesDiscoveryServiceFutureStub build(
-        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
-      return new ScopedRoutesDiscoveryServiceFutureStub(channel, callOptions);
-    }
-
-    /**
-     */
-    public com.google.common.util.concurrent.ListenableFuture<io.envoyproxy.envoy.api.v2.DiscoveryResponse> fetchScopedRoutes(
-        io.envoyproxy.envoy.api.v2.DiscoveryRequest request) {
-      return io.grpc.stub.ClientCalls.futureUnaryCall(
-          getChannel().newCall(getFetchScopedRoutesMethod(), getCallOptions()), request);
-    }
-  }
-
-  private static final int METHODID_FETCH_SCOPED_ROUTES = 0;
-  private static final int METHODID_STREAM_SCOPED_ROUTES = 1;
-  private static final int METHODID_DELTA_SCOPED_ROUTES = 2;
-
-  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 ScopedRoutesDiscoveryServiceImplBase serviceImpl;
-    private final int methodId;
-
-    MethodHandlers(ScopedRoutesDiscoveryServiceImplBase 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_SCOPED_ROUTES:
-          serviceImpl.fetchScopedRoutes((io.envoyproxy.envoy.api.v2.DiscoveryRequest) request,
-              (io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DiscoveryResponse>) 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_SCOPED_ROUTES:
-          return (io.grpc.stub.StreamObserver<Req>) serviceImpl.streamScopedRoutes(
-              (io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DiscoveryResponse>) responseObserver);
-        case METHODID_DELTA_SCOPED_ROUTES:
-          return (io.grpc.stub.StreamObserver<Req>) serviceImpl.deltaScopedRoutes(
-              (io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse>) responseObserver);
-        default:
-          throw new AssertionError();
-      }
-    }
-  }
-
-  private static abstract class ScopedRoutesDiscoveryServiceBaseDescriptorSupplier
-      implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier {
-    ScopedRoutesDiscoveryServiceBaseDescriptorSupplier() {}
-
-    @java.lang.Override
-    public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
-      return io.envoyproxy.envoy.api.v2.SrdsProto.getDescriptor();
-    }
-
-    @java.lang.Override
-    public com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() {
-      return getFileDescriptor().findServiceByName("ScopedRoutesDiscoveryService");
-    }
-  }
-
-  private static final class ScopedRoutesDiscoveryServiceFileDescriptorSupplier
-      extends ScopedRoutesDiscoveryServiceBaseDescriptorSupplier {
-    ScopedRoutesDiscoveryServiceFileDescriptorSupplier() {}
-  }
-
-  private static final class ScopedRoutesDiscoveryServiceMethodDescriptorSupplier
-      extends ScopedRoutesDiscoveryServiceBaseDescriptorSupplier
-      implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
-    private final String methodName;
-
-    ScopedRoutesDiscoveryServiceMethodDescriptorSupplier(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 (ScopedRoutesDiscoveryServiceGrpc.class) {
-        result = serviceDescriptor;
-        if (result == null) {
-          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
-              .setSchemaDescriptor(new ScopedRoutesDiscoveryServiceFileDescriptorSupplier())
-              .addMethod(getStreamScopedRoutesMethod())
-              .addMethod(getDeltaScopedRoutesMethod())
-              .addMethod(getFetchScopedRoutesMethod())
-              .build();
-        }
-      }
-    }
-    return result;
-  }
-}
diff --git a/xds/src/generated/main/grpc/io/envoyproxy/envoy/api/v2/VirtualHostDiscoveryServiceGrpc.java b/xds/src/generated/main/grpc/io/envoyproxy/envoy/api/v2/VirtualHostDiscoveryServiceGrpc.java
deleted file mode 100644
index 768f4fa0d83..00000000000
--- a/xds/src/generated/main/grpc/io/envoyproxy/envoy/api/v2/VirtualHostDiscoveryServiceGrpc.java
+++ /dev/null
@@ -1,319 +0,0 @@
-package io.envoyproxy.envoy.api.v2;
-
-import static io.grpc.MethodDescriptor.generateFullMethodName;
-
-/**
- * <pre>
- * Virtual Host Discovery Service (VHDS) is used to dynamically update the list of virtual hosts for
- * a given RouteConfiguration. If VHDS is configured a virtual host list update will be triggered
- * during the processing of an HTTP request if a route for the request cannot be resolved. The
- * :ref:`resource_names_subscribe &lt;envoy_api_field_DeltaDiscoveryRequest.resource_names_subscribe&gt;`
- * field contains a list of virtual host names or aliases to track. The contents of an alias would
- * be the contents of a *host* or *authority* header used to make an http request. An xDS server
- * will match an alias to a virtual host based on the content of :ref:`domains'
- * &lt;envoy_api_field_route.VirtualHost.domains&gt;` field. The *resource_names_unsubscribe* field
- * contains a list of virtual host names that have been :ref:`unsubscribed
- * &lt;xds_protocol_unsubscribe&gt;` from the routing table associated with the RouteConfiguration.
- * </pre>
- */
-@javax.annotation.Generated(
-    value = "by gRPC proto compiler",
-    comments = "Source: envoy/api/v2/rds.proto")
-public final class VirtualHostDiscoveryServiceGrpc {
-
-  private VirtualHostDiscoveryServiceGrpc() {}
-
-  public static final String SERVICE_NAME = "envoy.api.v2.VirtualHostDiscoveryService";
-
-  // Static method descriptors that strictly reflect the proto.
-  private static volatile io.grpc.MethodDescriptor<io.envoyproxy.envoy.api.v2.DeltaDiscoveryRequest,
-      io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse> getDeltaVirtualHostsMethod;
-
-  @io.grpc.stub.annotations.RpcMethod(
-      fullMethodName = SERVICE_NAME + '/' + "DeltaVirtualHosts",
-      requestType = io.envoyproxy.envoy.api.v2.DeltaDiscoveryRequest.class,
-      responseType = io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse.class,
-      methodType = io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
-  public static io.grpc.MethodDescriptor<io.envoyproxy.envoy.api.v2.DeltaDiscoveryRequest,
-      io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse> getDeltaVirtualHostsMethod() {
-    io.grpc.MethodDescriptor<io.envoyproxy.envoy.api.v2.DeltaDiscoveryRequest, io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse> getDeltaVirtualHostsMethod;
-    if ((getDeltaVirtualHostsMethod = VirtualHostDiscoveryServiceGrpc.getDeltaVirtualHostsMethod) == null) {
-      synchronized (VirtualHostDiscoveryServiceGrpc.class) {
-        if ((getDeltaVirtualHostsMethod = VirtualHostDiscoveryServiceGrpc.getDeltaVirtualHostsMethod) == null) {
-          VirtualHostDiscoveryServiceGrpc.getDeltaVirtualHostsMethod = getDeltaVirtualHostsMethod =
-              io.grpc.MethodDescriptor.<io.envoyproxy.envoy.api.v2.DeltaDiscoveryRequest, io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse>newBuilder()
-              .setType(io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
-              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "DeltaVirtualHosts"))
-              .setSampledToLocalTracing(true)
-              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
-                  io.envoyproxy.envoy.api.v2.DeltaDiscoveryRequest.getDefaultInstance()))
-              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
-                  io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse.getDefaultInstance()))
-              .setSchemaDescriptor(new VirtualHostDiscoveryServiceMethodDescriptorSupplier("DeltaVirtualHosts"))
-              .build();
-        }
-      }
-    }
-    return getDeltaVirtualHostsMethod;
-  }
-
-  /**
-   * Creates a new async stub that supports all call types for the service
-   */
-  public static VirtualHostDiscoveryServiceStub newStub(io.grpc.Channel channel) {
-    io.grpc.stub.AbstractStub.StubFactory<VirtualHostDiscoveryServiceStub> factory =
-      new io.grpc.stub.AbstractStub.StubFactory<VirtualHostDiscoveryServiceStub>() {
-        @java.lang.Override
-        public VirtualHostDiscoveryServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
-          return new VirtualHostDiscoveryServiceStub(channel, callOptions);
-        }
-      };
-    return VirtualHostDiscoveryServiceStub.newStub(factory, channel);
-  }
-
-  /**
-   * Creates a new blocking-style stub that supports unary and streaming output calls on the service
-   */
-  public static VirtualHostDiscoveryServiceBlockingStub newBlockingStub(
-      io.grpc.Channel channel) {
-    io.grpc.stub.AbstractStub.StubFactory<VirtualHostDiscoveryServiceBlockingStub> factory =
-      new io.grpc.stub.AbstractStub.StubFactory<VirtualHostDiscoveryServiceBlockingStub>() {
-        @java.lang.Override
-        public VirtualHostDiscoveryServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
-          return new VirtualHostDiscoveryServiceBlockingStub(channel, callOptions);
-        }
-      };
-    return VirtualHostDiscoveryServiceBlockingStub.newStub(factory, channel);
-  }
-
-  /**
-   * Creates a new ListenableFuture-style stub that supports unary calls on the service
-   */
-  public static VirtualHostDiscoveryServiceFutureStub newFutureStub(
-      io.grpc.Channel channel) {
-    io.grpc.stub.AbstractStub.StubFactory<VirtualHostDiscoveryServiceFutureStub> factory =
-      new io.grpc.stub.AbstractStub.StubFactory<VirtualHostDiscoveryServiceFutureStub>() {
-        @java.lang.Override
-        public VirtualHostDiscoveryServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
-          return new VirtualHostDiscoveryServiceFutureStub(channel, callOptions);
-        }
-      };
-    return VirtualHostDiscoveryServiceFutureStub.newStub(factory, channel);
-  }
-
-  /**
-   * <pre>
-   * Virtual Host Discovery Service (VHDS) is used to dynamically update the list of virtual hosts for
-   * a given RouteConfiguration. If VHDS is configured a virtual host list update will be triggered
-   * during the processing of an HTTP request if a route for the request cannot be resolved. The
-   * :ref:`resource_names_subscribe &lt;envoy_api_field_DeltaDiscoveryRequest.resource_names_subscribe&gt;`
-   * field contains a list of virtual host names or aliases to track. The contents of an alias would
-   * be the contents of a *host* or *authority* header used to make an http request. An xDS server
-   * will match an alias to a virtual host based on the content of :ref:`domains'
-   * &lt;envoy_api_field_route.VirtualHost.domains&gt;` field. The *resource_names_unsubscribe* field
-   * contains a list of virtual host names that have been :ref:`unsubscribed
-   * &lt;xds_protocol_unsubscribe&gt;` from the routing table associated with the RouteConfiguration.
-   * </pre>
-   */
-  public static abstract class VirtualHostDiscoveryServiceImplBase implements io.grpc.BindableService {
-
-    /**
-     */
-    public io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DeltaDiscoveryRequest> deltaVirtualHosts(
-        io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse> responseObserver) {
-      return io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall(getDeltaVirtualHostsMethod(), responseObserver);
-    }
-
-    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
-      return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
-          .addMethod(
-            getDeltaVirtualHostsMethod(),
-            io.grpc.stub.ServerCalls.asyncBidiStreamingCall(
-              new MethodHandlers<
-                io.envoyproxy.envoy.api.v2.DeltaDiscoveryRequest,
-                io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse>(
-                  this, METHODID_DELTA_VIRTUAL_HOSTS)))
-          .build();
-    }
-  }
-
-  /**
-   * <pre>
-   * Virtual Host Discovery Service (VHDS) is used to dynamically update the list of virtual hosts for
-   * a given RouteConfiguration. If VHDS is configured a virtual host list update will be triggered
-   * during the processing of an HTTP request if a route for the request cannot be resolved. The
-   * :ref:`resource_names_subscribe &lt;envoy_api_field_DeltaDiscoveryRequest.resource_names_subscribe&gt;`
-   * field contains a list of virtual host names or aliases to track. The contents of an alias would
-   * be the contents of a *host* or *authority* header used to make an http request. An xDS server
-   * will match an alias to a virtual host based on the content of :ref:`domains'
-   * &lt;envoy_api_field_route.VirtualHost.domains&gt;` field. The *resource_names_unsubscribe* field
-   * contains a list of virtual host names that have been :ref:`unsubscribed
-   * &lt;xds_protocol_unsubscribe&gt;` from the routing table associated with the RouteConfiguration.
-   * </pre>
-   */
-  public static final class VirtualHostDiscoveryServiceStub extends io.grpc.stub.AbstractAsyncStub<VirtualHostDiscoveryServiceStub> {
-    private VirtualHostDiscoveryServiceStub(
-        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
-      super(channel, callOptions);
-    }
-
-    @java.lang.Override
-    protected VirtualHostDiscoveryServiceStub build(
-        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
-      return new VirtualHostDiscoveryServiceStub(channel, callOptions);
-    }
-
-    /**
-     */
-    public io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DeltaDiscoveryRequest> deltaVirtualHosts(
-        io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse> responseObserver) {
-      return io.grpc.stub.ClientCalls.asyncBidiStreamingCall(
-          getChannel().newCall(getDeltaVirtualHostsMethod(), getCallOptions()), responseObserver);
-    }
-  }
-
-  /**
-   * <pre>
-   * Virtual Host Discovery Service (VHDS) is used to dynamically update the list of virtual hosts for
-   * a given RouteConfiguration. If VHDS is configured a virtual host list update will be triggered
-   * during the processing of an HTTP request if a route for the request cannot be resolved. The
-   * :ref:`resource_names_subscribe &lt;envoy_api_field_DeltaDiscoveryRequest.resource_names_subscribe&gt;`
-   * field contains a list of virtual host names or aliases to track. The contents of an alias would
-   * be the contents of a *host* or *authority* header used to make an http request. An xDS server
-   * will match an alias to a virtual host based on the content of :ref:`domains'
-   * &lt;envoy_api_field_route.VirtualHost.domains&gt;` field. The *resource_names_unsubscribe* field
-   * contains a list of virtual host names that have been :ref:`unsubscribed
-   * &lt;xds_protocol_unsubscribe&gt;` from the routing table associated with the RouteConfiguration.
-   * </pre>
-   */
-  public static final class VirtualHostDiscoveryServiceBlockingStub extends io.grpc.stub.AbstractBlockingStub<VirtualHostDiscoveryServiceBlockingStub> {
-    private VirtualHostDiscoveryServiceBlockingStub(
-        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
-      super(channel, callOptions);
-    }
-
-    @java.lang.Override
-    protected VirtualHostDiscoveryServiceBlockingStub build(
-        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
-      return new VirtualHostDiscoveryServiceBlockingStub(channel, callOptions);
-    }
-  }
-
-  /**
-   * <pre>
-   * Virtual Host Discovery Service (VHDS) is used to dynamically update the list of virtual hosts for
-   * a given RouteConfiguration. If VHDS is configured a virtual host list update will be triggered
-   * during the processing of an HTTP request if a route for the request cannot be resolved. The
-   * :ref:`resource_names_subscribe &lt;envoy_api_field_DeltaDiscoveryRequest.resource_names_subscribe&gt;`
-   * field contains a list of virtual host names or aliases to track. The contents of an alias would
-   * be the contents of a *host* or *authority* header used to make an http request. An xDS server
-   * will match an alias to a virtual host based on the content of :ref:`domains'
-   * &lt;envoy_api_field_route.VirtualHost.domains&gt;` field. The *resource_names_unsubscribe* field
-   * contains a list of virtual host names that have been :ref:`unsubscribed
-   * &lt;xds_protocol_unsubscribe&gt;` from the routing table associated with the RouteConfiguration.
-   * </pre>
-   */
-  public static final class VirtualHostDiscoveryServiceFutureStub extends io.grpc.stub.AbstractFutureStub<VirtualHostDiscoveryServiceFutureStub> {
-    private VirtualHostDiscoveryServiceFutureStub(
-        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
-      super(channel, callOptions);
-    }
-
-    @java.lang.Override
-    protected VirtualHostDiscoveryServiceFutureStub build(
-        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
-      return new VirtualHostDiscoveryServiceFutureStub(channel, callOptions);
-    }
-  }
-
-  private static final int METHODID_DELTA_VIRTUAL_HOSTS = 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 VirtualHostDiscoveryServiceImplBase serviceImpl;
-    private final int methodId;
-
-    MethodHandlers(VirtualHostDiscoveryServiceImplBase 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_DELTA_VIRTUAL_HOSTS:
-          return (io.grpc.stub.StreamObserver<Req>) serviceImpl.deltaVirtualHosts(
-              (io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse>) responseObserver);
-        default:
-          throw new AssertionError();
-      }
-    }
-  }
-
-  private static abstract class VirtualHostDiscoveryServiceBaseDescriptorSupplier
-      implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier {
-    VirtualHostDiscoveryServiceBaseDescriptorSupplier() {}
-
-    @java.lang.Override
-    public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
-      return io.envoyproxy.envoy.api.v2.RdsProto.getDescriptor();
-    }
-
-    @java.lang.Override
-    public com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() {
-      return getFileDescriptor().findServiceByName("VirtualHostDiscoveryService");
-    }
-  }
-
-  private static final class VirtualHostDiscoveryServiceFileDescriptorSupplier
-      extends VirtualHostDiscoveryServiceBaseDescriptorSupplier {
-    VirtualHostDiscoveryServiceFileDescriptorSupplier() {}
-  }
-
-  private static final class VirtualHostDiscoveryServiceMethodDescriptorSupplier
-      extends VirtualHostDiscoveryServiceBaseDescriptorSupplier
-      implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
-    private final String methodName;
-
-    VirtualHostDiscoveryServiceMethodDescriptorSupplier(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 (VirtualHostDiscoveryServiceGrpc.class) {
-        result = serviceDescriptor;
-        if (result == null) {
-          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
-              .setSchemaDescriptor(new VirtualHostDiscoveryServiceFileDescriptorSupplier())
-              .addMethod(getDeltaVirtualHostsMethod())
-              .build();
-        }
-      }
-    }
-    return result;
-  }
-}
diff --git a/xds/src/generated/main/grpc/io/envoyproxy/envoy/service/discovery/v2/AggregatedDiscoveryServiceGrpc.java b/xds/src/generated/main/grpc/io/envoyproxy/envoy/service/discovery/v2/AggregatedDiscoveryServiceGrpc.java
deleted file mode 100644
index 4311af92977..00000000000
--- a/xds/src/generated/main/grpc/io/envoyproxy/envoy/service/discovery/v2/AggregatedDiscoveryServiceGrpc.java
+++ /dev/null
@@ -1,363 +0,0 @@
-package io.envoyproxy.envoy.service.discovery.v2;
-
-import static io.grpc.MethodDescriptor.generateFullMethodName;
-
-/**
- * <pre>
- * See https://github.com/lyft/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>
- */
-@javax.annotation.Generated(
-    value = "by gRPC proto compiler",
-    comments = "Source: envoy/service/discovery/v2/ads.proto")
-public final class AggregatedDiscoveryServiceGrpc {
-
-  private AggregatedDiscoveryServiceGrpc() {}
-
-  public static final String SERVICE_NAME = "envoy.service.discovery.v2.AggregatedDiscoveryService";
-
-  // Static method descriptors that strictly reflect the proto.
-  private static volatile io.grpc.MethodDescriptor<io.envoyproxy.envoy.api.v2.DiscoveryRequest,
-      io.envoyproxy.envoy.api.v2.DiscoveryResponse> getStreamAggregatedResourcesMethod;
-
-  @io.grpc.stub.annotations.RpcMethod(
-      fullMethodName = SERVICE_NAME + '/' + "StreamAggregatedResources",
-      requestType = io.envoyproxy.envoy.api.v2.DiscoveryRequest.class,
-      responseType = io.envoyproxy.envoy.api.v2.DiscoveryResponse.class,
-      methodType = io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
-  public static io.grpc.MethodDescriptor<io.envoyproxy.envoy.api.v2.DiscoveryRequest,
-      io.envoyproxy.envoy.api.v2.DiscoveryResponse> getStreamAggregatedResourcesMethod() {
-    io.grpc.MethodDescriptor<io.envoyproxy.envoy.api.v2.DiscoveryRequest, io.envoyproxy.envoy.api.v2.DiscoveryResponse> getStreamAggregatedResourcesMethod;
-    if ((getStreamAggregatedResourcesMethod = AggregatedDiscoveryServiceGrpc.getStreamAggregatedResourcesMethod) == null) {
-      synchronized (AggregatedDiscoveryServiceGrpc.class) {
-        if ((getStreamAggregatedResourcesMethod = AggregatedDiscoveryServiceGrpc.getStreamAggregatedResourcesMethod) == null) {
-          AggregatedDiscoveryServiceGrpc.getStreamAggregatedResourcesMethod = getStreamAggregatedResourcesMethod =
-              io.grpc.MethodDescriptor.<io.envoyproxy.envoy.api.v2.DiscoveryRequest, io.envoyproxy.envoy.api.v2.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.api.v2.DiscoveryRequest.getDefaultInstance()))
-              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
-                  io.envoyproxy.envoy.api.v2.DiscoveryResponse.getDefaultInstance()))
-              .setSchemaDescriptor(new AggregatedDiscoveryServiceMethodDescriptorSupplier("StreamAggregatedResources"))
-              .build();
-        }
-      }
-    }
-    return getStreamAggregatedResourcesMethod;
-  }
-
-  private static volatile io.grpc.MethodDescriptor<io.envoyproxy.envoy.api.v2.DeltaDiscoveryRequest,
-      io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse> getDeltaAggregatedResourcesMethod;
-
-  @io.grpc.stub.annotations.RpcMethod(
-      fullMethodName = SERVICE_NAME + '/' + "DeltaAggregatedResources",
-      requestType = io.envoyproxy.envoy.api.v2.DeltaDiscoveryRequest.class,
-      responseType = io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse.class,
-      methodType = io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
-  public static io.grpc.MethodDescriptor<io.envoyproxy.envoy.api.v2.DeltaDiscoveryRequest,
-      io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse> getDeltaAggregatedResourcesMethod() {
-    io.grpc.MethodDescriptor<io.envoyproxy.envoy.api.v2.DeltaDiscoveryRequest, io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse> getDeltaAggregatedResourcesMethod;
-    if ((getDeltaAggregatedResourcesMethod = AggregatedDiscoveryServiceGrpc.getDeltaAggregatedResourcesMethod) == null) {
-      synchronized (AggregatedDiscoveryServiceGrpc.class) {
-        if ((getDeltaAggregatedResourcesMethod = AggregatedDiscoveryServiceGrpc.getDeltaAggregatedResourcesMethod) == null) {
-          AggregatedDiscoveryServiceGrpc.getDeltaAggregatedResourcesMethod = getDeltaAggregatedResourcesMethod =
-              io.grpc.MethodDescriptor.<io.envoyproxy.envoy.api.v2.DeltaDiscoveryRequest, io.envoyproxy.envoy.api.v2.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.api.v2.DeltaDiscoveryRequest.getDefaultInstance()))
-              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
-                  io.envoyproxy.envoy.api.v2.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 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/lyft/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 {
-
-    /**
-     * <pre>
-     * This is a gRPC-only API.
-     * </pre>
-     */
-    public io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DiscoveryRequest> streamAggregatedResources(
-        io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DiscoveryResponse> responseObserver) {
-      return io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall(getStreamAggregatedResourcesMethod(), responseObserver);
-    }
-
-    /**
-     */
-    public io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DeltaDiscoveryRequest> deltaAggregatedResources(
-        io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse> responseObserver) {
-      return io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall(getDeltaAggregatedResourcesMethod(), responseObserver);
-    }
-
-    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
-      return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
-          .addMethod(
-            getStreamAggregatedResourcesMethod(),
-            io.grpc.stub.ServerCalls.asyncBidiStreamingCall(
-              new MethodHandlers<
-                io.envoyproxy.envoy.api.v2.DiscoveryRequest,
-                io.envoyproxy.envoy.api.v2.DiscoveryResponse>(
-                  this, METHODID_STREAM_AGGREGATED_RESOURCES)))
-          .addMethod(
-            getDeltaAggregatedResourcesMethod(),
-            io.grpc.stub.ServerCalls.asyncBidiStreamingCall(
-              new MethodHandlers<
-                io.envoyproxy.envoy.api.v2.DeltaDiscoveryRequest,
-                io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse>(
-                  this, METHODID_DELTA_AGGREGATED_RESOURCES)))
-          .build();
-    }
-  }
-
-  /**
-   * <pre>
-   * See https://github.com/lyft/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.api.v2.DiscoveryRequest> streamAggregatedResources(
-        io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DiscoveryResponse> responseObserver) {
-      return io.grpc.stub.ClientCalls.asyncBidiStreamingCall(
-          getChannel().newCall(getStreamAggregatedResourcesMethod(), getCallOptions()), responseObserver);
-    }
-
-    /**
-     */
-    public io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DeltaDiscoveryRequest> deltaAggregatedResources(
-        io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse> responseObserver) {
-      return io.grpc.stub.ClientCalls.asyncBidiStreamingCall(
-          getChannel().newCall(getDeltaAggregatedResourcesMethod(), getCallOptions()), responseObserver);
-    }
-  }
-
-  /**
-   * <pre>
-   * See https://github.com/lyft/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);
-    }
-  }
-
-  /**
-   * <pre>
-   * See https://github.com/lyft/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 AggregatedDiscoveryServiceImplBase serviceImpl;
-    private final int methodId;
-
-    MethodHandlers(AggregatedDiscoveryServiceImplBase 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.api.v2.DiscoveryResponse>) responseObserver);
-        case METHODID_DELTA_AGGREGATED_RESOURCES:
-          return (io.grpc.stub.StreamObserver<Req>) serviceImpl.deltaAggregatedResources(
-              (io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse>) responseObserver);
-        default:
-          throw new AssertionError();
-      }
-    }
-  }
-
-  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.v2.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 String methodName;
-
-    AggregatedDiscoveryServiceMethodDescriptorSupplier(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/main/grpc/io/envoyproxy/envoy/service/discovery/v2/SecretDiscoveryServiceGrpc.java b/xds/src/generated/main/grpc/io/envoyproxy/envoy/service/discovery/v2/SecretDiscoveryServiceGrpc.java
deleted file mode 100644
index e9623f6ca0e..00000000000
--- a/xds/src/generated/main/grpc/io/envoyproxy/envoy/service/discovery/v2/SecretDiscoveryServiceGrpc.java
+++ /dev/null
@@ -1,391 +0,0 @@
-package io.envoyproxy.envoy.service.discovery.v2;
-
-import static io.grpc.MethodDescriptor.generateFullMethodName;
-
-/**
- */
-@javax.annotation.Generated(
-    value = "by gRPC proto compiler",
-    comments = "Source: envoy/service/discovery/v2/sds.proto")
-public final class SecretDiscoveryServiceGrpc {
-
-  private SecretDiscoveryServiceGrpc() {}
-
-  public static final String SERVICE_NAME = "envoy.service.discovery.v2.SecretDiscoveryService";
-
-  // Static method descriptors that strictly reflect the proto.
-  private static volatile io.grpc.MethodDescriptor<io.envoyproxy.envoy.api.v2.DeltaDiscoveryRequest,
-      io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse> getDeltaSecretsMethod;
-
-  @io.grpc.stub.annotations.RpcMethod(
-      fullMethodName = SERVICE_NAME + '/' + "DeltaSecrets",
-      requestType = io.envoyproxy.envoy.api.v2.DeltaDiscoveryRequest.class,
-      responseType = io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse.class,
-      methodType = io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
-  public static io.grpc.MethodDescriptor<io.envoyproxy.envoy.api.v2.DeltaDiscoveryRequest,
-      io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse> getDeltaSecretsMethod() {
-    io.grpc.MethodDescriptor<io.envoyproxy.envoy.api.v2.DeltaDiscoveryRequest, io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse> getDeltaSecretsMethod;
-    if ((getDeltaSecretsMethod = SecretDiscoveryServiceGrpc.getDeltaSecretsMethod) == null) {
-      synchronized (SecretDiscoveryServiceGrpc.class) {
-        if ((getDeltaSecretsMethod = SecretDiscoveryServiceGrpc.getDeltaSecretsMethod) == null) {
-          SecretDiscoveryServiceGrpc.getDeltaSecretsMethod = getDeltaSecretsMethod =
-              io.grpc.MethodDescriptor.<io.envoyproxy.envoy.api.v2.DeltaDiscoveryRequest, io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse>newBuilder()
-              .setType(io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
-              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "DeltaSecrets"))
-              .setSampledToLocalTracing(true)
-              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
-                  io.envoyproxy.envoy.api.v2.DeltaDiscoveryRequest.getDefaultInstance()))
-              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
-                  io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse.getDefaultInstance()))
-              .setSchemaDescriptor(new SecretDiscoveryServiceMethodDescriptorSupplier("DeltaSecrets"))
-              .build();
-        }
-      }
-    }
-    return getDeltaSecretsMethod;
-  }
-
-  private static volatile io.grpc.MethodDescriptor<io.envoyproxy.envoy.api.v2.DiscoveryRequest,
-      io.envoyproxy.envoy.api.v2.DiscoveryResponse> getStreamSecretsMethod;
-
-  @io.grpc.stub.annotations.RpcMethod(
-      fullMethodName = SERVICE_NAME + '/' + "StreamSecrets",
-      requestType = io.envoyproxy.envoy.api.v2.DiscoveryRequest.class,
-      responseType = io.envoyproxy.envoy.api.v2.DiscoveryResponse.class,
-      methodType = io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
-  public static io.grpc.MethodDescriptor<io.envoyproxy.envoy.api.v2.DiscoveryRequest,
-      io.envoyproxy.envoy.api.v2.DiscoveryResponse> getStreamSecretsMethod() {
-    io.grpc.MethodDescriptor<io.envoyproxy.envoy.api.v2.DiscoveryRequest, io.envoyproxy.envoy.api.v2.DiscoveryResponse> getStreamSecretsMethod;
-    if ((getStreamSecretsMethod = SecretDiscoveryServiceGrpc.getStreamSecretsMethod) == null) {
-      synchronized (SecretDiscoveryServiceGrpc.class) {
-        if ((getStreamSecretsMethod = SecretDiscoveryServiceGrpc.getStreamSecretsMethod) == null) {
-          SecretDiscoveryServiceGrpc.getStreamSecretsMethod = getStreamSecretsMethod =
-              io.grpc.MethodDescriptor.<io.envoyproxy.envoy.api.v2.DiscoveryRequest, io.envoyproxy.envoy.api.v2.DiscoveryResponse>newBuilder()
-              .setType(io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
-              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "StreamSecrets"))
-              .setSampledToLocalTracing(true)
-              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
-                  io.envoyproxy.envoy.api.v2.DiscoveryRequest.getDefaultInstance()))
-              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
-                  io.envoyproxy.envoy.api.v2.DiscoveryResponse.getDefaultInstance()))
-              .setSchemaDescriptor(new SecretDiscoveryServiceMethodDescriptorSupplier("StreamSecrets"))
-              .build();
-        }
-      }
-    }
-    return getStreamSecretsMethod;
-  }
-
-  private static volatile io.grpc.MethodDescriptor<io.envoyproxy.envoy.api.v2.DiscoveryRequest,
-      io.envoyproxy.envoy.api.v2.DiscoveryResponse> getFetchSecretsMethod;
-
-  @io.grpc.stub.annotations.RpcMethod(
-      fullMethodName = SERVICE_NAME + '/' + "FetchSecrets",
-      requestType = io.envoyproxy.envoy.api.v2.DiscoveryRequest.class,
-      responseType = io.envoyproxy.envoy.api.v2.DiscoveryResponse.class,
-      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
-  public static io.grpc.MethodDescriptor<io.envoyproxy.envoy.api.v2.DiscoveryRequest,
-      io.envoyproxy.envoy.api.v2.DiscoveryResponse> getFetchSecretsMethod() {
-    io.grpc.MethodDescriptor<io.envoyproxy.envoy.api.v2.DiscoveryRequest, io.envoyproxy.envoy.api.v2.DiscoveryResponse> getFetchSecretsMethod;
-    if ((getFetchSecretsMethod = SecretDiscoveryServiceGrpc.getFetchSecretsMethod) == null) {
-      synchronized (SecretDiscoveryServiceGrpc.class) {
-        if ((getFetchSecretsMethod = SecretDiscoveryServiceGrpc.getFetchSecretsMethod) == null) {
-          SecretDiscoveryServiceGrpc.getFetchSecretsMethod = getFetchSecretsMethod =
-              io.grpc.MethodDescriptor.<io.envoyproxy.envoy.api.v2.DiscoveryRequest, io.envoyproxy.envoy.api.v2.DiscoveryResponse>newBuilder()
-              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
-              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "FetchSecrets"))
-              .setSampledToLocalTracing(true)
-              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
-                  io.envoyproxy.envoy.api.v2.DiscoveryRequest.getDefaultInstance()))
-              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
-                  io.envoyproxy.envoy.api.v2.DiscoveryResponse.getDefaultInstance()))
-              .setSchemaDescriptor(new SecretDiscoveryServiceMethodDescriptorSupplier("FetchSecrets"))
-              .build();
-        }
-      }
-    }
-    return getFetchSecretsMethod;
-  }
-
-  /**
-   * Creates a new async stub that supports all call types for the service
-   */
-  public static SecretDiscoveryServiceStub newStub(io.grpc.Channel channel) {
-    io.grpc.stub.AbstractStub.StubFactory<SecretDiscoveryServiceStub> factory =
-      new io.grpc.stub.AbstractStub.StubFactory<SecretDiscoveryServiceStub>() {
-        @java.lang.Override
-        public SecretDiscoveryServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
-          return new SecretDiscoveryServiceStub(channel, callOptions);
-        }
-      };
-    return SecretDiscoveryServiceStub.newStub(factory, channel);
-  }
-
-  /**
-   * Creates a new blocking-style stub that supports unary and streaming output calls on the service
-   */
-  public static SecretDiscoveryServiceBlockingStub newBlockingStub(
-      io.grpc.Channel channel) {
-    io.grpc.stub.AbstractStub.StubFactory<SecretDiscoveryServiceBlockingStub> factory =
-      new io.grpc.stub.AbstractStub.StubFactory<SecretDiscoveryServiceBlockingStub>() {
-        @java.lang.Override
-        public SecretDiscoveryServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
-          return new SecretDiscoveryServiceBlockingStub(channel, callOptions);
-        }
-      };
-    return SecretDiscoveryServiceBlockingStub.newStub(factory, channel);
-  }
-
-  /**
-   * Creates a new ListenableFuture-style stub that supports unary calls on the service
-   */
-  public static SecretDiscoveryServiceFutureStub newFutureStub(
-      io.grpc.Channel channel) {
-    io.grpc.stub.AbstractStub.StubFactory<SecretDiscoveryServiceFutureStub> factory =
-      new io.grpc.stub.AbstractStub.StubFactory<SecretDiscoveryServiceFutureStub>() {
-        @java.lang.Override
-        public SecretDiscoveryServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
-          return new SecretDiscoveryServiceFutureStub(channel, callOptions);
-        }
-      };
-    return SecretDiscoveryServiceFutureStub.newStub(factory, channel);
-  }
-
-  /**
-   */
-  public static abstract class SecretDiscoveryServiceImplBase implements io.grpc.BindableService {
-
-    /**
-     */
-    public io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DeltaDiscoveryRequest> deltaSecrets(
-        io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse> responseObserver) {
-      return io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall(getDeltaSecretsMethod(), responseObserver);
-    }
-
-    /**
-     */
-    public io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DiscoveryRequest> streamSecrets(
-        io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DiscoveryResponse> responseObserver) {
-      return io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall(getStreamSecretsMethod(), responseObserver);
-    }
-
-    /**
-     */
-    public void fetchSecrets(io.envoyproxy.envoy.api.v2.DiscoveryRequest request,
-        io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DiscoveryResponse> responseObserver) {
-      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getFetchSecretsMethod(), responseObserver);
-    }
-
-    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
-      return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
-          .addMethod(
-            getDeltaSecretsMethod(),
-            io.grpc.stub.ServerCalls.asyncBidiStreamingCall(
-              new MethodHandlers<
-                io.envoyproxy.envoy.api.v2.DeltaDiscoveryRequest,
-                io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse>(
-                  this, METHODID_DELTA_SECRETS)))
-          .addMethod(
-            getStreamSecretsMethod(),
-            io.grpc.stub.ServerCalls.asyncBidiStreamingCall(
-              new MethodHandlers<
-                io.envoyproxy.envoy.api.v2.DiscoveryRequest,
-                io.envoyproxy.envoy.api.v2.DiscoveryResponse>(
-                  this, METHODID_STREAM_SECRETS)))
-          .addMethod(
-            getFetchSecretsMethod(),
-            io.grpc.stub.ServerCalls.asyncUnaryCall(
-              new MethodHandlers<
-                io.envoyproxy.envoy.api.v2.DiscoveryRequest,
-                io.envoyproxy.envoy.api.v2.DiscoveryResponse>(
-                  this, METHODID_FETCH_SECRETS)))
-          .build();
-    }
-  }
-
-  /**
-   */
-  public static final class SecretDiscoveryServiceStub extends io.grpc.stub.AbstractAsyncStub<SecretDiscoveryServiceStub> {
-    private SecretDiscoveryServiceStub(
-        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
-      super(channel, callOptions);
-    }
-
-    @java.lang.Override
-    protected SecretDiscoveryServiceStub build(
-        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
-      return new SecretDiscoveryServiceStub(channel, callOptions);
-    }
-
-    /**
-     */
-    public io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DeltaDiscoveryRequest> deltaSecrets(
-        io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse> responseObserver) {
-      return io.grpc.stub.ClientCalls.asyncBidiStreamingCall(
-          getChannel().newCall(getDeltaSecretsMethod(), getCallOptions()), responseObserver);
-    }
-
-    /**
-     */
-    public io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DiscoveryRequest> streamSecrets(
-        io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DiscoveryResponse> responseObserver) {
-      return io.grpc.stub.ClientCalls.asyncBidiStreamingCall(
-          getChannel().newCall(getStreamSecretsMethod(), getCallOptions()), responseObserver);
-    }
-
-    /**
-     */
-    public void fetchSecrets(io.envoyproxy.envoy.api.v2.DiscoveryRequest request,
-        io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DiscoveryResponse> responseObserver) {
-      io.grpc.stub.ClientCalls.asyncUnaryCall(
-          getChannel().newCall(getFetchSecretsMethod(), getCallOptions()), request, responseObserver);
-    }
-  }
-
-  /**
-   */
-  public static final class SecretDiscoveryServiceBlockingStub extends io.grpc.stub.AbstractBlockingStub<SecretDiscoveryServiceBlockingStub> {
-    private SecretDiscoveryServiceBlockingStub(
-        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
-      super(channel, callOptions);
-    }
-
-    @java.lang.Override
-    protected SecretDiscoveryServiceBlockingStub build(
-        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
-      return new SecretDiscoveryServiceBlockingStub(channel, callOptions);
-    }
-
-    /**
-     */
-    public io.envoyproxy.envoy.api.v2.DiscoveryResponse fetchSecrets(io.envoyproxy.envoy.api.v2.DiscoveryRequest request) {
-      return io.grpc.stub.ClientCalls.blockingUnaryCall(
-          getChannel(), getFetchSecretsMethod(), getCallOptions(), request);
-    }
-  }
-
-  /**
-   */
-  public static final class SecretDiscoveryServiceFutureStub extends io.grpc.stub.AbstractFutureStub<SecretDiscoveryServiceFutureStub> {
-    private SecretDiscoveryServiceFutureStub(
-        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
-      super(channel, callOptions);
-    }
-
-    @java.lang.Override
-    protected SecretDiscoveryServiceFutureStub build(
-        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
-      return new SecretDiscoveryServiceFutureStub(channel, callOptions);
-    }
-
-    /**
-     */
-    public com.google.common.util.concurrent.ListenableFuture<io.envoyproxy.envoy.api.v2.DiscoveryResponse> fetchSecrets(
-        io.envoyproxy.envoy.api.v2.DiscoveryRequest request) {
-      return io.grpc.stub.ClientCalls.futureUnaryCall(
-          getChannel().newCall(getFetchSecretsMethod(), getCallOptions()), request);
-    }
-  }
-
-  private static final int METHODID_FETCH_SECRETS = 0;
-  private static final int METHODID_DELTA_SECRETS = 1;
-  private static final int METHODID_STREAM_SECRETS = 2;
-
-  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 SecretDiscoveryServiceImplBase serviceImpl;
-    private final int methodId;
-
-    MethodHandlers(SecretDiscoveryServiceImplBase 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_SECRETS:
-          serviceImpl.fetchSecrets((io.envoyproxy.envoy.api.v2.DiscoveryRequest) request,
-              (io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DiscoveryResponse>) 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_DELTA_SECRETS:
-          return (io.grpc.stub.StreamObserver<Req>) serviceImpl.deltaSecrets(
-              (io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DeltaDiscoveryResponse>) responseObserver);
-        case METHODID_STREAM_SECRETS:
-          return (io.grpc.stub.StreamObserver<Req>) serviceImpl.streamSecrets(
-              (io.grpc.stub.StreamObserver<io.envoyproxy.envoy.api.v2.DiscoveryResponse>) responseObserver);
-        default:
-          throw new AssertionError();
-      }
-    }
-  }
-
-  private static abstract class SecretDiscoveryServiceBaseDescriptorSupplier
-      implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier {
-    SecretDiscoveryServiceBaseDescriptorSupplier() {}
-
-    @java.lang.Override
-    public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
-      return io.envoyproxy.envoy.service.discovery.v2.SdsProto.getDescriptor();
-    }
-
-    @java.lang.Override
-    public com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() {
-      return getFileDescriptor().findServiceByName("SecretDiscoveryService");
-    }
-  }
-
-  private static final class SecretDiscoveryServiceFileDescriptorSupplier
-      extends SecretDiscoveryServiceBaseDescriptorSupplier {
-    SecretDiscoveryServiceFileDescriptorSupplier() {}
-  }
-
-  private static final class SecretDiscoveryServiceMethodDescriptorSupplier
-      extends SecretDiscoveryServiceBaseDescriptorSupplier
-      implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
-    private final String methodName;
-
-    SecretDiscoveryServiceMethodDescriptorSupplier(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 (SecretDiscoveryServiceGrpc.class) {
-        result = serviceDescriptor;
-        if (result == null) {
-          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
-              .setSchemaDescriptor(new SecretDiscoveryServiceFileDescriptorSupplier())
-              .addMethod(getDeltaSecretsMethod())
-              .addMethod(getStreamSecretsMethod())
-              .addMethod(getFetchSecretsMethod())
-              .build();
-        }
-      }
-    }
-    return result;
-  }
-}
diff --git a/xds/src/generated/main/grpc/io/envoyproxy/envoy/service/discovery/v3/AggregatedDiscoveryServiceGrpc.java b/xds/src/generated/main/grpc/io/envoyproxy/envoy/service/discovery/v3/AggregatedDiscoveryServiceGrpc.java
deleted file mode 100644
index 80f88463a66..00000000000
--- a/xds/src/generated/main/grpc/io/envoyproxy/envoy/service/discovery/v3/AggregatedDiscoveryServiceGrpc.java
+++ /dev/null
@@ -1,363 +0,0 @@
-package io.envoyproxy.envoy.service.discovery.v3;
-
-import static io.grpc.MethodDescriptor.generateFullMethodName;
-
-/**
- * <pre>
- * See https://github.com/lyft/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>
- */
-@javax.annotation.Generated(
-    value = "by gRPC proto compiler",
-    comments = "Source: envoy/service/discovery/v3/ads.proto")
-public final class AggregatedDiscoveryServiceGrpc {
-
-  private AggregatedDiscoveryServiceGrpc() {}
-
-  public static final 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 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/lyft/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 {
-
-    /**
-     * <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.ServerCalls.asyncUnimplementedStreamingCall(getStreamAggregatedResourcesMethod(), 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.ServerCalls.asyncUnimplementedStreamingCall(getDeltaAggregatedResourcesMethod(), responseObserver);
-    }
-
-    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
-      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>(
-                  this, 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>(
-                  this, METHODID_DELTA_AGGREGATED_RESOURCES)))
-          .build();
-    }
-  }
-
-  /**
-   * <pre>
-   * See https://github.com/lyft/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);
-    }
-  }
-
-  /**
-   * <pre>
-   * See https://github.com/lyft/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);
-    }
-  }
-
-  /**
-   * <pre>
-   * See https://github.com/lyft/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 AggregatedDiscoveryServiceImplBase serviceImpl;
-    private final int methodId;
-
-    MethodHandlers(AggregatedDiscoveryServiceImplBase 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();
-      }
-    }
-  }
-
-  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 String methodName;
-
-    AggregatedDiscoveryServiceMethodDescriptorSupplier(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/main/grpc/io/envoyproxy/envoy/service/load_stats/v2/LoadReportingServiceGrpc.java b/xds/src/generated/main/grpc/io/envoyproxy/envoy/service/load_stats/v2/LoadReportingServiceGrpc.java
deleted file mode 100644
index 631fc417642..00000000000
--- a/xds/src/generated/main/grpc/io/envoyproxy/envoy/service/load_stats/v2/LoadReportingServiceGrpc.java
+++ /dev/null
@@ -1,317 +0,0 @@
-package io.envoyproxy.envoy.service.load_stats.v2;
-
-import static io.grpc.MethodDescriptor.generateFullMethodName;
-
-/**
- */
-@javax.annotation.Generated(
-    value = "by gRPC proto compiler",
-    comments = "Source: envoy/service/load_stats/v2/lrs.proto")
-public final class LoadReportingServiceGrpc {
-
-  private LoadReportingServiceGrpc() {}
-
-  public static final String SERVICE_NAME = "envoy.service.load_stats.v2.LoadReportingService";
-
-  // Static method descriptors that strictly reflect the proto.
-  private static volatile io.grpc.MethodDescriptor<io.envoyproxy.envoy.service.load_stats.v2.LoadStatsRequest,
-      io.envoyproxy.envoy.service.load_stats.v2.LoadStatsResponse> getStreamLoadStatsMethod;
-
-  @io.grpc.stub.annotations.RpcMethod(
-      fullMethodName = SERVICE_NAME + '/' + "StreamLoadStats",
-      requestType = io.envoyproxy.envoy.service.load_stats.v2.LoadStatsRequest.class,
-      responseType = io.envoyproxy.envoy.service.load_stats.v2.LoadStatsResponse.class,
-      methodType = io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
-  public static io.grpc.MethodDescriptor<io.envoyproxy.envoy.service.load_stats.v2.LoadStatsRequest,
-      io.envoyproxy.envoy.service.load_stats.v2.LoadStatsResponse> getStreamLoadStatsMethod() {
-    io.grpc.MethodDescriptor<io.envoyproxy.envoy.service.load_stats.v2.LoadStatsRequest, io.envoyproxy.envoy.service.load_stats.v2.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.v2.LoadStatsRequest, io.envoyproxy.envoy.service.load_stats.v2.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.v2.LoadStatsRequest.getDefaultInstance()))
-              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
-                  io.envoyproxy.envoy.service.load_stats.v2.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 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 static abstract class LoadReportingServiceImplBase implements io.grpc.BindableService {
-
-    /**
-     * <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.v2.LoadStatsRequest> streamLoadStats(
-        io.grpc.stub.StreamObserver<io.envoyproxy.envoy.service.load_stats.v2.LoadStatsResponse> responseObserver) {
-      return io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall(getStreamLoadStatsMethod(), responseObserver);
-    }
-
-    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
-      return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
-          .addMethod(
-            getStreamLoadStatsMethod(),
-            io.grpc.stub.ServerCalls.asyncBidiStreamingCall(
-              new MethodHandlers<
-                io.envoyproxy.envoy.service.load_stats.v2.LoadStatsRequest,
-                io.envoyproxy.envoy.service.load_stats.v2.LoadStatsResponse>(
-                  this, METHODID_STREAM_LOAD_STATS)))
-          .build();
-    }
-  }
-
-  /**
-   */
-  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.v2.LoadStatsRequest> streamLoadStats(
-        io.grpc.stub.StreamObserver<io.envoyproxy.envoy.service.load_stats.v2.LoadStatsResponse> responseObserver) {
-      return io.grpc.stub.ClientCalls.asyncBidiStreamingCall(
-          getChannel().newCall(getStreamLoadStatsMethod(), getCallOptions()), responseObserver);
-    }
-  }
-
-  /**
-   */
-  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);
-    }
-  }
-
-  /**
-   */
-  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 LoadReportingServiceImplBase serviceImpl;
-    private final int methodId;
-
-    MethodHandlers(LoadReportingServiceImplBase 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.v2.LoadStatsResponse>) responseObserver);
-        default:
-          throw new AssertionError();
-      }
-    }
-  }
-
-  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.v2.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 String methodName;
-
-    LoadReportingServiceMethodDescriptorSupplier(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/main/grpc/io/envoyproxy/envoy/service/load_stats/v3/LoadReportingServiceGrpc.java b/xds/src/generated/main/grpc/io/envoyproxy/envoy/service/load_stats/v3/LoadReportingServiceGrpc.java
deleted file mode 100644
index db40989ed00..00000000000
--- a/xds/src/generated/main/grpc/io/envoyproxy/envoy/service/load_stats/v3/LoadReportingServiceGrpc.java
+++ /dev/null
@@ -1,317 +0,0 @@
-package io.envoyproxy.envoy.service.load_stats.v3;
-
-import static io.grpc.MethodDescriptor.generateFullMethodName;
-
-/**
- */
-@javax.annotation.Generated(
-    value = "by gRPC proto compiler",
-    comments = "Source: envoy/service/load_stats/v3/lrs.proto")
-public final class LoadReportingServiceGrpc {
-
-  private LoadReportingServiceGrpc() {}
-
-  public static final 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 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 static abstract class LoadReportingServiceImplBase implements io.grpc.BindableService {
-
-    /**
-     * <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.ServerCalls.asyncUnimplementedStreamingCall(getStreamLoadStatsMethod(), responseObserver);
-    }
-
-    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
-      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>(
-                  this, METHODID_STREAM_LOAD_STATS)))
-          .build();
-    }
-  }
-
-  /**
-   */
-  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);
-    }
-  }
-
-  /**
-   */
-  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);
-    }
-  }
-
-  /**
-   */
-  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 LoadReportingServiceImplBase serviceImpl;
-    private final int methodId;
-
-    MethodHandlers(LoadReportingServiceImplBase 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();
-      }
-    }
-  }
-
-  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 String methodName;
-
-    LoadReportingServiceMethodDescriptorSupplier(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/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/AbstractXdsClient.java b/xds/src/main/java/io/grpc/xds/AbstractXdsClient.java
deleted file mode 100644
index 9470b67acc8..00000000000
--- a/xds/src/main/java/io/grpc/xds/AbstractXdsClient.java
+++ /dev/null
@@ -1,718 +0,0 @@
-/*
- * 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 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.ManagedChannel;
-import io.grpc.Status;
-import io.grpc.SynchronizationContext;
-import io.grpc.SynchronizationContext.ScheduledHandle;
-import io.grpc.internal.BackoffPolicy;
-import io.grpc.stub.StreamObserver;
-import io.grpc.xds.EnvoyProtoData.Node;
-import io.grpc.xds.XdsLogger.XdsLogLevel;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.List;
-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.
- */
-abstract class AbstractXdsClient extends XdsClient {
-
-  private static final String ADS_TYPE_URL_LDS_V2 = "type.googleapis.com/envoy.api.v2.Listener";
-  private static final String ADS_TYPE_URL_LDS =
-      "type.googleapis.com/envoy.config.listener.v3.Listener";
-  private static final String ADS_TYPE_URL_RDS_V2 =
-      "type.googleapis.com/envoy.api.v2.RouteConfiguration";
-  private static final String ADS_TYPE_URL_RDS =
-      "type.googleapis.com/envoy.config.route.v3.RouteConfiguration";
-  @VisibleForTesting
-  static final String ADS_TYPE_URL_CDS_V2 = "type.googleapis.com/envoy.api.v2.Cluster";
-  private static final String ADS_TYPE_URL_CDS =
-      "type.googleapis.com/envoy.config.cluster.v3.Cluster";
-  private static final String ADS_TYPE_URL_EDS_V2 =
-      "type.googleapis.com/envoy.api.v2.ClusterLoadAssignment";
-  private static final String ADS_TYPE_URL_EDS =
-      "type.googleapis.com/envoy.config.endpoint.v3.ClusterLoadAssignment";
-
-  private final SynchronizationContext syncContext = new SynchronizationContext(
-      new Thread.UncaughtExceptionHandler() {
-        @Override
-        public void uncaughtException(Thread t, Throwable e) {
-          getLogger().log(
-              XdsLogLevel.ERROR,
-              "Uncaught exception in XdsClient SynchronizationContext. Panic!",
-              e);
-          // TODO(chengyuanzhang): better error handling.
-          throw new AssertionError(e);
-        }
-      });
-  private final MessagePrinter msgPrinter = new MessagePrinter();
-  private final InternalLogId logId;
-  private final XdsLogger logger;
-  private final ManagedChannel channel;
-  private final boolean useProtocolV3;
-  private final ScheduledExecutorService timeService;
-  private final BackoffPolicy.Provider backoffPolicyProvider;
-  private final Stopwatch stopwatch;
-  // The node identifier to be included in xDS requests. Management server only requires the
-  // first request to carry the node identifier on a stream. It should be identical if present
-  // more than once.
-  // FIXME(chengyuanzhang): should immutable and invisible to child classes. Currently server side
-  //  has some protocol workaround usages.
-  protected Node node;
-
-  // 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 String ldsVersion = "";
-  private String rdsVersion = "";
-  private String cdsVersion = "";
-  private String edsVersion = "";
-
-  private boolean shutdown;
-  @Nullable
-  private AbstractAdsStream adsStream;
-  @Nullable
-  private BackoffPolicy retryBackoffPolicy;
-  @Nullable
-  private ScheduledHandle rpcRetryTimer;
-
-  AbstractXdsClient(ManagedChannel channel, boolean useProtocolV3, Node node,
-      ScheduledExecutorService timeService, BackoffPolicy.Provider backoffPolicyProvider,
-      Supplier<Stopwatch> stopwatchSupplier) {
-    this.channel = checkNotNull(channel, "channel");
-    this.useProtocolV3 = useProtocolV3;
-    this.node = checkNotNull(node, "node");
-    this.timeService = checkNotNull(timeService, "timeService");
-    this.backoffPolicyProvider = checkNotNull(backoffPolicyProvider, "backoffPolicyProvider");
-    stopwatch = checkNotNull(stopwatchSupplier, "stopwatchSupplier").get();
-    logId = InternalLogId.allocate("xds-client", null);
-    logger = XdsLogger.withLogId(logId);
-    logger.log(XdsLogLevel.INFO, "Created");
-  }
-
-  /**
-   * Called when an LDS response is received.
-   */
-  // Must be synchronized.
-  protected void handleLdsResponse(String versionInfo, List<Any> resources, String nonce) {
-  }
-
-  /**
-   * Called when a RDS response is received.
-   */
-  // Must be synchronized.
-  protected void handleRdsResponse(String versionInfo, List<Any> resources, String nonce) {
-  }
-
-  /**
-   * Called when a CDS response is received.
-   */
-  // Must be synchronized.
-  protected void handleCdsResponse(String versionInfo, List<Any> resources, String nonce) {
-  }
-
-  /**
-   * Called when an EDS response is received.
-   */
-  // Must be synchronized.
-  protected void handleEdsResponse(String versionInfo, List<Any> resources, String nonce) {
-  }
-
-  /**
-   * Called when the ADS stream is closed passively.
-   */
-  // Must be synchronized.
-  protected void handleStreamClosed(Status error) {
-  }
-
-  /**
-   * Called when the ADS stream has been recreated.
-   */
-  // Must be synchronized.
-  protected void handleStreamRestarted() {
-  }
-
-  /**
-   * Called when being shut down.
-   */
-  // Must be synchronized.
-  protected void handleShutdown() {
-  }
-
-  @Override
-  final 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();
-        }
-        handleShutdown();
-      }
-    });
-  }
-
-  @Override
-  boolean isShutDown() {
-    return shutdown;
-  }
-
-  @Override
-  public String toString() {
-    return logId.toString();
-  }
-
-  /**
-   * Returns the collection of resources currently subscribing to or {@code null} if not
-   * subscribing to any resources for the given type.
-   *
-   * <p>Note an empty collection indicates subscribing to resources of the given type with
-   * wildcard mode.
-   */
-  // Must be synchronized.
-  @Nullable
-  abstract Collection<String> getSubscribedResources(ResourceType type);
-
-  /**
-   * Updates the resource subscription for the given resource type.
-   */
-  // Must be synchronized.
-  protected final void adjustResourceSubscription(ResourceType type) {
-    if (isInBackoff()) {
-      return;
-    }
-    if (adsStream == null) {
-      startRpcStream();
-    }
-    Collection<String> resources = getSubscribedResources(type);
-    if (resources != null) {
-      adsStream.sendDiscoveryRequest(type, resources);
-    }
-  }
-
-  /**
-   * 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.
-  protected final void ackResponse(ResourceType type, String versionInfo, String nonce) {
-    switch (type) {
-      case LDS:
-        ldsVersion = versionInfo;
-        break;
-      case RDS:
-        rdsVersion = versionInfo;
-        break;
-      case CDS:
-        cdsVersion = versionInfo;
-        break;
-      case EDS:
-        edsVersion = versionInfo;
-        break;
-      case UNKNOWN:
-      default:
-        throw new AssertionError("Unknown resource type: " + type);
-    }
-    logger.log(XdsLogLevel.INFO, "Sending ACK for {0} update, nonce: {1}, current version: {2}",
-        type, nonce, versionInfo);
-    Collection<String> resources = getSubscribedResources(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.
-  protected final void nackResponse(ResourceType type, String nonce, String errorDetail) {
-    String versionInfo = getCurrentVersion(type);
-    logger.log(XdsLogLevel.INFO, "Sending NACK for {0} update, nonce: {1}, current version: {2}",
-        type, nonce, versionInfo);
-    Collection<String> resources = getSubscribedResources(type);
-    if (resources == null) {
-      resources = Collections.emptyList();
-    }
-    adsStream.sendDiscoveryRequest(type, versionInfo, resources, nonce, errorDetail);
-  }
-
-  protected final SynchronizationContext getSyncContext() {
-    return syncContext;
-  }
-
-  protected final ScheduledExecutorService getTimeService() {
-    return timeService;
-  }
-
-  protected final XdsLogger getLogger() {
-    return logger;
-  }
-
-  /**
-   * Returns {@code true} if the resource discovery is currently in backoff.
-   */
-  // Must be synchronized.
-  protected final boolean isInBackoff() {
-    return rpcRetryTimer != null && rpcRetryTimer.isPending();
-  }
-
-  /**
-   * 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 (useProtocolV3) {
-      adsStream = new AdsStreamV3();
-    } else {
-      adsStream = new AdsStreamV2();
-    }
-    adsStream.start();
-    logger.log(XdsLogLevel.INFO, "ADS stream started");
-    stopwatch.reset().start();
-  }
-
-  /**
-   * Returns the latest accepted version of the given resource type.
-   */
-  // Must be synchronized.
-  private String getCurrentVersion(ResourceType type) {
-    String version;
-    switch (type) {
-      case LDS:
-        version = ldsVersion;
-        break;
-      case RDS:
-        version = rdsVersion;
-        break;
-      case CDS:
-        version = cdsVersion;
-        break;
-      case EDS:
-        version = edsVersion;
-        break;
-      case UNKNOWN:
-      default:
-        throw new AssertionError("Unknown resource type: " + type);
-    }
-    return version;
-  }
-
-  @VisibleForTesting
-  final class RpcRetryTask implements Runnable {
-    @Override
-    public void run() {
-      if (shutdown) {
-        return;
-      }
-      startRpcStream();
-      for (ResourceType type : ResourceType.values()) {
-        if (type == ResourceType.UNKNOWN) {
-          continue;
-        }
-        Collection<String> resources = getSubscribedResources(type);
-        if (resources != null) {
-          adsStream.sendDiscoveryRequest(type, resources);
-        }
-      }
-      handleStreamRestarted();
-    }
-  }
-
-  protected enum ResourceType {
-    UNKNOWN, LDS, RDS, CDS, EDS;
-
-    String typeUrl() {
-      switch (this) {
-        case LDS:
-          return ADS_TYPE_URL_LDS;
-        case RDS:
-          return ADS_TYPE_URL_RDS;
-        case CDS:
-          return ADS_TYPE_URL_CDS;
-        case EDS:
-          return ADS_TYPE_URL_EDS;
-        case UNKNOWN:
-        default:
-          throw new AssertionError("Unknown or missing case in enum switch: " + this);
-      }
-    }
-
-    String typeUrlV2() {
-      switch (this) {
-        case LDS:
-          return ADS_TYPE_URL_LDS_V2;
-        case RDS:
-          return ADS_TYPE_URL_RDS_V2;
-        case CDS:
-          return ADS_TYPE_URL_CDS_V2;
-        case EDS:
-          return ADS_TYPE_URL_EDS_V2;
-        case UNKNOWN:
-        default:
-          throw new AssertionError("Unknown or missing case in enum switch: " + this);
-      }
-    }
-
-    private static ResourceType fromTypeUrl(String typeUrl) {
-      switch (typeUrl) {
-        case ADS_TYPE_URL_LDS:
-          // fall trough
-        case ADS_TYPE_URL_LDS_V2:
-          return LDS;
-        case ADS_TYPE_URL_RDS:
-          // fall through
-        case ADS_TYPE_URL_RDS_V2:
-          return RDS;
-        case ADS_TYPE_URL_CDS:
-          // fall through
-        case ADS_TYPE_URL_CDS_V2:
-          return CDS;
-        case ADS_TYPE_URL_EDS:
-          // fall through
-        case ADS_TYPE_URL_EDS_V2:
-          return EDS;
-        default:
-          return UNKNOWN;
-      }
-    }
-  }
-
-  private abstract class AbstractAdsStream {
-    private boolean responseReceived;
-    private boolean closed;
-
-    // Response nonce for the most recently received discovery responses of each resource type.
-    // Client initiated requests start response nonce with empty string.
-    // A nonce is used to indicate the specific DiscoveryResponse each DiscoveryRequest
-    // corresponds to.
-    // A nonce becomes stale following a newer nonce being presented to the client in a
-    // DiscoveryResponse.
-    private String ldsRespNonce = "";
-    private String rdsRespNonce = "";
-    private String cdsRespNonce = "";
-    private String edsRespNonce = "";
-
-    abstract void start();
-
-    abstract void sendError(Exception error);
-
-    /**
-     * 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(ResourceType, Collection)}.
-     */
-    abstract void sendDiscoveryRequest(ResourceType type, String versionInfo,
-        Collection<String> resources, String nonce, @Nullable String errorDetail);
-
-    /**
-     * Sends a client-initiated discovery request.
-     */
-    final void sendDiscoveryRequest(ResourceType type, Collection<String> resources) {
-      String nonce;
-      switch (type) {
-        case LDS:
-          nonce = ldsRespNonce;
-          break;
-        case RDS:
-          nonce = rdsRespNonce;
-          break;
-        case CDS:
-          nonce = cdsRespNonce;
-          break;
-        case EDS:
-          nonce = edsRespNonce;
-          break;
-        case UNKNOWN:
-        default:
-          throw new AssertionError("Unknown resource type: " + type);
-      }
-      logger.log(XdsLogLevel.INFO, "Sending {0} request for resources: {1}", type, resources);
-      sendDiscoveryRequest(type, getCurrentVersion(type), resources, nonce, null);
-    }
-
-    final void handleRpcResponse(
-        ResourceType type, String versionInfo, List<Any> resources, String nonce) {
-      if (closed) {
-        return;
-      }
-      responseReceived = true;
-      // 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.
-      switch (type) {
-        case LDS:
-          ldsRespNonce = nonce;
-          handleLdsResponse(versionInfo, resources, nonce);
-          break;
-        case RDS:
-          rdsRespNonce = nonce;
-          handleRdsResponse(versionInfo, resources, nonce);
-          break;
-        case CDS:
-          cdsRespNonce = nonce;
-          handleCdsResponse(versionInfo, resources, nonce);
-          break;
-        case EDS:
-          edsRespNonce = nonce;
-          handleEdsResponse(versionInfo, resources, nonce);
-          break;
-        case UNKNOWN:
-        default:
-          logger.log(XdsLogLevel.WARNING, "Ignore an unknown type of DiscoveryResponse");
-      }
-    }
-
-    final void handleRpcError(Throwable t) {
-      handleRpcStreamClosed(Status.fromThrowable(t));
-    }
-
-    final void handleRpcCompleted() {
-      handleRpcStreamClosed(Status.UNAVAILABLE.withDescription("Closed by server"));
-    }
-
-    private void handleRpcStreamClosed(Status error) {
-      checkArgument(!error.isOk(), "unexpected OK status");
-      if (closed) {
-        return;
-      }
-      logger.log(
-          XdsLogLevel.ERROR,
-          "ADS stream closed with status {0}: {1}. Cause: {2}",
-          error.getCode(), error.getDescription(), error.getCause());
-      closed = true;
-      handleStreamClosed(error);
-      cleanUp();
-      if (responseReceived || retryBackoffPolicy == null) {
-        // Reset the backoff sequence if had received a response, or backoff sequence
-        // has never been initialized.
-        retryBackoffPolicy = backoffPolicyProvider.get();
-      }
-      long delayNanos = 0;
-      if (!responseReceived) {
-        delayNanos =
-            Math.max(
-                0,
-                retryBackoffPolicy.nextBackoffNanos()
-                    - stopwatch.elapsed(TimeUnit.NANOSECONDS));
-      }
-      logger.log(XdsLogLevel.INFO, "Retry ADS stream in {0} ns", delayNanos);
-      rpcRetryTimer = syncContext.schedule(
-          new RpcRetryTask(), delayNanos, TimeUnit.NANOSECONDS, timeService);
-    }
-
-    private void close(Exception error) {
-      if (closed) {
-        return;
-      }
-      closed = true;
-      cleanUp();
-      sendError(error);
-    }
-
-    private void cleanUp() {
-      if (adsStream == this) {
-        adsStream = null;
-      }
-    }
-  }
-
-  private final class AdsStreamV2 extends AbstractAdsStream {
-    private StreamObserver<io.envoyproxy.envoy.api.v2.DiscoveryRequest> requestWriter;
-
-    @Override
-    void start() {
-      io.envoyproxy.envoy.service.discovery.v2.AggregatedDiscoveryServiceGrpc
-          .AggregatedDiscoveryServiceStub stub =
-          io.envoyproxy.envoy.service.discovery.v2.AggregatedDiscoveryServiceGrpc.newStub(channel);
-      StreamObserver<io.envoyproxy.envoy.api.v2.DiscoveryResponse> responseReaderV2 =
-          new StreamObserver<io.envoyproxy.envoy.api.v2.DiscoveryResponse>() {
-            @Override
-            public void onNext(final io.envoyproxy.envoy.api.v2.DiscoveryResponse response) {
-              syncContext.execute(new Runnable() {
-                @Override
-                public void run() {
-                  ResourceType type = ResourceType.fromTypeUrl(response.getTypeUrl());
-                  if (logger.isLoggable(XdsLogLevel.DEBUG)) {
-                    logger.log(XdsLogLevel.DEBUG, "Received {0} response:\n{1}",
-                        type, msgPrinter.print(response));
-                  }
-                  handleRpcResponse(type, response.getVersionInfo(), response.getResourcesList(),
-                      response.getNonce());
-                }
-              });
-            }
-
-            @Override
-            public void onError(final Throwable t) {
-              syncContext.execute(new Runnable() {
-                @Override
-                public void run() {
-                  handleRpcError(t);
-                }
-              });
-            }
-
-            @Override
-            public void onCompleted() {
-              syncContext.execute(new Runnable() {
-                @Override
-                public void run() {
-                  handleRpcCompleted();
-                }
-              });
-            }
-          };
-      requestWriter = stub.withWaitForReady().streamAggregatedResources(responseReaderV2);
-    }
-
-    @Override
-    void sendDiscoveryRequest(ResourceType type, String versionInfo, Collection<String> resources,
-        String nonce, @Nullable String errorDetail) {
-      checkState(requestWriter != null, "ADS stream has not been started");
-      io.envoyproxy.envoy.api.v2.DiscoveryRequest.Builder builder =
-          io.envoyproxy.envoy.api.v2.DiscoveryRequest.newBuilder()
-              .setVersionInfo(versionInfo)
-              .setNode(node.toEnvoyProtoNodeV2())
-              .addAllResourceNames(resources)
-              .setTypeUrl(type.typeUrlV2())
-              .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);
-      }
-      io.envoyproxy.envoy.api.v2.DiscoveryRequest request = builder.build();
-      requestWriter.onNext(request);
-      logger.log(XdsLogLevel.DEBUG, "Sent DiscoveryRequest\n{0}", msgPrinter.print(request));
-    }
-
-    @Override
-    void sendError(Exception error) {
-      requestWriter.onError(error);
-    }
-  }
-
-  private final class AdsStreamV3 extends AbstractAdsStream {
-    private StreamObserver<DiscoveryRequest> requestWriter;
-
-    @Override
-    void start() {
-      AggregatedDiscoveryServiceGrpc.AggregatedDiscoveryServiceStub stub =
-          AggregatedDiscoveryServiceGrpc.newStub(channel);
-      StreamObserver<DiscoveryResponse> responseReader = new StreamObserver<DiscoveryResponse>() {
-        @Override
-        public void onNext(final DiscoveryResponse response) {
-          syncContext.execute(new Runnable() {
-            @Override
-            public void run() {
-              ResourceType type = ResourceType.fromTypeUrl(response.getTypeUrl());
-              if (logger.isLoggable(XdsLogLevel.DEBUG)) {
-                logger.log(XdsLogLevel.DEBUG, "Received {0} response:\n{1}",
-                    type, msgPrinter.print(response));
-              }
-              handleRpcResponse(type, response.getVersionInfo(), response.getResourcesList(),
-                  response.getNonce());
-            }
-          });
-        }
-
-        @Override
-        public void onError(final Throwable t) {
-          syncContext.execute(new Runnable() {
-            @Override
-            public void run() {
-              handleRpcError(t);
-            }
-          });
-        }
-
-        @Override
-        public void onCompleted() {
-          syncContext.execute(new Runnable() {
-            @Override
-            public void run() {
-              handleRpcCompleted();
-            }
-          });
-        }
-      };
-      requestWriter = stub.withWaitForReady().streamAggregatedResources(responseReader);
-    }
-
-    @Override
-    void sendDiscoveryRequest(ResourceType type, String versionInfo, Collection<String> resources,
-        String nonce, @Nullable String errorDetail) {
-      checkState(requestWriter != null, "ADS stream has not been started");
-      DiscoveryRequest.Builder builder =
-          DiscoveryRequest.newBuilder()
-              .setVersionInfo(versionInfo)
-              .setNode(node.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();
-      requestWriter.onNext(request);
-      logger.log(XdsLogLevel.DEBUG, "Sent DiscoveryRequest\n{0}", msgPrinter.print(request));
-    }
-
-    @Override
-    void sendError(Exception error) {
-      requestWriter.onError(error);
-    }
-  }
-}
diff --git a/xds/src/main/java/io/grpc/xds/Bootstrapper.java b/xds/src/main/java/io/grpc/xds/Bootstrapper.java
deleted file mode 100644
index f3ccbf2d9df..00000000000
--- a/xds/src/main/java/io/grpc/xds/Bootstrapper.java
+++ /dev/null
@@ -1,147 +0,0 @@
-/*
- * 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.annotations.VisibleForTesting;
-import io.grpc.ChannelCredentials;
-import io.grpc.Internal;
-import io.grpc.xds.EnvoyProtoData.Node;
-import java.util.Collections;
-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 {
-
-  /**
-   * Returns system-loaded bootstrap configuration.
-   */
-  public abstract BootstrapInfo bootstrap() throws XdsInitializationException;
-
-  /**
-   * Returns bootstrap configuration given by the raw data in JSON format.
-   */
-  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.
-   */
-  @Internal
-  static class ServerInfo {
-    private final String target;
-    private final ChannelCredentials channelCredentials;
-    private final boolean useProtocolV3;
-
-    @VisibleForTesting
-    ServerInfo(String target, ChannelCredentials channelCredentials, boolean useProtocolV3) {
-      this.target = checkNotNull(target, "target");
-      this.channelCredentials = checkNotNull(channelCredentials, "channelCredentials");
-      this.useProtocolV3 = useProtocolV3;
-    }
-
-    String getTarget() {
-      return target;
-    }
-
-    ChannelCredentials getChannelCredentials() {
-      return channelCredentials;
-    }
-
-    boolean isUseProtocolV3() {
-      return useProtocolV3;
-    }
-  }
-
-  /**
-   * Data class containing Certificate provider information: the plugin-name and an opaque
-   * Map that represents the config for that plugin.
-   */
-  @Internal
-  public static class CertificateProviderInfo {
-    private final String pluginName;
-    private final Map<String, ?> config;
-
-    CertificateProviderInfo(String pluginName, Map<String, ?> config) {
-      this.pluginName = checkNotNull(pluginName, "pluginName");
-      this.config = checkNotNull(config, "config");
-    }
-
-    public String getPluginName() {
-      return pluginName;
-    }
-
-    public Map<String, ?> getConfig() {
-      return config;
-    }
-  }
-
-  /**
-   * Data class containing the results of reading bootstrap.
-   */
-  @Internal
-  public static class BootstrapInfo {
-    private List<ServerInfo> servers;
-    private final Node node;
-    @Nullable private final Map<String, CertificateProviderInfo> certProviders;
-    @Nullable private final String grpcServerResourceId;
-
-    @VisibleForTesting
-    BootstrapInfo(
-        List<ServerInfo> servers,
-        Node node,
-        Map<String, CertificateProviderInfo> certProviders,
-        String grpcServerResourceId) {
-      this.servers = servers;
-      this.node = node;
-      this.certProviders = certProviders;
-      this.grpcServerResourceId = grpcServerResourceId;
-    }
-
-    /**
-     * Returns the list of xDS servers to be connected to.
-     */
-    List<ServerInfo> getServers() {
-      return Collections.unmodifiableList(servers);
-    }
-
-    /**
-     * Returns the node identifier to be included in xDS requests.
-     */
-    public Node getNode() {
-      return node;
-    }
-
-    /** Returns the cert-providers config map. */
-    public Map<String, CertificateProviderInfo> getCertProviders() {
-      return Collections.unmodifiableMap(certProviders);
-    }
-
-    @Nullable
-    public String getGrpcServerResourceId() {
-      return grpcServerResourceId;
-    }
-  }
-}
diff --git a/xds/src/main/java/io/grpc/xds/BootstrapperImpl.java b/xds/src/main/java/io/grpc/xds/BootstrapperImpl.java
deleted file mode 100644
index 406baaf571f..00000000000
--- a/xds/src/main/java/io/grpc/xds/BootstrapperImpl.java
+++ /dev/null
@@ -1,272 +0,0 @@
-/*
- * 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.ChannelCredentials;
-import io.grpc.InsecureChannelCredentials;
-import io.grpc.Internal;
-import io.grpc.InternalLogId;
-import io.grpc.TlsChannelCredentials;
-import io.grpc.alts.GoogleDefaultChannelCredentials;
-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.EnvoyProtoData.Node;
-import io.grpc.xds.XdsLogger.XdsLogLevel;
-import java.io.IOException;
-import java.nio.charset.StandardCharsets;
-import java.nio.file.Files;
-import java.nio.file.Paths;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import javax.annotation.Nullable;
-
-/**
- * A {@link Bootstrapper} implementation that reads xDS configurations from local file system.
- */
-@Internal
-public class BootstrapperImpl extends Bootstrapper {
-
-  private static final String BOOTSTRAP_PATH_SYS_ENV_VAR = "GRPC_XDS_BOOTSTRAP";
-  @VisibleForTesting
-  static String bootstrapPathFromEnvVar = System.getenv(BOOTSTRAP_PATH_SYS_ENV_VAR);
-  private static final String BOOTSTRAP_PATH_SYS_PROPERTY = "io.grpc.xds.bootstrap";
-  @VisibleForTesting
-  static String bootstrapPathFromSysProp = System.getProperty(BOOTSTRAP_PATH_SYS_PROPERTY);
-  private static final String BOOTSTRAP_CONFIG_SYS_ENV_VAR = "GRPC_XDS_BOOTSTRAP_CONFIG";
-  @VisibleForTesting
-  static String bootstrapConfigFromEnvVar = System.getenv(BOOTSTRAP_CONFIG_SYS_ENV_VAR);
-  private static final String BOOTSTRAP_CONFIG_SYS_PROPERTY_VAR = "io.grpc.xds.bootstrapValue";
-  @VisibleForTesting
-  static String bootstrapConfigFromSysProp = System.getProperty(BOOTSTRAP_CONFIG_SYS_PROPERTY_VAR);
-  private static final String XDS_V3_SERVER_FEATURE = "xds_v3";
-  @VisibleForTesting
-  static final String CLIENT_FEATURE_DISABLE_OVERPROVISIONING =
-      "envoy.lb.does_not_support_overprovisioning";
-
-  private final XdsLogger logger;
-  private FileReader reader = LocalFileReader.INSTANCE;
-
-  public BootstrapperImpl() {
-    logger = XdsLogger.withLogId(InternalLogId.allocate("bootstrapper", null));
-  }
-
-  /**
-   * Reads and parses bootstrap config. 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.bootstrap_value"</li>
-   * </ol>
-   */
-  @SuppressWarnings("unchecked")
-  @Override
-  public BootstrapInfo bootstrap() throws XdsInitializationException {
-    String filePath =
-        bootstrapPathFromEnvVar != null ? bootstrapPathFromEnvVar : bootstrapPathFromSysProp;
-    String fileContent;
-    if (filePath != null) {
-      logger.log(XdsLogLevel.INFO, "Reading bootstrap file from {0}", filePath);
-      try {
-        fileContent = reader.readFile(filePath);
-      } catch (IOException e) {
-        throw new XdsInitializationException("Fail to read bootstrap file", e);
-      }
-    } else {
-      fileContent = bootstrapConfigFromEnvVar != null
-          ? bootstrapConfigFromEnvVar : bootstrapConfigFromSysProp;
-    }
-    if (fileContent == 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_VAR + "\n\n");
-    }
-
-    logger.log(XdsLogLevel.INFO, "Reading bootstrap from " + filePath);
-    Map<String, ?> rawBootstrap;
-    try {
-      rawBootstrap = (Map<String, ?>) JsonParser.parse(fileContent);
-    } catch (IOException e) {
-      throw new XdsInitializationException("Failed to parse JSON", e);
-    }
-    logger.log(XdsLogLevel.DEBUG, "Bootstrap configuration:\n{0}", rawBootstrap);
-    return bootstrap(rawBootstrap);
-  }
-
-  @Override
-  BootstrapInfo bootstrap(Map<String, ?> rawData) throws XdsInitializationException {
-    List<ServerInfo> servers = new ArrayList<>();
-    List<?> rawServerConfigs = JsonUtil.getList(rawData, "xds_servers");
-    if (rawServerConfigs == null) {
-      throw new XdsInitializationException("Invalid bootstrap: 'xds_servers' does not exist.");
-    }
-    logger.log(XdsLogLevel.INFO, "Configured with {0} xDS servers", rawServerConfigs.size());
-    // TODO(chengyuanzhang): require at least one server URI.
-    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);
-
-      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");
-      }
-
-      boolean useProtocolV3 = false;
-      List<String> serverFeatures = JsonUtil.getListOfStrings(serverConfig, "server_features");
-      if (serverFeatures != null) {
-        logger.log(XdsLogLevel.INFO, "Server features: {0}", serverFeatures);
-        useProtocolV3 = serverFeatures.contains(XDS_V3_SERVER_FEATURE);
-      }
-      servers.add(new ServerInfo(serverUri, channelCredentials, useProtocolV3));
-    }
-
-    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: {0}, subZone: {0}",
-            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);
-
-    Map<String, ?> certProvidersBlob = JsonUtil.getObject(rawData, "certificate_providers");
-    Map<String, CertificateProviderInfo> certProviders = null;
-    if (certProvidersBlob != null) {
-      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");
-        Map<String, ?> config = checkForNull(JsonUtil.getObject(valueMap, "config"), "config");
-        CertificateProviderInfo certificateProviderInfo =
-            new CertificateProviderInfo(pluginName, config);
-        certProviders.put(name, certificateProviderInfo);
-      }
-    }
-    String grpcServerResourceId = JsonUtil.getString(rawData, "grpc_server_resource_name_id");
-    return new BootstrapInfo(servers, nodeBuilder.build(), certProviders, grpcServerResourceId);
-  }
-
-  @VisibleForTesting
-  void setFileReader(FileReader reader) {
-    this.reader = reader;
-  }
-
-  /**
-   * Reads the content of the file with the given path in the file system.
-   */
-  interface FileReader {
-    String readFile(String path) throws IOException;
-  }
-
-  private 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;
-  }
-
-  @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");
-      }
-      switch (type) {
-        case "google_default":
-          return GoogleDefaultChannelCredentials.create();
-        case "insecure":
-          return InsecureChannelCredentials.create();
-        case "tls":
-          return TlsChannelCredentials.create();
-        default:
-      }
-    }
-    return null;
-  }
-}
diff --git a/xds/src/main/java/io/grpc/xds/CdsLoadBalancer2.java b/xds/src/main/java/io/grpc/xds/CdsLoadBalancer2.java
index 4ba0a32030e..f6ee60ab1ef 100644
--- a/xds/src/main/java/io/grpc/xds/CdsLoadBalancer2.java
+++ b/xds/src/main/java/io/grpc/xds/CdsLoadBalancer2.java
@@ -18,33 +18,58 @@
 
 import static com.google.common.base.Preconditions.checkNotNull;
 import static io.grpc.ConnectivityState.TRANSIENT_FAILURE;
-import static io.grpc.xds.XdsLbPolicies.CLUSTER_RESOLVER_POLICY_NAME;
+import static io.grpc.xds.XdsLbPolicies.CDS_POLICY_NAME;
+import static io.grpc.xds.XdsLbPolicies.PRIORITY_POLICY_NAME;
 
-import com.google.common.annotations.VisibleForTesting;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.primitives.UnsignedInts;
+import com.google.errorprone.annotations.CheckReturnValue;
+import io.grpc.Attributes;
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.HttpConnectProxiedSocketAddress;
+import io.grpc.InternalEquivalentAddressGroup;
 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.SynchronizationContext;
-import io.grpc.internal.ObjectPool;
-import io.grpc.internal.ServiceConfigUtil.PolicySelection;
+import io.grpc.StatusOr;
+import io.grpc.internal.GrpcUtil;
+import io.grpc.util.GracefulSwitchLoadBalancer;
+import io.grpc.util.OutlierDetectionLoadBalancer.OutlierDetectionLoadBalancerConfig;
 import io.grpc.xds.CdsLoadBalancerProvider.CdsConfig;
-import io.grpc.xds.ClusterResolverLoadBalancerProvider.ClusterResolverConfig;
-import io.grpc.xds.ClusterResolverLoadBalancerProvider.ClusterResolverConfig.DiscoveryMechanism;
-import io.grpc.xds.XdsClient.CdsResourceWatcher;
-import io.grpc.xds.XdsClient.CdsUpdate;
-import io.grpc.xds.XdsClient.CdsUpdate.ClusterType;
-import io.grpc.xds.XdsLogger.XdsLogLevel;
-import io.grpc.xds.XdsSubchannelPickers.ErrorPicker;
-import java.util.ArrayDeque;
+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.LinkedHashMap;
+import java.util.HashMap;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
-import java.util.Queue;
-import javax.annotation.Nullable;
+import java.util.Set;
+import java.util.TreeMap;
 
 /**
  * Load balancer for cds_experimental LB policy. One instance per top-level cluster.
@@ -52,267 +77,541 @@
  * by a group of sub-clusters in a tree hierarchy.
  */
 final class CdsLoadBalancer2 extends LoadBalancer {
+  static boolean pickFirstWeightedShuffling =
+      GrpcUtil.getFlag("GRPC_EXPERIMENTAL_PF_WEIGHTED_SHUFFLING", true);
+
   private final XdsLogger logger;
   private final Helper helper;
-  private final SynchronizationContext syncContext;
   private final LoadBalancerRegistry lbRegistry;
+  private final ClusterState clusterState = new ClusterState();
+  private GracefulSwitchLoadBalancer delegate;
   // Following fields are effectively final.
-  private ObjectPool<XdsClient> xdsClientPool;
-  private XdsClient xdsClient;
-  private CdsLbState cdsLbState;
-  private ResolvedAddresses resolvedAddresses;
-
-  CdsLoadBalancer2(Helper helper) {
-    this(helper, LoadBalancerRegistry.getDefaultRegistry());
-  }
+  private String clusterName;
+  private Subscription clusterSubscription;
 
-  @VisibleForTesting
   CdsLoadBalancer2(Helper helper, LoadBalancerRegistry lbRegistry) {
     this.helper = checkNotNull(helper, "helper");
-    this.syncContext = checkNotNull(helper.getSynchronizationContext(), "syncContext");
     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 void handleResolvedAddresses(ResolvedAddresses resolvedAddresses) {
-    if (this.resolvedAddresses != null) {
-      return;
-    }
+  public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
     logger.log(XdsLogLevel.DEBUG, "Received resolution result: {0}", resolvedAddresses);
-    this.resolvedAddresses = resolvedAddresses;
-    xdsClientPool = resolvedAddresses.getAttributes().get(InternalXdsAttributes.XDS_CLIENT_POOL);
-    xdsClient = xdsClientPool.getObject();
-    CdsConfig config = (CdsConfig) resolvedAddresses.getLoadBalancingPolicyConfig();
-    logger.log(XdsLogLevel.INFO, "Config: {0}", config);
-    cdsLbState = new CdsLbState(config.name);
-    cdsLbState.start();
+    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 (cdsLbState != null && cdsLbState.childLb != null) {
-      cdsLbState.childLb.handleNameResolutionError(error);
+    if (delegate != null) {
+      delegate.handleNameResolutionError(error);
     } else {
-      helper.updateBalancingState(TRANSIENT_FAILURE, new ErrorPicker(error));
+      helper.updateBalancingState(
+          TRANSIENT_FAILURE, new FixedResultPicker(PickResult.withError(error)));
     }
   }
 
   @Override
   public void shutdown() {
     logger.log(XdsLogLevel.INFO, "Shutdown");
-    if (cdsLbState != null) {
-      cdsLbState.shutdown();
-    }
-    if (xdsClientPool != null) {
-      xdsClientPool.returnObject(xdsClient);
+    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 + ": ";
+  }
+
   /**
-   * The state of a CDS working session of {@link CdsLoadBalancer2}. Created and started when
-   * receiving the CDS LB policy config with the top-level cluster name.
+   * The number of bits assigned to the fractional part of fixed-point values. We normalize weights
+   * to a fixed-point number between 0 and 1, representing that item's proportion of traffic (1 ==
+   * 100% of traffic). We reserve at least one bit for the whole number so that we don't need to
+   * special case a single item, and so that we can round up very low values without risking uint32
+   * overflow of the sum of weights.
    */
-  private final class CdsLbState {
-    private final ClusterState root;
-    private LoadBalancer childLb;
+  private static final int FIXED_POINT_FRACTIONAL_BITS = 31;
 
-    private CdsLbState(String rootCluster) {
-      root = new ClusterState(rootCluster);
-    }
+  /** Divide two uint32s and produce a fixed-point uint32 result. */
+  private static long fractionToFixedPoint(long numerator, long denominator) {
+    long one = 1L << FIXED_POINT_FRACTIONAL_BITS;
+    return numerator * one / denominator;
+  }
 
-    private void start() {
-      root.start();
-    }
+  /** Multiply two uint32 fixed-point numbers, returning a uint32 fixed-point. */
+  private static long fixedPointMultiply(long a, long b) {
+    return (a * b) >> FIXED_POINT_FRACTIONAL_BITS;
+  }
 
-    private void shutdown() {
-      root.shutdown();
+  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();
+  }
 
-    private void handleClusterDiscovered() {
-      List<DiscoveryMechanism> instances = new ArrayList<>();
-      // Level-order traversal.
-      // Collect configurations for all non-aggregate (leaf) clusters.
-      Queue<ClusterState> queue = new ArrayDeque<>();
-      queue.add(root);
-      while (!queue.isEmpty()) {
-        int size = queue.size();
-        for (int i = 0; i < size; i++) {
-          ClusterState clusterState = queue.remove();
-          if (!clusterState.discovered) {
-            return;  // do not proceed until all clusters discovered
+  /**
+   * 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);
+      Map<String, Long> priorityLocalityWeightSums;
+      if (pickFirstWeightedShuffling) {
+        priorityLocalityWeightSums = new HashMap<>(sortedPriorityNames.size() * 2);
+        for (Locality locality : localityLbEndpoints.keySet()) {
+          LocalityLbEndpoints localityLbInfo = localityLbEndpoints.get(locality);
+          String priorityName = localityPriorityNames.get(locality);
+          Long sum = priorityLocalityWeightSums.get(priorityName);
+          if (sum == null) {
+            sum = 0L;
           }
-          if (clusterState.result == null) {  // resource revoked or not exists
-            continue;
+          long weight = UnsignedInts.toLong(localityLbInfo.localityWeight());
+          priorityLocalityWeightSums.put(priorityName, sum + weight);
+        }
+      } else {
+        priorityLocalityWeightSums = null;
+      }
+
+      for (Locality locality : localityLbEndpoints.keySet()) {
+        LocalityLbEndpoints localityLbInfo = localityLbEndpoints.get(locality);
+        String priorityName = localityPriorityNames.get(locality);
+        boolean discard = true;
+        // These sums _should_ fit in uint32, but XdsEndpointResource isn't actually verifying that
+        // is true today. Since we are using long to avoid signedness trouble, the math happens to
+        // still work if it turns out the sums exceed uint32.
+        long localityWeightSum = 0;
+        long endpointWeightSum = 0;
+        if (pickFirstWeightedShuffling) {
+          localityWeightSum = priorityLocalityWeightSums.get(priorityName);
+          for (LbEndpoint endpoint : localityLbInfo.endpoints()) {
+            if (endpoint.isHealthy()) {
+              endpointWeightSum += UnsignedInts.toLong(endpoint.loadBalancingWeight());
+            }
           }
-          if (clusterState.isLeaf) {
-            DiscoveryMechanism instance;
-            if (clusterState.result.clusterType() ==  ClusterType.EDS) {
-              instance = DiscoveryMechanism.forEds(
-                  clusterState.name, clusterState.result.edsServiceName(),
-                  clusterState.result.lrsServerName(), clusterState.result.maxConcurrentRequests(),
-                  clusterState.result.upstreamTlsContext());
-            } else {  // logical DNS
-              instance = DiscoveryMechanism.forLogicalDns(
-                  clusterState.name, clusterState.result.lrsServerName(),
-                  clusterState.result.maxConcurrentRequests(),
-                  clusterState.result.upstreamTlsContext());
+        }
+        for (LbEndpoint endpoint : localityLbInfo.endpoints()) {
+          if (endpoint.isHealthy()) {
+            discard = false;
+            long weight;
+            if (pickFirstWeightedShuffling) {
+              // Combine locality and endpoint weights as defined by gRFC A113
+              long localityWeight = fractionToFixedPoint(
+                  UnsignedInts.toLong(localityLbInfo.localityWeight()), localityWeightSum);
+              long endpointWeight = fractionToFixedPoint(
+                  UnsignedInts.toLong(endpoint.loadBalancingWeight()), endpointWeightSum);
+              weight = fixedPointMultiply(localityWeight, endpointWeight);
+              if (weight == 0) {
+                weight = 1;
+              }
+            } else {
+              weight = localityLbInfo.localityWeight();
+              if (endpoint.loadBalancingWeight() != 0) {
+                weight *= endpoint.loadBalancingWeight();
+              }
             }
-            instances.add(instance);
-          } else {
-            if (clusterState.childClusterStates != null) {
-              queue.addAll(clusterState.childClusterStates.values());
+
+            String localityName = localityName(locality);
+            Attributes attr =
+                endpoint.eag().getAttributes().toBuilder()
+                    .set(InternalEquivalentAddressGroup.ATTR_BACKEND_SERVICE, clusterName)
+                    .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 (instances.isEmpty()) {  // none of non-aggregate clusters exists
-        if (childLb != null) {
-          childLb.shutdown();
-          childLb = null;
+        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>());
         }
-        Status unavailable =
-            Status.UNAVAILABLE.withDescription("Cluster " + root.name + " unusable");
-        helper.updateBalancingState(TRANSIENT_FAILURE, new ErrorPicker(unavailable));
-        return;
+        prioritizedLocalityWeights.get(priorityName).put(
+            locality, localityLbInfo.localityWeight());
       }
-      String endpointPickingPolicy = root.result.lbPolicy();
-      LoadBalancerProvider localityPickingLbProvider =
-          lbRegistry.getProvider(XdsLbPolicies.WEIGHTED_TARGET_POLICY_NAME);  // hardcoded
-      LoadBalancerProvider endpointPickingLbProvider =
-          lbRegistry.getProvider(endpointPickingPolicy);
-      ClusterResolverConfig config = new ClusterResolverConfig(
-          Collections.unmodifiableList(instances),
-          new PolicySelection(localityPickingLbProvider, null /* by cluster_resolver LB policy */),
-          new PolicySelection(endpointPickingLbProvider, null));
-      if (childLb == null) {
-        childLb = lbRegistry.getProvider(CLUSTER_RESOLVER_POLICY_NAME).newLoadBalancer(helper);
+      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);
       }
-      childLb.handleResolvedAddresses(
-          resolvedAddresses.toBuilder().setLoadBalancingPolicyConfig(config).build());
+      sortedPriorityNames.retainAll(prioritizedLocalityWeights.keySet());
+      Map<String, PriorityChildConfig> priorityChildConfigs =
+          generatePriorityChildConfigs(
+              clusterName, discovery, lbConfig, lbRegistry,
+              prioritizedLocalityWeights, dropOverloads);
+      return StatusOr.fromValue(new ClusterResolutionResult(addresses, priorityChildConfigs,
+          sortedPriorityNames));
     }
 
-    private void handleClusterDiscoveryError(Status error) {
-      if (childLb != null) {
-        childLb.handleNameResolutionError(error);
-      } else {
-        helper.updateBalancingState(TRANSIENT_FAILURE, new ErrorPicker(error));
+    private SocketAddress rewriteAddress(SocketAddress addr,
+        ImmutableMap<String, Object> endpointMetadata,
+        ImmutableMap<String, Object> localityMetadata) {
+      if (!(addr instanceof InetSocketAddress)) {
+        return addr;
       }
-    }
 
-    private final class ClusterState implements CdsResourceWatcher {
-      private final String name;
-      @Nullable
-      private Map<String, ClusterState> childClusterStates;
-      @Nullable
-      private CdsUpdate result;
-      // Following fields are effectively final.
-      private boolean isLeaf;
-      private boolean discovered;
-      private boolean shutdown;
-
-      private ClusterState(String name) {
-        this.name = name;
+      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;
       }
 
-      private void start() {
-        xdsClient.watchCdsResource(name, this);
+      if (proxyAddress == null) {
+        return addr;
       }
 
-      void shutdown() {
-        shutdown = true;
-        xdsClient.cancelCdsResourceWatch(name, this);
-        if (childClusterStates != null) {  // recursively shut down all descendants
-          for (ClusterState state : childClusterStates.values()) {
-            state.shutdown();
+      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;
+    }
+  }
 
-      @Override
-      public void onError(final Status error) {
-        syncContext.execute(new Runnable() {
-          @Override
-          public void run() {
-            if (shutdown) {
-              return;
-            }
-            // All watchers should receive the same error, so we only propagate it once.
-            if (ClusterState.this == root) {
-              handleClusterDiscoveryError(error);
-            }
-          }
-        });
+  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));
       }
 
-      @Override
-      public void onResourceDoesNotExist(String resourceName) {
-        syncContext.execute(new Runnable() {
-          @Override
-          public void run() {
-            if (shutdown) {
-              return;
-            }
-            discovered = true;
-            result = null;
-            if (childClusterStates != null) {
-              for (ClusterState state : childClusterStates.values()) {
-                state.shutdown();
-              }
-              childClusterStates = null;
-            }
-            handleClusterDiscovered();
-          }
-        });
+      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());
       }
 
-      @Override
-      public void onChanged(final CdsUpdate update) {
-        class ClusterDiscovered implements Runnable {
-          @Override
-          public void run() {
-            if (shutdown) {
-              return;
-            }
-            logger.log(XdsLogLevel.DEBUG, "Received cluster update {0}", update);
-            discovered = true;
-            result = update;
-            if (update.clusterType() == ClusterType.AGGREGATE) {
-              isLeaf = false;
-              logger.log(XdsLogLevel.INFO, "Aggregate cluster {0}, underlying clusters: {1}",
-                  update.clusterName(), update.prioritizedClusterNames());
-              Map<String, ClusterState> newChildStates = new LinkedHashMap<>();
-              for (String cluster : update.prioritizedClusterNames()) {
-                if (childClusterStates == null || !childClusterStates.containsKey(cluster)) {
-                  ClusterState childState = new ClusterState(cluster);
-                  childState.start();
-                  newChildStates.put(cluster, childState);
-                } else {
-                  newChildStates.put(cluster, childClusterStates.remove(cluster));
-                }
-              }
-              if (childClusterStates != null) {  // stop subscribing to revoked child clusters
-                for (ClusterState watcher : childClusterStates.values()) {
-                  watcher.shutdown();
-                }
-              }
-              childClusterStates = newChildStates;
-            } else if (update.clusterType() == ClusterType.EDS) {
-              isLeaf = true;
-              logger.log(XdsLogLevel.INFO, "EDS cluster {0}, edsServiceName: {1}",
-                  update.clusterName(), update.edsServiceName());
-            } else {  // logical DNS
-              isLeaf = true;
-              logger.log(XdsLogLevel.INFO, "Logical DNS cluster {0}", update.clusterName());
-            }
-            handleClusterDiscovered();
-          }
-        }
+      configBuilder.setSuccessRateEjection(successRateConfigBuilder.build());
+    }
 
-        syncContext.execute(new ClusterDiscovered());
+    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
index d2e3de10efa..875af9089ed 100644
--- a/xds/src/main/java/io/grpc/xds/CdsLoadBalancerProvider.java
+++ b/xds/src/main/java/io/grpc/xds/CdsLoadBalancerProvider.java
@@ -23,6 +23,7 @@
 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;
@@ -36,8 +37,6 @@
 @Internal
 public class CdsLoadBalancerProvider extends LoadBalancerProvider {
 
-  private static final String CLUSTER_KEY = "cluster";
-
   @Override
   public boolean isAvailable() {
     return true;
@@ -53,9 +52,24 @@ 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) {
-    return new CdsLoadBalancer2(helper);
+    LoadBalancerRegistry loadBalancerRegistry = this.loadBalancerRegistry;
+    if (loadBalancerRegistry == null) {
+      loadBalancerRegistry = LoadBalancerRegistry.getDefaultRegistry();
+    }
+
+    return new CdsLoadBalancer2(helper, loadBalancerRegistry);
   }
 
   @Override
@@ -70,12 +84,15 @@ public ConfigOrError parseLoadBalancingPolicyConfig(
    */
   static ConfigOrError parseLoadBalancingConfigPolicy(Map<String, ?> rawLoadBalancingPolicyConfig) {
     try {
-      String cluster =
-          JsonUtil.getString(rawLoadBalancingPolicyConfig, CLUSTER_KEY);
-      return ConfigOrError.fromConfig(new CdsConfig(cluster));
+      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.fromThrowable(e).withDescription(
+          Status.UNAVAILABLE.withCause(e).withDescription(
               "Failed to parse CDS LB config: " + rawLoadBalancingPolicyConfig));
     }
   }
@@ -89,15 +106,28 @@ 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).toString();
+      return MoreObjects.toStringHelper(this)
+          .add("name", name)
+          .add("isDynamic", isDynamic)
+          .toString();
     }
   }
 }
diff --git a/xds/src/main/java/io/grpc/xds/ClientXdsClient.java b/xds/src/main/java/io/grpc/xds/ClientXdsClient.java
deleted file mode 100644
index 826c2cf52ce..00000000000
--- a/xds/src/main/java/io/grpc/xds/ClientXdsClient.java
+++ /dev/null
@@ -1,1466 +0,0 @@
-/*
- * 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 static io.grpc.xds.EnvoyServerProtoData.TRANSPORT_SOCKET_NAME_TLS;
-
-import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.CaseFormat;
-import com.google.common.base.Stopwatch;
-import com.google.common.base.Supplier;
-import com.google.common.collect.ImmutableList;
-import com.google.protobuf.Any;
-import com.google.protobuf.InvalidProtocolBufferException;
-import com.google.protobuf.util.Durations;
-import com.google.re2j.Pattern;
-import com.google.re2j.PatternSyntaxException;
-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.LbPolicy;
-import io.envoyproxy.envoy.config.cluster.v3.Cluster.RingHashLbConfig;
-import io.envoyproxy.envoy.config.core.v3.HttpProtocolOptions;
-import io.envoyproxy.envoy.config.core.v3.RoutingPriority;
-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.filters.http.fault.v3.HTTPFault;
-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.type.v3.FractionalPercent;
-import io.envoyproxy.envoy.type.v3.FractionalPercent.DenominatorType;
-import io.grpc.EquivalentAddressGroup;
-import io.grpc.ManagedChannel;
-import io.grpc.Status;
-import io.grpc.SynchronizationContext.ScheduledHandle;
-import io.grpc.internal.BackoffPolicy;
-import io.grpc.internal.GrpcUtil;
-import io.grpc.xds.Endpoints.DropOverload;
-import io.grpc.xds.Endpoints.LbEndpoint;
-import io.grpc.xds.Endpoints.LocalityLbEndpoints;
-import io.grpc.xds.EnvoyProtoData.Node;
-import io.grpc.xds.EnvoyServerProtoData.UpstreamTlsContext;
-import io.grpc.xds.HttpFault.FaultAbort;
-import io.grpc.xds.HttpFault.FaultDelay;
-import io.grpc.xds.LoadStatsManager2.ClusterDropStats;
-import io.grpc.xds.LoadStatsManager2.ClusterLocalityStats;
-import io.grpc.xds.Matchers.FractionMatcher;
-import io.grpc.xds.Matchers.HeaderMatcher;
-import io.grpc.xds.Matchers.PathMatcher;
-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.XdsClient.CdsUpdate.HashFunction;
-import io.grpc.xds.XdsLogger.XdsLogLevel;
-import java.net.InetSocketAddress;
-import java.util.ArrayList;
-import java.util.Collection;
-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 java.util.concurrent.ScheduledExecutorService;
-import java.util.concurrent.TimeUnit;
-import javax.annotation.Nullable;
-
-/**
- * XdsClient implementation for client side usages.
- */
-final class ClientXdsClient extends AbstractXdsClient {
-
-  // Longest time to wait, since the subscription to some resource, for concluding its absence.
-  @VisibleForTesting
-  static final int INITIAL_RESOURCE_FETCH_TIMEOUT_SEC = 15;
-  @VisibleForTesting
-  static final String AGGREGATE_CLUSTER_TYPE_NAME = "envoy.clusters.aggregate";
-  private static final String HTTP_FAULT_FILTER_NAME = "envoy.fault";
-  @VisibleForTesting
-  static final String HASH_POLICY_FILTER_STATE_KEY = "io.grpc.channel_id";
-  @VisibleForTesting
-  static boolean enableFaultInjection =
-      Boolean.parseBoolean(System.getenv("GRPC_XDS_EXPERIMENTAL_FAULT_INJECTION"));
-
-  private static final String TYPE_URL_HTTP_CONNECTION_MANAGER_V2 =
-      "type.googleapis.com/envoy.config.filter.network.http_connection_manager.v2"
-          + ".HttpConnectionManager";
-  private static final String TYPE_URL_HTTP_CONNECTION_MANAGER =
-      "type.googleapis.com/envoy.extensions.filters.network.http_connection_manager.v3"
-          + ".HttpConnectionManager";
-  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";
-  private static final String TYPE_URL_CLUSTER_CONFIG_V2 =
-      "type.googleapis.com/envoy.config.cluster.aggregate.v2alpha.ClusterConfig";
-  private static final String TYPE_URL_CLUSTER_CONFIG =
-      "type.googleapis.com/envoy.extensions.clusters.aggregate.v3.ClusterConfig";
-
-  private final Map<String, ResourceSubscriber> ldsResourceSubscribers = new HashMap<>();
-  private final Map<String, ResourceSubscriber> rdsResourceSubscribers = new HashMap<>();
-  private final Map<String, ResourceSubscriber> cdsResourceSubscribers = new HashMap<>();
-  private final Map<String, ResourceSubscriber> edsResourceSubscribers = new HashMap<>();
-  private final LoadStatsManager2 loadStatsManager;
-  private final LoadReportClient lrsClient;
-  private boolean reportingLoad;
-
-  ClientXdsClient(ManagedChannel channel, boolean useProtocolV3, Node node,
-      ScheduledExecutorService timeService, BackoffPolicy.Provider backoffPolicyProvider,
-      Supplier<Stopwatch> stopwatchSupplier) {
-    super(channel, useProtocolV3, node, timeService, backoffPolicyProvider, stopwatchSupplier);
-    loadStatsManager = new LoadStatsManager2(stopwatchSupplier);
-    lrsClient = new LoadReportClient(loadStatsManager, channel, useProtocolV3, node,
-        getSyncContext(), timeService, backoffPolicyProvider, stopwatchSupplier);
-  }
-
-  @Override
-  protected void handleLdsResponse(String versionInfo, List<Any> resources, String nonce) {
-    // Unpack Listener messages.
-    List<Listener> listeners = new ArrayList<>(resources.size());
-    List<String> listenerNames = new ArrayList<>(resources.size());
-    try {
-      for (com.google.protobuf.Any res : resources) {
-        if (res.getTypeUrl().equals(ResourceType.LDS.typeUrlV2())) {
-          res = res.toBuilder().setTypeUrl(ResourceType.LDS.typeUrl()).build();
-        }
-        Listener listener = res.unpack(Listener.class);
-        listeners.add(listener);
-        listenerNames.add(listener.getName());
-      }
-    } catch (InvalidProtocolBufferException e) {
-      getLogger().log(XdsLogLevel.WARNING, "Failed to unpack Listeners in LDS response {0}", e);
-      nackResponse(ResourceType.LDS, nonce, "Malformed LDS response: " + e);
-      return;
-    }
-    getLogger().log(XdsLogLevel.INFO, "Received LDS response for resources: {0}", listenerNames);
-
-    // Unpack HttpConnectionManager messages.
-    Map<String, HttpConnectionManager> httpConnectionManagers = new HashMap<>(listeners.size());
-    try {
-      for (Listener listener : listeners) {
-        Any apiListener = listener.getApiListener().getApiListener();
-        if (apiListener.getTypeUrl().equals(TYPE_URL_HTTP_CONNECTION_MANAGER_V2)) {
-          apiListener =
-              apiListener.toBuilder().setTypeUrl(TYPE_URL_HTTP_CONNECTION_MANAGER).build();
-        }
-        HttpConnectionManager hcm = apiListener.unpack(HttpConnectionManager.class);
-        httpConnectionManagers.put(listener.getName(), hcm);
-      }
-    } catch (InvalidProtocolBufferException e) {
-      getLogger().log(
-          XdsLogLevel.WARNING,
-          "Failed to unpack HttpConnectionManagers in Listeners of LDS response {0}", e);
-      nackResponse(ResourceType.LDS, nonce, "Malformed LDS response: " + e);
-      return;
-    }
-
-    Map<String, LdsUpdate> ldsUpdates = new HashMap<>();
-    Set<String> rdsNames = new HashSet<>();
-    for (Map.Entry<String, HttpConnectionManager> entry : httpConnectionManagers.entrySet()) {
-      LdsUpdate update;
-      String listenerName = entry.getKey();
-      HttpConnectionManager hcm = entry.getValue();
-      long maxStreamDuration = 0;
-      if (hcm.hasCommonHttpProtocolOptions()) {
-        HttpProtocolOptions options = hcm.getCommonHttpProtocolOptions();
-        if (options.hasMaxStreamDuration()) {
-          maxStreamDuration = Durations.toNanos(options.getMaxStreamDuration());
-        }
-      }
-      boolean hasFaultInjection = false;
-      HttpFault httpFault = null;
-      if (enableFaultInjection) {
-        List<HttpFilter> httpFilters = hcm.getHttpFiltersList();
-        for (HttpFilter httpFilter : httpFilters) {
-          if (HTTP_FAULT_FILTER_NAME.equals(httpFilter.getName())) {
-            hasFaultInjection = true;
-            if (httpFilter.hasTypedConfig()) {
-              StructOrError<HttpFault> httpFaultOrError =
-                  decodeFaultFilterConfig(httpFilter.getTypedConfig());
-              if (httpFaultOrError != null) {
-                if (httpFaultOrError.getErrorDetail() != null) {
-                  nackResponse(ResourceType.LDS, nonce,
-                      "Listener " + listenerName + " contains invalid HttpFault filter: "
-                          + httpFaultOrError.getErrorDetail());
-                  return;
-                }
-                httpFault = httpFaultOrError.getStruct();
-              }
-            }
-            break;
-          }
-        }
-      }
-      if (hcm.hasRouteConfig()) {
-        List<VirtualHost> virtualHosts = new ArrayList<>();
-        for (io.envoyproxy.envoy.config.route.v3.VirtualHost virtualHostProto
-            : hcm.getRouteConfig().getVirtualHostsList()) {
-          StructOrError<VirtualHost> virtualHost = parseVirtualHost(virtualHostProto);
-          if (virtualHost.getErrorDetail() != null) {
-            nackResponse(ResourceType.LDS, nonce,
-                "Listener " + listenerName + " contains invalid virtual host: "
-                    + virtualHost.getErrorDetail());
-            return;
-          }
-          virtualHosts.add(virtualHost.getStruct());
-        }
-        update = new LdsUpdate(maxStreamDuration, virtualHosts, hasFaultInjection, httpFault);
-      } else if (hcm.hasRds()) {
-        Rds rds = hcm.getRds();
-        if (!rds.getConfigSource().hasAds()) {
-          nackResponse(ResourceType.LDS, nonce,
-              "Listener " + listenerName + " with RDS config_source not set to ADS");
-          return;
-        }
-        update = new LdsUpdate(
-            maxStreamDuration, rds.getRouteConfigName(), hasFaultInjection, httpFault);
-        rdsNames.add(rds.getRouteConfigName());
-      } else {
-        nackResponse(ResourceType.LDS, nonce,
-            "Listener " + listenerName + " without inline RouteConfiguration or RDS");
-        return;
-      }
-      ldsUpdates.put(listenerName, update);
-    }
-    ackResponse(ResourceType.LDS, versionInfo, nonce);
-
-    for (String resource : ldsResourceSubscribers.keySet()) {
-      ResourceSubscriber subscriber = ldsResourceSubscribers.get(resource);
-      if (ldsUpdates.containsKey(resource)) {
-        subscriber.onData(ldsUpdates.get(resource));
-      } else {
-        subscriber.onAbsent();
-      }
-    }
-    for (String resource : rdsResourceSubscribers.keySet()) {
-      if (!rdsNames.contains(resource)) {
-        ResourceSubscriber subscriber = rdsResourceSubscribers.get(resource);
-        subscriber.onAbsent();
-      }
-    }
-  }
-
-  private static StructOrError<VirtualHost> parseVirtualHost(
-      io.envoyproxy.envoy.config.route.v3.VirtualHost proto) {
-    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);
-      if (route == null) {
-        continue;
-      }
-      if (route.getErrorDetail() != null) {
-        return StructOrError.fromError(
-            "Virtual host [" + name + "] contains invalid route : " + route.getErrorDetail());
-      }
-      routes.add(route.getStruct());
-    }
-    HttpFault httpFault = null;
-    Map<String, Any> filterConfigMap = proto.getTypedPerFilterConfigMap();
-    if (filterConfigMap.containsKey(HTTP_FAULT_FILTER_NAME)) {
-      Any rawFaultFilterConfig = filterConfigMap.get(HTTP_FAULT_FILTER_NAME);
-      StructOrError<HttpFault> httpFaultOrError = decodeFaultFilterConfig(rawFaultFilterConfig);
-      if (httpFaultOrError != null) {
-        if (httpFaultOrError.getErrorDetail() != null) {
-          return StructOrError.fromError(
-              "Virtual host [" + name + "] contains invalid HttpFault filter : "
-                  + httpFaultOrError.getErrorDetail());
-        }
-        httpFault = httpFaultOrError.getStruct();
-      }
-    }
-    return StructOrError.fromStruct(VirtualHost.create(
-        name, proto.getDomainsList(), routes, httpFault));
-  }
-
-  @VisibleForTesting
-  @Nullable
-  static StructOrError<Route> parseRoute(io.envoyproxy.envoy.config.route.v3.Route proto) {
-    StructOrError<RouteMatch> routeMatch = parseRouteMatch(proto.getMatch());
-    if (routeMatch == null) {
-      return null;
-    }
-    if (routeMatch.getErrorDetail() != null) {
-      return StructOrError.fromError(
-          "Invalid route [" + proto.getName() + "]: " + routeMatch.getErrorDetail());
-    }
-
-    StructOrError<RouteAction> routeAction;
-    switch (proto.getActionCase()) {
-      case ROUTE:
-        routeAction = parseRouteAction(proto.getRoute());
-        break;
-      case REDIRECT:
-        return StructOrError.fromError("Unsupported action type: redirect");
-      case DIRECT_RESPONSE:
-        return StructOrError.fromError("Unsupported action type: direct_response");
-      case FILTER_ACTION:
-        return StructOrError.fromError("Unsupported action type: filter_action");
-      case ACTION_NOT_SET:
-      default:
-        return StructOrError.fromError("Unknown action type: " + proto.getActionCase());
-    }
-    if (routeAction == null) {
-      return null;
-    }
-    if (routeAction.getErrorDetail() != null) {
-      return StructOrError.fromError(
-          "Invalid route [" + proto.getName() + "]: " + routeAction.getErrorDetail());
-    }
-
-    HttpFault httpFault = null;
-    Map<String, Any> filterConfigMap = proto.getTypedPerFilterConfigMap();
-    if (filterConfigMap.containsKey(HTTP_FAULT_FILTER_NAME)) {
-      Any rawFaultFilterConfig = filterConfigMap.get(HTTP_FAULT_FILTER_NAME);
-      StructOrError<HttpFault> httpFaultOrError = decodeFaultFilterConfig(rawFaultFilterConfig);
-      if (httpFaultOrError != null) {
-        if (httpFaultOrError.getErrorDetail() != null) {
-          return StructOrError.fromError(
-              "Route [" + proto.getName() + "] contains invalid HttpFault filter: "
-                  + httpFaultOrError.getErrorDetail());
-        }
-        httpFault = httpFaultOrError.getStruct();
-      }
-    }
-    return StructOrError.fromStruct(Route.create(
-        routeMatch.getStruct(), routeAction.getStruct(), httpFault));
-  }
-
-  @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) {
-    switch (proto.getHeaderMatchSpecifierCase()) {
-      case EXACT_MATCH:
-        return StructOrError.fromStruct(HeaderMatcher.forExactValue(
-            proto.getName(), proto.getExactMatch(), proto.getInvertMatch()));
-      case SAFE_REGEX_MATCH:
-        String rawPattern = proto.getSafeRegexMatch().getRegex();
-        Pattern safeRegExMatch;
-        try {
-          safeRegExMatch = Pattern.compile(rawPattern);
-        } catch (PatternSyntaxException e) {
-          return StructOrError.fromError(
-              "HeaderMatcher [" + proto.getName() + "] contains malformed safe regex pattern: "
-                  + e.getMessage());
-        }
-        return StructOrError.fromStruct(HeaderMatcher.forSafeRegEx(
-            proto.getName(), safeRegExMatch, proto.getInvertMatch()));
-      case RANGE_MATCH:
-        HeaderMatcher.Range rangeMatch = HeaderMatcher.Range.create(
-            proto.getRangeMatch().getStart(), proto.getRangeMatch().getEnd());
-        return StructOrError.fromStruct(HeaderMatcher.forRange(
-            proto.getName(), rangeMatch, proto.getInvertMatch()));
-      case PRESENT_MATCH:
-        return StructOrError.fromStruct(HeaderMatcher.forPresent(
-            proto.getName(), proto.getPresentMatch(), proto.getInvertMatch()));
-      case PREFIX_MATCH:
-        return StructOrError.fromStruct(HeaderMatcher.forPrefix(
-            proto.getName(), proto.getPrefixMatch(), proto.getInvertMatch()));
-      case SUFFIX_MATCH:
-        return StructOrError.fromStruct(HeaderMatcher.forSuffix(
-            proto.getName(), proto.getSuffixMatch(), proto.getInvertMatch()));
-      case HEADERMATCHSPECIFIER_NOT_SET:
-      default:
-        return StructOrError.fromError("Unknown header matcher type");
-    }
-  }
-
-  @VisibleForTesting
-  @Nullable
-  static StructOrError<RouteAction> parseRouteAction(
-      io.envoyproxy.envoy.config.route.v3.RouteAction proto) {
-    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());
-      }
-    }
-    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()
-              && headerCfg.getRegexRewrite().getPattern().hasGoogleRe2()) {
-            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));
-      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<>();
-        for (io.envoyproxy.envoy.config.route.v3.WeightedCluster.ClusterWeight clusterWeight
-            : clusterWeights) {
-          StructOrError<ClusterWeight> clusterWeightOrError = parseClusterWeight(clusterWeight);
-          if (clusterWeightOrError.getErrorDetail() != null) {
-            return StructOrError.fromError("RouteAction contains invalid ClusterWeight: "
-                + clusterWeightOrError.getErrorDetail());
-          }
-          weightedClusters.add(clusterWeightOrError.getStruct());
-        }
-        // TODO(chengyuanzhang): validate if the sum of weights equals to total weight.
-        return StructOrError.fromStruct(RouteAction.forWeightedClusters(
-            weightedClusters, hashPolicies, timeoutNano));
-      case CLUSTERSPECIFIER_NOT_SET:
-      default:
-        return StructOrError.fromError(
-            "Unknown cluster specifier: " + proto.getClusterSpecifierCase());
-    }
-  }
-
-  @VisibleForTesting
-  static StructOrError<ClusterWeight> parseClusterWeight(
-      io.envoyproxy.envoy.config.route.v3.WeightedCluster.ClusterWeight proto) {
-    HttpFault httpFault = null;
-    Map<String, Any> filterConfigMap = proto.getTypedPerFilterConfigMap();
-    if (filterConfigMap.containsKey(HTTP_FAULT_FILTER_NAME)) {
-      Any rawFaultFilterConfig = filterConfigMap.get(HTTP_FAULT_FILTER_NAME);
-      StructOrError<HttpFault> httpFaultOrError = decodeFaultFilterConfig(rawFaultFilterConfig);
-      if (httpFaultOrError != null) {
-        if (httpFaultOrError.getErrorDetail() != null) {
-          return StructOrError.fromError(
-              "ClusterWeight [" + proto.getName() + "] contains invalid HttpFault filter: "
-                  + httpFaultOrError.getErrorDetail());
-        }
-        httpFault = httpFaultOrError.getStruct();
-      }
-    }
-    return StructOrError.fromStruct(
-        ClusterWeight.create(proto.getName(), proto.getWeight().getValue(), httpFault));
-  }
-
-  @Nullable
-  private static StructOrError<HttpFault> decodeFaultFilterConfig(Any rawFaultFilterConfig) {
-    if (!rawFaultFilterConfig.getTypeUrl().equals(
-        "type.googleapis.com/envoy.extensions.filters.http.fault.v3.HTTPFault")) {
-      return null;
-    }
-    HTTPFault httpFaultProto;
-    try {
-      httpFaultProto = rawFaultFilterConfig.unpack(HTTPFault.class);
-    } catch (InvalidProtocolBufferException e) {
-      return StructOrError.fromError("Invalid proto: " + e);
-    }
-    return parseHttpFault(httpFaultProto);
-  }
-
-  private static StructOrError<HttpFault> parseHttpFault(HTTPFault httpFault) {
-    FaultDelay faultDelay = null;
-    FaultAbort faultAbort = null;
-    if (httpFault.hasDelay()) {
-      faultDelay = parseFaultDelay(httpFault.getDelay());
-    }
-    if (httpFault.hasAbort()) {
-      StructOrError<FaultAbort> faultAbortOrError = parseFaultAbort(httpFault.getAbort());
-      if (faultAbortOrError.getErrorDetail() != null) {
-        return StructOrError.fromError(
-            "HttpFault contains invalid FaultAbort: " + faultAbortOrError.getErrorDetail());
-      }
-      faultAbort = faultAbortOrError.getStruct();
-    }
-    if (faultDelay == null && faultAbort == null) {
-      return StructOrError.fromError(
-          "Invalid HttpFault: neither fault_delay nor fault_abort is specified");
-    }
-    String upstreamCluster = httpFault.getUpstreamCluster();
-    List<String> downstreamNodes = httpFault.getDownstreamNodesList();
-    List<HeaderMatcher> headers = new ArrayList<>();
-    for (io.envoyproxy.envoy.config.route.v3.HeaderMatcher proto : httpFault.getHeadersList()) {
-      StructOrError<HeaderMatcher> headerMatcherOrError = parseHeaderMatcher(proto);
-      if (headerMatcherOrError.getErrorDetail() != null) {
-        return StructOrError.fromError(
-            "HttpFault contains invalid header matcher: "
-                + headerMatcherOrError.getErrorDetail());
-      }
-      headers.add(headerMatcherOrError.getStruct());
-    }
-    Integer maxActiveFaults = null;
-    if (httpFault.hasMaxActiveFaults()) {
-      maxActiveFaults = httpFault.getMaxActiveFaults().getValue();
-      if (maxActiveFaults < 0) {
-        maxActiveFaults = Integer.MAX_VALUE;
-      }
-    }
-    return StructOrError.fromStruct(HttpFault.create(
-        faultDelay, faultAbort, upstreamCluster, downstreamNodes, headers, maxActiveFaults));
-  }
-
-  private static FaultDelay parseFaultDelay(
-      io.envoyproxy.envoy.extensions.filters.common.fault.v3.FaultDelay faultDelay) {
-    HttpFault.FractionalPercent percent = parsePercent(faultDelay.getPercentage());
-    if (faultDelay.hasHeaderDelay()) {
-      return FaultDelay.forHeader(percent);
-    }
-    return FaultDelay.forFixedDelay(Durations.toNanos(faultDelay.getFixedDelay()), percent);
-  }
-
-  @VisibleForTesting
-  static StructOrError<FaultAbort> parseFaultAbort(
-      io.envoyproxy.envoy.extensions.filters.http.fault.v3.FaultAbort faultAbort) {
-    HttpFault.FractionalPercent percent = parsePercent(faultAbort.getPercentage());
-    switch (faultAbort.getErrorTypeCase()) {
-      case HEADER_ABORT:
-        return StructOrError.fromStruct(FaultAbort.forHeader(percent));
-      case HTTP_STATUS:
-        return StructOrError.fromStruct(FaultAbort.forStatus(
-            GrpcUtil.httpStatusToGrpcStatus(faultAbort.getHttpStatus()), percent));
-      case GRPC_STATUS:
-        return StructOrError.fromStruct(FaultAbort.forStatus(
-            Status.fromCodeValue(faultAbort.getGrpcStatus()), percent));
-      case ERRORTYPE_NOT_SET:
-      default:
-        return StructOrError.fromError(
-            "Unknown error type case: " + faultAbort.getErrorTypeCase());
-    }
-  }
-
-  private static HttpFault.FractionalPercent parsePercent(FractionalPercent proto) {
-    switch (proto.getDenominator()) {
-      case HUNDRED:
-        return HttpFault.FractionalPercent.perHundred(proto.getNumerator());
-      case TEN_THOUSAND:
-        return HttpFault.FractionalPercent.perTenThousand(proto.getNumerator());
-      case MILLION:
-        return HttpFault.FractionalPercent.perMillion(proto.getNumerator());
-      case UNRECOGNIZED:
-      default:
-        throw new IllegalArgumentException("Unknown denominator type: " + proto.getDenominator());
-    }
-  }
-
-  @Override
-  protected void handleRdsResponse(String versionInfo, List<Any> resources, String nonce) {
-    // Unpack RouteConfiguration messages.
-    Map<String, RouteConfiguration> routeConfigs = new HashMap<>(resources.size());
-    try {
-      for (com.google.protobuf.Any res : resources) {
-        if (res.getTypeUrl().equals(ResourceType.RDS.typeUrlV2())) {
-          res = res.toBuilder().setTypeUrl(ResourceType.RDS.typeUrl()).build();
-        }
-        RouteConfiguration rc = res.unpack(RouteConfiguration.class);
-        routeConfigs.put(rc.getName(), rc);
-      }
-    } catch (InvalidProtocolBufferException e) {
-      getLogger().log(
-          XdsLogLevel.WARNING, "Failed to unpack RouteConfiguration in RDS response {0}", e);
-      nackResponse(ResourceType.RDS, nonce, "Malformed RDS response: " + e);
-      return;
-    }
-    getLogger().log(
-        XdsLogLevel.INFO, "Received RDS response for resources: {0}", routeConfigs.keySet());
-
-    Map<String, RdsUpdate> rdsUpdates = new HashMap<>();
-    for (Map.Entry<String, RouteConfiguration> entry : routeConfigs.entrySet()) {
-      String routeConfigName = entry.getKey();
-      RouteConfiguration routeConfig = entry.getValue();
-      List<VirtualHost> virtualHosts =
-          new ArrayList<>(routeConfig.getVirtualHostsCount());
-      for (io.envoyproxy.envoy.config.route.v3.VirtualHost virtualHostProto
-          : routeConfig.getVirtualHostsList()) {
-        StructOrError<VirtualHost> virtualHost = parseVirtualHost(virtualHostProto);
-        if (virtualHost.getErrorDetail() != null) {
-          nackResponse(ResourceType.RDS, nonce, "RouteConfiguration " + routeConfigName
-              + " contains invalid virtual host: " + virtualHost.getErrorDetail());
-          return;
-        }
-        virtualHosts.add(virtualHost.getStruct());
-      }
-      rdsUpdates.put(routeConfigName, new RdsUpdate(virtualHosts));
-    }
-    ackResponse(ResourceType.RDS, versionInfo, nonce);
-
-    for (String resource : rdsResourceSubscribers.keySet()) {
-      if (rdsUpdates.containsKey(resource)) {
-        ResourceSubscriber subscriber = rdsResourceSubscribers.get(resource);
-        subscriber.onData(rdsUpdates.get(resource));
-      }
-    }
-  }
-
-  @Override
-  protected void handleCdsResponse(String versionInfo, List<Any> resources, String nonce) {
-    // Unpack Cluster messages.
-    List<Cluster> clusters = new ArrayList<>(resources.size());
-    List<String> clusterNames = new ArrayList<>(resources.size());
-    try {
-      for (com.google.protobuf.Any res : resources) {
-        if (res.getTypeUrl().equals(ResourceType.CDS.typeUrlV2())) {
-          res = res.toBuilder().setTypeUrl(ResourceType.CDS.typeUrl()).build();
-        }
-        Cluster cluster = res.unpack(Cluster.class);
-        clusters.add(cluster);
-        clusterNames.add(cluster.getName());
-      }
-    } catch (InvalidProtocolBufferException e) {
-      getLogger().log(XdsLogLevel.WARNING, "Failed to unpack Clusters in CDS response {0}", e);
-      nackResponse(ResourceType.CDS, nonce, "Malformed CDS response: " + e);
-      return;
-    }
-    getLogger().log(XdsLogLevel.INFO, "Received CDS response for resources: {0}", clusterNames);
-
-    Map<String, CdsUpdate> cdsUpdates = new HashMap<>();
-    // CDS responses represents the state of the world, EDS resources not referenced in CDS
-    // resources should be deleted.
-    Set<String> edsResources = new HashSet<>();  // retained EDS resources
-    for (Cluster cluster : clusters) {
-      String clusterName = cluster.getName();
-      // 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.
-      if (!cdsResourceSubscribers.containsKey(clusterName)) {
-        continue;
-      }
-      StructOrError<CdsUpdate.Builder> structOrError;
-      switch (cluster.getClusterDiscoveryTypeCase()) {
-        case TYPE:
-          structOrError = parseNonAggregateCluster(cluster, edsResources);
-          break;
-        case CLUSTER_TYPE:
-          structOrError = parseAggregateCluster(cluster);
-          break;
-        case CLUSTERDISCOVERYTYPE_NOT_SET:
-        default:
-          nackResponse(ResourceType.CDS, nonce,
-              "Cluster " + clusterName + ": cluster discovery type unspecified");
-          return;
-      }
-      if (structOrError.getErrorDetail() != null) {
-        nackResponse(ResourceType.CDS, nonce, structOrError.errorDetail);
-        return;
-      }
-      CdsUpdate.Builder updateBuilder = structOrError.getStruct();
-      String lbPolicy = CaseFormat.UPPER_UNDERSCORE.to(
-          CaseFormat.LOWER_UNDERSCORE, cluster.getLbPolicy().name());
-      if (cluster.getLbPolicy() == LbPolicy.RING_HASH) {
-        HashFunction hashFunction;
-        RingHashLbConfig lbConfig = cluster.getRingHashLbConfig();
-        if (lbConfig.getHashFunction() == RingHashLbConfig.HashFunction.XX_HASH) {
-          hashFunction = HashFunction.XX_HASH;
-        } else {
-          nackResponse(ResourceType.CDS, nonce,
-              "Cluster " + clusterName + ": unsupported ring hash function: "
-                  + lbConfig.getHashFunction());
-          return;
-        }
-        updateBuilder.lbPolicy(lbPolicy, lbConfig.getMinimumRingSize().getValue(),
-            lbConfig.getMaximumRingSize().getValue(), hashFunction);
-      } else {
-        updateBuilder.lbPolicy(lbPolicy);
-      }
-      cdsUpdates.put(clusterName, updateBuilder.build());
-    }
-    ackResponse(ResourceType.CDS, versionInfo, nonce);
-
-    for (String resource : cdsResourceSubscribers.keySet()) {
-      ResourceSubscriber subscriber = cdsResourceSubscribers.get(resource);
-      if (cdsUpdates.containsKey(resource)) {
-        subscriber.onData(cdsUpdates.get(resource));
-      } else {
-        subscriber.onAbsent();
-      }
-    }
-    for (String resource : edsResourceSubscribers.keySet()) {
-      ResourceSubscriber subscriber = edsResourceSubscribers.get(resource);
-      if (!edsResources.contains(resource)) {
-        subscriber.onAbsent();
-      }
-    }
-  }
-
-  private static StructOrError<CdsUpdate.Builder> parseAggregateCluster(Cluster cluster) {
-    String clusterName = cluster.getName();
-    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;
-    Any unpackedClusterConfig = customType.getTypedConfig();
-    if (unpackedClusterConfig.getTypeUrl().equals(TYPE_URL_CLUSTER_CONFIG_V2)) {
-      unpackedClusterConfig =
-          unpackedClusterConfig.toBuilder().setTypeUrl(TYPE_URL_CLUSTER_CONFIG).build();
-    }
-    try {
-      clusterConfig = unpackedClusterConfig.unpack(
-          io.envoyproxy.envoy.extensions.clusters.aggregate.v3.ClusterConfig.class);
-    } catch (InvalidProtocolBufferException e) {
-      StructOrError.fromError("Cluster " + clusterName + ": malformed ClusterConfig: " + e);
-      return null;
-    }
-    return StructOrError.fromStruct(CdsUpdate.forAggregate(
-        clusterName, clusterConfig.getClustersList()));
-  }
-
-  private static StructOrError<CdsUpdate.Builder> parseNonAggregateCluster(
-      Cluster cluster, Set<String> edsResources) {
-    String clusterName = cluster.getName();
-    String lrsServerName = null;
-    Long maxConcurrentRequests = null;
-    UpstreamTlsContext upstreamTlsContext = null;
-    if (cluster.hasLrsServer()) {
-      if (!cluster.getLrsServer().hasSelf()) {
-        return StructOrError.fromError(
-            "Cluster " + clusterName + ": only support LRS for the same management server");
-      }
-      lrsServerName = "";
-    }
-    if (cluster.hasCircuitBreakers()) {
-      List<Thresholds> thresholds = cluster.getCircuitBreakers().getThresholdsList();
-      for (Thresholds threshold : thresholds) {
-        if (threshold.getPriority() != RoutingPriority.DEFAULT) {
-          continue;
-        }
-        if (threshold.hasMaxRequests()) {
-          maxConcurrentRequests = (long) threshold.getMaxRequests().getValue();
-        }
-      }
-    }
-    if (cluster.hasTransportSocket()
-        && TRANSPORT_SOCKET_NAME_TLS.equals(cluster.getTransportSocket().getName())) {
-      Any any = cluster.getTransportSocket().getTypedConfig();
-      if (any.getTypeUrl().equals(TYPE_URL_UPSTREAM_TLS_CONTEXT_V2)) {
-        any = any.toBuilder().setTypeUrl(TYPE_URL_UPSTREAM_TLS_CONTEXT).build();
-      }
-      io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.UpstreamTlsContext unpacked;
-      try {
-        unpacked = any.unpack(
-            io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.UpstreamTlsContext.class);
-      } catch (InvalidProtocolBufferException e) {
-        return StructOrError.fromError(
-            "Cluster " + clusterName + ": malformed UpstreamTlsContext: " + e);
-      }
-      upstreamTlsContext = UpstreamTlsContext.fromEnvoyProtoUpstreamTlsContext(unpacked);
-    }
-
-    DiscoveryType type = cluster.getType();
-    if (type == DiscoveryType.EDS) {
-      String edsServiceName = null;
-      io.envoyproxy.envoy.config.cluster.v3.Cluster.EdsClusterConfig edsClusterConfig =
-          cluster.getEdsClusterConfig();
-      if (!edsClusterConfig.getEdsConfig().hasAds()) {
-        return StructOrError.fromError("Cluster " + clusterName
-            + ": field eds_cluster_config must be set to indicate to use EDS over ADS.");
-      }
-      // If the service_name field is set, that value will be used for the EDS request.
-      if (!edsClusterConfig.getServiceName().isEmpty()) {
-        edsServiceName = edsClusterConfig.getServiceName();
-        edsResources.add(edsServiceName);
-      } else {
-        edsResources.add(clusterName);
-      }
-      return StructOrError.fromStruct(CdsUpdate.forEds(
-          clusterName, edsServiceName, lrsServerName, maxConcurrentRequests, upstreamTlsContext));
-    } else if (type.equals(DiscoveryType.LOGICAL_DNS)) {
-      return StructOrError.fromStruct(CdsUpdate.forLogicalDns(
-          clusterName, lrsServerName, maxConcurrentRequests, upstreamTlsContext));
-    }
-    return StructOrError.fromError(
-        "Cluster " + clusterName + ": unsupported built-in discovery type: " + type);
-  }
-
-  @Override
-  protected void handleEdsResponse(String versionInfo, List<Any> resources, String nonce) {
-    // Unpack ClusterLoadAssignment messages.
-    List<ClusterLoadAssignment> clusterLoadAssignments = new ArrayList<>(resources.size());
-    List<String> claNames = new ArrayList<>(resources.size());
-    try {
-      for (com.google.protobuf.Any res : resources) {
-        if (res.getTypeUrl().equals(ResourceType.EDS.typeUrlV2())) {
-          res = res.toBuilder().setTypeUrl(ResourceType.EDS.typeUrl()).build();
-        }
-        ClusterLoadAssignment assignment = res.unpack(ClusterLoadAssignment.class);
-        clusterLoadAssignments.add(assignment);
-        claNames.add(assignment.getClusterName());
-      }
-    } catch (InvalidProtocolBufferException e) {
-      getLogger().log(
-          XdsLogLevel.WARNING, "Failed to unpack ClusterLoadAssignments in EDS response {0}", e);
-      nackResponse(ResourceType.EDS, nonce, "Malformed EDS response: " + e);
-      return;
-    }
-    getLogger().log(XdsLogLevel.INFO, "Received EDS response for resources: {0}", claNames);
-
-    Map<String, EdsUpdate> edsUpdates = new HashMap<>();
-    for (ClusterLoadAssignment assignment : clusterLoadAssignments) {
-      String clusterName = assignment.getClusterName();
-      // Skip information for clusters not requested.
-      // 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.
-      if (!edsResourceSubscribers.containsKey(clusterName)) {
-        continue;
-      }
-      Set<Integer> priorities = new HashSet<>();
-      Map<Locality, LocalityLbEndpoints> localityLbEndpointsMap = new LinkedHashMap<>();
-      List<DropOverload> dropOverloads = new ArrayList<>();
-      int maxPriority = -1;
-      for (io.envoyproxy.envoy.config.endpoint.v3.LocalityLbEndpoints localityLbEndpointsProto
-          : assignment.getEndpointsList()) {
-        StructOrError<LocalityLbEndpoints> localityLbEndpoints =
-            parseLocalityLbEndpoints(localityLbEndpointsProto);
-        if (localityLbEndpoints == null) {
-          continue;
-        }
-        if (localityLbEndpoints.getErrorDetail() != null) {
-          nackResponse(ResourceType.EDS, nonce, "ClusterLoadAssignment " + clusterName + ": "
-              + localityLbEndpoints.getErrorDetail());
-          return;
-        }
-        maxPriority = Math.max(maxPriority, localityLbEndpoints.getStruct().priority());
-        priorities.add(localityLbEndpoints.getStruct().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().
-        localityLbEndpointsMap.put(
-            parseLocality(localityLbEndpointsProto.getLocality()),
-            localityLbEndpoints.getStruct());
-      }
-      if (priorities.size() != maxPriority + 1) {
-        nackResponse(ResourceType.EDS, nonce,
-            "ClusterLoadAssignment " + clusterName + " : sparse priorities.");
-        return;
-      }
-      for (ClusterLoadAssignment.Policy.DropOverload dropOverloadProto
-          : assignment.getPolicy().getDropOverloadsList()) {
-        dropOverloads.add(parseDropOverload(dropOverloadProto));
-      }
-      EdsUpdate update = new EdsUpdate(clusterName, localityLbEndpointsMap, dropOverloads);
-      edsUpdates.put(clusterName, update);
-    }
-    ackResponse(ResourceType.EDS, versionInfo, nonce);
-
-    for (String resource : edsResourceSubscribers.keySet()) {
-      ResourceSubscriber subscriber = edsResourceSubscribers.get(resource);
-      if (edsUpdates.containsKey(resource)) {
-        subscriber.onData(edsUpdates.get(resource));
-      }
-    }
-  }
-
-  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()));
-  }
-
-  @VisibleForTesting
-  @Nullable
-  static StructOrError<LocalityLbEndpoints> parseLocalityLbEndpoints(
-      io.envoyproxy.envoy.config.endpoint.v3.LocalityLbEndpoints proto) {
-    // 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");
-    }
-    List<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");
-      }
-      io.envoyproxy.envoy.config.core.v3.SocketAddress socketAddress =
-          endpoint.getEndpoint().getAddress().getSocketAddress();
-      InetSocketAddress addr =
-          new InetSocketAddress(socketAddress.getAddress(), socketAddress.getPortValue());
-      boolean isHealthy =
-          endpoint.getHealthStatus() == io.envoyproxy.envoy.config.core.v3.HealthStatus.HEALTHY
-              || endpoint.getHealthStatus()
-              == io.envoyproxy.envoy.config.core.v3.HealthStatus.UNKNOWN;
-      endpoints.add(LbEndpoint.create(
-          new EquivalentAddressGroup(ImmutableList.<java.net.SocketAddress>of(addr)),
-          endpoint.getLoadBalancingWeight().getValue(), isHealthy));
-    }
-    return StructOrError.fromStruct(LocalityLbEndpoints.create(
-        endpoints, proto.getLoadBalancingWeight().getValue(), proto.getPriority()));
-  }
-
-  private static int getRatePerMillion(FractionalPercent percent) {
-    int numerator = percent.getNumerator();
-    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;
-  }
-
-  @Override
-  protected void handleStreamClosed(Status error) {
-    cleanUpResourceTimers();
-    for (ResourceSubscriber subscriber : ldsResourceSubscribers.values()) {
-      subscriber.onError(error);
-    }
-    for (ResourceSubscriber subscriber : rdsResourceSubscribers.values()) {
-      subscriber.onError(error);
-    }
-    for (ResourceSubscriber subscriber : cdsResourceSubscribers.values()) {
-      subscriber.onError(error);
-    }
-    for (ResourceSubscriber subscriber : edsResourceSubscribers.values()) {
-      subscriber.onError(error);
-    }
-  }
-
-  @Override
-  protected void handleStreamRestarted() {
-    for (ResourceSubscriber subscriber : ldsResourceSubscribers.values()) {
-      subscriber.restartTimer();
-    }
-    for (ResourceSubscriber subscriber : rdsResourceSubscribers.values()) {
-      subscriber.restartTimer();
-    }
-    for (ResourceSubscriber subscriber : cdsResourceSubscribers.values()) {
-      subscriber.restartTimer();
-    }
-    for (ResourceSubscriber subscriber : edsResourceSubscribers.values()) {
-      subscriber.restartTimer();
-    }
-  }
-
-  @Override
-  protected void handleShutdown() {
-    if (reportingLoad) {
-      lrsClient.stopLoadReporting();
-    }
-    cleanUpResourceTimers();
-  }
-
-  @Nullable
-  @Override
-  Collection<String> getSubscribedResources(ResourceType type) {
-    switch (type) {
-      case LDS:
-        return ldsResourceSubscribers.isEmpty() ? null : ldsResourceSubscribers.keySet();
-      case RDS:
-        return rdsResourceSubscribers.isEmpty() ? null : rdsResourceSubscribers.keySet();
-      case CDS:
-        return cdsResourceSubscribers.isEmpty() ? null : cdsResourceSubscribers.keySet();
-      case EDS:
-        return edsResourceSubscribers.isEmpty() ? null : edsResourceSubscribers.keySet();
-      case UNKNOWN:
-      default:
-        throw new AssertionError("Unknown resource type");
-    }
-  }
-
-  @Override
-  void watchLdsResource(final String resourceName, final LdsResourceWatcher watcher) {
-    getSyncContext().execute(new Runnable() {
-      @Override
-      public void run() {
-        ResourceSubscriber subscriber = ldsResourceSubscribers.get(resourceName);
-        if (subscriber == null) {
-          getLogger().log(XdsLogLevel.INFO, "Subscribe LDS resource {0}", resourceName);
-          subscriber = new ResourceSubscriber(ResourceType.LDS, resourceName);
-          ldsResourceSubscribers.put(resourceName, subscriber);
-          adjustResourceSubscription(ResourceType.LDS);
-        }
-        subscriber.addWatcher(watcher);
-      }
-    });
-  }
-
-  @Override
-  void cancelLdsResourceWatch(final String resourceName, final LdsResourceWatcher watcher) {
-    getSyncContext().execute(new Runnable() {
-      @Override
-      public void run() {
-        ResourceSubscriber subscriber = ldsResourceSubscribers.get(resourceName);
-        subscriber.removeWatcher(watcher);
-        if (!subscriber.isWatched()) {
-          subscriber.stopTimer();
-          getLogger().log(XdsLogLevel.INFO, "Unsubscribe LDS resource {0}", resourceName);
-          ldsResourceSubscribers.remove(resourceName);
-          adjustResourceSubscription(ResourceType.LDS);
-        }
-      }
-    });
-  }
-
-  @Override
-  void watchRdsResource(final String resourceName, final RdsResourceWatcher watcher) {
-    getSyncContext().execute(new Runnable() {
-      @Override
-      public void run() {
-        ResourceSubscriber subscriber = rdsResourceSubscribers.get(resourceName);
-        if (subscriber == null) {
-          getLogger().log(XdsLogLevel.INFO, "Subscribe RDS resource {0}", resourceName);
-          subscriber = new ResourceSubscriber(ResourceType.RDS, resourceName);
-          rdsResourceSubscribers.put(resourceName, subscriber);
-          adjustResourceSubscription(ResourceType.RDS);
-        }
-        subscriber.addWatcher(watcher);
-      }
-    });
-  }
-
-  @Override
-  void cancelRdsResourceWatch(final String resourceName, final RdsResourceWatcher watcher) {
-    getSyncContext().execute(new Runnable() {
-      @Override
-      public void run() {
-        ResourceSubscriber subscriber = rdsResourceSubscribers.get(resourceName);
-        subscriber.removeWatcher(watcher);
-        if (!subscriber.isWatched()) {
-          subscriber.stopTimer();
-          getLogger().log(XdsLogLevel.INFO, "Unsubscribe RDS resource {0}", resourceName);
-          rdsResourceSubscribers.remove(resourceName);
-          adjustResourceSubscription(ResourceType.RDS);
-        }
-      }
-    });
-  }
-
-  @Override
-  void watchCdsResource(final String resourceName, final CdsResourceWatcher watcher) {
-    getSyncContext().execute(new Runnable() {
-      @Override
-      public void run() {
-        ResourceSubscriber subscriber = cdsResourceSubscribers.get(resourceName);
-        if (subscriber == null) {
-          getLogger().log(XdsLogLevel.INFO, "Subscribe CDS resource {0}", resourceName);
-          subscriber = new ResourceSubscriber(ResourceType.CDS, resourceName);
-          cdsResourceSubscribers.put(resourceName, subscriber);
-          adjustResourceSubscription(ResourceType.CDS);
-        }
-        subscriber.addWatcher(watcher);
-      }
-    });
-  }
-
-  @Override
-  void cancelCdsResourceWatch(final String resourceName, final CdsResourceWatcher watcher) {
-    getSyncContext().execute(new Runnable() {
-      @Override
-      public void run() {
-        ResourceSubscriber subscriber = cdsResourceSubscribers.get(resourceName);
-        subscriber.removeWatcher(watcher);
-        if (!subscriber.isWatched()) {
-          subscriber.stopTimer();
-          getLogger().log(XdsLogLevel.INFO, "Unsubscribe CDS resource {0}", resourceName);
-          cdsResourceSubscribers.remove(resourceName);
-          adjustResourceSubscription(ResourceType.CDS);
-        }
-      }
-    });
-  }
-
-  @Override
-  void watchEdsResource(final String resourceName, final EdsResourceWatcher watcher) {
-    getSyncContext().execute(new Runnable() {
-      @Override
-      public void run() {
-        ResourceSubscriber subscriber = edsResourceSubscribers.get(resourceName);
-        if (subscriber == null) {
-          getLogger().log(XdsLogLevel.INFO, "Subscribe EDS resource {0}", resourceName);
-          subscriber = new ResourceSubscriber(ResourceType.EDS, resourceName);
-          edsResourceSubscribers.put(resourceName, subscriber);
-          adjustResourceSubscription(ResourceType.EDS);
-        }
-        subscriber.addWatcher(watcher);
-      }
-    });
-  }
-
-  @Override
-  void cancelEdsResourceWatch(final String resourceName, final EdsResourceWatcher watcher) {
-    getSyncContext().execute(new Runnable() {
-      @Override
-      public void run() {
-        ResourceSubscriber subscriber = edsResourceSubscribers.get(resourceName);
-        subscriber.removeWatcher(watcher);
-        if (!subscriber.isWatched()) {
-          subscriber.stopTimer();
-          getLogger().log(XdsLogLevel.INFO, "Unsubscribe EDS resource {0}", resourceName);
-          edsResourceSubscribers.remove(resourceName);
-          adjustResourceSubscription(ResourceType.EDS);
-        }
-      }
-    });
-  }
-
-  @Override
-  ClusterDropStats addClusterDropStats(String clusterName, @Nullable String edsServiceName) {
-    ClusterDropStats dropCounter =
-        loadStatsManager.getClusterDropStats(clusterName, edsServiceName);
-    getSyncContext().execute(new Runnable() {
-      @Override
-      public void run() {
-        if (!reportingLoad) {
-          lrsClient.startLoadReporting();
-          reportingLoad = true;
-        }
-      }
-    });
-    return dropCounter;
-  }
-
-  @Override
-  ClusterLocalityStats addClusterLocalityStats(String clusterName,
-      @Nullable String edsServiceName, Locality locality) {
-    ClusterLocalityStats loadCounter =
-        loadStatsManager.getClusterLocalityStats(clusterName, edsServiceName, locality);
-    getSyncContext().execute(new Runnable() {
-      @Override
-      public void run() {
-        if (!reportingLoad) {
-          lrsClient.startLoadReporting();
-          reportingLoad = true;
-        }
-      }
-    });
-    return loadCounter;
-  }
-
-  private void cleanUpResourceTimers() {
-    for (ResourceSubscriber subscriber : ldsResourceSubscribers.values()) {
-      subscriber.stopTimer();
-    }
-    for (ResourceSubscriber subscriber : rdsResourceSubscribers.values()) {
-      subscriber.stopTimer();
-    }
-    for (ResourceSubscriber subscriber : cdsResourceSubscribers.values()) {
-      subscriber.stopTimer();
-    }
-    for (ResourceSubscriber subscriber : edsResourceSubscribers.values()) {
-      subscriber.stopTimer();
-    }
-  }
-
-  /**
-   * Tracks a single subscribed resource.
-   */
-  private final class ResourceSubscriber {
-    private final ResourceType type;
-    private final String resource;
-    private final Set<ResourceWatcher> watchers = new HashSet<>();
-    private ResourceUpdate data;
-    private boolean absent;
-    private ScheduledHandle respTimer;
-
-    ResourceSubscriber(ResourceType type, String resource) {
-      this.type = type;
-      this.resource = resource;
-      if (isInBackoff()) {
-        return;
-      }
-      restartTimer();
-    }
-
-    void addWatcher(ResourceWatcher watcher) {
-      checkArgument(!watchers.contains(watcher), "watcher %s already registered", watcher);
-      watchers.add(watcher);
-      if (data != null) {
-        notifyWatcher(watcher, data);
-      } else if (absent) {
-        watcher.onResourceDoesNotExist(resource);
-      }
-    }
-
-    void removeWatcher(ResourceWatcher watcher) {
-      checkArgument(watchers.contains(watcher), "watcher %s not registered", watcher);
-      watchers.remove(watcher);
-    }
-
-    void restartTimer() {
-      if (data != null || absent) {  // resource already resolved
-        return;
-      }
-      class ResourceNotFound implements Runnable {
-        @Override
-        public void run() {
-          getLogger().log(XdsLogLevel.INFO, "{0} resource {1} initial fetch timeout",
-              type, resource);
-          respTimer = null;
-          onAbsent();
-        }
-
-        @Override
-        public String toString() {
-          return type + this.getClass().getSimpleName();
-        }
-      }
-
-      respTimer = getSyncContext().schedule(
-          new ResourceNotFound(), INITIAL_RESOURCE_FETCH_TIMEOUT_SEC, TimeUnit.SECONDS,
-          getTimeService());
-    }
-
-    void stopTimer() {
-      if (respTimer != null && respTimer.isPending()) {
-        respTimer.cancel();
-        respTimer = null;
-      }
-    }
-
-    boolean isWatched() {
-      return !watchers.isEmpty();
-    }
-
-    void onData(ResourceUpdate data) {
-      if (respTimer != null && respTimer.isPending()) {
-        respTimer.cancel();
-        respTimer = null;
-      }
-      ResourceUpdate oldData = this.data;
-      this.data = data;
-      absent = false;
-      if (!Objects.equals(oldData, data)) {
-        for (ResourceWatcher watcher : watchers) {
-          notifyWatcher(watcher, data);
-        }
-      }
-    }
-
-    void onAbsent() {
-      if (respTimer != null && respTimer.isPending()) {  // too early to conclude absence
-        return;
-      }
-      getLogger().log(XdsLogLevel.INFO, "Conclude {0} resource {1} not exist", type, resource);
-      if (!absent) {
-        data = null;
-        absent = true;
-        for (ResourceWatcher watcher : watchers) {
-          watcher.onResourceDoesNotExist(resource);
-        }
-      }
-    }
-
-    void onError(Status error) {
-      if (respTimer != null && respTimer.isPending()) {
-        respTimer.cancel();
-        respTimer = null;
-      }
-      for (ResourceWatcher watcher : watchers) {
-        watcher.onError(error);
-      }
-    }
-
-    private void notifyWatcher(ResourceWatcher watcher, ResourceUpdate update) {
-      switch (type) {
-        case LDS:
-          ((LdsResourceWatcher) watcher).onChanged((LdsUpdate) update);
-          break;
-        case RDS:
-          ((RdsResourceWatcher) watcher).onChanged((RdsUpdate) update);
-          break;
-        case CDS:
-          ((CdsResourceWatcher) watcher).onChanged((CdsUpdate) update);
-          break;
-        case EDS:
-          ((EdsResourceWatcher) watcher).onChanged((EdsUpdate) update);
-          break;
-        case UNKNOWN:
-        default:
-          throw new AssertionError("should never be here");
-      }
-    }
-  }
-
-  @VisibleForTesting
-  static final class StructOrError<T> {
-
-    /**
-     * Returns a {@link StructOrError} for the successfully converted data object.
-     */
-    private static <T> StructOrError<T> fromStruct(T struct) {
-      return new StructOrError<>(struct);
-    }
-
-    /**
-     * Returns a {@link StructOrError} for the failure to convert the data object.
-     */
-    private 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
-    T getStruct() {
-      return struct;
-    }
-
-    /**
-     * Returns error detail if exists, otherwise null.
-     */
-    @VisibleForTesting
-    @Nullable
-    String getErrorDetail() {
-      return errorDetail;
-    }
-  }
-}
diff --git a/xds/src/main/java/io/grpc/xds/ClusterImplLoadBalancer.java b/xds/src/main/java/io/grpc/xds/ClusterImplLoadBalancer.java
index a405e74bca8..64105144240 100644
--- a/xds/src/main/java/io/grpc/xds/ClusterImplLoadBalancer.java
+++ b/xds/src/main/java/io/grpc/xds/ClusterImplLoadBalancer.java
@@ -17,39 +17,56 @@
 package io.grpc.xds;
 
 import static com.google.common.base.Preconditions.checkNotNull;
-import static io.grpc.xds.XdsSubchannelPickers.BUFFER_PICKER;
+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.ObjectPool;
-import io.grpc.util.ForwardingClientStreamTracer;
+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.LoadStatsManager2.ClusterDropStats;
-import io.grpc.xds.LoadStatsManager2.ClusterLocalityStats;
 import io.grpc.xds.ThreadSafeRandom.ThreadSafeRandomImpl;
-import io.grpc.xds.XdsLogger.XdsLogLevel;
 import io.grpc.xds.XdsNameResolverProvider.CallCounterProvider;
-import io.grpc.xds.XdsSubchannelPickers.ErrorPicker;
-import io.grpc.xds.internal.sds.SslContextProviderSupplier;
-import io.grpc.xds.internal.sds.TlsContextManager;
-import io.grpc.xds.internal.sds.TlsContextManagerImpl;
+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;
 
 /**
@@ -65,86 +82,99 @@ final class ClusterImplLoadBalancer extends LoadBalancer {
   static final long DEFAULT_PER_CLUSTER_MAX_CONCURRENT_REQUESTS = 1024L;
   @VisibleForTesting
   static boolean enableCircuitBreaking =
-      Boolean.parseBoolean(System.getenv("GRPC_XDS_EXPERIMENTAL_CIRCUIT_BREAKING"));
+      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 boolean enableSecurity =
-      Boolean.parseBoolean(System.getenv("GRPC_XDS_EXPERIMENTAL_SECURITY_SUPPORT"));
-  private static final Attributes.Key<ClusterLocalityStats> ATTR_CLUSTER_LOCALITY_STATS =
-      Attributes.Key.create("io.grpc.xds.ClusterImplLoadBalancer.clusterLocalityStats");
+  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;
-  private final TlsContextManager tlsContextManager;
   // The following fields are effectively final.
   private String cluster;
   @Nullable
   private String edsServiceName;
-  private ObjectPool<XdsClient> xdsClientPool;
   private XdsClient xdsClient;
   private CallCounterProvider callCounterProvider;
   private ClusterDropStats dropStats;
   private ClusterImplLbHelper childLbHelper;
-  private LoadBalancer childLb;
+  private GracefulSwitchLoadBalancer childSwitchLb;
 
   ClusterImplLoadBalancer(Helper helper) {
-    this(helper, ThreadSafeRandomImpl.instance, TlsContextManagerImpl.getInstance());
+    this(helper, ThreadSafeRandomImpl.instance);
   }
 
-  ClusterImplLoadBalancer(Helper helper, ThreadSafeRandom random,
-      TlsContextManager tlsContextManager) {
+  ClusterImplLoadBalancer(Helper helper, ThreadSafeRandom random) {
     this.helper = checkNotNull(helper, "helper");
     this.random = checkNotNull(random, "random");
-    this.tlsContextManager = checkNotNull(tlsContextManager, "tlsContextManager");
     InternalLogId logId = InternalLogId.allocate("cluster-impl-lb", helper.getAuthority());
     logger = XdsLogger.withLogId(logId);
     logger.log(XdsLogLevel.INFO, "Created");
   }
 
   @Override
-  public void handleResolvedAddresses(ResolvedAddresses resolvedAddresses) {
+  public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
     logger.log(XdsLogLevel.DEBUG, "Received resolution result: {0}", resolvedAddresses);
     Attributes attributes = resolvedAddresses.getAttributes();
-    if (xdsClientPool == null) {
-      xdsClientPool = attributes.get(InternalXdsAttributes.XDS_CLIENT_POOL);
-      xdsClient = xdsClientPool.getObject();
+    if (xdsClient == null) {
+      xdsClient = checkNotNull(attributes.get(io.grpc.xds.XdsAttributes.XDS_CLIENT), "xdsClient");
     }
     if (callCounterProvider == null) {
-      callCounterProvider = attributes.get(InternalXdsAttributes.CALL_COUNTER_PROVIDER);
+      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));
-      childLb = config.childPolicy.getProvider().newLoadBalancer(childLbHelper);
+          callCounterProvider.getOrCreate(config.cluster, config.edsServiceName),
+          config.lrsServerInfo);
+      childSwitchLb = new GracefulSwitchLoadBalancer(childLbHelper);
       // Assume load report server does not change throughout cluster lifetime.
-      if (config.lrsServerName != null) {
-        if (config.lrsServerName.isEmpty()) {
-          dropStats = xdsClient.addClusterDropStats(cluster, edsServiceName);
-        } else {
-          logger.log(XdsLogLevel.WARNING, "Can only report load to the same management server");
-        }
+      if (config.lrsServerInfo != null) {
+        dropStats = xdsClient.addClusterDropStats(config.lrsServerInfo, cluster, edsServiceName);
       }
     }
+
     childLbHelper.updateDropPolicies(config.dropCategories);
     childLbHelper.updateMaxConcurrentRequests(config.maxConcurrentRequests);
     childLbHelper.updateSslContextProviderSupplier(config.tlsContext);
-    childLb.handleResolvedAddresses(
+    childLbHelper.updateFilterMetadata(config.filterMetadata);
+    childLbHelper.updateBackendMetricPropagation(config.backendMetricPropagation);
+
+    return childSwitchLb.acceptResolvedAddresses(
         resolvedAddresses.toBuilder()
-            .setAttributes(attributes)
-            .setLoadBalancingPolicyConfig(config.childPolicy.getConfig())
+            .setAttributes(attributes.toBuilder()
+              .set(NameResolver.ATTR_BACKEND_SERVICE, cluster)
+              .build())
+            .setLoadBalancingPolicyConfig(config.childConfig)
             .build());
   }
 
   @Override
   public void handleNameResolutionError(Status error) {
-    if (childLb != null) {
-      childLb.handleNameResolutionError(error);
+    if (childSwitchLb != null) {
+      childSwitchLb.handleNameResolutionError(error);
     } else {
-      helper.updateBalancingState(ConnectivityState.TRANSIENT_FAILURE, new ErrorPicker(error));
+      helper.updateBalancingState(
+          ConnectivityState.TRANSIENT_FAILURE, new FixedResultPicker(PickResult.withError(error)));
+    }
+  }
+
+  @Override
+  public void requestConnection() {
+    if (childSwitchLb != null) {
+      childSwitchLb.requestConnection();
     }
   }
 
@@ -153,18 +183,14 @@ public void shutdown() {
     if (dropStats != null) {
       dropStats.release();
     }
-    if (childLb != null) {
-      childLb.shutdown();
-      childLbHelper = null;
-    }
-    if (xdsClient != null) {
-      xdsClient = xdsClientPool.returnObject(xdsClient);
+    if (childSwitchLb != null) {
+      childSwitchLb.shutdown();
+      if (childLbHelper != null) {
+        childLbHelper.updateSslContextProviderSupplier(null);
+        childLbHelper = null;
+      }
     }
-  }
-
-  @Override
-  public boolean canHandleEmptyAddressListFromNameResolution() {
-    return true;
+    xdsClient = null;
   }
 
   /**
@@ -174,65 +200,144 @@ public boolean canHandleEmptyAddressListFromNameResolution() {
   private final class ClusterImplLbHelper extends ForwardingLoadBalancerHelper {
     private final AtomicLong inFlights;
     private ConnectivityState currentState = ConnectivityState.IDLE;
-    private SubchannelPicker currentPicker = BUFFER_PICKER;
+    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) {
+    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);
+      SubchannelPicker picker = new RequestLimitingSubchannelPicker(
+          newPicker, dropPolicies, maxConcurrentRequests, filterMetadata);
       delegate().updateBalancingState(newState, picker);
     }
 
     @Override
     public Subchannel createSubchannel(CreateSubchannelArgs args) {
-      List<EquivalentAddressGroup> addresses = new ArrayList<>();
-      for (EquivalentAddressGroup eag : args.getAddresses()) {
+      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 ClusterImplSubchannel(subchannel, localityAtomicReference);
+    }
+
+    private final class ClusterImplSubchannel extends ForwardingSubchannel {
+      private final Subchannel delegate;
+      private final AtomicReference<ClusterLocality> localityAtomicReference;
+
+      private ClusterImplSubchannel(
+          Subchannel delegate, AtomicReference<ClusterLocality> localityAtomicReference) {
+        this.delegate = delegate;
+        this.localityAtomicReference = localityAtomicReference;
+      }
+
+      @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(
+                          delegate.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 delegate;
+      }
+    }
+
+    private List<EquivalentAddressGroup> withAdditionalAttributes(
+        List<EquivalentAddressGroup> addresses) {
+      List<EquivalentAddressGroup> newAddresses = new ArrayList<>();
+      for (EquivalentAddressGroup eag : addresses) {
         Attributes.Builder attrBuilder = eag.getAttributes().toBuilder().set(
-            InternalXdsAttributes.ATTR_CLUSTER_NAME, cluster);
-        if (enableSecurity && sslContextProviderSupplier != null) {
+            io.grpc.xds.XdsAttributes.ATTR_CLUSTER_NAME, cluster);
+        if (sslContextProviderSupplier != null) {
           attrBuilder.set(
-              InternalXdsAttributes.ATTR_SSL_CONTEXT_PROVIDER_SUPPLIER,
+              SecurityProtocolNegotiators.ATTR_SSL_CONTEXT_PROVIDER_SUPPLIER,
               sslContextProviderSupplier);
         }
-        addresses.add(new EquivalentAddressGroup(eag.getAddresses(), attrBuilder.build()));
+        newAddresses.add(new EquivalentAddressGroup(eag.getAddresses(), attrBuilder.build()));
       }
-      Locality locality = args.getAddresses().get(0).getAttributes().get(
-          InternalXdsAttributes.ATTR_LOCALITY);  // all addresses should be in the same locality
+      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.
+      // 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 = xdsClient.addClusterLocalityStats(
-          cluster, edsServiceName, locality);
-      Attributes attrs = args.getAttributes().toBuilder().set(
-          ATTR_CLUSTER_LOCALITY_STATS, localityStats).build();
-      args = args.toBuilder().setAddresses(addresses).setAttributes(attrs).build();
-      final Subchannel subchannel = delegate().createSubchannel(args);
 
-      return new ForwardingSubchannel() {
-        @Override
-        public void shutdown() {
-          localityStats.release();
-          delegate().shutdown();
-        }
+      final ClusterLocalityStats localityStats =
+          (lrsServerInfo == null)
+              ? null
+              : xdsClient.addClusterLocalityStats(lrsServerInfo, cluster,
+                  edsServiceName, locality, backendMetricPropagation);
 
-        @Override
-        protected Subchannel delegate() {
-          return subchannel;
-        }
-      };
+      return new ClusterLocality(localityStats, localityName);
     }
 
     @Override
@@ -261,7 +366,7 @@ private void updateMaxConcurrentRequests(@Nullable Long maxConcurrentRequests) {
     private void updateSslContextProviderSupplier(@Nullable UpstreamTlsContext tlsContext) {
       UpstreamTlsContext currentTlsContext =
           sslContextProviderSupplier != null
-              ? sslContextProviderSupplier.getUpstreamTlsContext()
+              ? (UpstreamTlsContext)sslContextProviderSupplier.getTlsContext()
               : null;
       if (Objects.equals(currentTlsContext,  tlsContext)) {
         return;
@@ -271,24 +376,40 @@ private void updateSslContextProviderSupplier(@Nullable UpstreamTlsContext tlsCo
       }
       sslContextProviderSupplier =
           tlsContext != null
-              ? new SslContextProviderSupplier(tlsContext, tlsContextManager)
+              ? 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) {
+          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()) {
@@ -301,30 +422,61 @@ public PickResult pickSubchannel(PickSubchannelArgs args) {
                 Status.UNAVAILABLE.withDescription("Dropped: " + dropOverload.category()));
           }
         }
-        final PickResult result = delegate.pickSubchannel(args);
+        PickResult result = delegate.pickSubchannel(args);
         if (result.getStatus().isOk() && result.getSubchannel() != null) {
+          Subchannel subchannel = result.getSubchannel();
+          if (subchannel instanceof ClusterImplLbHelper.ClusterImplSubchannel) {
+            subchannel = ((ClusterImplLbHelper.ClusterImplSubchannel) subchannel).delegate();
+            result = result.copyWithSubchannel(subchannel);
+          }
           if (enableCircuitBreaking) {
             if (inFlights.get() >= maxConcurrentRequests) {
               if (dropStats != null) {
                 dropStats.recordDroppedRequest();
               }
               return PickResult.withDrop(Status.UNAVAILABLE.withDescription(
-                  "Cluster max concurrent requests limit exceeded"));
+                  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 = result.copyWithStreamTracerFactory(orcaTracerFactory);
             }
           }
-          final ClusterLocalityStats stats =
-              result.getSubchannel().getAttributes().get(ATTR_CLUSTER_LOCALITY_STATS);
-          ClientStreamTracer.Factory tracerFactory = new CountingStreamTracerFactory(
-              stats, inFlights, result.getStreamTracerFactory());
-          return PickResult.withSubchannel(result.getSubchannel(), tracerFactory);
+          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 ClusterLocalityStats stats;
+  private static final class CountingStreamTracerFactory extends
+      ClientStreamTracer.Factory {
+    private final ClusterLocalityStats stats;
     private final AtomicLong inFlights;
     @Nullable
     private final ClientStreamTracer.Factory delegate;
@@ -366,4 +518,59 @@ public void streamClosed(Status 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
index 939734fe4f0..f369c3b99b4 100644
--- a/xds/src/main/java/io/grpc/xds/ClusterImplLoadBalancerProvider.java
+++ b/xds/src/main/java/io/grpc/xds/ClusterImplLoadBalancerProvider.java
@@ -19,19 +19,25 @@
 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.internal.ServiceConfigUtil.PolicySelection;
+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;
 
 /**
@@ -41,6 +47,11 @@
  */
 @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() {
@@ -59,7 +70,8 @@ public String getPolicyName() {
 
   @Override
   public ConfigOrError parseLoadBalancingPolicyConfig(Map<String, ?> rawLoadBalancingPolicyConfig) {
-    throw new UnsupportedOperationException("not supported as top-level LB policy");
+    return ConfigOrError.fromError(
+        Status.INTERNAL.withDescription(getPolicyName() + " cannot be used from service config"));
   }
 
   @Override
@@ -73,9 +85,9 @@ static final class ClusterImplConfig {
     // Resource name used in discovering endpoints via EDS. Only valid for EDS clusters.
     @Nullable
     final String edsServiceName;
-    // Load report server name. Null if load reporting is disabled.
+    // Load report server info. Null if load reporting is disabled.
     @Nullable
-    final String lrsServerName;
+    final ServerInfo lrsServerInfo;
     // Cluster-level max concurrent request threshold. Null if not specified.
     @Nullable
     final Long maxConcurrentRequests;
@@ -85,20 +97,26 @@ static final class ClusterImplConfig {
     // Drop configurations.
     final List<DropOverload> dropCategories;
     // Provides the direct child policy and its config.
-    final PolicySelection childPolicy;
+    final Object childConfig;
+    final Map<String, Struct> filterMetadata;
+    @Nullable
+    final BackendMetricPropagation backendMetricPropagation;
 
     ClusterImplConfig(String cluster, @Nullable String edsServiceName,
-        @Nullable String lrsServerName, @Nullable Long maxConcurrentRequests,
-        List<DropOverload> dropCategories, PolicySelection childPolicy,
-        @Nullable UpstreamTlsContext tlsContext) {
+        @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.lrsServerName = lrsServerName;
+      this.lrsServerInfo = lrsServerInfo;
       this.maxConcurrentRequests = maxConcurrentRequests;
       this.tlsContext = tlsContext;
+      this.filterMetadata = ImmutableMap.copyOf(filterMetadata);
       this.dropCategories = Collections.unmodifiableList(
           new ArrayList<>(checkNotNull(dropCategories, "dropCategories")));
-      this.childPolicy = checkNotNull(childPolicy, "childPolicy");
+      this.childConfig = checkNotNull(childConfig, "childConfig");
+      this.backendMetricPropagation = backendMetricPropagation;
     }
 
     @Override
@@ -106,11 +124,11 @@ public String toString() {
       return MoreObjects.toStringHelper(this)
           .add("cluster", cluster)
           .add("edsServiceName", edsServiceName)
-          .add("lrsServerName", lrsServerName)
+          .add("lrsServerInfo", lrsServerInfo)
           .add("maxConcurrentRequests", maxConcurrentRequests)
           // Exclude tlsContext as its string representation is cumbersome.
           .add("dropCategories", dropCategories)
-          .add("childPolicy", childPolicy)
+          .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
index 69238c39ddb..22b5aaa7d73 100644
--- a/xds/src/main/java/io/grpc/xds/ClusterManagerLoadBalancer.java
+++ b/xds/src/main/java/io/grpc/xds/ClusterManagerLoadBalancer.java
@@ -17,190 +17,208 @@
 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 static io.grpc.xds.XdsSubchannelPickers.BUFFER_PICKER;
 
 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.LoadBalancerProvider;
 import io.grpc.Status;
 import io.grpc.SynchronizationContext;
 import io.grpc.SynchronizationContext.ScheduledHandle;
-import io.grpc.internal.ServiceConfigUtil.PolicySelection;
-import io.grpc.util.ForwardingLoadBalancerHelper;
 import io.grpc.util.GracefulSwitchLoadBalancer;
+import io.grpc.util.MultiChildLoadBalancer;
 import io.grpc.xds.ClusterManagerLoadBalancerProvider.ClusterManagerConfig;
-import io.grpc.xds.XdsLogger.XdsLogLevel;
-import io.grpc.xds.XdsSubchannelPickers.ErrorPicker;
+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.
+ * 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 LoadBalancer {
+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
-  static final int DELAYED_CHILD_DELETION_TIME_MINUTES = 15;
-
-  private final Map<String, ChildLbState> childLbStates = new HashMap<>();
-  private final Helper helper;
-  private final SynchronizationContext syncContext;
+  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) {
-    this.helper = checkNotNull(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
-  public void handleResolvedAddresses(ResolvedAddresses resolvedAddresses) {
-    logger.log(XdsLogLevel.DEBUG, "Received resolution result: {0}", resolvedAddresses);
+  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();
-    Map<String, PolicySelection> newChildPolicies = config.childPolicies;
     logger.log(
         XdsLogLevel.INFO,
-        "Received cluster_manager lb config: child names={0}", newChildPolicies.keySet());
-    for (Map.Entry<String, PolicySelection> entry : newChildPolicies.entrySet()) {
-      final String name = entry.getKey();
-      LoadBalancerProvider childPolicyProvider = entry.getValue().getProvider();
-      Object childConfig = entry.getValue().getConfig();
-      if (!childLbStates.containsKey(name)) {
-        childLbStates.put(name, new ChildLbState(name, childPolicyProvider));
+        "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 {
-        childLbStates.get(name).reactivate(childPolicyProvider);
+        // Inactive child
+        if (state.deletionTimer == null) {
+          state.deactivateChild();
+        }
+        if (state.deletionTimer.isPending()) {
+          childAddresses.put(state.getKey(), null); // Preserve child, without config update
+        }
       }
-      LoadBalancer childLb = childLbStates.get(name).lb;
-      ResolvedAddresses childAddresses =
-          resolvedAddresses.toBuilder().setLoadBalancingPolicyConfig(childConfig).build();
-      childLb.handleResolvedAddresses(childAddresses);
     }
-    for (String name : childLbStates.keySet()) {
-      if (!newChildPolicies.containsKey(name)) {
-        childLbStates.get(name).deactivate();
+
+    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;
     }
-    // Must update channel picker before return so that new RPCs will not be routed to deleted
-    // clusters and resolver can remove them in service config.
-    updateOverallBalancingState();
+  }
+
+  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 : childLbStates.values()) {
-      if (!state.deactivated) {
+    for (ChildLbState state : getChildLbStates()) {
+      if (((ClusterManagerLbState) state).deletionTimer == null) {
         gotoTransientFailure = false;
-        state.lb.handleNameResolutionError(error);
+        state.getLb().handleNameResolutionError(error);
       }
     }
     if (gotoTransientFailure) {
-      helper.updateBalancingState(TRANSIENT_FAILURE, new ErrorPicker(error));
+      getHelper().updateBalancingState(
+          TRANSIENT_FAILURE, new FixedResultPicker(PickResult.withError(error)));
     }
   }
 
-  @Override
-  public boolean canHandleEmptyAddressListFromNameResolution() {
-    return true;
-  }
+  /**
+   * 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;
 
-  @Override
-  public void shutdown() {
-    logger.log(XdsLogLevel.INFO, "Shutdown");
-    for (ChildLbState state : childLbStates.values()) {
-      state.shutdown();
+    public ClusterManagerLbState(Object key, LoadBalancer.Factory policyFactory) {
+      super(key, policyFactory);
     }
-  }
 
-  private void updateOverallBalancingState() {
-    ConnectivityState overallState = null;
-    final Map<String, SubchannelPicker> childPickers = new HashMap<>();
-    for (ChildLbState childLbState : childLbStates.values()) {
-      if (childLbState.deactivated) {
-        continue;
-      }
-      childPickers.put(childLbState.name, childLbState.currentPicker);
-      overallState = aggregateState(overallState, childLbState.currentState);
+    @Override
+    protected ChildLbStateHelper createChildHelper() {
+      return new ClusterManagerChildHelper();
     }
-    if (overallState != null) {
-      SubchannelPicker picker = new SubchannelPicker() {
-        @Override
-        public PickResult pickSubchannel(PickSubchannelArgs args) {
-          String clusterName =
-              args.getCallOptions().getOption(XdsNameResolver.CLUSTER_SELECTION_KEY);
-          SubchannelPicker delegate = childPickers.get(clusterName);
-          if (delegate == null) {
-            return
-                PickResult.withError(
-                    Status.UNAVAILABLE.withDescription("Unable to find cluster " + clusterName));
-          }
-          return delegate.pickSubchannel(args);
-        }
-      };
-      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;
+    @Override
+    protected void shutdown() {
+      if (deletionTimer != null) {
+        deletionTimer.cancel();
+        deletionTimer = null;
+      }
+      super.shutdown();
     }
-    return overallState;
-  }
 
-  private final class ChildLbState {
-    private final String name;
-    private final GracefulSwitchLoadBalancer lb;
-    private LoadBalancerProvider policyProvider;
-    private ConnectivityState currentState = CONNECTING;
-    private SubchannelPicker currentPicker = BUFFER_PICKER;
-    private boolean deactivated;
-    @Nullable
-    ScheduledHandle deletionTimer;
-
-    ChildLbState(String name, LoadBalancerProvider policyProvider) {
-      this.name = name;
-      this.policyProvider = policyProvider;
-      lb = new GracefulSwitchLoadBalancer(new ChildLbStateHelper());
-      lb.switchTo(policyProvider);
+    void reactivateChild() {
+      assert deletionTimer != null;
+      deletionTimer.cancel();
+      deletionTimer = null;
+      logger.log(XdsLogLevel.DEBUG, "Child balancer {0} reactivated", getKey());
     }
 
-    void deactivate() {
-      if (deactivated) {
-        return;
-      }
+    void deactivateChild() {
+      assert deletionTimer == null;
 
       class DeletionTask implements Runnable {
+
         @Override
         public void run() {
-          shutdown();
-          childLbStates.remove(name);
+          acceptResolvedAddresses(lastResolvedAddresses);
         }
       }
 
@@ -210,58 +228,36 @@ public void run() {
               DELAYED_CHILD_DELETION_TIME_MINUTES,
               TimeUnit.MINUTES,
               timeService);
-      deactivated = true;
-      logger.log(XdsLogLevel.DEBUG, "Child balancer {0} deactivated", name);
+      logger.log(XdsLogLevel.DEBUG, "Child balancer {0} deactivated", getKey());
     }
 
-    void reactivate(LoadBalancerProvider policyProvider) {
-      if (deletionTimer != null && deletionTimer.isPending()) {
-        deletionTimer.cancel();
-        deactivated = false;
-        logger.log(XdsLogLevel.DEBUG, "Child balancer {0} reactivated", name);
-      }
-      if (!this.policyProvider.getPolicyName().equals(policyProvider.getPolicyName())) {
-        logger.log(
-            XdsLogLevel.DEBUG,
-            "Child balancer {0} switching policy from {1} to {2}",
-            name, this.policyProvider.getPolicyName(), policyProvider.getPolicyName());
-        lb.switchTo(policyProvider);
-        this.policyProvider = policyProvider;
-      }
-    }
+    private class ClusterManagerChildHelper extends ChildLbStateHelper {
+      @Override
+      public void updateBalancingState(final ConnectivityState newState,
+                                       final SubchannelPicker newPicker) {
+        if (getCurrentState() == ConnectivityState.SHUTDOWN) {
+          return;
+        }
 
-    void shutdown() {
-      deactivated = true;
-      if (deletionTimer != null && deletionTimer.isPending()) {
-        deletionTimer.cancel();
+        // 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();
+        }
       }
-      lb.shutdown();
-      logger.log(XdsLogLevel.DEBUG, "Child balancer {0} deleted", name);
     }
+  }
 
-    private final class ChildLbStateHelper extends ForwardingLoadBalancerHelper {
-
-      @Override
-      public void updateBalancingState(final ConnectivityState newState,
-          final SubchannelPicker newPicker) {
-        syncContext.execute(new Runnable() {
-          @Override
-          public void run() {
-            currentState = newState;
-            currentPicker = newPicker;
-            // Subchannel picker and state are saved, but will only be propagated to the channel
-            // when the child instance exits deactivated state.
-            if (!deactivated) {
-              updateOverallBalancingState();
-            }
-          }
-        });
-      }
+  static final class GracefulSwitchLoadBalancerFactory extends LoadBalancer.Factory {
+    static final LoadBalancer.Factory INSTANCE = new GracefulSwitchLoadBalancerFactory();
 
-      @Override
-      protected Helper delegate() {
-        return helper;
-      }
+    @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
index e219c0467ac..7a7e16286f8 100644
--- a/xds/src/main/java/io/grpc/xds/ClusterManagerLoadBalancerProvider.java
+++ b/xds/src/main/java/io/grpc/xds/ClusterManagerLoadBalancerProvider.java
@@ -26,12 +26,9 @@
 import io.grpc.NameResolver.ConfigOrError;
 import io.grpc.Status;
 import io.grpc.internal.JsonUtil;
-import io.grpc.internal.ServiceConfigUtil;
-import io.grpc.internal.ServiceConfigUtil.LbConfig;
-import io.grpc.internal.ServiceConfigUtil.PolicySelection;
+import io.grpc.util.GracefulSwitchLoadBalancer;
 import java.util.Collections;
 import java.util.LinkedHashMap;
-import java.util.List;
 import java.util.Map;
 import java.util.Objects;
 import javax.annotation.Nullable;
@@ -73,7 +70,7 @@ public String getPolicyName() {
 
   @Override
   public ConfigOrError parseLoadBalancingPolicyConfig(Map<String, ?> rawConfig) {
-    Map<String, PolicySelection> parsedChildPolicies = new LinkedHashMap<>();
+    Map<String, Object> parsedChildPolicies = new LinkedHashMap<>();
     try {
       Map<String, ?> childPolicies = JsonUtil.getObject(rawConfig, "childPolicy");
       if (childPolicies == null || childPolicies.isEmpty()) {
@@ -86,31 +83,23 @@ public ConfigOrError parseLoadBalancingPolicyConfig(Map<String, ?> rawConfig) {
           return ConfigOrError.fromError(Status.INTERNAL.withDescription(
               "No config for child " + name + " in cluster_manager LB policy: " + rawConfig));
         }
-        List<LbConfig> childConfigCandidates =
-            ServiceConfigUtil.unwrapLoadBalancingConfigList(
-                JsonUtil.getListOfObjects(childPolicy, "lbPolicy"));
-        if (childConfigCandidates == null || childConfigCandidates.isEmpty()) {
-          return ConfigOrError.fromError(Status.INTERNAL.withDescription(
-              "No config specified for child " + name + " in cluster_manager Lb policy: "
-                  + rawConfig));
-        }
         LoadBalancerRegistry registry =
             lbRegistry != null ? lbRegistry : LoadBalancerRegistry.getDefaultRegistry();
-        ConfigOrError selectedConfig =
-            ServiceConfigUtil.selectLbPolicyFromList(childConfigCandidates, registry);
-        if (selectedConfig.getError() != null) {
-          Status error = selectedConfig.getError();
+        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 select config for child " + name));
+                  .augmentDescription("Failed to parse config for child " + name));
         }
-        parsedChildPolicies.put(name, (PolicySelection) selectedConfig.getConfig());
+        parsedChildPolicies.put(name, childConfig.getConfig());
       }
     } catch (RuntimeException e) {
       return ConfigOrError.fromError(
-          Status.fromThrowable(e).withDescription(
+          Status.INTERNAL.withCause(e).withDescription(
               "Failed to parse cluster_manager LB config: " + rawConfig));
     }
     return ConfigOrError.fromConfig(new ClusterManagerConfig(parsedChildPolicies));
@@ -122,9 +111,9 @@ public LoadBalancer newLoadBalancer(Helper helper) {
   }
 
   static class ClusterManagerConfig {
-    final Map<String, PolicySelection> childPolicies;
+    final Map<String, Object> childPolicies;
 
-    ClusterManagerConfig(Map<String, PolicySelection> childPolicies) {
+    ClusterManagerConfig(Map<String, Object> childPolicies) {
       this.childPolicies = Collections.unmodifiableMap(childPolicies);
     }
 
diff --git a/xds/src/main/java/io/grpc/xds/ClusterResolverLoadBalancer.java b/xds/src/main/java/io/grpc/xds/ClusterResolverLoadBalancer.java
deleted file mode 100644
index 4ee0e773a2d..00000000000
--- a/xds/src/main/java/io/grpc/xds/ClusterResolverLoadBalancer.java
+++ /dev/null
@@ -1,687 +0,0 @@
-/*
- * 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.TRANSIENT_FAILURE;
-import static io.grpc.xds.XdsLbPolicies.PRIORITY_POLICY_NAME;
-import static io.grpc.xds.XdsSubchannelPickers.BUFFER_PICKER;
-
-import com.google.common.annotations.VisibleForTesting;
-import io.grpc.Attributes;
-import io.grpc.EquivalentAddressGroup;
-import io.grpc.InternalLogId;
-import io.grpc.LoadBalancer;
-import io.grpc.LoadBalancerProvider;
-import io.grpc.LoadBalancerRegistry;
-import io.grpc.NameResolver;
-import io.grpc.NameResolver.ResolutionResult;
-import io.grpc.Status;
-import io.grpc.SynchronizationContext;
-import io.grpc.SynchronizationContext.ScheduledHandle;
-import io.grpc.internal.BackoffPolicy;
-import io.grpc.internal.ExponentialBackoffPolicy;
-import io.grpc.internal.ObjectPool;
-import io.grpc.internal.ServiceConfigUtil.PolicySelection;
-import io.grpc.util.ForwardingLoadBalancerHelper;
-import io.grpc.util.GracefulSwitchLoadBalancer;
-import io.grpc.xds.ClusterImplLoadBalancerProvider.ClusterImplConfig;
-import io.grpc.xds.ClusterResolverLoadBalancerProvider.ClusterResolverConfig;
-import io.grpc.xds.ClusterResolverLoadBalancerProvider.ClusterResolverConfig.DiscoveryMechanism;
-import io.grpc.xds.Endpoints.DropOverload;
-import io.grpc.xds.Endpoints.LbEndpoint;
-import io.grpc.xds.Endpoints.LocalityLbEndpoints;
-import io.grpc.xds.EnvoyServerProtoData.UpstreamTlsContext;
-import io.grpc.xds.PriorityLoadBalancerProvider.PriorityLbConfig;
-import io.grpc.xds.PriorityLoadBalancerProvider.PriorityLbConfig.PriorityChildConfig;
-import io.grpc.xds.WeightedTargetLoadBalancerProvider.WeightedPolicySelection;
-import io.grpc.xds.WeightedTargetLoadBalancerProvider.WeightedTargetConfig;
-import io.grpc.xds.XdsClient.EdsResourceWatcher;
-import io.grpc.xds.XdsClient.EdsUpdate;
-import io.grpc.xds.XdsLogger.XdsLogLevel;
-import io.grpc.xds.XdsSubchannelPickers.ErrorPicker;
-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.List;
-import java.util.Map;
-import java.util.Objects;
-import java.util.concurrent.ScheduledExecutorService;
-import java.util.concurrent.TimeUnit;
-import javax.annotation.Nullable;
-
-/**
- * Load balancer for cluster_resolver_experimental LB policy. This LB policy is the child LB policy
- * of the cds_experimental LB policy and the parent LB policy of the priority_experimental LB
- * policy in the xDS load balancing hierarchy. This policy resolves endpoints of non-aggregate
- * clusters (e.g., EDS or Logical DNS) and groups endpoints in priorities and localities to be
- * used in the downstream LB policies for fine-grained load balancing purposes.
- */
-final class ClusterResolverLoadBalancer extends LoadBalancer {
-
-  private static final Locality LOGICAL_DNS_CLUSTER_LOCALITY = Locality.create("", "", "");
-  private final XdsLogger logger;
-  private final String authority;
-  private final SynchronizationContext syncContext;
-  private final ScheduledExecutorService timeService;
-  private final LoadBalancerRegistry lbRegistry;
-  private final BackoffPolicy.Provider backoffPolicyProvider;
-  private final GracefulSwitchLoadBalancer delegate;
-  private ObjectPool<XdsClient> xdsClientPool;
-  private XdsClient xdsClient;
-  private ClusterResolverConfig config;
-
-  ClusterResolverLoadBalancer(Helper helper) {
-    this(helper, LoadBalancerRegistry.getDefaultRegistry(),
-        new ExponentialBackoffPolicy.Provider());
-  }
-
-  @VisibleForTesting
-  ClusterResolverLoadBalancer(Helper helper, LoadBalancerRegistry lbRegistry,
-      BackoffPolicy.Provider backoffPolicyProvider) {
-    this.lbRegistry = checkNotNull(lbRegistry, "lbRegistry");
-    this.backoffPolicyProvider = checkNotNull(backoffPolicyProvider, "backoffPolicyProvider");
-    this.authority = checkNotNull(checkNotNull(helper, "helper").getAuthority(), "authority");
-    this.syncContext = checkNotNull(helper.getSynchronizationContext(), "syncContext");
-    this.timeService = checkNotNull(helper.getScheduledExecutorService(), "timeService");
-    delegate = new GracefulSwitchLoadBalancer(helper);
-    logger = XdsLogger.withLogId(
-        InternalLogId.allocate("cluster-resolver-lb", helper.getAuthority()));
-    logger.log(XdsLogLevel.INFO, "Created");
-  }
-
-  @Override
-  public void handleResolvedAddresses(ResolvedAddresses resolvedAddresses) {
-    logger.log(XdsLogLevel.DEBUG, "Received resolution result: {0}", resolvedAddresses);
-    if (xdsClientPool == null) {
-      xdsClientPool = resolvedAddresses.getAttributes().get(InternalXdsAttributes.XDS_CLIENT_POOL);
-      xdsClient = xdsClientPool.getObject();
-    }
-    ClusterResolverConfig config =
-        (ClusterResolverConfig) resolvedAddresses.getLoadBalancingPolicyConfig();
-    if (!Objects.equals(this.config, config)) {
-      logger.log(XdsLogLevel.DEBUG, "Config: {0}", config);
-      delegate.switchTo(new ClusterResolverLbStateFactory());
-      this.config = config;
-      delegate.handleResolvedAddresses(resolvedAddresses);
-    }
-  }
-
-  @Override
-  public void handleNameResolutionError(Status error) {
-    logger.log(XdsLogLevel.WARNING, "Received name resolution error: {0}", error);
-    delegate.handleNameResolutionError(error);
-  }
-
-  @Override
-  public void shutdown() {
-    logger.log(XdsLogLevel.INFO, "Shutdown");
-    delegate.shutdown();
-    if (xdsClientPool != null) {
-      xdsClientPool.returnObject(xdsClient);
-    }
-  }
-
-  private final class ClusterResolverLbStateFactory extends LoadBalancer.Factory {
-    @Override
-    public LoadBalancer newLoadBalancer(Helper helper) {
-      return new ClusterResolverLbState(helper);
-    }
-  }
-
-  /**
-   * The state of a cluster_resolver LB working session. A new instance is created whenever
-   * the cluster_resolver LB receives a new config. The old instance is replaced when the
-   * new one is ready to handle new RPCs.
-   */
-  private final class ClusterResolverLbState extends LoadBalancer {
-    private final Helper helper;
-    private final List<String> clusters = new ArrayList<>();
-    private final Map<String, ClusterState> clusterStates = new HashMap<>();
-    // An aggregate cluster is thought of as a cluster that groups the endpoints of the underlying
-    // clusters together for load balancing purposes only. Load balancing policies (both locality
-    // level and endpoint level) are configured by the aggregate cluster and apply to all of its
-    // underlying clusters.
-    private PolicySelection localityPickingPolicy;
-    private PolicySelection endpointPickingPolicy;
-    private ResolvedAddresses resolvedAddresses;
-    private LoadBalancer childLb;
-
-    ClusterResolverLbState(Helper helper) {
-      this.helper = new RefreshableHelper(checkNotNull(helper, "helper"));
-      logger.log(XdsLogLevel.DEBUG, "New ClusterResolverLbState");
-    }
-
-    @Override
-    public void handleResolvedAddresses(ResolvedAddresses resolvedAddresses) {
-      this.resolvedAddresses = resolvedAddresses;
-      ClusterResolverConfig config =
-          (ClusterResolverConfig) resolvedAddresses.getLoadBalancingPolicyConfig();
-      localityPickingPolicy = config.localityPickingPolicy;
-      endpointPickingPolicy = config.endpointPickingPolicy;
-      for (DiscoveryMechanism instance : config.discoveryMechanisms) {
-        clusters.add(instance.cluster);
-        ClusterState state;
-        if (instance.type == DiscoveryMechanism.Type.EDS) {
-          state = new EdsClusterState(instance.cluster, instance.edsServiceName,
-              instance.lrsServerName, instance.maxConcurrentRequests, instance.tlsContext);
-          clusterStates.put(instance.cluster, state);
-        } else {  // logical DNS
-          state = new LogicalDnsClusterState(instance.cluster, instance.lrsServerName,
-              instance.maxConcurrentRequests, instance.tlsContext);
-          clusterStates.put(instance.cluster, state);
-        }
-        state.start();
-      }
-    }
-
-    @Override
-    public void handleNameResolutionError(Status error) {
-      if (childLb != null) {
-        childLb.handleNameResolutionError(error);
-      } else {
-        helper.updateBalancingState(TRANSIENT_FAILURE, new ErrorPicker(error));
-      }
-    }
-
-    @Override
-    public void shutdown() {
-      for (ClusterState state : clusterStates.values()) {
-        state.shutdown();
-      }
-      if (childLb != null) {
-        childLb.shutdown();
-      }
-    }
-
-    private void handleEndpointResourceUpdate() {
-      List<EquivalentAddressGroup> addresses = new ArrayList<>();
-      Map<String, PriorityChildConfig> priorityChildConfigs = new HashMap<>();
-      List<String> priorities = new ArrayList<>();  // totally ordered priority list
-      boolean allResolved = true;
-      for (String cluster : clusters) {
-        ClusterState state = clusterStates.get(cluster);
-        if (!state.resolved) {
-          allResolved = false;
-          continue;
-        }
-        if (state.result != null) {
-          addresses.addAll(state.result.addresses);
-          priorityChildConfigs.putAll(state.result.priorityChildConfigs);
-          priorities.addAll(state.result.priorities);
-        }
-      }
-      if (addresses.isEmpty()) {
-        if (childLb != null) {
-          childLb.shutdown();
-          childLb = null;
-        }
-        if (allResolved) {
-          Status unavailable = Status.UNAVAILABLE.withDescription("No usable endpoint");
-          helper.updateBalancingState(TRANSIENT_FAILURE, new ErrorPicker(unavailable));
-        } else {
-          helper.updateBalancingState(CONNECTING, BUFFER_PICKER);
-        }
-        return;
-      }
-      PriorityLbConfig childConfig =
-          new PriorityLbConfig(Collections.unmodifiableMap(priorityChildConfigs),
-              Collections.unmodifiableList(priorities));
-      if (childLb == null) {
-        childLb = lbRegistry.getProvider(PRIORITY_POLICY_NAME).newLoadBalancer(helper);
-      }
-      childLb.handleResolvedAddresses(
-          resolvedAddresses.toBuilder()
-              .setLoadBalancingPolicyConfig(childConfig)
-              .setAddresses(Collections.unmodifiableList(addresses))
-              .build());
-    }
-
-    private void handleEndpointResolutionError() {
-      boolean allInError = true;
-      for (ClusterState state :  clusterStates.values()) {
-        if (state.status.isOk()) {
-          allInError = false;
-        }
-      }
-      if (allInError) {
-        // Propagate the error status of the last cluster. This is the best we can do.
-        Status error = clusterStates.get(clusters.get(clusters.size() - 1)).status;
-        if (childLb != null) {
-          childLb.handleNameResolutionError(error);
-        } else {
-          helper.updateBalancingState(TRANSIENT_FAILURE, new ErrorPicker(error));
-        }
-      }
-    }
-
-    /**
-     * Wires re-resolution requests from downstream LB policies with DNS resolver.
-     */
-    private final class RefreshableHelper extends ForwardingLoadBalancerHelper {
-      private final Helper delegate;
-
-      private RefreshableHelper(Helper delegate) {
-        this.delegate = checkNotNull(delegate, "delegate");
-      }
-
-      @Override
-      public void refreshNameResolution() {
-        for (ClusterState state : clusterStates.values()) {
-          if (state instanceof LogicalDnsClusterState) {
-            ((LogicalDnsClusterState) state).refresh();
-          }
-        }
-      }
-
-      @Override
-      protected Helper delegate() {
-        return delegate;
-      }
-    }
-
-    /**
-     * Resolution state of an underlying cluster.
-     */
-    private abstract class ClusterState {
-      // Name of the cluster to be resolved.
-      protected final String name;
-      // The resource name to be used for resolving endpoints via EDS.
-      // Always null if the cluster is a logical DNS cluster.
-      @Nullable
-      protected final String edsServiceName;
-      @Nullable
-      protected final String lrsServerName;
-      @Nullable
-      protected final Long maxConcurrentRequests;
-      @Nullable
-      protected final UpstreamTlsContext tlsContext;
-      // Resolution status, may contain most recent error encountered.
-      protected Status status = Status.OK;
-      // True if has received resolution result.
-      protected boolean resolved;
-      // Most recently resolved addresses and config, or null if resource not exists.
-      @Nullable
-      protected ClusterResolutionResult result;
-      protected boolean shutdown;
-
-      private ClusterState(String name, @Nullable String edsServiceName,
-          @Nullable String lrsServerName, @Nullable Long maxConcurrentRequests,
-          @Nullable UpstreamTlsContext tlsContext) {
-        this.name = name;
-        this.edsServiceName = edsServiceName;
-        this.lrsServerName = lrsServerName;
-        this.maxConcurrentRequests = maxConcurrentRequests;
-        this.tlsContext = tlsContext;
-      }
-
-      abstract void start();
-
-      void shutdown() {
-        shutdown = true;
-      }
-    }
-
-    private class EdsClusterState extends ClusterState implements EdsResourceWatcher {
-
-      private EdsClusterState(String name, @Nullable String edsServiceName,
-          @Nullable String lrsServerName, @Nullable Long maxConcurrentRequests,
-          @Nullable UpstreamTlsContext tlsContext) {
-        super(name, edsServiceName, lrsServerName, maxConcurrentRequests, tlsContext);
-      }
-
-      @Override
-      void start() {
-        String resourceName = edsServiceName != null ? edsServiceName : name;
-        logger.log(XdsLogLevel.INFO, "Start watching EDS resource {0}", resourceName);
-        xdsClient.watchEdsResource(resourceName, this);
-      }
-
-      @Override
-      protected void shutdown() {
-        super.shutdown();
-        String resourceName = edsServiceName != null ? edsServiceName : name;
-        logger.log(XdsLogLevel.INFO, "Stop watching EDS resource {0}", resourceName);
-        xdsClient.cancelEdsResourceWatch(resourceName, this);
-      }
-
-      @Override
-      public void onChanged(final EdsUpdate update) {
-        class EndpointsUpdated implements Runnable {
-          @Override
-          public void run() {
-            if (shutdown) {
-              return;
-            }
-            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",
-                  update.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<>();
-            for (Locality locality : localityLbEndpoints.keySet()) {
-              LocalityLbEndpoints localityLbInfo = localityLbEndpoints.get(locality);
-              int priority = localityLbInfo.priority();
-              String priorityName = priorityName(name, priority);
-              boolean discard = true;
-              for (LbEndpoint endpoint : localityLbInfo.endpoints()) {
-                if (endpoint.isHealthy()) {
-                  discard = false;
-                  Attributes attr = endpoint.eag().getAttributes().toBuilder()
-                      .set(InternalXdsAttributes.ATTR_LOCALITY, locality).build();
-                  EquivalentAddressGroup eag =
-                      new EquivalentAddressGroup(endpoint.eag().getAddresses(), attr);
-                  eag = AddressFilter.setPathFilter(
-                      eag, Arrays.asList(priorityName, localityName(locality)));
-                  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", update.clusterName);
-            }
-            List<String> priorities = new ArrayList<>(prioritizedLocalityWeights.keySet());
-            Collections.sort(priorities);
-            Map<String, PriorityChildConfig> priorityChildConfigs = generatePriorityChildConfigs(
-                name, edsServiceName, lrsServerName, maxConcurrentRequests, tlsContext,
-                localityPickingPolicy, endpointPickingPolicy, true, lbRegistry,
-                prioritizedLocalityWeights, dropOverloads);
-            status = Status.OK;
-            resolved = true;
-            result = new ClusterResolutionResult(addresses, priorityChildConfigs, priorities);
-            handleEndpointResourceUpdate();
-          }
-        }
-
-        syncContext.execute(new EndpointsUpdated());
-      }
-
-      @Override
-      public void onResourceDoesNotExist(final String resourceName) {
-        syncContext.execute(new Runnable() {
-          @Override
-          public void run() {
-            if (shutdown) {
-              return;
-            }
-            logger.log(XdsLogLevel.INFO, "Resource {0} unavailable", resourceName);
-            status = Status.OK;
-            resolved = true;
-            result = null;  // resource revoked
-            handleEndpointResourceUpdate();
-          }
-        });
-      }
-
-      @Override
-      public void onError(final Status error) {
-        syncContext.execute(new Runnable() {
-          @Override
-          public void run() {
-            if (shutdown) {
-              return;
-            }
-            status = error;
-            logger.log(XdsLogLevel.WARNING, "Received EDS error: {0}", error);
-            handleEndpointResolutionError();
-          }
-        });
-      }
-    }
-
-    private class LogicalDnsClusterState extends ClusterState {
-      private final NameResolver resolver;
-      @Nullable
-      private BackoffPolicy backoffPolicy;
-      @Nullable
-      private ScheduledHandle scheduledRefresh;
-
-      private LogicalDnsClusterState(String name, @Nullable String lrsServerName,
-          @Nullable Long maxConcurrentRequests, @Nullable UpstreamTlsContext tlsContext) {
-        super(name, null, lrsServerName, maxConcurrentRequests, tlsContext);
-        NameResolver.Args args = helper.getNameResolverArgs();
-        URI uri;
-        try {
-          uri = new URI(authority);
-        } catch (URISyntaxException e) {
-          // TODO(chengyuanzhang): unlikely to happen, but maybe handle it more gracefully.
-          throw new AssertionError("Bug, invalid authority: " + authority, e);
-        }
-        resolver = helper.getNameResolverRegistry().asFactory().newNameResolver(uri, args);
-      }
-
-      @Override
-      void start() {
-        resolver.start(new NameResolverListener());
-      }
-
-      void refresh() {
-        cancelBackoff();
-        resolver.refresh();
-      }
-
-      @Override
-      void shutdown() {
-        super.shutdown();
-        resolver.shutdown();
-        cancelBackoff();
-      }
-
-      private void cancelBackoff() {
-        if (scheduledRefresh != null) {
-          scheduledRefresh.cancel();
-          scheduledRefresh = null;
-          backoffPolicy = null;
-        }
-      }
-
-      private class DelayedNameResolverRefresh implements Runnable {
-        @Override
-        public void run() {
-          scheduledRefresh = null;
-          if (!shutdown) {
-            resolver.refresh();
-          }
-        }
-      }
-
-      private class NameResolverListener extends NameResolver.Listener2 {
-        @Override
-        public void onResult(final ResolutionResult resolutionResult) {
-          class NameResolved implements Runnable {
-            @Override
-            public void run() {
-              if (shutdown) {
-                return;
-              }
-              backoffPolicy = null;  // reset backoff sequence if succeeded
-              String priorityName = priorityName(name, 0);  // value doesn't matter
-              List<EquivalentAddressGroup> addresses = new ArrayList<>();
-              for (EquivalentAddressGroup eag : resolutionResult.getAddresses()) {
-                Attributes attr = eag.getAttributes().toBuilder().set(
-                    InternalXdsAttributes.ATTR_LOCALITY, LOGICAL_DNS_CLUSTER_LOCALITY).build();
-                eag = new EquivalentAddressGroup(eag.getAddresses(), attr);
-                eag = AddressFilter.setPathFilter(
-                    eag, Arrays.asList(priorityName, LOGICAL_DNS_CLUSTER_LOCALITY.toString()));
-                addresses.add(eag);
-              }
-              PolicySelection endpointPickingPolicy =
-                  new PolicySelection(lbRegistry.getProvider("pick_first"), null);
-              PriorityChildConfig priorityChildConfig = generatePriorityChildConfig(
-                  name, edsServiceName, lrsServerName, maxConcurrentRequests, tlsContext,
-                  endpointPickingPolicy, false, lbRegistry,
-                  Collections.<DropOverload>emptyList());
-              status = Status.OK;
-              resolved = true;
-              result = new ClusterResolutionResult(addresses, priorityName, priorityChildConfig);
-              handleEndpointResourceUpdate();
-            }
-          }
-
-          syncContext.execute(new NameResolved());
-        }
-
-        @Override
-        public void onError(final Status error) {
-          syncContext.execute(new Runnable() {
-            @Override
-            public void run() {
-              if (shutdown) {
-                return;
-              }
-              status = error;
-              // NameResolver.Listener API cannot distinguish transient errors, we should avoid
-              // waiting for DNS addresses indefinitely.
-              resolved = true;
-              handleEndpointResolutionError();
-              if (scheduledRefresh != null && scheduledRefresh.isPending()) {
-                return;
-              }
-              if (backoffPolicy == null) {
-                backoffPolicy = backoffPolicyProvider.get();
-              }
-              long delayNanos = backoffPolicy.nextBackoffNanos();
-              logger.log(XdsLogLevel.DEBUG,
-                  "Scheduling DNS resolution backoff for {0} ns", delayNanos);
-              scheduledRefresh =
-                  syncContext.schedule(
-                      new DelayedNameResolverRefresh(), delayNanos, TimeUnit.NANOSECONDS,
-                      timeService);
-            }
-          });
-        }
-      }
-    }
-  }
-
-  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, String priority,
-        PriorityChildConfig config) {
-      this(addresses, Collections.singletonMap(priority, config),
-          Collections.singletonList(priority));
-    }
-
-    ClusterResolutionResult(List<EquivalentAddressGroup> addresses,
-        Map<String, PriorityChildConfig> configs, List<String> priorities) {
-      this.addresses = addresses;
-      this.priorityChildConfigs = configs;
-      this.priorities = priorities;
-    }
-  }
-
-  /**
-   * Generates the config to be used in the priority LB policy for a single priority.
-   *
-   * <p>priority LB -> cluster_impl LB -> pick_first
-   */
-  private static PriorityChildConfig generatePriorityChildConfig(
-      String cluster, @Nullable String edsServiceName, @Nullable String lrsServerName,
-      @Nullable Long maxConcurrentRequests, @Nullable UpstreamTlsContext tlsContext,
-      PolicySelection endpointPickingPolicy, boolean ignoreReresolution,
-      LoadBalancerRegistry lbRegistry, List<DropOverload> dropOverloads) {
-    ClusterImplConfig clusterImplConfig =
-        new ClusterImplConfig(cluster, edsServiceName, lrsServerName, maxConcurrentRequests,
-            dropOverloads, endpointPickingPolicy, tlsContext);
-    LoadBalancerProvider clusterImplLbProvider =
-        lbRegistry.getProvider(XdsLbPolicies.CLUSTER_IMPL_POLICY_NAME);
-    PolicySelection clusterImplPolicy =
-        new PolicySelection(clusterImplLbProvider, clusterImplConfig);
-    return new PriorityChildConfig(clusterImplPolicy, ignoreReresolution);
-  }
-
-  /**
-   * Generates configs to be used in the priority LB policy for priorities in the cluster.
-   *
-   * <p>priority LB -> cluster_impl LB (one per priority) -> weighted_target LB
-   * -> round_robin (one per locality))
-   */
-  private static Map<String, PriorityChildConfig> generatePriorityChildConfigs(
-      String cluster, @Nullable String edsServiceName, @Nullable String lrsServerName,
-      @Nullable Long maxConcurrentRequests, @Nullable UpstreamTlsContext tlsContext,
-      PolicySelection localityPickingPolicy, PolicySelection endpointPickingPolicy,
-      boolean ignoreReresolution, LoadBalancerRegistry lbRegistry,
-      Map<String, Map<Locality, Integer>> prioritizedLocalityWeights,
-      List<DropOverload> dropOverloads) {
-    Map<String, PriorityChildConfig> configs = new HashMap<>();
-    for (String priority : prioritizedLocalityWeights.keySet()) {
-      Map<Locality, Integer> localityWeights = prioritizedLocalityWeights.get(priority);
-      Map<String, WeightedPolicySelection> targets = new HashMap<>();
-      for (Locality locality : localityWeights.keySet()) {
-        int weight = localityWeights.get(locality);
-        targets.put(localityName(locality),
-            new WeightedPolicySelection(weight, endpointPickingPolicy));
-      }
-      PolicySelection localityPicking = new PolicySelection(
-          localityPickingPolicy.getProvider(),
-          new WeightedTargetConfig(Collections.unmodifiableMap(targets)));
-      ClusterImplConfig clusterImplConfig =
-          new ClusterImplConfig(cluster, edsServiceName, lrsServerName, maxConcurrentRequests,
-              dropOverloads, localityPicking, tlsContext);
-      LoadBalancerProvider clusterImplLbProvider =
-          lbRegistry.getProvider(XdsLbPolicies.CLUSTER_IMPL_POLICY_NAME);
-      PolicySelection clusterImplPolicy =
-          new PolicySelection(clusterImplLbProvider, clusterImplConfig);
-      configs.put(priority, new PriorityChildConfig(clusterImplPolicy, ignoreReresolution));
-    }
-    return configs;
-  }
-
-  /**
-   * 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 + "[priority" + 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 locality.toString();
-  }
-}
diff --git a/xds/src/main/java/io/grpc/xds/ClusterResolverLoadBalancerProvider.java b/xds/src/main/java/io/grpc/xds/ClusterResolverLoadBalancerProvider.java
deleted file mode 100644
index 9442e88e12a..00000000000
--- a/xds/src/main/java/io/grpc/xds/ClusterResolverLoadBalancerProvider.java
+++ /dev/null
@@ -1,195 +0,0 @@
-/*
- * 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 io.grpc.Internal;
-import io.grpc.LoadBalancer;
-import io.grpc.LoadBalancer.Helper;
-import io.grpc.LoadBalancerProvider;
-import io.grpc.NameResolver.ConfigOrError;
-import io.grpc.internal.ServiceConfigUtil.PolicySelection;
-import io.grpc.xds.EnvoyServerProtoData.UpstreamTlsContext;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
-import javax.annotation.Nullable;
-
-/**
- * The provider for the cluster_resolver load 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 "cluster_resolver_experimental".
- */
-@Internal
-public final class ClusterResolverLoadBalancerProvider extends LoadBalancerProvider {
-
-  @Override
-  public boolean isAvailable() {
-    return true;
-  }
-
-  @Override
-  public int getPriority() {
-    return 5;
-  }
-
-  @Override
-  public String getPolicyName() {
-    return XdsLbPolicies.CLUSTER_RESOLVER_POLICY_NAME;
-  }
-
-  @Override
-  public ConfigOrError parseLoadBalancingPolicyConfig(Map<String, ?> rawLoadBalancingPolicyConfig) {
-    throw new UnsupportedOperationException("not supported as top-level LB policy");
-  }
-
-  @Override
-  public LoadBalancer newLoadBalancer(Helper helper) {
-    return new ClusterResolverLoadBalancer(helper);
-  }
-
-  static final class ClusterResolverConfig {
-    // Ordered list of clusters to be resolved.
-    final List<DiscoveryMechanism> discoveryMechanisms;
-    final PolicySelection localityPickingPolicy;
-    final PolicySelection endpointPickingPolicy;
-
-    ClusterResolverConfig(List<DiscoveryMechanism> discoveryMechanisms,
-        PolicySelection localityPickingPolicy, PolicySelection endpointPickingPolicy) {
-      this.discoveryMechanisms = checkNotNull(discoveryMechanisms, "discoveryMechanisms");
-      this.localityPickingPolicy = checkNotNull(localityPickingPolicy, "localityPickingPolicy");
-      this.endpointPickingPolicy = checkNotNull(endpointPickingPolicy, "endpointPickingPolicy");
-    }
-
-    @Override
-    public int hashCode() {
-      return Objects.hash(discoveryMechanisms, localityPickingPolicy, endpointPickingPolicy);
-    }
-
-    @Override
-    public boolean equals(Object o) {
-      if (this == o) {
-        return true;
-      }
-      if (o == null || getClass() != o.getClass()) {
-        return false;
-      }
-      ClusterResolverConfig that = (ClusterResolverConfig) o;
-      return discoveryMechanisms.equals(that.discoveryMechanisms)
-          && localityPickingPolicy.equals(that.localityPickingPolicy)
-          && endpointPickingPolicy.equals(that.endpointPickingPolicy);
-    }
-
-    @Override
-    public String toString() {
-      return MoreObjects.toStringHelper(this)
-          .add("discoveryMechanisms", discoveryMechanisms)
-          .add("localityPickingPolicy", localityPickingPolicy)
-          .add("endpointPickingPolicy", endpointPickingPolicy)
-          .toString();
-    }
-
-    // Describes the mechanism for a specific cluster.
-    static final class DiscoveryMechanism {
-      // Name of the cluster to resolve.
-      final String cluster;
-      // Type of the cluster.
-      final Type type;
-      // Load reporting server name. Null if not enabled.
-      @Nullable
-      final String lrsServerName;
-      // Cluster-level max concurrent request threshold. Null if not specified.
-      @Nullable
-      final Long maxConcurrentRequests;
-      // TLS context for connections to endpoints in the cluster.
-      @Nullable
-      final UpstreamTlsContext tlsContext;
-      // Resource name for resolving endpoints via EDS. Only valid for EDS clusters.
-      @Nullable
-      final String edsServiceName;
-
-      enum Type {
-        EDS,
-        LOGICAL_DNS,
-      }
-
-      private DiscoveryMechanism(String cluster, Type type, @Nullable String edsServiceName,
-          @Nullable String lrsServerName, @Nullable Long maxConcurrentRequests,
-          @Nullable UpstreamTlsContext tlsContext) {
-        this.cluster = checkNotNull(cluster, "cluster");
-        this.type = checkNotNull(type, "type");
-        this.edsServiceName = edsServiceName;
-        this.lrsServerName = lrsServerName;
-        this.maxConcurrentRequests = maxConcurrentRequests;
-        this.tlsContext = tlsContext;
-      }
-
-      static DiscoveryMechanism forEds(String cluster, @Nullable String edsServiceName,
-          @Nullable String lrsServerName, @Nullable Long maxConcurrentRequests,
-          @Nullable UpstreamTlsContext tlsContext) {
-        return new DiscoveryMechanism(cluster, Type.EDS, edsServiceName, lrsServerName,
-            maxConcurrentRequests, tlsContext);
-      }
-
-      static DiscoveryMechanism forLogicalDns(String cluster, @Nullable String lrsServerName,
-          @Nullable Long maxConcurrentRequests, @Nullable UpstreamTlsContext tlsContext) {
-        return new DiscoveryMechanism(cluster, Type.LOGICAL_DNS, null, lrsServerName,
-            maxConcurrentRequests, tlsContext);
-      }
-
-      @Override
-      public int hashCode() {
-        return Objects.hash(cluster, type, lrsServerName, maxConcurrentRequests, tlsContext,
-            edsServiceName);
-      }
-
-      @Override
-      public boolean equals(Object o) {
-        if (this == o) {
-          return true;
-        }
-        if (o == null || getClass() != o.getClass()) {
-          return false;
-        }
-        DiscoveryMechanism that = (DiscoveryMechanism) o;
-        return cluster.equals(that.cluster)
-            && type == that.type
-            && Objects.equals(edsServiceName, that.edsServiceName)
-            && Objects.equals(lrsServerName, that.lrsServerName)
-            && Objects.equals(maxConcurrentRequests, that.maxConcurrentRequests)
-            && Objects.equals(tlsContext, that.tlsContext);
-      }
-
-      @Override
-      public String toString() {
-        MoreObjects.ToStringHelper toStringHelper =
-            MoreObjects.toStringHelper(this)
-                .add("cluster", cluster)
-                .add("type", type)
-                .add("lrsServerName", lrsServerName)
-                // Exclude tlsContext as its string representation is cumbersome.
-                .add("maxConcurrentRequests", maxConcurrentRequests);
-        if (type == Type.EDS) {
-          toStringHelper.add("edsServiceName", edsServiceName);
-        }
-        return toStringHelper.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
index 5f871c9d269..558e3932ddc 100644
--- a/xds/src/main/java/io/grpc/xds/Endpoints.java
+++ b/xds/src/main/java/io/grpc/xds/Endpoints.java
@@ -16,9 +16,13 @@
 
 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;
@@ -33,16 +37,19 @@ abstract static class LocalityLbEndpoints {
     // Endpoints to be load balanced.
     abstract ImmutableList<LbEndpoint> endpoints();
 
-    // Locality's weight for inter-locality load balancing.
+    // 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) {
+        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);
+          ImmutableList.copyOf(endpoints), localityWeight, priority, localityMetadata);
     }
   }
 
@@ -52,23 +59,32 @@ abstract static class LbEndpoint {
     // The endpoint address to be connected to.
     abstract EquivalentAddressGroup eag();
 
-    // Endpoint's wight for load balancing.
+    // Endpoint's weight for load balancing. Guaranteed not to be 0.
     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) {
-      return new AutoValue_Endpoints_LbEndpoint(eag, loadBalancingWeight, isHealthy);
+        boolean isHealthy, String hostname, ImmutableMap<String, Object> endpointMetadata) {
+      if (loadBalancingWeight == 0) {
+        loadBalancingWeight = 1;
+      }
+      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) {
-      return LbEndpoint.create(new EquivalentAddressGroup(new InetSocketAddress(address, port)),
-          loadBalancingWeight, isHealthy);
+    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);
     }
   }
 
diff --git a/xds/src/main/java/io/grpc/xds/EnvoyServerProtoData.java b/xds/src/main/java/io/grpc/xds/EnvoyServerProtoData.java
index 1dab0db9fa7..3cf28d23578 100644
--- a/xds/src/main/java/io/grpc/xds/EnvoyServerProtoData.java
+++ b/xds/src/main/java/io/grpc/xds/EnvoyServerProtoData.java
@@ -16,19 +16,18 @@
 
 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.base.MoreObjects;
-import com.google.protobuf.Any;
-import com.google.protobuf.InvalidProtocolBufferException;
-import io.envoyproxy.envoy.config.core.v3.Address;
-import io.envoyproxy.envoy.config.core.v3.SocketAddress;
+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.net.UnknownHostException;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
 import java.util.Objects;
 import javax.annotation.Nullable;
 
@@ -39,20 +38,18 @@
 @Internal
 public final class EnvoyServerProtoData {
 
-  static final String TRANSPORT_SOCKET_NAME_TLS = "envoy.transport_sockets.tls";
-
   // Prevent instantiation.
   private EnvoyServerProtoData() {
   }
 
   public abstract static class BaseTlsContext {
-    @Nullable protected final CommonTlsContext commonTlsContext;
+    protected final CommonTlsContext commonTlsContext;
 
-    protected BaseTlsContext(@Nullable CommonTlsContext commonTlsContext) {
-      this.commonTlsContext = commonTlsContext;
+    protected BaseTlsContext(CommonTlsContext commonTlsContext) {
+      this.commonTlsContext = checkNotNull(commonTlsContext, "commonTlsContext cannot be null.");
     }
 
-    @Nullable public CommonTlsContext getCommonTlsContext() {
+    public CommonTlsContext getCommonTlsContext() {
       return commonTlsContext;
     }
 
@@ -76,20 +73,81 @@ public int hashCode() {
 
   public static final class UpstreamTlsContext extends BaseTlsContext {
 
+    private final String sni;
+    private final boolean autoHostSni;
+    private final boolean autoSniSanValidation;
+
     @VisibleForTesting
     public UpstreamTlsContext(CommonTlsContext commonTlsContext) {
+      this(commonTlsContext, "", false, false);
+    }
+
+    @VisibleForTesting
+    public UpstreamTlsContext(
+        CommonTlsContext commonTlsContext, String sni, boolean autoHostSni,
+        boolean autoSniSanValidation) {
       super(commonTlsContext);
+      this.sni = sni == null ? "" : sni;
+      this.autoHostSni = autoHostSni;
+      this.autoSniSanValidation = autoSniSanValidation;
+    }
+
+    @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.getCommonTlsContext());
+      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 + '}';
+      return "UpstreamTlsContext{"
+          + "commonTlsContext=" + commonTlsContext
+          + "\nsni=" + sni
+          + "\nauto_host_sni=" + autoHostSni
+          + "\nauto_sni_san_validation=" + autoSniSanValidation
+          + "}";
+    }
+
+    @Override
+    public boolean equals(Object o) {
+      if (this == o) {
+        return true;
+      }
+      if (o == null || getClass() != o.getClass()) {
+        return false;
+      }
+      UpstreamTlsContext that = (UpstreamTlsContext) o;
+      return autoHostSni == that.autoHostSni
+          && autoSniSanValidation == that.autoSniSanValidation
+          && Objects.equals(commonTlsContext, that.commonTlsContext)
+          && Objects.equals(sni, that.sni);
+    }
+
+    @Override
+    public int hashCode() {
+      return Objects.hash(commonTlsContext, sni, autoHostSni, autoSniSanValidation);
     }
   }
 
@@ -146,57 +204,16 @@ public int hashCode() {
     }
   }
 
-  static final class CidrRange {
-    private final InetAddress addressPrefix;
-    private final int prefixLen;
+  @AutoValue
+  abstract static class CidrRange {
 
-    @VisibleForTesting
-    CidrRange(String addressPrefix, int prefixLen) throws InvalidProtocolBufferException {
-      try {
-        this.addressPrefix = InetAddress.getByName(addressPrefix);
-      } catch (UnknownHostException e) {
-        throw new InvalidProtocolBufferException(e.getMessage());
-      }
-      this.prefixLen = prefixLen;
-    }
+    abstract InetAddress addressPrefix();
 
-    static CidrRange fromEnvoyProtoCidrRange(
-        io.envoyproxy.envoy.config.core.v3.CidrRange proto) throws InvalidProtocolBufferException {
-      return new CidrRange(proto.getAddressPrefix(), proto.getPrefixLen().getValue());
-    }
-
-    public InetAddress getAddressPrefix() {
-      return addressPrefix;
-    }
+    abstract int prefixLen();
 
-    public int getPrefixLen() {
-      return prefixLen;
-    }
-
-    @Override
-    public boolean equals(Object o) {
-      if (this == o) {
-        return true;
-      }
-      if (o == null || getClass() != o.getClass()) {
-        return false;
-      }
-      CidrRange cidrRange = (CidrRange) o;
-      return prefixLen == cidrRange.prefixLen
-          && java.util.Objects.equals(addressPrefix, cidrRange.addressPrefix);
-    }
-
-    @Override
-    public int hashCode() {
-      return java.util.Objects.hash(addressPrefix, prefixLen);
-    }
-
-    @Override
-    public String toString() {
-      return "CidrRange{"
-          + "addressPrefix='" + addressPrefix + '\''
-          + ", prefixLen=" + prefixLen
-          + '}';
+    static CidrRange create(InetAddress addressPrefix, int prefixLen) {
+      return new AutoValue_EnvoyServerProtoData_CidrRange(
+          addressPrefix, prefixLen);
     }
   }
 
@@ -213,330 +230,241 @@ enum ConnectionSourceType {
 
   /**
    * Corresponds to Envoy proto message
-   * {@link io.envoyproxy.envoy.api.v2.listener.FilterChainMatch}.
+   * {@link io.envoyproxy.envoy.config.listener.v3.FilterChainMatch}.
    */
-  static final class FilterChainMatch {
-    private final int destinationPort;
-    private final List<CidrRange> prefixRanges;
-    private final List<String> applicationProtocols;
-    private final List<CidrRange> sourcePrefixRanges;
-    private final ConnectionSourceType sourceType;
-    private final List<Integer> sourcePorts;
+  @AutoValue
+  abstract static class FilterChainMatch {
 
-    @VisibleForTesting
-    FilterChainMatch(
-        int destinationPort,
-        List<CidrRange> prefixRanges,
-        List<String> applicationProtocols,
-        List<CidrRange> sourcePrefixRanges,
-        ConnectionSourceType sourceType,
-        List<Integer> sourcePorts) {
-      this.destinationPort = destinationPort;
-      this.prefixRanges = Collections.unmodifiableList(prefixRanges);
-      this.applicationProtocols = Collections.unmodifiableList(applicationProtocols);
-      this.sourcePrefixRanges = sourcePrefixRanges;
-      this.sourceType = sourceType;
-      this.sourcePorts = sourcePorts;
-    }
+    abstract int destinationPort();
 
-    static FilterChainMatch fromEnvoyProtoFilterChainMatch(
-        io.envoyproxy.envoy.config.listener.v3.FilterChainMatch proto)
-        throws InvalidProtocolBufferException {
-      List<CidrRange> prefixRanges = new ArrayList<>();
-      for (io.envoyproxy.envoy.config.core.v3.CidrRange range : proto.getPrefixRangesList()) {
-        prefixRanges.add(CidrRange.fromEnvoyProtoCidrRange(range));
-      }
-      List<CidrRange> sourcePrefixRanges = new ArrayList<>();
-      for (io.envoyproxy.envoy.config.core.v3.CidrRange range : proto.getSourcePrefixRangesList()) {
-        sourcePrefixRanges.add(CidrRange.fromEnvoyProtoCidrRange(range));
-      }
-      List<String> applicationProtocols = new ArrayList<>();
-      for (String appProtocol : proto.getApplicationProtocolsList()) {
-        applicationProtocols.add(appProtocol);
-      }
-      ConnectionSourceType sourceType = null;
-      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 InvalidProtocolBufferException("Unknown source-type:" + proto.getSourceType());
-      }
-      return new FilterChainMatch(
-          proto.getDestinationPort().getValue(),
-          prefixRanges,
-          applicationProtocols,
-          sourcePrefixRanges,
-          sourceType,
-          proto.getSourcePortsList());
-    }
+    abstract ImmutableList<CidrRange> prefixRanges();
 
-    public int getDestinationPort() {
-      return destinationPort;
-    }
-
-    public List<CidrRange> getPrefixRanges() {
-      return prefixRanges;
-    }
-
-    public List<String> getApplicationProtocols() {
-      return applicationProtocols;
-    }
+    abstract ImmutableList<String> applicationProtocols();
 
-    public List<CidrRange> getSourcePrefixRanges() {
-      return sourcePrefixRanges;
-    }
+    abstract ImmutableList<CidrRange> sourcePrefixRanges();
 
-    public ConnectionSourceType getConnectionSourceType() {
-      return sourceType;
-    }
+    abstract ConnectionSourceType connectionSourceType();
 
-    public List<Integer> getSourcePorts() {
-      return sourcePorts;
-    }
+    abstract ImmutableList<Integer> sourcePorts();
 
-    @Override
-    public boolean equals(Object o) {
-      if (this == o) {
-        return true;
-      }
-      if (o == null || getClass() != o.getClass()) {
-        return false;
-      }
-      FilterChainMatch that = (FilterChainMatch) o;
-      return destinationPort == that.destinationPort
-          && Objects.equals(prefixRanges, that.prefixRanges)
-          && Objects.equals(applicationProtocols, that.applicationProtocols)
-          && Objects.equals(sourcePrefixRanges, that.sourcePrefixRanges)
-          && sourceType == that.sourceType
-          && Objects.equals(sourcePorts, that.sourcePorts);
-    }
+    abstract ImmutableList<String> serverNames();
 
-    @Override
-    public int hashCode() {
-      return Objects.hash(
-          destinationPort,
-          prefixRanges,
-          applicationProtocols,
-          sourcePrefixRanges,
-          sourceType,
-          sourcePorts);
-    }
+    abstract String transportProtocol();
 
-    @Override
-    public String toString() {
-      return MoreObjects.toStringHelper(this)
-              .add("destinationPort", destinationPort)
-              .add("prefixRanges", prefixRanges)
-              .add("applicationProtocols", applicationProtocols)
-              .add("sourcePrefixRanges", sourcePrefixRanges)
-              .add("sourceType", sourceType)
-              .add("sourcePorts", sourcePorts)
-              .toString();
+    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.api.v2.listener.FilterChain}.
+   * Corresponds to Envoy proto message {@link io.envoyproxy.envoy.config.listener.v3.FilterChain}.
    */
-  static final class FilterChain {
-    // TODO(sanjaypujare): flatten structure by moving FilterChainMatch class members here.
-    private final FilterChainMatch filterChainMatch;
-    @Nullable
-    private final DownstreamTlsContext downstreamTlsContext;
+  @AutoValue
+  abstract static class FilterChain {
 
-    @VisibleForTesting
-    FilterChain(
-        FilterChainMatch filterChainMatch, @Nullable DownstreamTlsContext downstreamTlsContext) {
-      this.filterChainMatch = filterChainMatch;
-      this.downstreamTlsContext = downstreamTlsContext;
-    }
+    // Must be unique per server instance (except the default chain).
+    abstract String name();
 
-    static FilterChain fromEnvoyProtoFilterChain(
-        io.envoyproxy.envoy.config.listener.v3.FilterChain proto)
-        throws InvalidProtocolBufferException {
-      return new FilterChain(
-          FilterChainMatch.fromEnvoyProtoFilterChainMatch(proto.getFilterChainMatch()),
-          getTlsContextFromFilterChain(proto)
-      );
-    }
+    // TODO(sanjaypujare): flatten structure by moving FilterChainMatch class members here.
+    abstract FilterChainMatch filterChainMatch();
+
+    abstract HttpConnectionManager httpConnectionManager();
 
     @Nullable
-    private static DownstreamTlsContext getTlsContextFromFilterChain(
-        io.envoyproxy.envoy.config.listener.v3.FilterChain filterChain)
-        throws InvalidProtocolBufferException {
-      if (filterChain.hasTransportSocket()
-          && TRANSPORT_SOCKET_NAME_TLS.equals(filterChain.getTransportSocket().getName())) {
-        Any any = filterChain.getTransportSocket().getTypedConfig();
-        return DownstreamTlsContext.fromEnvoyProtoDownstreamTlsContext(
-            io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.DownstreamTlsContext.parseFrom(
-                any.getValue()));
-      }
-      return null;
+    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);
     }
+  }
 
-    public FilterChainMatch getFilterChainMatch() {
-      return filterChainMatch;
-    }
+  /**
+   * 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
-    public DownstreamTlsContext getDownstreamTlsContext() {
-      return downstreamTlsContext;
-    }
+    abstract String address();
 
-    @Override
-    public boolean equals(Object o) {
-      if (this == o) {
-        return true;
-      }
-      if (o == null || getClass() != o.getClass()) {
-        return false;
-      }
-      FilterChain that = (FilterChain) o;
-      return java.util.Objects.equals(filterChainMatch, that.filterChainMatch)
-          && java.util.Objects.equals(downstreamTlsContext, that.downstreamTlsContext);
-    }
+    abstract ImmutableList<FilterChain> filterChains();
 
-    @Override
-    public int hashCode() {
-      return java.util.Objects.hash(filterChainMatch, downstreamTlsContext);
-    }
+    @Nullable
+    abstract FilterChain defaultFilterChain();
 
-    @Override
-    public String toString() {
-      return "FilterChain{"
-          + "filterChainMatch=" + filterChainMatch
-          + ", downstreamTlsContext=" + downstreamTlsContext
-          + '}';
+    @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.api.v2.Listener} & related
-   * classes.
+   * 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").
    */
-  static final class Listener {
-    private final String name;
+  @AutoValue
+  abstract static class OutlierDetection {
+
     @Nullable
-    private final String address;
-    private final List<FilterChain> filterChains;
-    private final FilterChain defaultFilterChain;
+    abstract Long intervalNanos();
 
-    @VisibleForTesting
-    Listener(String name, String address,
-        List<FilterChain> filterChains, FilterChain defaultFilterChain) {
-      this.name = name;
-      this.address = address;
-      this.filterChains = Collections.unmodifiableList(filterChains);
-      this.defaultFilterChain = defaultFilterChain;
-    }
+    @Nullable
+    abstract Long baseEjectionTimeNanos();
 
-    private static String convertEnvoyAddressToString(Address proto) {
-      if (proto.hasSocketAddress()) {
-        SocketAddress socketAddress = proto.getSocketAddress();
-        String address = socketAddress.getAddress();
-        switch (socketAddress.getPortSpecifierCase()) {
-          case NAMED_PORT:
-            return address + ":" + socketAddress.getNamedPort();
-          case PORT_VALUE:
-            return address + ":" + socketAddress.getPortValue();
-          default:
-            return address;
-        }
-      }
-      return null;
-    }
+    @Nullable
+    abstract Long maxEjectionTimeNanos();
 
-    static Listener fromEnvoyProtoListener(io.envoyproxy.envoy.config.listener.v3.Listener proto)
-        throws InvalidProtocolBufferException {
-      List<FilterChain> filterChains = new ArrayList<>(proto.getFilterChainsCount());
-      for (io.envoyproxy.envoy.config.listener.v3.FilterChain filterChain :
-          proto.getFilterChainsList()) {
-        if (isAcceptable(filterChain.getFilterChainMatch())) {
-          filterChains.add(FilterChain.fromEnvoyProtoFilterChain(filterChain));
-        }
-      }
-      return new Listener(
-          proto.getName(),
-          convertEnvoyAddressToString(proto.getAddress()),
-          filterChains, FilterChain.fromEnvoyProtoFilterChain(proto.getDefaultFilterChain()));
-    }
+    @Nullable
+    abstract Integer maxEjectionPercent();
 
-    // check if a filter is acceptable for gRPC server side processing
-    private static boolean isAcceptable(
-        io.envoyproxy.envoy.config.listener.v3.FilterChainMatch filterChainMatch) {
-      // reject if filer-chain-match
-      // - has server_name
-      // - transport protocol is other than "raw_buffer"
-      // - application_protocols is non-empty (for now accept "managed-mtls")
-      if (!filterChainMatch.getServerNamesList().isEmpty()) {
-        return false;
+    @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);
       }
-      String transportProtocol = filterChainMatch.getTransportProtocol();
-      if (!transportProtocol.isEmpty() && !"raw_buffer".equals(transportProtocol)) {
-        return false;
+
+      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);
       }
-      List<String> appProtocols = filterChainMatch.getApplicationProtocolsList();
-      return appProtocols.isEmpty()
-          || appProtocols.contains("managed-mtls"); // TODO(sanjaypujare): remove once TD fixed
-    }
 
-    public String getName() {
-      return name;
+      return create(intervalNanos, baseEjectionTimeNanos, maxEjectionTimeNanos,
+          maxEjectionPercentage, successRateEjection, failurePercentageEjection);
     }
+  }
 
-    public String getAddress() {
-      return address;
-    }
+  @AutoValue
+  abstract static class SuccessRateEjection {
 
-    public List<FilterChain> getFilterChains() {
-      return filterChains;
-    }
+    @Nullable
+    abstract Integer stdevFactor();
 
-    public FilterChain getDefaultFilterChain() {
-      return defaultFilterChain;
-    }
+    @Nullable
+    abstract Integer enforcementPercentage();
 
-    @Override
-    public boolean equals(Object o) {
-      if (this == o) {
-        return true;
-      }
-      if (o == null || getClass() != o.getClass()) {
-        return false;
-      }
-      Listener listener = (Listener) o;
-      return Objects.equals(name, listener.name)
-          && Objects.equals(address, listener.address)
-          && Objects.equals(filterChains, listener.filterChains)
-          && Objects.equals(defaultFilterChain, listener.defaultFilterChain);
-    }
+    @Nullable
+    abstract Integer minimumHosts();
 
-    @Override
-    public int hashCode() {
-      return Objects.hash(name, address, filterChains, defaultFilterChain);
+    @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);
     }
+  }
 
-    @Override
-    public String toString() {
-      return "Listener{"
-          + "name='"
-          + name
-          + '\''
-          + ", address='"
-          + address
-          + '\''
-          + ", filterChains="
-          + filterChains
-          + ", defaultFilterChain="
-          + defaultFilterChain
-          + '}';
+  @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/ExtAuthzConfigParser.java b/xds/src/main/java/io/grpc/xds/ExtAuthzConfigParser.java
new file mode 100644
index 00000000000..853e8a5c03a
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/ExtAuthzConfigParser.java
@@ -0,0 +1,103 @@
+/*
+ * 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 com.google.common.collect.ImmutableList;
+import io.envoyproxy.envoy.extensions.filters.http.ext_authz.v3.ExtAuthz;
+import io.grpc.internal.GrpcUtil;
+import io.grpc.xds.client.Bootstrapper.BootstrapInfo;
+import io.grpc.xds.client.Bootstrapper.ServerInfo;
+import io.grpc.xds.internal.MatcherParser;
+import io.grpc.xds.internal.extauthz.ExtAuthzConfig;
+import io.grpc.xds.internal.extauthz.ExtAuthzParseException;
+import io.grpc.xds.internal.grpcservice.GrpcServiceConfig;
+import io.grpc.xds.internal.grpcservice.GrpcServiceParseException;
+import io.grpc.xds.internal.headermutations.HeaderMutationRulesParseException;
+import io.grpc.xds.internal.headermutations.HeaderMutationRulesParser;
+
+
+/**
+ * Parser for {@link io.envoyproxy.envoy.extensions.filters.http.ext_authz.v3.ExtAuthz}.
+ */
+final class ExtAuthzConfigParser {
+
+  private ExtAuthzConfigParser() {}
+
+  /**
+   * Parses the {@link io.envoyproxy.envoy.extensions.filters.http.ext_authz.v3.ExtAuthz} proto to
+   * create an {@link ExtAuthzConfig} instance.
+   *
+   * @param extAuthzProto The ext_authz proto to parse.
+   * @return An {@link ExtAuthzConfig} instance.
+   * @throws ExtAuthzParseException if the proto is invalid or contains unsupported features.
+   */
+  public static ExtAuthzConfig parse(
+      ExtAuthz extAuthzProto, BootstrapInfo bootstrapInfo, ServerInfo serverInfo)
+      throws ExtAuthzParseException {
+    if (!extAuthzProto.hasGrpcService()) {
+      throw new ExtAuthzParseException(
+          "unsupported ExtAuthz service type: only grpc_service is supported");
+    }
+    GrpcServiceConfig grpcServiceConfig;
+    try {
+      grpcServiceConfig =
+          GrpcServiceConfigParser.parse(extAuthzProto.getGrpcService(), bootstrapInfo, serverInfo);
+    } catch (GrpcServiceParseException e) {
+      throw new ExtAuthzParseException("Failed to parse GrpcService config: " + e.getMessage(), e);
+    }
+    ExtAuthzConfig.Builder builder = ExtAuthzConfig.builder().grpcService(grpcServiceConfig)
+        .failureModeAllow(extAuthzProto.getFailureModeAllow())
+        .failureModeAllowHeaderAdd(extAuthzProto.getFailureModeAllowHeaderAdd())
+        .includePeerCertificate(extAuthzProto.getIncludePeerCertificate())
+        .denyAtDisable(extAuthzProto.getDenyAtDisable().getDefaultValue().getValue());
+
+    if (extAuthzProto.hasFilterEnabled()) {
+      try {
+        builder.filterEnabled(
+            MatcherParser.parseFractionMatcher(extAuthzProto.getFilterEnabled().getDefaultValue()));
+      } catch (IllegalArgumentException e) {
+        throw new ExtAuthzParseException(e.getMessage());
+      }
+    }
+
+    if (extAuthzProto.hasStatusOnError()) {
+      builder.statusOnError(
+          GrpcUtil.httpStatusToGrpcStatus(extAuthzProto.getStatusOnError().getCodeValue()));
+    }
+
+    if (extAuthzProto.hasAllowedHeaders()) {
+      builder.allowedHeaders(extAuthzProto.getAllowedHeaders().getPatternsList().stream()
+          .map(MatcherParser::parseStringMatcher).collect(ImmutableList.toImmutableList()));
+    }
+
+    if (extAuthzProto.hasDisallowedHeaders()) {
+      builder.disallowedHeaders(extAuthzProto.getDisallowedHeaders().getPatternsList().stream()
+          .map(MatcherParser::parseStringMatcher).collect(ImmutableList.toImmutableList()));
+    }
+
+    if (extAuthzProto.hasDecoderHeaderMutationRules()) {
+      try {
+        builder.decoderHeaderMutationRules(
+            HeaderMutationRulesParser.parse(extAuthzProto.getDecoderHeaderMutationRules()));
+      } catch (HeaderMutationRulesParseException e) {
+        throw new ExtAuthzParseException(e.getMessage(), e);
+      }
+    }
+
+    return builder.build();
+  }
+}
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..ce764c7e943
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/FaultFilter.java
@@ -0,0 +1,499 @@
+/*
+ * 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, FilterConfigParseContext context) {
+      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, FilterConfigParseContext context) {
+      return parseFilterConfig(rawProtoMessage, context);
+    }
+
+    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..4fa56beb1de
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/Filter.java
@@ -0,0 +1,196 @@
+/*
+ * 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.base.MoreObjects;
+import com.google.protobuf.Message;
+import io.grpc.ClientInterceptor;
+import io.grpc.ServerInterceptor;
+import io.grpc.xds.client.Bootstrapper.BootstrapInfo;
+import io.grpc.xds.client.Bootstrapper.ServerInfo;
+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, FilterConfigParseContext context);
+
+    /**
+     * 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, FilterConfigParseContext context);
+  }
+
+  /** 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() {}
+
+  /** Context carrying dynamic metadata for a filter. */
+  @AutoValue
+  abstract static class FilterConfigParseContext {
+    abstract BootstrapInfo bootstrapInfo();
+
+    abstract ServerInfo serverInfo();
+
+    static Builder builder() {
+      return new AutoValue_Filter_FilterConfigParseContext.Builder();
+    }
+
+    @AutoValue.Builder
+    abstract static class Builder {
+      abstract Builder bootstrapInfo(BootstrapInfo info);
+
+      abstract Builder serverInfo(ServerInfo info);
+
+      abstract FilterConfigParseContext build();
+    }
+  }
+
+  /** 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..e87c402fcb0
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/GcpAuthenticationFilter.java
@@ -0,0 +1,328 @@
+/*
+ * 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, FilterConfigParseContext context) {
+      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, FilterConfigParseContext context) {
+      return parseFilterConfig(rawProtoMessage, context);
+    }
+  }
+
+  @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/GoogleCloudToProdNameResolver.java b/xds/src/main/java/io/grpc/xds/GoogleCloudToProdNameResolver.java
deleted file mode 100644
index 0f10ffd4bd8..00000000000
--- a/xds/src/main/java/io/grpc/xds/GoogleCloudToProdNameResolver.java
+++ /dev/null
@@ -1,275 +0,0 @@
-/*
- * 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.common.annotations.VisibleForTesting;
-import com.google.common.base.Charsets;
-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 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.XdsNameResolverProvider.XdsClientPoolFactory;
-import java.io.IOException;
-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.util.concurrent.Executor;
-
-/**
- * CloudToProd version of {@link NameResolver}.
- */
-final class GoogleCloudToProdNameResolver extends NameResolver {
-
-  @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";
-  @VisibleForTesting
-  static boolean isOnGcp = InternalCheckGcpEnvironment.isOnGcp();
-  @VisibleForTesting
-  static boolean xdsBootstrapProvided =
-      System.getenv("GRPC_XDS_BOOTSTRAP") != null
-          || System.getProperty("io.grpc.xds.bootstrap") != null
-          || System.getenv("GRPC_XDS_BOOTSTRAP_CONFIG") != null
-          || System.getProperty("io.grpc.xds.bootstrapValue") != null;
-
-  private HttpConnectionProvider httpConnectionProvider = HttpConnectionFactory.INSTANCE;
-  private final String authority;
-  private final SynchronizationContext syncContext;
-  private final Resource<Executor> executorResource;
-  private final XdsClientPoolFactory xdsClientPoolFactory;
-  private final NameResolver delegate;
-  private final boolean usingExecutorResource;
-  // It's not possible to use both PSM and DirectPath C2P in the same application.
-  // Delegate to DNS if user-provided bootstrap is found.
-  private final String schemeOverride = !isOnGcp || xdsBootstrapProvided ? "dns" : "xds";
-  private Executor executor;
-  private Listener2 listener;
-  private boolean succeeded;
-  private boolean resolving;
-  private boolean shutdown;
-
-  GoogleCloudToProdNameResolver(URI targetUri, Args args, Resource<Executor> executorResource,
-      XdsClientPoolFactory xdsClientPoolFactory) {
-    this(targetUri, args, executorResource, xdsClientPoolFactory,
-        NameResolverRegistry.getDefaultRegistry().asFactory());
-  }
-
-  @VisibleForTesting
-  GoogleCloudToProdNameResolver(URI targetUri, Args args, Resource<Executor> executorResource,
-      XdsClientPoolFactory xdsClientPoolFactory, NameResolver.Factory nameResolverFactory) {
-    this.executorResource = checkNotNull(executorResource, "executorResource");
-    this.xdsClientPoolFactory = checkNotNull(xdsClientPoolFactory, "xdsClientPoolFactory");
-    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();
-    delegate = checkNotNull(nameResolverFactory, "nameResolverFactory").newNameResolver(
-        overrideUriScheme(targetUri, schemeOverride), 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 (schemeOverride.equals("dns")) {
-      delegate.start(listener);
-      succeeded = true;
-      resolving = false;
-      return;
-    }
-    if (executor == null) {
-      executor = SharedResourceHolder.get(executorResource);
-    }
-
-    class Resolve implements Runnable {
-      @Override
-      public void run() {
-        String zone;
-        boolean supportIpv6;
-        ImmutableMap<String, ?> rawBootstrap = null;
-        try {
-          zone = queryZoneMetadata(METADATA_URL_ZONE);
-          supportIpv6 = queryIpv6SupportMetadata(METADATA_URL_SUPPORT_IPV6);
-          rawBootstrap = generateBootstrap(zone, supportIpv6);
-        } catch (IOException e) {
-          listener.onError(Status.INTERNAL.withDescription("Unable to get metadata").withCause(e));
-        } finally {
-          final ImmutableMap<String, ?> finalRawBootstrap = rawBootstrap;
-          syncContext.execute(new Runnable() {
-            @Override
-            public void run() {
-              if (!shutdown && finalRawBootstrap != null) {
-                xdsClientPoolFactory.setBootstrapOverride(finalRawBootstrap);
-                delegate.start(listener);
-                succeeded = true;
-              }
-              resolving = false;
-            }
-          });
-        }
-      }
-    }
-
-    executor.execute(new Resolve());
-  }
-
-  private static ImmutableMap<String, ?> generateBootstrap(String zone, boolean supportIpv6) {
-    ImmutableMap.Builder<String, Object> nodeBuilder = ImmutableMap.builder();
-    nodeBuilder.put("id", "C2P");
-    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();
-    serverBuilder.put("server_uri", "directpath-trafficdirector.googleapis.com");
-    serverBuilder.put("channel_creds",
-        ImmutableList.of(ImmutableMap.of("type", "google_default")));
-    return ImmutableMap.of(
-        "node", nodeBuilder.build(),
-        "xds_servers", ImmutableList.of(serverBuilder.build()));
-  }
-
-  @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 (executor != null && usingExecutorResource) {
-      executor = SharedResourceHolder.release(executorResource, executor);
-    }
-  }
-
-  private 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(), Charsets.UTF_8)) {
-        respBody = CharStreams.toString(reader);
-      }
-    } finally {
-      if (con != null) {
-        con.disconnect();
-      }
-    }
-    int index = respBody.lastIndexOf('/');
-    return index == -1 ? "" : respBody.substring(index + 1);
-  }
-
-  private boolean queryIpv6SupportMetadata(String url) throws IOException {
-    HttpURLConnection con = null;
-    try {
-      con = httpConnectionProvider.createConnection(url);
-      return con.getResponseCode() == 200;
-    } finally {
-      if (con != null) {
-        con.disconnect();
-      }
-    }
-  }
-
-  @VisibleForTesting
-  void setHttpConnectionProvider(HttpConnectionProvider httpConnectionProvider) {
-    this.httpConnectionProvider = httpConnectionProvider;
-  }
-
-  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 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/xds/src/main/java/io/grpc/xds/GoogleCloudToProdNameResolverProvider.java b/xds/src/main/java/io/grpc/xds/GoogleCloudToProdNameResolverProvider.java
deleted file mode 100644
index be8324b93cf..00000000000
--- a/xds/src/main/java/io/grpc/xds/GoogleCloudToProdNameResolverProvider.java
+++ /dev/null
@@ -1,63 +0,0 @@
-/*
- * 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.grpc.Internal;
-import io.grpc.NameResolver;
-import io.grpc.NameResolver.Args;
-import io.grpc.NameResolverProvider;
-import io.grpc.internal.GrpcUtil;
-import java.net.URI;
-
-/**
- * A provider for {@link GoogleCloudToProdNameResolver}.
- */
-@Internal
-public final class GoogleCloudToProdNameResolverProvider extends NameResolverProvider {
-
-  private static final boolean enableC2PResolver =
-      Boolean.parseBoolean(System.getenv("GRPC_EXPERIMENTAL_GOOGLE_C2P_RESOLVER"));
-  private static final String SCHEME = "google-c2p";
-
-  @Override
-  public NameResolver newNameResolver(URI targetUri, Args args) {
-    if (SCHEME.equals(targetUri.getScheme())) {
-      return new GoogleCloudToProdNameResolver(
-          targetUri, args, GrpcUtil.SHARED_CHANNEL_EXECUTOR,
-          SharedXdsClientPoolProvider.getDefaultProvider());
-    }
-    return null;
-  }
-
-  @Override
-  public String getDefaultScheme() {
-    return SCHEME;
-  }
-
-  @Override
-  protected boolean isAvailable() {
-    if (enableC2PResolver) {
-      return true;
-    }
-    return false;
-  }
-
-  @Override
-  protected int priority() {
-    return 4;
-  }
-}
diff --git a/xds/src/main/java/io/grpc/xds/GrpcBootstrapImplConfig.java b/xds/src/main/java/io/grpc/xds/GrpcBootstrapImplConfig.java
new file mode 100644
index 00000000000..e119321fb6c
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/GrpcBootstrapImplConfig.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.xds;
+
+import com.google.auto.value.AutoValue;
+import io.grpc.Internal;
+import io.grpc.xds.client.AllowedGrpcServices;
+
+/**
+ * Custom configuration for gRPC xDS bootstrap implementation.
+ */
+@Internal
+@AutoValue
+public abstract class GrpcBootstrapImplConfig {
+  public abstract AllowedGrpcServices allowedGrpcServices();
+
+  public static GrpcBootstrapImplConfig create(AllowedGrpcServices services) {
+    return new AutoValue_GrpcBootstrapImplConfig(services);
+  }
+}
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..00a2e0d48d6
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/GrpcBootstrapperImpl.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.xds;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.collect.ImmutableMap;
+import com.google.errorprone.annotations.concurrent.GuardedBy;
+import io.grpc.CallCredentials;
+import io.grpc.ChannelCredentials;
+import io.grpc.internal.JsonUtil;
+import io.grpc.xds.client.AllowedGrpcServices;
+import io.grpc.xds.client.AllowedGrpcServices.AllowedGrpcService;
+import io.grpc.xds.client.BootstrapperImpl;
+import io.grpc.xds.client.ConfiguredChannelCredentials;
+import io.grpc.xds.client.ConfiguredChannelCredentials.ChannelCredsConfig;
+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 java.util.Optional;
+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 {
+    ConfiguredChannelCredentials configuredChannel = getChannelCredentials(serverConfig, serverUri);
+    return configuredChannel != null ? configuredChannel.channelCredentials() : null;
+  }
+
+  @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 ConfiguredChannelCredentials 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");
+    }
+    ConfiguredChannelCredentials credentials =
+        parseChannelCredentials(JsonUtil.checkObjectList(rawChannelCredsList), serverUri);
+    if (credentials == null) {
+      throw new XdsInitializationException(
+          "Server " + serverUri + ": no supported channel credentials found");
+    }
+    return credentials;
+  }
+
+  @Nullable
+  private static ConfiguredChannelCredentials 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();
+        }
+
+        ChannelCredentials creds = provider.newChannelCredentials(config);
+        if (creds == null) {
+          return null;
+        }
+        return ConfiguredChannelCredentials.create(creds, new JsonChannelCredsConfig(type, config));
+      }
+    }
+    return null;
+  }
+
+  @Override
+  protected Optional<Object> parseImplSpecificObject(
+      @Nullable Map<String, ?> rawAllowedGrpcServices)
+      throws XdsInitializationException {
+    if (rawAllowedGrpcServices == null || rawAllowedGrpcServices.isEmpty()) {
+      return Optional.of(GrpcBootstrapImplConfig.create(AllowedGrpcServices.empty()));
+    }
+
+    ImmutableMap.Builder<String, AllowedGrpcService> builder =
+        ImmutableMap.builder();
+    for (String targetUri : rawAllowedGrpcServices.keySet()) {
+      Map<String, ?> serviceConfig = JsonUtil.getObject(rawAllowedGrpcServices, targetUri);
+      if (serviceConfig == null) {
+        throw new XdsInitializationException(
+            "Invalid allowed_grpc_services config for " + targetUri);
+      }
+      ConfiguredChannelCredentials configuredChannel =
+          getChannelCredentials(serviceConfig, targetUri);
+
+      Optional<CallCredentials> callCredentials = Optional.empty();
+      List<?> rawCallCredsList = JsonUtil.getList(serviceConfig, "call_creds");
+      if (rawCallCredsList != null && !rawCallCredsList.isEmpty()) {
+        callCredentials =
+            parseCallCredentials(JsonUtil.checkObjectList(rawCallCredsList), targetUri);
+      }
+
+      AllowedGrpcService.Builder b = AllowedGrpcService.builder()
+          .configuredChannelCredentials(configuredChannel);
+      callCredentials.ifPresent(b::callCredentials);
+      builder.put(targetUri, b.build());
+    }
+    GrpcBootstrapImplConfig customConfig =
+        GrpcBootstrapImplConfig.create(AllowedGrpcServices.create(builder.build()));
+    return Optional.of(customConfig);
+  }
+
+  @SuppressWarnings("unused")
+  private static Optional<CallCredentials> parseCallCredentials(List<Map<String, ?>> jsonList,
+                                                          String targetUri)
+      throws XdsInitializationException {
+    // TODO(sauravzg): Currently no xDS call credentials providers are implemented (no
+    // XdsCallCredentialsRegistry).
+    // As per A102/A97, we should just ignore unsupported call credentials types
+    // without throwing an exception.
+    return Optional.empty();
+  }
+
+  private static final class JsonChannelCredsConfig implements ChannelCredsConfig {
+    private final String type;
+    private final Map<String, ?> config;
+
+    JsonChannelCredsConfig(String type, Map<String, ?> config) {
+      this.type = type;
+      this.config = config;
+    }
+
+    @Override
+    public String type() {
+      return type;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+      if (this == o) {
+        return true;
+      }
+      if (o == null || getClass() != o.getClass()) {
+        return false;
+      }
+      JsonChannelCredsConfig that = (JsonChannelCredsConfig) o;
+      return java.util.Objects.equals(type, that.type)
+          && java.util.Objects.equals(config, that.config);
+    }
+
+    @Override
+    public int hashCode() {
+      return java.util.Objects.hash(type, config);
+    }
+  }
+
+}
+
diff --git a/xds/src/main/java/io/grpc/xds/GrpcServiceConfigParser.java b/xds/src/main/java/io/grpc/xds/GrpcServiceConfigParser.java
new file mode 100644
index 00000000000..1510924f74c
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/GrpcServiceConfigParser.java
@@ -0,0 +1,339 @@
+/*
+ * 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 com.google.auth.oauth2.AccessToken;
+import com.google.auth.oauth2.OAuth2Credentials;
+import com.google.common.collect.ImmutableList;
+import com.google.protobuf.Any;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.google.protobuf.util.Durations;
+import io.envoyproxy.envoy.config.core.v3.GrpcService;
+import io.envoyproxy.envoy.extensions.grpc_service.call_credentials.access_token.v3.AccessTokenCredentials;
+import io.envoyproxy.envoy.extensions.grpc_service.channel_credentials.xds.v3.XdsCredentials;
+import io.grpc.CallCredentials;
+import io.grpc.CompositeCallCredentials;
+import io.grpc.InsecureChannelCredentials;
+import io.grpc.Metadata;
+import io.grpc.NameResolverRegistry;
+import io.grpc.SecurityLevel;
+import io.grpc.alts.GoogleDefaultChannelCredentials;
+import io.grpc.auth.MoreCallCredentials;
+import io.grpc.xds.client.AllowedGrpcServices;
+import io.grpc.xds.client.AllowedGrpcServices.AllowedGrpcService;
+import io.grpc.xds.client.Bootstrapper;
+import io.grpc.xds.client.ConfiguredChannelCredentials;
+import io.grpc.xds.internal.grpcservice.GrpcServiceConfig;
+import io.grpc.xds.internal.grpcservice.GrpcServiceParseException;
+import io.grpc.xds.internal.grpcservice.HeaderValue;
+import io.grpc.xds.internal.grpcservice.HeaderValueValidationUtils;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.time.Duration;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+import java.util.Optional;
+import java.util.concurrent.Executor;
+
+/**
+ * Parser for {@link io.envoyproxy.envoy.config.core.v3.GrpcService} and related protos.
+ */
+final class GrpcServiceConfigParser {
+
+  static final String TLS_CREDENTIALS_TYPE_URL =
+      "type.googleapis.com/envoy.extensions.grpc_service.channel_credentials."
+          + "tls.v3.TlsCredentials";
+  static final String LOCAL_CREDENTIALS_TYPE_URL =
+      "type.googleapis.com/envoy.extensions.grpc_service.channel_credentials."
+          + "local.v3.LocalCredentials";
+  static final String XDS_CREDENTIALS_TYPE_URL =
+      "type.googleapis.com/envoy.extensions.grpc_service.channel_credentials."
+          + "xds.v3.XdsCredentials";
+  static final String INSECURE_CREDENTIALS_TYPE_URL =
+      "type.googleapis.com/envoy.extensions.grpc_service.channel_credentials."
+          + "insecure.v3.InsecureCredentials";
+  static final String GOOGLE_DEFAULT_CREDENTIALS_TYPE_URL =
+      "type.googleapis.com/envoy.extensions.grpc_service.channel_credentials."
+          + "google_default.v3.GoogleDefaultCredentials";
+
+
+
+  /**
+   * Parses the {@link io.envoyproxy.envoy.config.core.v3.GrpcService} proto to create a
+   * {@link GrpcServiceConfig} instance.
+   *
+   * @param grpcServiceProto The proto to parse.
+   * @return A {@link GrpcServiceConfig} instance.
+   * @throws GrpcServiceParseException if the proto is invalid or uses unsupported features.
+   */
+  public static GrpcServiceConfig parse(GrpcService grpcServiceProto,
+      Bootstrapper.BootstrapInfo bootstrapInfo, Bootstrapper.ServerInfo serverInfo)
+      throws GrpcServiceParseException {
+    if (!grpcServiceProto.hasGoogleGrpc()) {
+      throw new GrpcServiceParseException(
+          "Unsupported: GrpcService must have GoogleGrpc, got: " + grpcServiceProto);
+    }
+    GrpcServiceConfig.GoogleGrpcConfig googleGrpcConfig =
+        parseGoogleGrpcConfig(grpcServiceProto.getGoogleGrpc(), bootstrapInfo, serverInfo);
+
+    GrpcServiceConfig.Builder builder = GrpcServiceConfig.builder().googleGrpc(googleGrpcConfig);
+
+    ImmutableList.Builder<HeaderValue> initialMetadata = ImmutableList.builder();
+    for (io.envoyproxy.envoy.config.core.v3.HeaderValue header : grpcServiceProto
+        .getInitialMetadataList()) {
+      String key = header.getKey();
+      HeaderValue headerValue;
+      if (key.endsWith(Metadata.BINARY_HEADER_SUFFIX)) {
+        headerValue = HeaderValue.create(key, header.getRawValue());
+      } else {
+        headerValue = HeaderValue.create(key, header.getValue());
+      }
+      if (HeaderValueValidationUtils.isDisallowed(headerValue)) {
+        throw new GrpcServiceParseException("Invalid initial metadata header: " + key);
+      }
+      initialMetadata.add(headerValue);
+    }
+    builder.initialMetadata(initialMetadata.build());
+
+    if (grpcServiceProto.hasTimeout()) {
+      com.google.protobuf.Duration timeout = grpcServiceProto.getTimeout();
+      if (!Durations.isValid(timeout) || Durations.compare(timeout, Durations.ZERO) <= 0) {
+        throw new GrpcServiceParseException("Timeout must be strictly positive and valid");
+      }
+      builder.timeout(Duration.ofSeconds(timeout.getSeconds(), timeout.getNanos()));
+    }
+    return builder.build();
+  }
+
+  /**
+   * Parses the {@link io.envoyproxy.envoy.config.core.v3.GrpcService.GoogleGrpc} proto to create a
+   * {@link GrpcServiceConfig.GoogleGrpcConfig} instance.
+   *
+   * @param googleGrpcProto The proto to parse.
+   * @return A {@link GrpcServiceConfig.GoogleGrpcConfig} instance.
+   * @throws GrpcServiceParseException if the proto is invalid.
+   */
+  public static GrpcServiceConfig.GoogleGrpcConfig parseGoogleGrpcConfig(
+      GrpcService.GoogleGrpc googleGrpcProto, Bootstrapper.BootstrapInfo bootstrapInfo,
+      Bootstrapper.ServerInfo serverInfo) throws GrpcServiceParseException {
+
+    String targetUri = googleGrpcProto.getTargetUri();
+
+    AllowedGrpcServices allowedGrpcServices =
+        bootstrapInfo.implSpecificObject()
+            .filter(GrpcBootstrapImplConfig.class::isInstance)
+            .map(GrpcBootstrapImplConfig.class::cast)
+            .map(GrpcBootstrapImplConfig::allowedGrpcServices)
+            .orElse(AllowedGrpcServices.empty());
+
+    boolean isTrustedControlPlane = serverInfo.isTrustedXdsServer();
+    Optional<AllowedGrpcService> override =
+        Optional.ofNullable(allowedGrpcServices.services().get(targetUri));
+
+    boolean isTargetUriSchemeSupported = false;
+    try {
+      URI uri = new URI(targetUri);
+      String scheme = uri.getScheme();
+      if (scheme == null) {
+        scheme = NameResolverRegistry.getDefaultRegistry().getDefaultScheme();
+      }
+      if (scheme != null) {
+        isTargetUriSchemeSupported =
+            NameResolverRegistry.getDefaultRegistry().getProviderForScheme(scheme) != null;
+      }
+    } catch (URISyntaxException e) {
+      // Fallback or ignore if not a valid URI
+    }
+
+    if (!isTargetUriSchemeSupported) {
+      throw new GrpcServiceParseException("Target URI scheme is not resolvable: " + targetUri);
+    }
+
+    if (!isTrustedControlPlane) {
+      if (!override.isPresent()) {
+        throw new GrpcServiceParseException(
+            "Untrusted xDS server & URI not found in allowed_grpc_services: " + targetUri);
+      }
+
+      GrpcServiceConfig.GoogleGrpcConfig.Builder builder =
+          GrpcServiceConfig.GoogleGrpcConfig.builder().target(targetUri)
+              .configuredChannelCredentials(override.get().configuredChannelCredentials());
+      if (override.get().callCredentials().isPresent()) {
+        builder.callCredentials(override.get().callCredentials().get());
+      }
+      return builder.build();
+    }
+
+    ConfiguredChannelCredentials channelCreds =
+        extractChannelCredentials(googleGrpcProto.getChannelCredentialsPluginList());
+
+    Optional<CallCredentials> callCreds =
+        extractCallCredentials(googleGrpcProto.getCallCredentialsPluginList());
+
+    GrpcServiceConfig.GoogleGrpcConfig.Builder builder =
+        GrpcServiceConfig.GoogleGrpcConfig.builder().target(googleGrpcProto.getTargetUri())
+            .configuredChannelCredentials(channelCreds);
+    if (callCreds.isPresent()) {
+      builder.callCredentials(callCreds.get());
+    }
+    return builder.build();
+  }
+
+  private static Optional<ConfiguredChannelCredentials> channelCredsFromProto(Any cred)
+      throws GrpcServiceParseException {
+    String typeUrl = cred.getTypeUrl();
+    try {
+      switch (typeUrl) {
+        case GOOGLE_DEFAULT_CREDENTIALS_TYPE_URL:
+          return Optional
+              .of(ConfiguredChannelCredentials.create(GoogleDefaultChannelCredentials.create(),
+                  new ProtoChannelCredsConfig(typeUrl, cred)));
+        case INSECURE_CREDENTIALS_TYPE_URL:
+          return Optional.of(ConfiguredChannelCredentials.create(
+              InsecureChannelCredentials.create(), new ProtoChannelCredsConfig(typeUrl, cred)));
+        case XDS_CREDENTIALS_TYPE_URL:
+          XdsCredentials xdsConfig = cred.unpack(XdsCredentials.class);
+          Optional<ConfiguredChannelCredentials> fallbackCreds =
+              channelCredsFromProto(xdsConfig.getFallbackCredentials());
+          if (!fallbackCreds.isPresent()) {
+            throw new GrpcServiceParseException(
+                "Unsupported fallback credentials type for XdsCredentials");
+          }
+          return Optional.of(ConfiguredChannelCredentials.create(
+              XdsChannelCredentials.create(fallbackCreds.get().channelCredentials()),
+              new ProtoChannelCredsConfig(typeUrl, cred)));
+        case LOCAL_CREDENTIALS_TYPE_URL:
+          throw new GrpcServiceParseException(
+              "LocalCredentials are not supported in grpc-java. "
+                  + "See https://github.com/grpc/grpc-java/issues/8928");
+        case TLS_CREDENTIALS_TYPE_URL:
+          // For this PR, we establish this structural skeleton,
+          // but throw an GrpcServiceParseException until the exact stream conversions are
+          // merged.
+          throw new GrpcServiceParseException(
+              "TlsCredentials input stream construction pending.");
+        default:
+          return Optional.empty();
+      }
+    } catch (InvalidProtocolBufferException e) {
+      throw new GrpcServiceParseException("Failed to parse channel credentials: " + e.getMessage());
+    }
+  }
+
+  private static ConfiguredChannelCredentials extractChannelCredentials(
+      List<Any> channelCredentialPlugins) throws GrpcServiceParseException {
+    for (Any cred : channelCredentialPlugins) {
+      Optional<ConfiguredChannelCredentials> parsed = channelCredsFromProto(cred);
+      if (parsed.isPresent()) {
+        return parsed.get();
+      }
+    }
+    throw new GrpcServiceParseException("No valid supported channel_credentials found");
+  }
+
+  private static Optional<CallCredentials> callCredsFromProto(Any cred)
+      throws GrpcServiceParseException {
+    if (cred.is(AccessTokenCredentials.class)) {
+      try {
+        AccessTokenCredentials accessToken = cred.unpack(AccessTokenCredentials.class);
+        if (accessToken.getToken().isEmpty()) {
+          throw new GrpcServiceParseException("Missing or empty access token in call credentials.");
+        }
+        return Optional
+            .of(new SecurityAwareAccessTokenCredentials(MoreCallCredentials.from(OAuth2Credentials
+                .create(new AccessToken(accessToken.getToken(), new Date(Long.MAX_VALUE))))));
+      } catch (InvalidProtocolBufferException e) {
+        throw new GrpcServiceParseException(
+            "Failed to parse access token credentials: " + e.getMessage());
+      }
+    }
+    return Optional.empty();
+  }
+
+  private static Optional<CallCredentials> extractCallCredentials(List<Any> callCredentialPlugins)
+      throws GrpcServiceParseException {
+    List<CallCredentials> creds = new ArrayList<>();
+    for (Any cred : callCredentialPlugins) {
+      Optional<CallCredentials> parsed = callCredsFromProto(cred);
+      if (parsed.isPresent()) {
+        creds.add(parsed.get());
+      }
+    }
+    return creds.stream().reduce(CompositeCallCredentials::new);
+  }
+
+  private static final class SecurityAwareAccessTokenCredentials extends CallCredentials {
+
+    private final CallCredentials delegate;
+
+    SecurityAwareAccessTokenCredentials(CallCredentials delegate) {
+      this.delegate = delegate;
+    }
+
+    @Override
+    public void applyRequestMetadata(RequestInfo requestInfo, Executor appExecutor,
+        MetadataApplier applier) {
+      if (requestInfo.getSecurityLevel() == SecurityLevel.PRIVACY_AND_INTEGRITY) {
+        delegate.applyRequestMetadata(requestInfo, appExecutor, applier);
+      } else {
+        applier.apply(new Metadata());
+      }
+    }
+  }
+
+  static final class ProtoChannelCredsConfig
+      implements ConfiguredChannelCredentials.ChannelCredsConfig {
+    private final String type;
+    private final Any configProto;
+
+    ProtoChannelCredsConfig(String type, Any configProto) {
+      this.type = type;
+      this.configProto = configProto;
+    }
+
+    @Override
+    public String type() {
+      return type;
+    }
+
+    Any configProto() {
+      return configProto;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+      if (this == o) {
+        return true;
+      }
+      if (o == null || getClass() != o.getClass()) {
+        return false;
+      }
+      ProtoChannelCredsConfig that = (ProtoChannelCredsConfig) o;
+      return java.util.Objects.equals(type, that.type)
+          && java.util.Objects.equals(configProto, that.configProto);
+    }
+
+    @Override
+    public int hashCode() {
+      return java.util.Objects.hash(type, configProto);
+    }
+  }
+
+
+
+}
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..5100537aea2
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/GrpcXdsTransportFactory.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.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.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * A factory for creating gRPC-based transports for xDS communication.
+ *
+ * <p>WARNING: This class reuses channels when possible, based on the provided {@link
+ * Bootstrapper.ServerInfo} with important considerations. The {@link Bootstrapper.ServerInfo}
+ * includes {@link ChannelCredentials}, which is compared by reference equality. This means every
+ * {@link Bootstrapper.BootstrapInfo} would have non-equal copies of {@link
+ * Bootstrapper.ServerInfo}, even if they all represent the same xDS server configuration. For gRPC
+ * name resolution with the {@code xds} and {@code google-c2p} scheme, this transport sharing works
+ * as expected as it internally reuses a single {@link Bootstrapper.BootstrapInfo} instance.
+ * Otherwise, new transports would be created for each {@link Bootstrapper.ServerInfo} despite them
+ * possibly representing the same xDS server configuration and defeating the purpose of transport
+ * sharing.
+ */
+final class GrpcXdsTransportFactory implements XdsTransportFactory {
+
+  private final CallCredentials callCredentials;
+  // The map of xDS server info to its corresponding gRPC xDS transport.
+  // This enables reusing and sharing the same underlying gRPC channel.
+  //
+  // NOTE: ConcurrentHashMap is used as a per-entry lock and all reads and writes must be a mutation
+  // via the ConcurrentHashMap APIs to acquire the per-entry lock in order to ensure thread safety
+  // for reference counting of each GrpcXdsTransport instance.
+  private static final Map<Bootstrapper.ServerInfo, GrpcXdsTransport> xdsServerInfoToTransportMap =
+      new ConcurrentHashMap<>();
+
+  GrpcXdsTransportFactory(CallCredentials callCredentials) {
+    this.callCredentials = callCredentials;
+  }
+
+  @Override
+  public XdsTransport create(Bootstrapper.ServerInfo serverInfo) {
+    return xdsServerInfoToTransportMap.compute(
+        serverInfo,
+        (info, transport) -> {
+          if (transport == null) {
+            transport = new GrpcXdsTransport(serverInfo, callCredentials);
+          }
+          ++transport.refCount;
+          return transport;
+        });
+  }
+
+  @VisibleForTesting
+  public XdsTransport createForTest(ManagedChannel channel) {
+    return new GrpcXdsTransport(channel, callCredentials, null);
+  }
+
+  @VisibleForTesting
+  static class GrpcXdsTransport implements XdsTransport {
+
+    private final ManagedChannel channel;
+    private final CallCredentials callCredentials;
+    private final Bootstrapper.ServerInfo serverInfo;
+    // Must only be accessed via the ConcurrentHashMap APIs which act as the locking methods.
+    private int refCount = 0;
+
+    public GrpcXdsTransport(Bootstrapper.ServerInfo serverInfo) {
+      this(serverInfo, null);
+    }
+
+    @VisibleForTesting
+    public GrpcXdsTransport(ManagedChannel channel) {
+      this(channel, null, 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;
+      this.serverInfo = serverInfo;
+    }
+
+    @VisibleForTesting
+    public GrpcXdsTransport(
+        ManagedChannel channel,
+        CallCredentials callCredentials,
+        Bootstrapper.ServerInfo serverInfo) {
+      this.channel = checkNotNull(channel, "channel");
+      this.callCredentials = callCredentials;
+      this.serverInfo = serverInfo;
+    }
+
+    @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() {
+      if (serverInfo == null) {
+        channel.shutdown();
+        return;
+      }
+      xdsServerInfoToTransportMap.computeIfPresent(
+          serverInfo,
+          (info, transport) -> {
+            if (--transport.refCount == 0) { // Prefix decrement and return the updated value.
+              transport.channel.shutdown();
+              return null; // Remove mapping.
+            }
+            return transport;
+          });
+    }
+
+    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/HttpFault.java b/xds/src/main/java/io/grpc/xds/HttpFault.java
deleted file mode 100644
index 252fd41d76a..00000000000
--- a/xds/src/main/java/io/grpc/xds/HttpFault.java
+++ /dev/null
@@ -1,129 +0,0 @@
-/*
- * 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.Status;
-import io.grpc.xds.Matchers.HeaderMatcher;
-import java.util.List;
-import javax.annotation.Nullable;
-
-/** Fault injection configurations. */
-@AutoValue
-abstract class HttpFault {
-  @Nullable
-  abstract FaultDelay faultDelay();
-
-  @Nullable
-  abstract FaultAbort faultAbort();
-
-  abstract String upstreamCluster();
-
-  abstract ImmutableList<String> downstreamNodes();
-
-  abstract ImmutableList<HeaderMatcher> headers();
-
-  @Nullable
-  abstract Integer maxActiveFaults();
-
-  static HttpFault create(@Nullable FaultDelay faultDelay, @Nullable FaultAbort faultAbort,
-      String upstreamCluster, List<String> downstreamNodes, List<HeaderMatcher> headers,
-      @Nullable Integer maxActiveFaults) {
-    return new AutoValue_HttpFault(faultDelay, faultAbort, upstreamCluster,
-        ImmutableList.copyOf(downstreamNodes), ImmutableList.copyOf(headers), 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_HttpFault_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_HttpFault_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_HttpFault_FractionalPercent(numerator, denominatorType);
-    }
-  }
-}
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
index 6f3062f22b7..ed70e6f5e78 100644
--- a/xds/src/main/java/io/grpc/xds/InternalXdsAttributes.java
+++ b/xds/src/main/java/io/grpc/xds/InternalXdsAttributes.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2019 The gRPC Authors
+ * 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.
@@ -18,55 +18,19 @@
 
 import io.grpc.Attributes;
 import io.grpc.EquivalentAddressGroup;
-import io.grpc.Grpc;
 import io.grpc.Internal;
-import io.grpc.NameResolver;
-import io.grpc.internal.ObjectPool;
-import io.grpc.xds.XdsNameResolverProvider.CallCounterProvider;
-import io.grpc.xds.internal.sds.SslContextProviderSupplier;
 
 /**
  * Internal attributes used for xDS implementation. Do not use.
  */
 @Internal
 public final class InternalXdsAttributes {
-
-  // TODO(sanjaypujare): move to xds internal package.
-  /** 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.sds.SslContextProviderSupplier");
-
-  /**
-   * Attribute key for passing around the XdsClient object pool across NameResolver/LoadBalancers.
-   */
-  @NameResolver.ResolutionResultAttr
-  static final Attributes.Key<ObjectPool<XdsClient>> XDS_CLIENT_POOL =
-      Attributes.Key.create("io.grpc.xds.InternalXdsAttributes.xdsClientPool");
-
-  /**
-   * 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.InternalXdsAttributes.callCounterProvider");
-
   /**
    * Name of the cluster that provides this EquivalentAddressGroup.
    */
-  @Internal
   @EquivalentAddressGroup.Attr
   public static final Attributes.Key<String> ATTR_CLUSTER_NAME =
-      Attributes.Key.create("io.grpc.xds.InternalXdsAttributes.clusterName");
-
-  /**
-   * The locality that this EquivalentAddressGroup is in.
-   */
-  @EquivalentAddressGroup.Attr
-  static final Attributes.Key<Locality> ATTR_LOCALITY =
-      Attributes.Key.create("io.grpc.xds.InternalXdsAttributes.locality");
+      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..5fd8ec5526e
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/LoadBalancerConfigFactory.java
@@ -0,0 +1,456 @@
+/*
+ * 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";
+  static final String METRIC_NAMES_FOR_COMPUTING_UTILIZATION = "metricNamesForComputingUtilization";
+
+  /**
+   * 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,
+      ImmutableList<String> metricNamesForComputingUtilization) {
+    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);
+    }
+    if (metricNamesForComputingUtilization != null
+        && !metricNamesForComputingUtilization.isEmpty()) {
+      configBuilder.put(METRIC_NAMES_FOR_COMPUTING_UTILIZATION, metricNamesForComputingUtilization);
+    }
+    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,
+            ImmutableList.copyOf(wrr.getMetricNamesForComputingUtilizationList()));
+      } 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/LoadReportClient.java b/xds/src/main/java/io/grpc/xds/LoadReportClient.java
deleted file mode 100644
index 603e3dcd6a8..00000000000
--- a/xds/src/main/java/io/grpc/xds/LoadReportClient.java
+++ /dev/null
@@ -1,491 +0,0 @@
-/*
- * 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 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.LoadReportingServiceGrpc.LoadReportingServiceStub;
-import io.envoyproxy.envoy.service.load_stats.v3.LoadStatsRequest;
-import io.envoyproxy.envoy.service.load_stats.v3.LoadStatsResponse;
-import io.grpc.InternalLogId;
-import io.grpc.ManagedChannel;
-import io.grpc.Status;
-import io.grpc.SynchronizationContext;
-import io.grpc.SynchronizationContext.ScheduledHandle;
-import io.grpc.internal.BackoffPolicy;
-import io.grpc.stub.StreamObserver;
-import io.grpc.xds.EnvoyProtoData.Node;
-import io.grpc.xds.Stats.ClusterStats;
-import io.grpc.xds.Stats.DroppedRequests;
-import io.grpc.xds.Stats.UpstreamLocalityStats;
-import io.grpc.xds.XdsLogger.XdsLogLevel;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-import java.util.concurrent.ScheduledExecutorService;
-import java.util.concurrent.TimeUnit;
-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.
- */
-final class LoadReportClient {
-  private final InternalLogId logId;
-  private final XdsLogger logger;
-  private final ManagedChannel channel;
-  private final boolean useProtocolV3;
-  private final Node node;
-  private final SynchronizationContext syncContext;
-  private final ScheduledExecutorService timerService;
-  private final Stopwatch retryStopwatch;
-  private final BackoffPolicy.Provider backoffPolicyProvider;
-  private final LoadStatsManager2 loadStatsManager;
-
-  private boolean started;
-  @Nullable
-  private BackoffPolicy lrsRpcRetryPolicy;
-  @Nullable
-  private ScheduledHandle lrsRpcRetryTimer;
-  @Nullable
-  private LrsStream lrsStream;
-
-  LoadReportClient(
-      LoadStatsManager2 loadStatsManager,
-      ManagedChannel channel,
-      boolean useProtocolV3,
-      Node node,
-      SynchronizationContext syncContext,
-      ScheduledExecutorService scheduledExecutorService,
-      BackoffPolicy.Provider backoffPolicyProvider,
-      Supplier<Stopwatch> stopwatchSupplier) {
-    this.loadStatsManager = checkNotNull(loadStatsManager, "loadStatsManager");
-    this.channel = checkNotNull(channel, "xdsChannel");
-    this.useProtocolV3 = useProtocolV3;
-    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");
-  }
-
-  /**
-   * 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.
-   */
-  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.
-   */
-  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 shutdown channel as it is not owned by LrsClient.
-  }
-
-  @VisibleForTesting
-  static class LoadReportingTask implements Runnable {
-    private final LrsStream stream;
-
-    LoadReportingTask(LrsStream stream) {
-      this.stream = stream;
-    }
-
-    @Override
-    public void run() {
-      stream.sendLoadReport();
-    }
-  }
-
-  @VisibleForTesting
-  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");
-    if (useProtocolV3) {
-      lrsStream = new LrsStreamV3();
-    } else {
-      lrsStream = new LrsStreamV2();
-    }
-    retryStopwatch.reset().start();
-    lrsStream.start();
-  }
-
-  private abstract class LrsStream {
-    boolean initialResponseReceived;
-    boolean closed;
-    long intervalNano = -1;
-    boolean reportAllClusters;
-    List<String> clusterNames;  // clusters to report loads for, if not report all.
-    ScheduledHandle loadReportTimer;
-
-    abstract void start();
-
-    abstract void sendLoadStatsRequest(List<ClusterStats> clusterStatsList);
-
-    abstract void sendError(Exception error);
-
-    final 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();
-    }
-
-    final void handleRpcError(Throwable t) {
-      handleStreamClosed(Status.fromThrowable(t));
-    }
-
-    final void handleRpcCompleted() {
-      handleStreamClosed(Status.UNAVAILABLE.withDescription("Closed by server"));
-    }
-
-    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();
-
-      long delayNanos = 0;
-      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();
-      }
-      // 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 =
-            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();
-      sendError(error);
-    }
-
-    private void cleanUp() {
-      if (loadReportTimer != null && loadReportTimer.isPending()) {
-        loadReportTimer.cancel();
-        loadReportTimer = null;
-      }
-      if (lrsStream == this) {
-        lrsStream = null;
-      }
-    }
-  }
-
-  private final class LrsStreamV2 extends LrsStream {
-    StreamObserver<io.envoyproxy.envoy.service.load_stats.v2.LoadStatsRequest> lrsRequestWriterV2;
-
-    @Override
-    void start() {
-      StreamObserver<io.envoyproxy.envoy.service.load_stats.v2.LoadStatsResponse>
-              lrsResponseReaderV2 =
-          new StreamObserver<io.envoyproxy.envoy.service.load_stats.v2.LoadStatsResponse>() {
-            @Override
-            public void onNext(
-                final io.envoyproxy.envoy.service.load_stats.v2.LoadStatsResponse response) {
-              syncContext.execute(new Runnable() {
-                @Override
-                public void run() {
-                  logger.log(XdsLogLevel.DEBUG, "Received LoadStatsResponse:\n{0}", response);
-                  handleRpcResponse(response.getClustersList(), response.getSendAllClusters(),
-                      Durations.toNanos(response.getLoadReportingInterval()));
-                }
-              });
-            }
-
-            @Override
-            public void onError(final Throwable t) {
-              syncContext.execute(new Runnable() {
-                @Override
-                public void run() {
-                  handleRpcError(t);
-                }
-              });
-            }
-
-            @Override
-            public void onCompleted() {
-              syncContext.execute(new Runnable() {
-                @Override
-                public void run() {
-                  handleRpcCompleted();
-                }
-              });
-            }
-          };
-      io.envoyproxy.envoy.service.load_stats.v2.LoadReportingServiceGrpc.LoadReportingServiceStub
-          stubV2 = io.envoyproxy.envoy.service.load_stats.v2.LoadReportingServiceGrpc.newStub(
-              channel);
-      lrsRequestWriterV2 = stubV2.withWaitForReady().streamLoadStats(lrsResponseReaderV2);
-      logger.log(XdsLogLevel.DEBUG, "Sending initial LRS request");
-      sendLoadStatsRequest(Collections.<ClusterStats>emptyList());
-    }
-
-    @Override
-    void sendLoadStatsRequest(List<ClusterStats> clusterStatsList) {
-      io.envoyproxy.envoy.service.load_stats.v2.LoadStatsRequest.Builder requestBuilder =
-          io.envoyproxy.envoy.service.load_stats.v2.LoadStatsRequest.newBuilder()
-              .setNode(node.toEnvoyProtoNodeV2());
-      for (ClusterStats stats : clusterStatsList) {
-        requestBuilder.addClusterStats(buildClusterStats(stats));
-      }
-      io.envoyproxy.envoy.service.load_stats.v2.LoadStatsRequest request = requestBuilder.build();
-      lrsRequestWriterV2.onNext(requestBuilder.build());
-      logger.log(XdsLogLevel.DEBUG, "Sent LoadStatsRequest\n{0}", request);
-    }
-
-    @Override
-    void sendError(Exception error) {
-      lrsRequestWriterV2.onError(error);
-    }
-
-    private io.envoyproxy.envoy.api.v2.endpoint.ClusterStats buildClusterStats(
-        ClusterStats stats) {
-      io.envoyproxy.envoy.api.v2.endpoint.ClusterStats.Builder builder =
-          io.envoyproxy.envoy.api.v2.endpoint.ClusterStats.newBuilder()
-              .setClusterName(stats.clusterName());
-      if (stats.clusterServiceName() != null) {
-        builder.setClusterServiceName(stats.clusterServiceName());
-      }
-      for (UpstreamLocalityStats upstreamLocalityStats : stats.upstreamLocalityStatsList()) {
-        builder.addUpstreamLocalityStats(
-            io.envoyproxy.envoy.api.v2.endpoint.UpstreamLocalityStats.newBuilder()
-            .setLocality(
-                io.envoyproxy.envoy.api.v2.core.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()));
-      }
-      for (DroppedRequests droppedRequests : stats.droppedRequestsList()) {
-        builder.addDroppedRequests(
-            io.envoyproxy.envoy.api.v2.endpoint.ClusterStats.DroppedRequests.newBuilder()
-                .setCategory(droppedRequests.category())
-                .setDroppedCount(droppedRequests.droppedCount()));
-      }
-      return builder.setTotalDroppedRequests(stats.totalDroppedRequests())
-          .setLoadReportInterval(Durations.fromNanos(stats.loadReportIntervalNano())).build();
-    }
-  }
-
-  private final class LrsStreamV3 extends LrsStream {
-    StreamObserver<LoadStatsRequest> lrsRequestWriterV3;
-
-    @Override
-    void start() {
-      StreamObserver<LoadStatsResponse> lrsResponseReaderV3 =
-          new StreamObserver<LoadStatsResponse>() {
-            @Override
-            public void onNext(final 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()));
-                }
-              });
-            }
-
-            @Override
-            public void onError(final Throwable t) {
-              syncContext.execute(new Runnable() {
-                @Override
-                public void run() {
-                  handleRpcError(t);
-                }
-              });
-            }
-
-            @Override
-            public void onCompleted() {
-              syncContext.execute(new Runnable() {
-                @Override
-                public void run() {
-                  handleRpcCompleted();
-                }
-              });
-            }
-          };
-      LoadReportingServiceStub stubV3 =
-          LoadReportingServiceGrpc.newStub(channel);
-      lrsRequestWriterV3 = stubV3.withWaitForReady().streamLoadStats(lrsResponseReaderV3);
-      logger.log(XdsLogLevel.DEBUG, "Sending initial LRS request");
-      sendLoadStatsRequest(Collections.<ClusterStats>emptyList());
-    }
-
-    @Override
-    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();
-      lrsRequestWriterV3.onNext(request);
-      logger.log(XdsLogLevel.DEBUG, "Sent LoadStatsRequest\n{0}", request);
-    }
-
-    @Override
-    void sendError(Exception error) {
-      lrsRequestWriterV3.onError(error);
-    }
-
-    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()));
-      }
-      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/LoadStatsManager2.java b/xds/src/main/java/io/grpc/xds/LoadStatsManager2.java
deleted file mode 100644
index 4bd0ba437be..00000000000
--- a/xds/src/main/java/io/grpc/xds/LoadStatsManager2.java
+++ /dev/null
@@ -1,392 +0,0 @@
-/*
- * 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 com.google.common.base.Stopwatch;
-import com.google.common.base.Supplier;
-import com.google.common.collect.Sets;
-import io.grpc.Status;
-import io.grpc.xds.Stats.ClusterStats;
-import io.grpc.xds.Stats.DroppedRequests;
-import io.grpc.xds.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
-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;
-
-  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.
-   */
-  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 not exits", 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). 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.
-   */
-  synchronized ClusterLocalityStats getClusterLocalityStats(
-      String cluster, @Nullable String edsServiceName, Locality locality) {
-    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())));
-    }
-    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.
-   */
-  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);
-          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
-  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.
-     */
-    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.
-     */
-    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.
-     */
-    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
-  final class ClusterLocalityStats {
-    private final String clusterName;
-    @Nullable
-    private final String edsServiceName;
-    private final Locality locality;
-    private final Stopwatch stopwatch;
-    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 ClusterLocalityStats(
-        String clusterName, @Nullable String edsServiceName, Locality locality,
-        Stopwatch stopwatch) {
-      this.clusterName = checkNotNull(clusterName, "clusterName");
-      this.edsServiceName = edsServiceName;
-      this.locality = checkNotNull(locality, "locality");
-      this.stopwatch = checkNotNull(stopwatch, "stopwatch");
-      stopwatch.reset().start();
-    }
-
-    /**
-     * Records a request being issued.
-     */
-    void recordCallStarted() {
-      callsIssued.getAndIncrement();
-      callsInProgress.getAndIncrement();
-    }
-
-    /**
-     * Records a request finished with the given status.
-     */
-    void recordCallFinished(Status status) {
-      callsInProgress.getAndDecrement();
-      if (status.isOk()) {
-        callsSucceeded.getAndIncrement();
-      } else {
-        callsFailed.getAndIncrement();
-      }
-    }
-
-    /**
-     * 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.
-     */
-    void release() {
-      LoadStatsManager2.this.releaseClusterLocalityLoadCounter(
-          clusterName, edsServiceName, locality);
-    }
-
-    private ClusterLocalityStatsSnapshot snapshot() {
-      long duration = stopwatch.elapsed(TimeUnit.NANOSECONDS);
-      stopwatch.reset().start();
-      return new ClusterLocalityStatsSnapshot(callsSucceeded.getAndSet(0), callsInProgress.get(),
-          callsFailed.getAndSet(0), callsIssued.getAndSet(0), duration);
-    }
-  }
-
-  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 ClusterLocalityStatsSnapshot(
-        long callsSucceeded, long callsInProgress, long callsFailed, long callsIssued,
-        long durationNano) {
-      this.callsSucceeded = callsSucceeded;
-      this.callsInProgress = callsInProgress;
-      this.callsFailed = callsFailed;
-      this.callsIssued = callsIssued;
-      this.durationNano = durationNano;
-    }
-  }
-}
diff --git a/xds/src/main/java/io/grpc/xds/Locality.java b/xds/src/main/java/io/grpc/xds/Locality.java
deleted file mode 100644
index caa8a01a288..00000000000
--- a/xds/src/main/java/io/grpc/xds/Locality.java
+++ /dev/null
@@ -1,33 +0,0 @@
-/*
- * 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;
-
-/** Represents a network locality. */
-@AutoValue
-abstract class Locality {
-  abstract String region();
-
-  abstract String zone();
-
-  abstract String subZone();
-
-  static Locality create(String region, String zone, String subZone) {
-    return new AutoValue_Locality(region, zone, subZone);
-  }
-}
diff --git a/xds/src/main/java/io/grpc/xds/Matchers.java b/xds/src/main/java/io/grpc/xds/Matchers.java
deleted file mode 100644
index 8018dc5ffad..00000000000
--- a/xds/src/main/java/io/grpc/xds/Matchers.java
+++ /dev/null
@@ -1,171 +0,0 @@
-/*
- * 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.re2j.Pattern;
-import javax.annotation.Nullable;
-
-/** A group of request matchers. */
-final class Matchers {
-  private Matchers() {}
-
-  /** 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 PathMatcher.create(path, null, null, caseSensitive);
-    }
-
-    static PathMatcher fromPrefix(String prefix, boolean caseSensitive) {
-      checkNotNull(prefix, "prefix");
-      return PathMatcher.create(null, prefix, null, caseSensitive);
-    }
-
-    static PathMatcher fromRegEx(Pattern regEx) {
-      checkNotNull(regEx, "regEx");
-      return PathMatcher.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_Matchers_PathMatcher(path, prefix, regEx, caseSensitive);
-    }
-  }
-
-  /** Matcher for HTTP request headers. */
-  @AutoValue
-  abstract static class HeaderMatcher {
-    // Name of the header to be matched.
-    abstract String name();
-
-    // Matches exact header value.
-    @Nullable
-    abstract String exactValue();
-
-    // Matches header value with the regular expression pattern.
-    @Nullable
-    abstract Pattern safeRegEx();
-
-    // Matches header value an integer value in the range.
-    @Nullable
-    abstract Range range();
-
-    // Matches header presence.
-    @Nullable
-    abstract Boolean present();
-
-    // Matches header value with the prefix.
-    @Nullable
-    abstract String prefix();
-
-    // Matches header value with the suffix.
-    @Nullable
-    abstract String suffix();
-
-    // Whether the matching semantics is inverted. E.g., present && !inverted -> !present
-    abstract boolean inverted();
-
-    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, inverted);
-    }
-
-    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, inverted);
-    }
-
-    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, inverted);
-    }
-
-    static HeaderMatcher forPresent(String name, boolean present, boolean inverted) {
-      checkNotNull(name, "name");
-      return HeaderMatcher.create(name, null, null, null, present, null, null, inverted);
-    }
-
-    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, inverted);
-    }
-
-    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, 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, boolean inverted) {
-      checkNotNull(name, "name");
-      return new AutoValue_Matchers_HeaderMatcher(name, exactValue, safeRegEx, range, present,
-          prefix, suffix, inverted);
-    }
-
-    /** Represents an integer range. */
-    @AutoValue
-    abstract static class Range {
-      abstract long start();
-
-      abstract long end();
-
-      static Range create(long start, long end) {
-        return new AutoValue_Matchers_HeaderMatcher_Range(start, end);
-      }
-
-    }
-  }
-
-  /** Represents a fractional value. */
-  @AutoValue
-  abstract static class FractionMatcher {
-    abstract int numerator();
-
-    abstract int denominator();
-
-    static FractionMatcher create(int numerator, int denominator) {
-      return new AutoValue_Matchers_FractionMatcher(numerator, denominator);
-    }
-  }
-}
diff --git a/xds/src/main/java/io/grpc/xds/MessagePrinter.java b/xds/src/main/java/io/grpc/xds/MessagePrinter.java
index bc738eed52a..d6fdaa81dd7 100644
--- a/xds/src/main/java/io/grpc/xds/MessagePrinter.java
+++ b/xds/src/main/java/io/grpc/xds/MessagePrinter.java
@@ -16,7 +16,10 @@
 
 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;
@@ -24,43 +27,74 @@
 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 {
-  private final JsonFormat.Printer printer;
+final class MessagePrinter implements MessagePrettyPrinter {
+  public static final MessagePrinter INSTANCE = new MessagePrinter();
 
-  MessagePrinter() {
-    TypeRegistry registry =
-        TypeRegistry.newBuilder()
-            .add(Listener.getDescriptor())
-            .add(io.envoyproxy.envoy.api.v2.Listener.getDescriptor())
-            .add(HttpConnectionManager.getDescriptor())
-            .add(io.envoyproxy.envoy.config.filter.network.http_connection_manager.v2
-                .HttpConnectionManager.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(io.envoyproxy.envoy.api.v2.RouteConfiguration.getDescriptor())
-            .add(Cluster.getDescriptor())
-            .add(io.envoyproxy.envoy.api.v2.Cluster.getDescriptor())
-            .add(ClusterLoadAssignment.getDescriptor())
-            .add(io.envoyproxy.envoy.api.v2.ClusterLoadAssignment.getDescriptor())
-            .build();
-    printer = JsonFormat.printer().usingTypeRegistry(registry);
+  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());
+    }
   }
 
-  String print(MessageOrBuilder message) {
+  @Override
+  public String print(MessageOrBuilder message) {
     String res;
     try {
-      res = printer.print(message);
+      res = LazyHolder.printer.print(message);
     } catch (InvalidProtocolBufferException e) {
       res = message + " (failed to pretty-print: " + e + ")";
     }
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/OrcaMetricReportingServerInterceptor.java b/xds/src/main/java/io/grpc/xds/OrcaMetricReportingServerInterceptor.java
deleted file mode 100644
index 8a503bd35f9..00000000000
--- a/xds/src/main/java/io/grpc/xds/OrcaMetricReportingServerInterceptor.java
+++ /dev/null
@@ -1,93 +0,0 @@
-/*
- * 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 com.github.udpa.udpa.data.orca.v1.OrcaLoadReport;
-import com.google.common.annotations.VisibleForTesting;
-import io.grpc.Context;
-import io.grpc.Contexts;
-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 java.util.Map;
-
-/**
- * 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
- */
-final class OrcaMetricReportingServerInterceptor implements ServerInterceptor {
-
-  private static final OrcaMetricReportingServerInterceptor INSTANCE =
-      new OrcaMetricReportingServerInterceptor();
-
-  @VisibleForTesting
-  static final Metadata.Key<OrcaLoadReport> ORCA_ENDPOINT_LOAD_METRICS_KEY =
-      Metadata.Key.of(
-          "x-endpoint-load-metrics-bin",
-          ProtoUtils.metadataMarshaller(OrcaLoadReport.getDefaultInstance()));
-
-  @VisibleForTesting
-  OrcaMetricReportingServerInterceptor() {
-  }
-
-  public static OrcaMetricReportingServerInterceptor getInstance() {
-    return INSTANCE;
-  }
-
-  @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) {
-            Map<String, Double> metricValues =
-                InternalCallMetricRecorder.finalizeAndDump(finalCallMetricRecorder);
-            // Only attach a metric report if there are some metric values to be reported.
-            if (!metricValues.isEmpty()) {
-              OrcaLoadReport report =
-                  OrcaLoadReport.newBuilder().putAllRequestCost(metricValues).build();
-              trailers.put(ORCA_ENDPOINT_LOAD_METRICS_KEY, report);
-            }
-            super.close(status, trailers);
-          }
-        };
-    return Contexts.interceptCall(
-        ctx,
-        trailerAttachingCall,
-        headers,
-        next);
-  }
-}
diff --git a/xds/src/main/java/io/grpc/xds/OrcaOobUtil.java b/xds/src/main/java/io/grpc/xds/OrcaOobUtil.java
deleted file mode 100644
index 1b5acd8c080..00000000000
--- a/xds/src/main/java/io/grpc/xds/OrcaOobUtil.java
+++ /dev/null
@@ -1,627 +0,0 @@
-/*
- * 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 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 com.github.udpa.udpa.data.orca.v1.OrcaLoadReport;
-import com.github.udpa.udpa.service.orca.v1.OpenRcaServiceGrpc;
-import com.github.udpa.udpa.service.orca.v1.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.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.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.util.ForwardingLoadBalancerHelper;
-import io.grpc.util.ForwardingSubchannel;
-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.ScheduledExecutorService;
-import java.util.concurrent.TimeUnit;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-import javax.annotation.Nullable;
-
-/**
- * Utility class that provides method for {@link LoadBalancer} to install listeners to receive
- * out-of-band backend cost metrics in the format of Open Request Cost Aggregation (ORCA).
- */
-abstract class OrcaOobUtil {
-
-  private static final Logger logger = Logger.getLogger(OrcaPerRequestUtil.class.getName());
-  private static final OrcaOobUtil DEFAULT_INSTANCE =
-      new OrcaOobUtil() {
-
-        @Override
-        public OrcaReportingHelperWrapper newOrcaReportingHelperWrapper(
-            LoadBalancer.Helper delegate,
-            OrcaOobReportListener listener) {
-          return newOrcaReportingHelperWrapper(
-              delegate,
-              listener,
-              new ExponentialBackoffPolicy.Provider(),
-              GrpcUtil.STOPWATCH_SUPPLIER);
-        }
-      };
-
-  /**
-   * Gets an {@code OrcaOobUtil} instance that provides actual implementation of
-   * {@link #newOrcaReportingHelperWrapper}.
-   */
-  public static OrcaOobUtil getInstance() {
-    return DEFAULT_INSTANCE;
-  }
-
-  /**
-   * Creates a new {@link 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 void handleResolvedAddresses(ResolvedAddresses resolvedAddresses) {
-   *           // listener implements the logic for WRR's usage of backend metrics.
-   *           OrcaReportingHelperWrapper orcaWrapper =
-   *               OrcaOobUtil.getInstance().newOrcaReportingHelperWrapper(originHelper, listener);
-   *           orcaWrapper.setReportingConfig(
-   *               OrcaRerportingConfig.newBuilder().setReportInterval(30, SECOND).build());
-   *           Subchannel subchannel =
-   *               orcaWrapper.asHelper().createSubchannel(CreateSubchannelArgs.newBuilder()...);
-   *           ...
-   *         }
-   *       }
-   *       }
-   *     </pre>
-   *   </li>
-   *   <li> Delegating policy doing per-child-policy aggregation
-   *     <pre>
-   *       {@code
-   *       class XdsLoadBalancer extends LoadBalancer {
-   *         private final Helper originHelper;  // the original 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.
-   *           OrcaReportingHelperWrapper orcaWrapper =
-   *               OrcaOobUtil.getInstance().newOrcaReportingHelperWrapper(originHelper, listener);
-   *           orcaWrapper.setReportingConfig(
-   *               OrcaRerportingConfig.newBuilder().setReportInterval(30, SECOND).build());
-   *           LoadBalancer childLb = childPolicyProvider.newLoadBalancer(orcaWrapper.asHelper());
-   *         }
-   *       }
-   *       }
-   *     </pre>
-   *   </li>
-   * </ul>
-   *
-   * @param delegate the delegate helper that provides essentials for establishing subchannels to
-   *     backends.
-   * @param listener contains the callback to be invoked when an out-of-band ORCA report is
-   *     received.
-   */
-  public abstract OrcaReportingHelperWrapper newOrcaReportingHelperWrapper(
-      LoadBalancer.Helper delegate,
-      OrcaOobReportListener listener);
-
-  @VisibleForTesting
-  static OrcaReportingHelperWrapper newOrcaReportingHelperWrapper(
-      LoadBalancer.Helper delegate,
-      OrcaOobReportListener listener,
-      BackoffPolicy.Provider backoffPolicyProvider,
-      Supplier<Stopwatch> stopwatchSupplier) {
-    final OrcaReportingHelper orcaHelper =
-        new OrcaReportingHelper(delegate, listener, backoffPolicyProvider, stopwatchSupplier);
-
-    return new OrcaReportingHelperWrapper() {
-      @Override
-      public void setReportingConfig(OrcaReportingConfig config) {
-        orcaHelper.setReportingConfig(config);
-      }
-
-      @Override
-      public Helper asHelper() {
-        return orcaHelper;
-      }
-    };
-  }
-
-  /**
-   * 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 ORCA protocol.
-     */
-    void onLoadReport(OrcaLoadReport report);
-  }
-
-  /**
-   * Blueprint for the wrapper that wraps a {@link LoadBalancer.Helper} with the capability of
-   * allowing {@link LoadBalancer}s interested in receiving out-of-band ORCA reports to update the
-   * reporting configuration such as reporting interval.
-   */
-  public abstract static class OrcaReportingHelperWrapper {
-
-    /**
-     * Sets the configuration of receiving ORCA reports, such as the interval of receiving reports.
-     *
-     * <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 config the configuration to be set.
-     */
-    public abstract void setReportingConfig(OrcaReportingConfig config);
-
-    /**
-     * Returns a wrapped {@link LoadBalancer.Helper}. Subchannels created through it will retrieve
-     * ORCA load reports if the server supports it.
-     */
-    public abstract LoadBalancer.Helper asHelper();
-  }
-
-  /**
-   * 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.
-   */
-  private static final class OrcaReportingHelper extends ForwardingLoadBalancerHelper
-      implements OrcaOobReportListener {
-
-    private static final CreateSubchannelArgs.Key<OrcaReportingState> ORCA_REPORTING_STATE_KEY =
-        CreateSubchannelArgs.Key.create("internal-orca-reporting-state");
-    private final LoadBalancer.Helper delegate;
-    private final OrcaOobReportListener listener;
-    private final SynchronizationContext syncContext;
-    private final BackoffPolicy.Provider backoffPolicyProvider;
-    private final Supplier<Stopwatch> stopwatchSupplier;
-    private final Set<OrcaReportingState> orcaStates = new HashSet<>();
-    @Nullable private OrcaReportingConfig orcaConfig;
-
-    OrcaReportingHelper(
-        LoadBalancer.Helper delegate,
-        OrcaOobReportListener listener,
-        BackoffPolicy.Provider backoffPolicyProvider,
-        Supplier<Stopwatch> stopwatchSupplier) {
-      this.delegate = checkNotNull(delegate, "delegate");
-      this.listener = checkNotNull(listener, "listener");
-      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();
-      OrcaReportingState orcaState = args.getOption(ORCA_REPORTING_STATE_KEY);
-      boolean augmented = false;
-      if (orcaState == null) {
-        // Only the first load balancing policy requesting ORCA reports instantiates an
-        // OrcaReportingState.
-        orcaState = new OrcaReportingState(this, syncContext,
-            delegate().getScheduledExecutorService());
-        args = args.toBuilder().addOption(ORCA_REPORTING_STATE_KEY, orcaState).build();
-        augmented = true;
-      }
-      orcaStates.add(orcaState);
-      orcaState.listeners.add(this);
-      Subchannel subchannel = super.createSubchannel(args);
-      if (augmented) {
-        subchannel = new SubchannelImpl(subchannel, orcaState);
-      }
-      if (orcaConfig != null) {
-        orcaState.setReportingConfig(this, orcaConfig);
-      }
-      return subchannel;
-    }
-
-    void setReportingConfig(final OrcaReportingConfig config) {
-      syncContext.throwIfNotInThisSynchronizationContext();
-      orcaConfig = config;
-      for (OrcaReportingState state : orcaStates) {
-        state.setReportingConfig(OrcaReportingHelper.this, config);
-      }
-    }
-
-    @Override
-    public void onLoadReport(OrcaLoadReport report) {
-      syncContext.throwIfNotInThisSynchronizationContext();
-      if (orcaConfig != null) {
-        listener.onLoadReport(report);
-      }
-    }
-
-    /**
-     * 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 OrcaReportingHelper orcaHelper;
-      private final SynchronizationContext syncContext;
-      private final ScheduledExecutorService timeService;
-      private final List<OrcaOobReportListener> listeners = new ArrayList<>();
-      private final Map<OrcaReportingHelper, 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;
-
-      OrcaReportingState(
-          OrcaReportingHelper orcaHelper,
-          SynchronizationContext syncContext,
-          ScheduledExecutorService timeService) {
-        this.orcaHelper = checkNotNull(orcaHelper, "orcaHelper");
-        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");
-      }
-
-      void setReportingConfig(OrcaReportingHelper helper, OrcaReportingConfig config) {
-        boolean reconfigured = false;
-        configs.put(helper, config);
-        // Real reporting interval is the minimum of intervals requested by all participating
-        // helpers.
-        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;
-        }
-        if (Objects.equal(newState.getState(), SHUTDOWN)) {
-          orcaHelper.orcaStates.remove(this);
-        }
-        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);
-          for (OrcaOobReportListener listener : listeners) {
-            listener.onLoadReport(response);
-          }
-          call.request(1);
-        }
-
-        void handleStreamClosed(Status status) {
-          if (Objects.equal(status.getCode(), Code.UNIMPLEMENTED)) {
-            disabled = true;
-            logger.log(
-                Level.SEVERE,
-                "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;
-
-    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) {
-      orcaState.init(this, listener);
-      super.start(orcaState);
-    }
-  }
-
-  /** 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/PriorityLoadBalancer.java b/xds/src/main/java/io/grpc/xds/PriorityLoadBalancer.java
index c8f63c4ad22..ca142af0af3 100644
--- a/xds/src/main/java/io/grpc/xds/PriorityLoadBalancer.java
+++ b/xds/src/main/java/io/grpc/xds/PriorityLoadBalancer.java
@@ -21,26 +21,27 @@
 import static io.grpc.ConnectivityState.IDLE;
 import static io.grpc.ConnectivityState.READY;
 import static io.grpc.ConnectivityState.TRANSIENT_FAILURE;
-import static io.grpc.xds.XdsSubchannelPickers.BUFFER_PICKER;
 
 import io.grpc.ConnectivityState;
 import io.grpc.InternalLogId;
 import io.grpc.LoadBalancer;
-import io.grpc.LoadBalancerProvider;
 import io.grpc.Status;
 import io.grpc.SynchronizationContext;
 import io.grpc.SynchronizationContext.ScheduledHandle;
-import io.grpc.internal.ServiceConfigUtil.PolicySelection;
+import io.grpc.internal.GrpcUtil;
 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.XdsLogger.XdsLogLevel;
-import io.grpc.xds.XdsSubchannelPickers.ErrorPicker;
+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;
@@ -57,7 +58,9 @@ final class PriorityLoadBalancer extends LoadBalancer {
   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 the its deactivation.
+  // 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.
@@ -66,8 +69,13 @@ final class PriorityLoadBalancer extends LoadBalancer {
   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;
+  static boolean enablePriorityLbChildPolicyCache =
+      GrpcUtil.getFlag("GRPC_EXPERIMENTAL_ENABLE_PRIORITY_LB_CHILD_POLICY_CACHE", false);
 
   PriorityLoadBalancer(Helper helper) {
     this.helper = checkNotNull(helper, "helper");
@@ -79,92 +87,126 @@ final class PriorityLoadBalancer extends LoadBalancer {
   }
 
   @Override
-  public void handleResolvedAddresses(ResolvedAddresses resolvedAddresses) {
+  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);
-    for (String priority : children.keySet()) {
+    ArrayList<String> childKeys = new ArrayList<>(children.keySet());
+    for (String priority : childKeys) {
       if (!prioritySet.contains(priority)) {
-        children.get(priority).deactivate();
+        ChildLbState childLbState = children.get(priority);
+        if (childLbState != null) {
+          if (enablePriorityLbChildPolicyCache) {
+            childLbState.deactivate();
+          } else {
+            childLbState.tearDown();
+            children.remove(priority);
+          }
+        }
       }
     }
+    handlingResolvedAddresses = true;
     for (String priority : priorityNames) {
-      if (children.containsKey(priority)) {
-        children.get(priority).updateResolvedAddresses();
+      ChildLbState childLbState = children.get(priority);
+      if (childLbState != null) {
+        Status newStatus = childLbState.updateResolvedAddresses();
+        if (!newStatus.isOk()) {
+          status = newStatus;
+        }
       }
     }
-    // Not to report connecting in case a pending priority bumps up on top of the current READY
-    // priority.
-    tryNextPriority(false);
+    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;
-    for (ChildLbState child : children.values()) {
+    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(TRANSIENT_FAILURE, new ErrorPicker(error));
+      updateOverallState(
+          null, TRANSIENT_FAILURE, new FixedResultPicker(PickResult.withError(error)));
     }
   }
 
   @Override
   public void shutdown() {
     logger.log(XdsLogLevel.INFO, "Shutdown");
-    for (ChildLbState child : children.values()) {
+    Collection<ChildLbState> childValues = new ArrayList<>(children.values());
+    for (ChildLbState child : childValues) {
       child.tearDown();
     }
+    children.clear();
   }
 
-  private void tryNextPriority(boolean reportConnecting) {
+  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.updateResolvedAddresses();
-        updateOverallState(CONNECTING, BUFFER_PICKER);
-        return; // Give priority i time to connect.
+        // 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(child.connectivityState, child.picker);
+        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;
+        return Status.OK;
       }
-      if (child.failOverTimer != null && child.failOverTimer.isPending()) {
-        if (reportConnecting) {
-          updateOverallState(CONNECTING, BUFFER_PICKER);
-        }
-        return; // Give priority i time to connect.
+      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;
       }
     }
-    // TODO(zdapeng): Include error details of each priority.
     logger.log(XdsLogLevel.DEBUG, "All priority failed");
     String lastPriority = priorityNames.get(priorityNames.size() - 1);
-    SubchannelPicker errorPicker = children.get(lastPriority).picker;
-    updateOverallState(TRANSIENT_FAILURE, errorPicker);
+    ChildLbState child = children.get(lastPriority);
+    updateOverallState(lastPriority, child.connectivityState, child.picker);
+    return Status.OK;
   }
 
-  private void updateOverallState(ConnectivityState state, SubchannelPicker picker) {
-    if (!state.equals(currentConnectivityState) || !picker.equals(currentPicker)) {
+  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);
@@ -177,35 +219,36 @@ private final class ChildLbState {
     final GracefulSwitchLoadBalancer lb;
     // Timer to fail over to the next priority if not connected in 10 sec. Scheduled only once at
     // child initialization.
-    final ScheduledHandle failOverTimer;
+    ScheduledHandle failOverTimer;
+    boolean seenReadyOrIdleSinceTransientFailure = false;
     // Timer to delay shutdown and deletion of the priority. Scheduled whenever the child is
     // deactivated.
     @Nullable ScheduledHandle deletionTimer;
-    @Nullable String policy;
     ConnectivityState connectivityState = CONNECTING;
-    SubchannelPicker picker = BUFFER_PICKER;
+    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);
+    }
 
-      class FailOverTask implements Runnable {
-        @Override
-        public void run() {
-          if (deletionTimer != null && deletionTimer.isPending()) {
-            // The child is deactivated.
-            return;
-          }
-          picker = new ErrorPicker(
-              Status.UNAVAILABLE.withDescription("Connection timeout for priority " + priority));
-          logger.log(XdsLogLevel.DEBUG, "Priority {0} failed over to next", priority);
-          tryNextPriority(true);
+    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();
         }
       }
-
-      failOverTimer = syncContext.schedule(new FailOverTask(), 10, TimeUnit.SECONDS, executor);
-      logger.log(XdsLogLevel.DEBUG, "Priority created: {0}", priority);
     }
 
     /**
@@ -255,20 +298,13 @@ void tearDown() {
      * resolvedAddresses}, or when priority lb receives a new resolved addresses while the child
      * already exists.
      */
-    void updateResolvedAddresses() {
+    Status updateResolvedAddresses() {
       PriorityLbConfig config =
           (PriorityLbConfig) resolvedAddresses.getLoadBalancingPolicyConfig();
-      PolicySelection childPolicySelection = config.childConfigs.get(priority).policySelection;
-      LoadBalancerProvider lbProvider = childPolicySelection.getProvider();
-      String newPolicy = lbProvider.getPolicyName();
-      if (!newPolicy.equals(policy)) {
-        policy = newPolicy;
-        lb.switchTo(lbProvider);
-      }
-      lb.handleResolvedAddresses(
+      return lb.acceptResolvedAddresses(
           resolvedAddresses.toBuilder()
               .setAddresses(AddressFilter.filter(resolvedAddresses.getAddresses(), priority))
-              .setLoadBalancingPolicyConfig(childPolicySelection.getConfig())
+              .setLoadBalancingPolicyConfig(config.childConfigs.get(priority).childConfig)
               .build());
     }
 
@@ -289,22 +325,38 @@ public void refreshNameResolution() {
       @Override
       public void updateBalancingState(final ConnectivityState newState,
           final SubchannelPicker newPicker) {
-        syncContext.execute(new Runnable() {
-          @Override
-          public void run() {
-            connectivityState = newState;
-            picker = newPicker;
-            if (deletionTimer != null && deletionTimer.isPending()) {
-              return;
-            }
-            if (failOverTimer.isPending()) {
-              if (newState.equals(READY) || newState.equals(TRANSIENT_FAILURE)) {
-                failOverTimer.cancel();
-              }
-            }
-            tryNextPriority(true);
+        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
diff --git a/xds/src/main/java/io/grpc/xds/PriorityLoadBalancerProvider.java b/xds/src/main/java/io/grpc/xds/PriorityLoadBalancerProvider.java
index dff1e778409..1aab6c31b08 100644
--- a/xds/src/main/java/io/grpc/xds/PriorityLoadBalancerProvider.java
+++ b/xds/src/main/java/io/grpc/xds/PriorityLoadBalancerProvider.java
@@ -25,7 +25,7 @@
 import io.grpc.LoadBalancer.Helper;
 import io.grpc.LoadBalancerProvider;
 import io.grpc.NameResolver.ConfigOrError;
-import io.grpc.internal.ServiceConfigUtil.PolicySelection;
+import io.grpc.Status;
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.List;
@@ -47,7 +47,7 @@ public int getPriority() {
 
   @Override
   public String getPolicyName() {
-    return "priority_experimental";
+    return XdsLbPolicies.PRIORITY_POLICY_NAME;
   }
 
   @Override
@@ -57,7 +57,8 @@ public LoadBalancer newLoadBalancer(Helper helper) {
 
   @Override
   public ConfigOrError parseLoadBalancingPolicyConfig(Map<String, ?> rawConfig) {
-    throw new UnsupportedOperationException();
+    return ConfigOrError.fromError(
+        Status.INTERNAL.withDescription(getPolicyName() + " cannot be used from service config"));
   }
 
   static final class PriorityLbConfig {
@@ -88,13 +89,21 @@ public String toString() {
     }
 
     static final class PriorityChildConfig {
-      final PolicySelection policySelection;
+      final Object childConfig;
       final boolean ignoreReresolution;
 
-      PriorityChildConfig(PolicySelection policySelection, boolean ignoreReresolution) {
-        this.policySelection = checkNotNull(policySelection, "policySelection");
+      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..58cc46fad3e
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/RbacFilter.java
@@ -0,0 +1,365 @@
+/*
+ * 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, FilterConfigParseContext context) {
+      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, FilterConfigParseContext context) {
+      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..090d1cfabad
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/RouterFilter.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.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, FilterConfigParseContext context) {
+      return ConfigOrError.fromConfig(ROUTER_CONFIG);
+    }
+
+    @Override
+    public ConfigOrError<? extends FilterConfig> parseFilterConfigOverride(
+        Message rawProtoMessage, FilterConfigParseContext context) {
+      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/ServerXdsClient.java b/xds/src/main/java/io/grpc/xds/ServerXdsClient.java
deleted file mode 100644
index c499ed7f24e..00000000000
--- a/xds/src/main/java/io/grpc/xds/ServerXdsClient.java
+++ /dev/null
@@ -1,261 +0,0 @@
-/*
- * 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 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.ImmutableList;
-import com.google.protobuf.Any;
-import com.google.protobuf.InvalidProtocolBufferException;
-import io.envoyproxy.envoy.config.core.v3.Address;
-import io.envoyproxy.envoy.config.core.v3.TrafficDirection;
-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.grpc.ManagedChannel;
-import io.grpc.Status;
-import io.grpc.SynchronizationContext.ScheduledHandle;
-import io.grpc.internal.BackoffPolicy;
-import io.grpc.xds.EnvoyProtoData.Node;
-import io.grpc.xds.XdsLogger.XdsLogLevel;
-import java.util.Collection;
-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 javax.annotation.Nullable;
-
-/**
- * XdsClient implementation for server side usages.
- */
-final class ServerXdsClient extends AbstractXdsClient {
-
-  // Longest time to wait, since the subscription to some resource, for concluding its absence.
-  @VisibleForTesting
-  static final int INITIAL_RESOURCE_FETCH_TIMEOUT_SEC = 15;
-  @Nullable
-  private ListenerWatcher listenerWatcher;
-  private int listenerPort = -1;
-  private final boolean useNewApiForListenerQuery;
-  @Nullable private final String instanceIp;
-  private String grpcServerResourceId;
-  @Nullable
-  private ScheduledHandle ldsRespTimer;
-
-  ServerXdsClient(
-      ManagedChannel channel,
-      boolean useProtocolV3,
-      Node node,
-      ScheduledExecutorService timeService,
-      BackoffPolicy.Provider backoffPolicyProvider,
-      Supplier<Stopwatch> stopwatchSupplier,
-      String instanceIp,
-      String grpcServerResourceId) {
-    super(channel, useProtocolV3, node, timeService, backoffPolicyProvider, stopwatchSupplier);
-    this.useNewApiForListenerQuery = useProtocolV3;
-    this.instanceIp = (instanceIp != null ? instanceIp : "0.0.0.0");
-    this.grpcServerResourceId = grpcServerResourceId;
-  }
-
-  @Override
-  void watchListenerData(final int port, final ListenerWatcher watcher) {
-    checkState(listenerWatcher == null, "ListenerWatcher already registered");
-    listenerWatcher = checkNotNull(watcher, "watcher");
-    checkArgument(port > 0, "port needs to be > 0");
-    listenerPort = port;
-    if (useNewApiForListenerQuery) {
-      String listeningAddress = instanceIp + ":" + listenerPort;
-      grpcServerResourceId =
-          grpcServerResourceId + "?udpa.resource.listening_address=" + listeningAddress;
-    } else {
-      grpcServerResourceId = ":" + listenerPort;
-    }
-    getSyncContext().execute(new Runnable() {
-      @Override
-      public void run() {
-        getLogger().log(XdsLogLevel.INFO, "Started watching listener for port {0}", port);
-        if (!useNewApiForListenerQuery) {
-          updateNodeMetadataForListenerRequest(port);
-        }
-        adjustResourceSubscription(ResourceType.LDS);
-        if (!isInBackoff()) {
-          ldsRespTimer =
-              getSyncContext()
-                  .schedule(
-                      new ListenerResourceFetchTimeoutTask(grpcServerResourceId),
-                      INITIAL_RESOURCE_FETCH_TIMEOUT_SEC, TimeUnit.SECONDS, getTimeService());
-        }
-      }
-    });
-  }
-
-  @Nullable
-  @Override
-  Collection<String> getSubscribedResources(ResourceType type) {
-    if (type != ResourceType.LDS) {
-      return null;
-    }
-    if (useNewApiForListenerQuery) {
-      return ImmutableList.<String>of(grpcServerResourceId);
-    } else {
-      return Collections.emptyList();
-    }
-  }
-
-  /** In case of Listener watcher metadata to be updated to include port. */
-  private void updateNodeMetadataForListenerRequest(int port) {
-    Map<String, Object> newMetadata = new HashMap<>();
-    if (node.getMetadata() != null) {
-      newMetadata.putAll(node.getMetadata());
-    }
-    newMetadata.put("TRAFFICDIRECTOR_INBOUND_INTERCEPTION_PORT", "15001");
-    newMetadata.put("TRAFFICDIRECTOR_INBOUND_BACKEND_PORTS", "" + port);
-    newMetadata.put("INSTANCE_IP", instanceIp);
-    node = node.toBuilder().setMetadata(newMetadata).build();
-  }
-
-  @Override
-  protected void handleLdsResponse(String versionInfo, List<Any> resources, String nonce) {
-    // Unpack Listener messages.
-    Listener requestedListener = null;
-    getLogger().log(XdsLogLevel.DEBUG, "Listener count: {0}", resources.size());
-    try {
-      for (com.google.protobuf.Any res : resources) {
-        if (res.getTypeUrl().equals(ResourceType.LDS.typeUrlV2())) {
-          res = res.toBuilder().setTypeUrl(ResourceType.LDS.typeUrl()).build();
-        }
-        Listener listener = res.unpack(Listener.class);
-        getLogger().log(XdsLogLevel.DEBUG, "Found listener {0}", listener.toString());
-        if (isRequestedListener(listener)) {
-          requestedListener = listener;
-          getLogger().log(XdsLogLevel.DEBUG, "Requested listener found: {0}", listener.getName());
-        }
-      }
-    } catch (InvalidProtocolBufferException e) {
-      getLogger().log(XdsLogLevel.WARNING, "Failed to unpack Listeners in LDS response {0}", e);
-      nackResponse(ResourceType.LDS, nonce, "Malformed LDS response: " + e);
-      return;
-    }
-    ListenerUpdate listenerUpdate = null;
-    if (requestedListener != null) {
-      if (ldsRespTimer != null) {
-        ldsRespTimer.cancel();
-        ldsRespTimer = null;
-      }
-      try {
-        listenerUpdate = ListenerUpdate.newBuilder()
-            .setListener(EnvoyServerProtoData.Listener.fromEnvoyProtoListener(requestedListener))
-            .build();
-      } catch (InvalidProtocolBufferException e) {
-        getLogger().log(XdsLogLevel.WARNING, "Failed to unpack Listener in LDS response {0}", e);
-        nackResponse(ResourceType.LDS, nonce, "Malformed LDS response: " + e);
-        return;
-      }
-    } else {
-      if (ldsRespTimer == null) {
-        listenerWatcher.onResourceDoesNotExist(grpcServerResourceId);
-      }
-    }
-    ackResponse(ResourceType.LDS, versionInfo, nonce);
-    if (listenerUpdate != null) {
-      listenerWatcher.onListenerChanged(listenerUpdate);
-    }
-  }
-
-  private boolean isRequestedListener(Listener listener) {
-    if (useNewApiForListenerQuery) {
-      return grpcServerResourceId.equals(listener.getName())
-          && listener.getTrafficDirection().equals(TrafficDirection.INBOUND)
-          && isAddressMatching(listener.getAddress(), listenerPort);
-    }
-    return isAddressMatching(listener.getAddress(), 15001)
-        && hasMatchingFilter(listener.getFilterChainsList());
-  }
-
-  private boolean isAddressMatching(Address address, int portToMatch) {
-    return address.hasSocketAddress() && address.getSocketAddress().getPortValue() == portToMatch;
-  }
-
-  private boolean hasMatchingFilter(List<FilterChain> filterChainsList) {
-    // TODO(sanjaypujare): if myIp to be checked against filterChainMatch.getPrefixRangesList()
-    for (FilterChain filterChain : filterChainsList) {
-      FilterChainMatch filterChainMatch = filterChain.getFilterChainMatch();
-
-      if (listenerPort == filterChainMatch.getDestinationPort().getValue()) {
-        return true;
-      }
-    }
-    return false;
-  }
-
-  @Override
-  protected void handleStreamClosed(Status error) {
-    cleanUpResourceTimer();
-    if (listenerWatcher != null) {
-      listenerWatcher.onError(error);
-    }
-  }
-
-  @Override
-  protected void handleStreamRestarted() {
-    if (listenerWatcher != null) {
-      ldsRespTimer =
-          getSyncContext()
-              .schedule(
-                  new ListenerResourceFetchTimeoutTask(grpcServerResourceId),
-                  INITIAL_RESOURCE_FETCH_TIMEOUT_SEC, TimeUnit.SECONDS, getTimeService());
-    }
-  }
-
-  @Override
-  protected void handleShutdown() {
-    cleanUpResourceTimer();
-  }
-
-  private void cleanUpResourceTimer() {
-    if (ldsRespTimer != null) {
-      ldsRespTimer.cancel();
-      ldsRespTimer = null;
-    }
-  }
-
-  @VisibleForTesting
-  final class ListenerResourceFetchTimeoutTask implements Runnable {
-    private String resourceName;
-
-    ListenerResourceFetchTimeoutTask(String resourceName) {
-      this.resourceName = resourceName;
-    }
-
-    @Override
-    public void run() {
-      getLogger().log(
-          XdsLogLevel.WARNING,
-          "Did not receive resource info {0} after {1} seconds, conclude it absent",
-          resourceName, INITIAL_RESOURCE_FETCH_TIMEOUT_SEC);
-      ldsRespTimer = null;
-      listenerWatcher.onResourceDoesNotExist(resourceName);
-    }
-  }
-}
diff --git a/xds/src/main/java/io/grpc/xds/SharedCallCounterMap.java b/xds/src/main/java/io/grpc/xds/SharedCallCounterMap.java
index 71cff0cedf3..7aa55c27429 100644
--- a/xds/src/main/java/io/grpc/xds/SharedCallCounterMap.java
+++ b/xds/src/main/java/io/grpc/xds/SharedCallCounterMap.java
@@ -58,8 +58,14 @@ public synchronized AtomicLong getOrCreate(String cluster, @Nullable String edsS
       counters.put(cluster, clusterCounters);
     }
     CounterReference ref = clusterCounters.get(edsServiceName);
-    AtomicLong counter;
-    if (ref == null || (counter = ref.get()) == null) {
+    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);
@@ -73,6 +79,9 @@ 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);
diff --git a/xds/src/main/java/io/grpc/xds/SharedXdsClientPoolProvider.java b/xds/src/main/java/io/grpc/xds/SharedXdsClientPoolProvider.java
index 46411c74830..45c379244af 100644
--- a/xds/src/main/java/io/grpc/xds/SharedXdsClientPoolProvider.java
+++ b/xds/src/main/java/io/grpc/xds/SharedXdsClientPoolProvider.java
@@ -19,23 +19,27 @@
 import static com.google.common.base.Preconditions.checkNotNull;
 
 import com.google.common.annotations.VisibleForTesting;
-import io.grpc.ChannelCredentials;
-import io.grpc.Grpc;
-import io.grpc.ManagedChannel;
+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.xds.Bootstrapper.BootstrapInfo;
-import io.grpc.xds.Bootstrapper.ServerInfo;
-import io.grpc.xds.EnvoyProtoData.Node;
-import io.grpc.xds.XdsNameResolverProvider.XdsClientPoolFactory;
+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.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;
 import javax.annotation.concurrent.ThreadSafe;
 
 /**
@@ -44,19 +48,24 @@
  */
 @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 AtomicReference<Map<String, ?>> bootstrapOverride = new AtomicReference<>();
-  private volatile ObjectPool<XdsClient> xdsClientPool;
+  private final Map<String, ObjectPool<XdsClient>> targetToXdsClientMap = new ConcurrentHashMap<>();
 
-  private SharedXdsClientPoolProvider() {
-    this(new BootstrapperImpl());
+  SharedXdsClientPoolProvider() {
+    this(null);
   }
 
   @VisibleForTesting
-  SharedXdsClientPoolProvider(Bootstrapper bootstrapper) {
-    this.bootstrapper = checkNotNull(bootstrapper, "bootstrapper");
+  SharedXdsClientPoolProvider(@Nullable Bootstrapper bootstrapper) {
+    this.bootstrapper = bootstrapper;
   }
 
   static SharedXdsClientPoolProvider getDefaultProvider() {
@@ -64,77 +73,118 @@ static SharedXdsClientPoolProvider getDefaultProvider() {
   }
 
   @Override
-  public void setBootstrapOverride(Map<String, ?> bootstrap) {
-    bootstrapOverride.set(bootstrap);
+  @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> getXdsClientPool() throws XdsInitializationException {
-    ObjectPool<XdsClient> ref = xdsClientPool;
+  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 = xdsClientPool;
+        ref = targetToXdsClientMap.get(target);
         if (ref == null) {
-          BootstrapInfo bootstrapInfo;
-          Map<String, ?> rawBootstrap = bootstrapOverride.get();
-          if (rawBootstrap != null) {
-            bootstrapInfo = bootstrapper.bootstrap(rawBootstrap);
-          } else {
-            bootstrapInfo = bootstrapper.bootstrap();
-          }
-          if (bootstrapInfo.getServers().isEmpty()) {
-            throw new XdsInitializationException("No xDS server provided");
-          }
-          ServerInfo serverInfo = bootstrapInfo.getServers().get(0);  // use first server
-          ref = xdsClientPool = new RefCountedXdsClientObjectPool(serverInfo.getTarget(),
-              serverInfo.getChannelCredentials(), serverInfo.isUseProtocolV3(),
-              bootstrapInfo.getNode());
+          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
-  static class RefCountedXdsClientObjectPool implements ObjectPool<XdsClient> {
-    private final String target;
-    private final ChannelCredentials channelCredentials;
-    private final Node node;
-    private final boolean useProtocolV3;
+  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 ManagedChannel channel;
-    @GuardedBy("lock")
     private XdsClient xdsClient;
     @GuardedBy("lock")
     private int refCount;
+    @GuardedBy("lock")
+    private XdsClientMetricReporterImpl metricReporter;
 
     @VisibleForTesting
-    RefCountedXdsClientObjectPool(String target, ChannelCredentials channelCredentials,
-        boolean useProtocolV3, Node node) {
-      this.target = checkNotNull(target, "target");
-      this.channelCredentials = checkNotNull(channelCredentials, "channelCredentials");
-      this.useProtocolV3 = useProtocolV3;
-      this.node = checkNotNull(node, "node");
+    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) {
-          channel = Grpc.newChannelBuilder(target, channelCredentials)
-              .keepAliveTime(5, TimeUnit.MINUTES)
-              .build();
+          if (LOG_XDS_NODE_ID) {
+            log.log(Level.INFO, "xDS node ID: {0}", bootstrapInfo.node().getId());
+          }
           scheduler = SharedResourceHolder.get(GrpcUtil.TIMER_SERVICE);
-          xdsClient = new ClientXdsClient(channel, useProtocolV3, node, scheduler,
-              new ExponentialBackoffPolicy.Provider(), GrpcUtil.STOPWATCH_SUPPLIER);
+          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;
@@ -148,21 +198,19 @@ public XdsClient returnObject(Object object) {
         if (refCount == 0) {
           xdsClient.shutdown();
           xdsClient = null;
-          channel.shutdown();
+          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
-    ManagedChannel getChannelForTest() {
-      synchronized (lock) {
-        return channel;
-      }
-    }
-
     @VisibleForTesting
     @Nullable
     XdsClient getXdsClientForTest() {
@@ -170,5 +218,10 @@ XdsClient getXdsClientForTest() {
         return xdsClient;
       }
     }
+
+    public String getTarget() {
+      return target;
+    }
   }
+
 }
diff --git a/xds/src/main/java/io/grpc/xds/Stats.java b/xds/src/main/java/io/grpc/xds/Stats.java
deleted file mode 100644
index 7e5fa8639d4..00000000000
--- a/xds/src/main/java/io/grpc/xds/Stats.java
+++ /dev/null
@@ -1,110 +0,0 @@
-/*
- * 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.ImmutableList;
-import javax.annotation.Nullable;
-
-/** Represents client load stats. */
-final class Stats {
-  private Stats() {}
-
-  /** Cluster-level load stats. */
-  @AutoValue
-  abstract static class ClusterStats {
-    abstract String clusterName();
-
-    @Nullable
-    abstract String clusterServiceName();
-
-    abstract ImmutableList<UpstreamLocalityStats> upstreamLocalityStatsList();
-
-    abstract ImmutableList<DroppedRequests> droppedRequestsList();
-
-    abstract long totalDroppedRequests();
-
-    abstract long loadReportIntervalNano();
-
-    static Builder newBuilder() {
-      return new AutoValue_Stats_ClusterStats.Builder()
-          .totalDroppedRequests(0L)  // default initialization
-          .loadReportIntervalNano(0L);
-    }
-
-    @AutoValue.Builder
-    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
-  abstract static class DroppedRequests {
-    abstract String category();
-
-    abstract long droppedCount();
-
-    static DroppedRequests create(String category, long droppedCount) {
-      return new AutoValue_Stats_DroppedRequests(category, droppedCount);
-    }
-  }
-
-  /** Load stats aggregated in locality level. */
-  @AutoValue
-  abstract static class UpstreamLocalityStats {
-    abstract Locality locality();
-
-    abstract long totalIssuedRequests();
-
-    abstract long totalSuccessfulRequests();
-
-    abstract long totalErrorRequests();
-
-    abstract long totalRequestsInProgress();
-
-    static UpstreamLocalityStats create(Locality locality, long totalIssuedRequests,
-        long totalSuccessfulRequests, long totalErrorRequests, long totalRequestsInProgress) {
-      return new AutoValue_Stats_UpstreamLocalityStats(locality, totalIssuedRequests,
-          totalSuccessfulRequests, totalErrorRequests, totalRequestsInProgress);
-    }
-  }
-}
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
index 6a01f0a3d7f..533ccee2375 100644
--- a/xds/src/main/java/io/grpc/xds/ThreadSafeRandom.java
+++ b/xds/src/main/java/io/grpc/xds/ThreadSafeRandom.java
@@ -23,6 +23,10 @@
 interface ThreadSafeRandom {
   int nextInt(int bound);
 
+  long nextLong();
+
+  long nextLong(long bound);
+
   final class ThreadSafeRandomImpl implements ThreadSafeRandom {
 
     static final ThreadSafeRandom instance = new ThreadSafeRandomImpl();
@@ -33,5 +37,15 @@ private ThreadSafeRandomImpl() {}
     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/internal/sds/TlsContextManager.java b/xds/src/main/java/io/grpc/xds/TlsContextManager.java
similarity index 95%
rename from xds/src/main/java/io/grpc/xds/internal/sds/TlsContextManager.java
rename to xds/src/main/java/io/grpc/xds/TlsContextManager.java
index 561806ec670..772a6cff102 100644
--- a/xds/src/main/java/io/grpc/xds/internal/sds/TlsContextManager.java
+++ b/xds/src/main/java/io/grpc/xds/TlsContextManager.java
@@ -14,11 +14,14 @@
  * limitations under the License.
  */
 
-package io.grpc.xds.internal.sds;
+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. */
diff --git a/xds/src/main/java/io/grpc/xds/VirtualHost.java b/xds/src/main/java/io/grpc/xds/VirtualHost.java
index 30e08d5e23c..5cc979984c6 100644
--- a/xds/src/main/java/io/grpc/xds/VirtualHost.java
+++ b/xds/src/main/java/io/grpc/xds/VirtualHost.java
@@ -22,15 +22,20 @@
 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.xds.Matchers.FractionMatcher;
-import io.grpc.xds.Matchers.HeaderMatcher;
-import io.grpc.xds.Matchers.PathMatcher;
+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;
 
-/** Reprsents an upstream virtual host. */
+/** Represents an upstream virtual host. */
 @AutoValue
 abstract class VirtualHost {
   // The canonical name of this virtual host.
@@ -42,27 +47,39 @@ abstract class VirtualHost {
   // The list of routes that will be matched, in order, for incoming requests.
   abstract ImmutableList<Route> routes();
 
-  @Nullable
-  abstract HttpFault httpFault();
+  abstract ImmutableMap<String, FilterConfig> filterConfigOverrides();
 
-  public static VirtualHost create(String name, List<String> domains, List<Route> routes,
-      @Nullable HttpFault httpFault) {
+  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), httpFault);
+        ImmutableList.copyOf(routes), ImmutableMap.copyOf(filterConfigOverrides));
   }
 
   @AutoValue
   abstract static class Route {
     abstract RouteMatch routeMatch();
 
+    @Nullable
     abstract RouteAction routeAction();
 
-    @Nullable
-    abstract HttpFault httpFault();
+    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);
+    }
 
-    static Route create(RouteMatch routeMatch, RouteAction routeAction,
-        @Nullable HttpFault httpFault) {
-      return new AutoValue_VirtualHost_Route(routeMatch, routeAction, httpFault);
+    private static Route create(
+        RouteMatch routeMatch, @Nullable RouteAction routeAction,
+        Map<String, FilterConfig> filterConfigOverrides) {
+      return new AutoValue_VirtualHost_Route(
+          routeMatch, routeAction, ImmutableMap.copyOf(filterConfigOverrides));
     }
 
     @AutoValue
@@ -86,6 +103,47 @@ static RouteMatch create(PathMatcher pathMatcher,
         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
@@ -102,38 +160,73 @@ abstract static class RouteAction {
       @Nullable
       abstract ImmutableList<ClusterWeight> weightedClusters();
 
-      static RouteAction forCluster(String cluster, List<HashPolicy> hashPolicies,
-          @Nullable Long timeoutNano) {
+      @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);
+        return RouteAction.create(hashPolicies, timeoutNano, cluster, null, null, retryPolicy,
+            autoHostRewrite);
       }
 
-      static RouteAction forWeightedClusters(List<ClusterWeight> weightedClusters,
-          List<HashPolicy> hashPolicies, @Nullable Long timeoutNano) {
+      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);
+        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) {
+      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));
+            ImmutableList.copyOf(hashPolicies),
+            timeoutNano,
+            cluster,
+            weightedClusters == null ? null : ImmutableList.copyOf(weightedClusters),
+            namedConfig,
+            retryPolicy,
+            autoHostRewrite);
       }
 
       @AutoValue
       abstract static class ClusterWeight {
         abstract String name();
 
-        abstract int weight();
+        abstract long weight();
 
-        @Nullable
-        abstract HttpFault httpFault();
+        abstract ImmutableMap<String, FilterConfig> filterConfigOverrides();
 
-        static ClusterWeight create(String name, int weight, @Nullable HttpFault httpFault) {
-          return new AutoValue_VirtualHost_Route_RouteAction_ClusterWeight(name, weight,
-              httpFault);
+        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));
         }
       }
 
@@ -182,6 +275,31 @@ 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
index 1f5fc6d01df..904f3872b6d 100644
--- a/xds/src/main/java/io/grpc/xds/WeightedRandomPicker.java
+++ b/xds/src/main/java/io/grpc/xds/WeightedRandomPicker.java
@@ -21,6 +21,7 @@
 
 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;
@@ -34,21 +35,22 @@ final class WeightedRandomPicker extends SubchannelPicker {
   final List<WeightedChildPicker> weightedChildPickers;
 
   private final ThreadSafeRandom random;
-  private final int totalWeight;
+  private final long totalWeight;
 
   static final class WeightedChildPicker {
-    private final int weight;
+    private final long weight;
     private final SubchannelPicker childPicker;
 
-    WeightedChildPicker(int weight, 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;
     }
 
-    int getWeight() {
+    long getWeight() {
       return weight;
     }
 
@@ -93,12 +95,16 @@ public String toString() {
 
     this.weightedChildPickers = Collections.unmodifiableList(weightedChildPickers);
 
-    int totalWeight = 0;
+    long totalWeight = 0;
     for (WeightedChildPicker weightedChildPicker : weightedChildPickers) {
-      int weight = weightedChildPicker.getWeight();
+      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;
   }
@@ -111,15 +117,15 @@ public final PickResult pickSubchannel(PickSubchannelArgs args) {
       childPicker =
           weightedChildPickers.get(random.nextInt(weightedChildPickers.size())).getPicker();
     } else {
-      int rand = random.nextInt(totalWeight);
+      long rand = random.nextLong(totalWeight);
 
       // Find the first idx such that rand < accumulatedWeights[idx]
       // Not using Arrays.binarySearch for better readability.
-      int accumulatedWeight = 0;
-      for (int idx = 0; idx < weightedChildPickers.size(); idx++) {
-        accumulatedWeight += weightedChildPickers.get(idx).getWeight();
+      long accumulatedWeight = 0;
+      for (WeightedChildPicker weightedChildPicker : weightedChildPickers) {
+        accumulatedWeight += weightedChildPicker.getWeight();
         if (rand < accumulatedWeight) {
-          childPicker = weightedChildPickers.get(idx).getPicker();
+          childPicker = weightedChildPicker.getPicker();
           break;
         }
       }
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..6744903de35
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/WeightedRoundRobinLoadBalancer.java
@@ -0,0 +1,890 @@
+/*
+ * 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.internal.MetricReportUtils;
+import io.grpc.xds.internal.MetricReportUtils.ParsedMetricName;
+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.OptionalDouble;
+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,
+        config.parsedMetricNamesForComputingUtilization);
+    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,
+        ImmutableList<ParsedMetricName> parsedMetricNamesForComputingUtilization) {
+      if (orcaReportListener != null
+          && orcaReportListener.errorUtilizationPenalty == errorUtilizationPenalty
+          && orcaReportListener.parsedMetricNamesForComputingUtilization
+              .equals(parsedMetricNamesForComputingUtilization)) {
+        return orcaReportListener;
+      }
+      orcaReportListener =
+          new OrcaReportListener(errorUtilizationPenalty, parsedMetricNamesForComputingUtilization);
+      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;
+      private final ImmutableList<ParsedMetricName> parsedMetricNamesForComputingUtilization;
+
+      OrcaReportListener(float errorUtilizationPenalty,
+          ImmutableList<ParsedMetricName> parsedMetricNamesForComputingUtilization) {
+        this.errorUtilizationPenalty = errorUtilizationPenalty;
+        this.parsedMetricNamesForComputingUtilization = parsedMetricNamesForComputingUtilization;
+      }
+
+      @Override
+      public void onLoadReport(MetricReport report) {
+        double utilization = getUtilization(report);
+
+        double newWeight = 0;
+        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;
+      }
+
+      /**
+       * Returns the utilization value computed from the specified metric names. If the custom
+       * metrics are present and valid, the maximum of the custom metrics is returned. Otherwise,
+       * if application utilization is > 0, it is returned. If neither are present, the CPU
+       * utilization is returned.
+       */
+      private double getUtilization(MetricReport report) {
+        OptionalDouble customUtil = getCustomMetricUtilization(report);
+        if (customUtil.isPresent()) {
+          return customUtil.getAsDouble();
+        }
+        double appUtil = report.getApplicationUtilization();
+        if (appUtil > 0) {
+          return appUtil;
+        }
+        return report.getCpuUtilization();
+      }
+
+      /**
+       * Returns the maximum utilization value among the parsed metric names.
+       * Returns OptionalDouble.empty() if NONE of the specified metrics are present in the report,
+       * or if all present metrics are NaN or non positive.
+       */
+      private OptionalDouble getCustomMetricUtilization(MetricReport report) {
+        OptionalDouble max = OptionalDouble.empty();
+        for (int i = 0; i < parsedMetricNamesForComputingUtilization.size(); i++) {
+          OptionalDouble opt = MetricReportUtils.getMetricValue(report,
+              parsedMetricNamesForComputingUtilization.get(i));
+          if (opt.isPresent()) {
+            double d = opt.getAsDouble();
+            if (!Double.isNaN(d) && d > 0 && (!max.isPresent() || d > max.getAsDouble())) {
+              max = opt;
+            }
+          }
+        }
+        return max;
+      }
+    }
+  }
+
+  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,
+                      config.parsedMetricNamesForComputingUtilization),
+              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,
+        ImmutableList<ParsedMetricName> parsedMetricNamesForComputingUtilization) {
+      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,
+            parsedMetricNamesForComputingUtilization));
+      }
+      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;
+      }
+      
+      subchannel = ((WrrSubchannel) subchannel).delegate();
+      if (!enableOobLoadReport) {
+        return pickResult.copyWithSubchannel(subchannel)
+            .copyWithStreamTracerFactory(
+                OrcaPerRequestUtil.getInstance().newOrcaClientStreamTracerFactory(
+                    reportListeners.get(pick)));
+      } else {
+        return pickResult.copyWithSubchannel(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;
+    final ImmutableList<ParsedMetricName> parsedMetricNamesForComputingUtilization;
+
+    public static Builder newBuilder() {
+      return new Builder();
+    }
+
+    private WeightedRoundRobinLoadBalancerConfig(long blackoutPeriodNanos,
+        long weightExpirationPeriodNanos, boolean enableOobLoadReport, long oobReportingPeriodNanos,
+        long weightUpdatePeriodNanos, float errorUtilizationPenalty,
+        ImmutableList<String> metricNamesForComputingUtilization) {
+      this.blackoutPeriodNanos = blackoutPeriodNanos;
+      this.weightExpirationPeriodNanos = weightExpirationPeriodNanos;
+      this.enableOobLoadReport = enableOobLoadReport;
+      this.oobReportingPeriodNanos = oobReportingPeriodNanos;
+      this.weightUpdatePeriodNanos = weightUpdatePeriodNanos;
+      this.errorUtilizationPenalty = errorUtilizationPenalty;
+
+      ImmutableList.Builder<ParsedMetricName> builder = ImmutableList.builder();
+      if (metricNamesForComputingUtilization != null) {
+        for (int i = 0; i < metricNamesForComputingUtilization.size(); i++) {
+          String metricName = metricNamesForComputingUtilization.get(i);
+          ParsedMetricName parsed = MetricReportUtils.ParsedMetricName.parse(metricName);
+          if (parsed.getMetricType() != MetricReportUtils.MetricType.INVALID) {
+            builder.add(parsed);
+          } else {
+            log.log(Level.FINE, "Invalid custom metric name configured and ignored: " + metricName);
+          }
+        }
+      }
+      this.parsedMetricNamesForComputingUtilization = builder.build();
+    }
+
+    @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
+          && Objects.equals(this.parsedMetricNamesForComputingUtilization,
+              that.parsedMetricNamesForComputingUtilization);
+    }
+
+    @Override
+    public int hashCode() {
+      return Objects.hash(blackoutPeriodNanos, weightExpirationPeriodNanos, enableOobLoadReport,
+          oobReportingPeriodNanos, weightUpdatePeriodNanos, errorUtilizationPenalty,
+          parsedMetricNamesForComputingUtilization);
+    }
+
+    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;
+      ImmutableList<String> metricNamesForComputingUtilization = ImmutableList.of();
+
+      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;
+      }
+
+      Builder setMetricNamesForComputingUtilization(
+          List<String> metricNamesForComputingUtilization) {
+        this.metricNamesForComputingUtilization =
+            ImmutableList.copyOf(metricNamesForComputingUtilization);
+        return this;
+      }
+
+      WeightedRoundRobinLoadBalancerConfig build() {
+        return new WeightedRoundRobinLoadBalancerConfig(blackoutPeriodNanos,
+            weightExpirationPeriodNanos, enableOobLoadReport, oobReportingPeriodNanos,
+            weightUpdatePeriodNanos, errorUtilizationPenalty, metricNamesForComputingUtilization);
+      }
+    }
+  }
+}
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..0f9fcf07c9a
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/WeightedRoundRobinLoadBalancerProvider.java
@@ -0,0 +1,115 @@
+/*
+ * 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.GrpcUtil;
+import io.grpc.internal.JsonUtil;
+import io.grpc.xds.WeightedRoundRobinLoadBalancer.WeightedRoundRobinLoadBalancerConfig;
+import java.util.List;
+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");
+    List<String> metricNamesForComputingUtilization = JsonUtil.getListOfStrings(rawConfig,
+        "metricNamesForComputingUtilization");
+
+    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);
+    }
+    if (metricNamesForComputingUtilization != null
+        && GrpcUtil.getFlag("GRPC_EXPERIMENTAL_WRR_CUSTOM_METRICS", false)) {
+      configBuilder.setMetricNamesForComputingUtilization(metricNamesForComputingUtilization);
+    }
+    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
index 75c11740a53..9468a9daf9d 100644
--- a/xds/src/main/java/io/grpc/xds/WeightedTargetLoadBalancer.java
+++ b/xds/src/main/java/io/grpc/xds/WeightedTargetLoadBalancer.java
@@ -21,21 +21,20 @@
 import static io.grpc.ConnectivityState.IDLE;
 import static io.grpc.ConnectivityState.READY;
 import static io.grpc.ConnectivityState.TRANSIENT_FAILURE;
-import static io.grpc.xds.XdsSubchannelPickers.BUFFER_PICKER;
 
 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.SynchronizationContext;
 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.XdsLogger.XdsLogLevel;
-import io.grpc.xds.XdsSubchannelPickers.ErrorPicker;
+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;
@@ -44,51 +43,63 @@
 
 /** 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 final SynchronizationContext syncContext;
 
   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");
-    this.syncContext = checkNotNull(helper.getSynchronizationContext(), "syncContext");
     logger = XdsLogger.withLogId(
         InternalLogId.allocate("weighted-target-lb", helper.getAuthority()));
     logger.log(XdsLogLevel.INFO, "Created");
   }
 
   @Override
-  public void handleResolvedAddresses(ResolvedAddresses resolvedAddresses) {
+  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()) {
-      WeightedPolicySelection weightedChildLbConfig = newTargets.get(targetName);
       if (!targets.containsKey(targetName)) {
-        ChildHelper childHelper = new ChildHelper();
+        ChildHelper childHelper = new ChildHelper(targetName);
         GracefulSwitchLoadBalancer childBalancer = new GracefulSwitchLoadBalancer(childHelper);
-        childBalancer.switchTo(weightedChildLbConfig.policySelection.getProvider());
         childHelpers.put(targetName, childHelper);
         childBalancers.put(targetName, childBalancer);
-      } else if (!weightedChildLbConfig.policySelection.getProvider().equals(
-          targets.get(targetName).policySelection.getProvider())) {
-        childBalancers.get(targetName)
-            .switchTo(weightedChildLbConfig.policySelection.getProvider());
       }
     }
     targets = newTargets;
+    Status status = Status.OK;
     for (String targetName : targets.keySet()) {
-      childBalancers.get(targetName).handleResolvedAddresses(
+      Status newStatus = childBalancers.get(targetName).acceptResolvedAddresses(
           resolvedAddresses.toBuilder()
               .setAddresses(AddressFilter.filter(resolvedAddresses.getAddresses(), targetName))
-              .setLoadBalancingPolicyConfig(targets.get(targetName).policySelection.getConfig())
+              .setLoadBalancingPolicyConfig(targets.get(targetName).childConfig)
+              .setAttributes(resolvedAddresses.getAttributes().toBuilder()
+                .set(CHILD_NAME, targetName)
+                .build())
               .build());
+      if (!newStatus.isOk()) {
+        status = newStatus;
+      }
     }
 
     // Cleanup removed targets.
@@ -101,13 +112,15 @@ public void handleResolvedAddresses(ResolvedAddresses resolvedAddresses) {
     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 ErrorPicker(error));
+      helper.updateBalancingState(
+          TRANSIENT_FAILURE, new FixedResultPicker(PickResult.withError(error)));
     }
     for (LoadBalancer childBalancer : childBalancers.values()) {
       childBalancer.handleNameResolutionError(error);
@@ -115,6 +128,8 @@ public void handleNameResolutionError(Status error) {
   }
 
   @Override
+  @Deprecated
+  @SuppressWarnings("InlineMeSuggester")
   public boolean canHandleEmptyAddressListFromNameResolution() {
     return true;
   }
@@ -125,28 +140,32 @@ public void 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) {
-        int weight = targets.get(name).weight;
         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 ErrorPicker(Status.UNAVAILABLE); // TODO: more details in status
+        picker = new WeightedRandomPicker(errorPickers);
       } else {
-        picker = XdsSubchannelPickers.BUFFER_PICKER;
+        picker = new FixedResultPicker(PickResult.withNoResult());
       }
     } else {
       picker = new WeightedRandomPicker(childPickers);
@@ -176,20 +195,25 @@ private static ConnectivityState aggregateState(
   }
 
   private final class ChildHelper extends ForwardingLoadBalancerHelper {
+    String name;
     ConnectivityState currentState = CONNECTING;
-    SubchannelPicker currentPicker = BUFFER_PICKER;
+    SubchannelPicker currentPicker = new FixedResultPicker(PickResult.withNoResult());
+
+    private ChildHelper(String name) {
+      this.name = name;
+    }
 
     @Override
     public void updateBalancingState(final ConnectivityState newState,
         final SubchannelPicker newPicker) {
-      syncContext.execute(new Runnable() {
-        @Override
-        public void run() {
-          currentState = newState;
-          currentPicker = newPicker;
-          updateOverallBalancingState();
-        }
-      });
+      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
diff --git a/xds/src/main/java/io/grpc/xds/WeightedTargetLoadBalancerProvider.java b/xds/src/main/java/io/grpc/xds/WeightedTargetLoadBalancerProvider.java
index 1ac3aa13be1..15318693aca 100644
--- a/xds/src/main/java/io/grpc/xds/WeightedTargetLoadBalancerProvider.java
+++ b/xds/src/main/java/io/grpc/xds/WeightedTargetLoadBalancerProvider.java
@@ -25,12 +25,10 @@
 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.internal.ServiceConfigUtil;
-import io.grpc.internal.ServiceConfigUtil.LbConfig;
-import io.grpc.internal.ServiceConfigUtil.PolicySelection;
+import io.grpc.util.GracefulSwitchLoadBalancer;
 import java.util.LinkedHashMap;
-import java.util.List;
 import java.util.Map;
 import java.util.Objects;
 import javax.annotation.Nullable;
@@ -97,27 +95,22 @@ public ConfigOrError parseLoadBalancingPolicyConfig(Map<String, ?> rawConfig) {
           return ConfigOrError.fromError(Status.INTERNAL.withDescription(
               "Wrong weight for target " + name + " in weighted_target LB policy:\n " + rawConfig));
         }
-        List<LbConfig> childConfigCandidates = ServiceConfigUtil.unwrapLoadBalancingConfigList(
-            JsonUtil.getListOfObjects(rawWeightedTarget, "childPolicy"));
-        if (childConfigCandidates == null || childConfigCandidates.isEmpty()) {
-          return ConfigOrError.fromError(Status.INTERNAL.withDescription(
-              "No child policy for target " + name + " in weighted_target LB policy:\n "
-                  + rawConfig));
-        }
         LoadBalancerRegistry lbRegistry =
             this.lbRegistry == null ? LoadBalancerRegistry.getDefaultRegistry() : this.lbRegistry;
-        ConfigOrError selectedConfig =
-            ServiceConfigUtil.selectLbPolicyFromList(childConfigCandidates, lbRegistry);
-        if (selectedConfig.getError() != null) {
-          return selectedConfig;
+        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()));
         }
-        PolicySelection policySelection = (PolicySelection) selectedConfig.getConfig();
-        parsedChildConfigs.put(name, new WeightedPolicySelection(weight, policySelection));
+        parsedChildConfigs.put(name, new WeightedPolicySelection(weight, childConfig.getConfig()));
       }
       return ConfigOrError.fromConfig(new WeightedTargetConfig(parsedChildConfigs));
     } catch (RuntimeException e) {
       return ConfigOrError.fromError(
-          Status.fromThrowable(e).withDescription(
+          Status.INTERNAL.withCause(e).withDescription(
               "Failed to parse weighted_target LB config: " + rawConfig));
     }
   }
@@ -125,11 +118,11 @@ public ConfigOrError parseLoadBalancingPolicyConfig(Map<String, ?> rawConfig) {
   static final class WeightedPolicySelection {
 
     final int weight;
-    final PolicySelection policySelection;
+    final Object childConfig;
 
-    WeightedPolicySelection(int weight, PolicySelection policySelection) {
+    WeightedPolicySelection(int weight, Object childConfig) {
       this.weight = weight;
-      this.policySelection = policySelection;
+      this.childConfig = childConfig;
     }
 
     @Override
@@ -141,19 +134,19 @@ public boolean equals(Object o) {
         return false;
       }
       WeightedPolicySelection that = (WeightedPolicySelection) o;
-      return weight == that.weight && Objects.equals(policySelection, that.policySelection);
+      return weight == that.weight && Objects.equals(childConfig, that.childConfig);
     }
 
     @Override
     public int hashCode() {
-      return Objects.hash(weight, policySelection);
+      return Objects.hash(weight, childConfig);
     }
 
     @Override
     public String toString() {
       return MoreObjects.toStringHelper(this)
           .add("weight", weight)
-          .add("policySelection", policySelection)
+          .add("childConfig", childConfig)
           .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..d3fe8d4619c
--- /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.InternalEquivalentAddressGroup;
+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 = InternalEquivalentAddressGroup.ATTR_WEIGHT;
+
+  /**
+   * 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
index 6ac464ebe5c..189ebc0ca19 100644
--- a/xds/src/main/java/io/grpc/xds/XdsChannelCredentials.java
+++ b/xds/src/main/java/io/grpc/xds/XdsChannelCredentials.java
@@ -22,9 +22,9 @@
 import io.grpc.ExperimentalApi;
 import io.grpc.netty.InternalNettyChannelCredentials;
 import io.grpc.netty.InternalProtocolNegotiator;
-import io.grpc.xds.internal.sds.SdsProtocolNegotiators;
+import io.grpc.xds.internal.security.SecurityProtocolNegotiators;
 
-@ExperimentalApi("https://github.com/grpc/grpc-java/issues/7479")
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/7514")
 public class XdsChannelCredentials {
   private XdsChannelCredentials() {} // prevent instantiation
 
@@ -40,6 +40,6 @@ public static ChannelCredentials create(ChannelCredentials fallback) {
     InternalProtocolNegotiator.ClientFactory fallbackNegotiator =
         InternalNettyChannelCredentials.toNegotiator(checkNotNull(fallback, "fallback"));
     return InternalNettyChannelCredentials.create(
-        SdsProtocolNegotiators.clientProtocolNegotiatorFactory(fallbackNegotiator));
+        SecurityProtocolNegotiators.clientProtocolNegotiatorFactory(fallbackNegotiator));
   }
 }
diff --git a/xds/src/main/java/io/grpc/xds/XdsClient.java b/xds/src/main/java/io/grpc/xds/XdsClient.java
deleted file mode 100644
index 4018770dec9..00000000000
--- a/xds/src/main/java/io/grpc/xds/XdsClient.java
+++ /dev/null
@@ -1,551 +0,0 @@
-/*
- * 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 static com.google.common.base.Preconditions.checkState;
-
-import com.google.auto.value.AutoValue;
-import com.google.common.base.MoreObjects;
-import com.google.common.base.MoreObjects.ToStringHelper;
-import com.google.common.collect.ImmutableList;
-import io.grpc.Status;
-import io.grpc.xds.Endpoints.DropOverload;
-import io.grpc.xds.Endpoints.LocalityLbEndpoints;
-import io.grpc.xds.EnvoyServerProtoData.Listener;
-import io.grpc.xds.EnvoyServerProtoData.UpstreamTlsContext;
-import io.grpc.xds.LoadStatsManager2.ClusterDropStats;
-import io.grpc.xds.LoadStatsManager2.ClusterLocalityStats;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
-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.
- */
-abstract class XdsClient {
-
-  static final class LdsUpdate implements ResourceUpdate {
-    // Total number of nanoseconds to keep alive an HTTP request/response stream.
-    final long httpMaxStreamDurationNano;
-    // The name of the route configuration to be used for RDS resource discovery.
-    @Nullable
-    final String rdsName;
-    // The list virtual hosts that make up the route table.
-    @Nullable
-    final List<VirtualHost> virtualHosts;
-    // Listener contains the HttpFault filter.
-    final boolean hasFaultInjection;
-    @Nullable // Can be null even if hasFaultInjection is true.
-    final HttpFault httpFault;
-
-    LdsUpdate(
-        long httpMaxStreamDurationNano, String rdsName, boolean hasFaultInjection,
-        @Nullable HttpFault httpFault) {
-      this(httpMaxStreamDurationNano, rdsName, null, hasFaultInjection, httpFault);
-    }
-
-    LdsUpdate(
-        long httpMaxStreamDurationNano, List<VirtualHost> virtualHosts,
-        boolean hasFaultInjection, @Nullable HttpFault httpFault) {
-      this(httpMaxStreamDurationNano, null, virtualHosts, hasFaultInjection, httpFault);
-    }
-
-    private LdsUpdate(
-        long httpMaxStreamDurationNano, @Nullable String rdsName,
-        @Nullable List<VirtualHost> virtualHosts, boolean hasFaultInjection,
-        @Nullable HttpFault httpFault) {
-      this.httpMaxStreamDurationNano = httpMaxStreamDurationNano;
-      this.rdsName = rdsName;
-      this.virtualHosts = virtualHosts == null
-          ? null : Collections.unmodifiableList(new ArrayList<>(virtualHosts));
-      this.hasFaultInjection = hasFaultInjection;
-      this.httpFault = httpFault;
-    }
-
-    @Override
-    public int hashCode() {
-      return Objects.hash(
-          httpMaxStreamDurationNano, rdsName, virtualHosts, hasFaultInjection, httpFault);
-    }
-
-    @Override
-    public boolean equals(Object o) {
-      if (this == o) {
-        return true;
-      }
-      if (o == null || getClass() != o.getClass()) {
-        return false;
-      }
-      LdsUpdate that = (LdsUpdate) o;
-      return httpMaxStreamDurationNano == that.httpMaxStreamDurationNano
-          && Objects.equals(rdsName, that.rdsName)
-          && Objects.equals(virtualHosts, that.virtualHosts)
-          && hasFaultInjection == that.hasFaultInjection
-          && Objects.equals(httpFault, that.httpFault);
-    }
-
-    @Override
-    public String toString() {
-      ToStringHelper toStringHelper = MoreObjects.toStringHelper(this);
-      toStringHelper.add("httpMaxStreamDurationNano", httpMaxStreamDurationNano);
-      if (rdsName != null) {
-        toStringHelper.add("rdsName", rdsName);
-      } else {
-        toStringHelper.add("virtualHosts", virtualHosts);
-      }
-      if (hasFaultInjection) {
-        toStringHelper.add("faultInjectionEnabled", true)
-            .add("httpFault", httpFault);
-      }
-      return toStringHelper.toString();
-    }
-  }
-
-  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);
-    }
-  }
-
-  /** xDS resource update for cluster-level configuration. */
-  @AutoValue
-  abstract static class CdsUpdate implements ResourceUpdate {
-    abstract String clusterName();
-
-    abstract ClusterType clusterType();
-
-    // Endpoint-level load balancing policy.
-    abstract String lbPolicy();
-
-    // Only valid if lbPolicy is "ring_hash".
-    abstract long minRingSize();
-
-    // Only valid if lbPolicy is "ring_hash".
-    abstract long maxRingSize();
-
-    // Only valid if lbPolicy is "ring_hash".
-    @Nullable
-    abstract HashFunction hashFunction();
-
-    // Alternative resource name to be used in EDS requests.
-    /// Only valid for EDS cluster.
-    @Nullable
-    abstract String edsServiceName();
-
-    // Load report server name for reporting loads via LRS.
-    // Only valid for EDS or LOGICAL_DNS cluster.
-    @Nullable
-    abstract String lrsServerName();
-
-    // 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();
-
-    // List of underlying clusters making of this aggregate cluster.
-    // Only valid for AGGREGATE cluster.
-    @Nullable
-    abstract ImmutableList<String> prioritizedClusterNames();
-
-    static Builder forAggregate(String clusterName, List<String> prioritizedClusterNames) {
-      checkNotNull(prioritizedClusterNames, "prioritizedClusterNames");
-      return new AutoValue_XdsClient_CdsUpdate.Builder()
-          .clusterName(clusterName)
-          .clusterType(ClusterType.AGGREGATE)
-          .minRingSize(0)
-          .maxRingSize(0)
-          .prioritizedClusterNames(ImmutableList.copyOf(prioritizedClusterNames));
-    }
-
-    static Builder forEds(String clusterName, @Nullable String edsServiceName,
-        @Nullable String lrsServerName, @Nullable Long maxConcurrentRequests,
-        @Nullable UpstreamTlsContext upstreamTlsContext) {
-      return new AutoValue_XdsClient_CdsUpdate.Builder()
-          .clusterName(clusterName)
-          .clusterType(ClusterType.EDS)
-          .minRingSize(0)
-          .maxRingSize(0)
-          .edsServiceName(edsServiceName)
-          .lrsServerName(lrsServerName)
-          .maxConcurrentRequests(maxConcurrentRequests)
-          .upstreamTlsContext(upstreamTlsContext);
-    }
-
-    static Builder forLogicalDns(String clusterName, @Nullable String lrsServerName,
-        @Nullable Long maxConcurrentRequests, @Nullable UpstreamTlsContext upstreamTlsContext) {
-      return new AutoValue_XdsClient_CdsUpdate.Builder()
-          .clusterName(clusterName)
-          .clusterType(ClusterType.LOGICAL_DNS)
-          .minRingSize(0)
-          .maxRingSize(0)
-          .lrsServerName(lrsServerName)
-          .maxConcurrentRequests(maxConcurrentRequests)
-          .upstreamTlsContext(upstreamTlsContext);
-    }
-
-    enum ClusterType {
-      EDS, LOGICAL_DNS, AGGREGATE
-    }
-
-    enum HashFunction {
-      XX_HASH
-    }
-
-    // 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("lbPolicy", lbPolicy())
-          .add("minRingSize", minRingSize())
-          .add("maxRingSize", maxRingSize())
-          .add("hashFunction", hashFunction())
-          .add("edsServiceName", edsServiceName())
-          .add("lrsServerName", lrsServerName())
-          .add("maxConcurrentRequests", maxConcurrentRequests())
-          // Exclude upstreamTlsContext as its string representation is cumbersome.
-          .add("prioritizedClusterNames", prioritizedClusterNames())
-          .toString();
-    }
-
-    @AutoValue.Builder
-    abstract static class Builder {
-      // Private do not use.
-      protected abstract Builder clusterName(String clusterName);
-
-      // Private do not use.
-      protected abstract Builder clusterType(ClusterType clusterType);
-
-      // Private do not use.
-      protected abstract Builder lbPolicy(String lbPolicy);
-
-      Builder lbPolicy(String lbPolicy, long minRingSize, long maxRingSize,
-          HashFunction hashFunction) {
-        return this.lbPolicy(lbPolicy).minRingSize(minRingSize).maxRingSize(maxRingSize)
-            .hashFunction(checkNotNull(hashFunction, "hashFunction"));
-      }
-
-      // Private do not use.
-      protected abstract Builder minRingSize(long minRingSize);
-
-      // Private do not use.
-      protected abstract Builder maxRingSize(long maxRingSize);
-
-      // Private do not use.
-      protected abstract Builder hashFunction(HashFunction hashFunction);
-
-      // Private do not use.
-      protected abstract Builder edsServiceName(String edsServiceName);
-
-      // Private do not use.
-      protected abstract Builder lrsServerName(String lrsServerName);
-
-      // Private do not use.
-      protected abstract Builder maxConcurrentRequests(Long maxConcurrentRequests);
-
-      // Private do not use.
-      protected abstract Builder upstreamTlsContext(UpstreamTlsContext upstreamTlsContext);
-
-      // Private do not use.
-      protected abstract Builder prioritizedClusterNames(List<String> prioritizedClusterNames);
-
-      abstract CdsUpdate build();
-    }
-  }
-
-  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();
-    }
-  }
-
-  /**
-   * Updates via resource discovery RPCs using LDS. Includes {@link Listener} object containing
-   * config for security, RBAC or other server side features such as rate limit.
-   */
-  static final class ListenerUpdate implements ResourceUpdate {
-    // TODO(sanjaypujare): flatten structure by moving Listener class members here.
-    private final Listener listener;
-
-    private ListenerUpdate(Listener listener) {
-      this.listener = listener;
-    }
-
-    public Listener getListener() {
-      return listener;
-    }
-
-    @Override
-    public String toString() {
-      return MoreObjects.toStringHelper(this)
-          .add("listener", listener)
-          .toString();
-    }
-
-    static Builder newBuilder() {
-      return new Builder();
-    }
-
-    static final class Builder {
-      private Listener listener;
-
-      // Use ListenerUpdate.newBuilder().
-      private Builder() {
-      }
-
-      Builder setListener(Listener listener) {
-        this.listener = listener;
-        return this;
-      }
-
-      ListenerUpdate build() {
-        checkState(listener != null, "listener is not set");
-        return new ListenerUpdate(listener);
-      }
-    }
-  }
-
-  interface ResourceUpdate {
-  }
-
-  /**
-   * Watcher interface for a single requested xDS resource.
-   */
-  interface ResourceWatcher {
-
-    /**
-     * Called when the resource discovery RPC encounters some transient error.
-     */
-    void onError(Status error);
-
-    /**
-     * Called when the requested resource is not available.
-     *
-     * @param resourceName name of the resource requested in discovery request.
-     */
-    void onResourceDoesNotExist(String resourceName);
-  }
-
-  interface LdsResourceWatcher extends ResourceWatcher {
-    void onChanged(LdsUpdate update);
-  }
-
-  interface RdsResourceWatcher extends ResourceWatcher {
-    void onChanged(RdsUpdate update);
-  }
-
-  interface CdsResourceWatcher extends ResourceWatcher {
-    void onChanged(CdsUpdate update);
-  }
-
-  interface EdsResourceWatcher extends ResourceWatcher {
-    void onChanged(EdsUpdate update);
-  }
-
-  /**
-   * Listener watcher interface. To be used by {@link XdsServerBuilder}.
-   */
-  interface ListenerWatcher extends ResourceWatcher {
-
-    /**
-     * Called when receiving an update on Listener configuration.
-     */
-    void onListenerChanged(ListenerUpdate update);
-  }
-
-  /**
-   * Shutdown this {@link XdsClient} and release resources.
-   */
-  void shutdown() {
-    throw new UnsupportedOperationException();
-  }
-
-  /**
-   * Returns {@code true} if {@link #shutdown()} has been called.
-   */
-  boolean isShutDown() {
-    throw new UnsupportedOperationException();
-  }
-
-  /**
-   * Registers a data watcher for the given LDS resource.
-   */
-  void watchLdsResource(String resourceName, LdsResourceWatcher watcher) {
-    throw new UnsupportedOperationException();
-  }
-
-  /**
-   * Unregisters the given LDS resource watcher.
-   */
-  void cancelLdsResourceWatch(String resourceName, LdsResourceWatcher watcher) {
-    throw new UnsupportedOperationException();
-  }
-
-  /**
-   * Registers a data watcher for the given RDS resource.
-   */
-  void watchRdsResource(String resourceName, RdsResourceWatcher watcher) {
-    throw new UnsupportedOperationException();
-  }
-
-  /**
-   * Unregisters the given RDS resource watcher.
-   */
-  void cancelRdsResourceWatch(String resourceName, RdsResourceWatcher watcher) {
-    throw new UnsupportedOperationException();
-  }
-
-  /**
-   * Registers a data watcher for the given CDS resource.
-   */
-  void watchCdsResource(String resourceName, CdsResourceWatcher watcher) {
-    throw new UnsupportedOperationException();
-  }
-
-  /**
-   * Unregisters the given CDS resource watcher.
-   */
-  void cancelCdsResourceWatch(String resourceName, CdsResourceWatcher watcher) {
-    throw new UnsupportedOperationException();
-  }
-
-  /**
-   * Registers a data watcher for the given EDS resource.
-   */
-  void watchEdsResource(String resourceName, EdsResourceWatcher watcher) {
-    throw new UnsupportedOperationException();
-  }
-
-  /**
-   * Unregisters the given EDS resource watcher.
-   */
-  void cancelEdsResourceWatch(String resourceName, EdsResourceWatcher watcher) {
-    throw new UnsupportedOperationException();
-  }
-
-  /**
-   * Registers a watcher for a Listener with the given port.
-   */
-  void watchListenerData(int port, ListenerWatcher 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 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.
-   */
-  ClusterDropStats addClusterDropStats(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 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.
-   */
-  ClusterLocalityStats addClusterLocalityStats(
-      String clusterName, @Nullable String edsServiceName, Locality locality) {
-    throw new UnsupportedOperationException();
-  }
-}
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/XdsClientWrapperForServerSds.java b/xds/src/main/java/io/grpc/xds/XdsClientWrapperForServerSds.java
deleted file mode 100644
index ab6cba383b2..00000000000
--- a/xds/src/main/java/io/grpc/xds/XdsClientWrapperForServerSds.java
+++ /dev/null
@@ -1,466 +0,0 @@
-/*
- * 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.base.Preconditions.checkState;
-
-import com.google.common.annotations.VisibleForTesting;
-import com.google.common.collect.ImmutableSet;
-import com.google.protobuf.UInt32Value;
-import io.grpc.Grpc;
-import io.grpc.Internal;
-import io.grpc.ManagedChannel;
-import io.grpc.Status;
-import io.grpc.internal.ExponentialBackoffPolicy;
-import io.grpc.internal.GrpcUtil;
-import io.grpc.internal.SharedResourceHolder;
-import io.grpc.xds.EnvoyProtoData.Node;
-import io.grpc.xds.EnvoyServerProtoData.CidrRange;
-import io.grpc.xds.EnvoyServerProtoData.DownstreamTlsContext;
-import io.grpc.xds.EnvoyServerProtoData.FilterChain;
-import io.grpc.xds.EnvoyServerProtoData.FilterChainMatch;
-import io.netty.channel.Channel;
-import io.netty.channel.epoll.Epoll;
-import io.netty.channel.epoll.EpollEventLoopGroup;
-import io.netty.util.concurrent.DefaultThreadFactory;
-import java.io.IOException;
-import java.math.BigInteger;
-import java.net.Inet6Address;
-import java.net.InetAddress;
-import java.net.InetSocketAddress;
-import java.net.SocketAddress;
-import java.util.ArrayList;
-import java.util.Comparator;
-import java.util.HashSet;
-import java.util.List;
-import java.util.PriorityQueue;
-import java.util.Set;
-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;
-
-/**
- * Serves as a wrapper for {@link XdsClient} used on the server side by {@link
- * XdsServerBuilder}.
- */
-@Internal
-public final class XdsClientWrapperForServerSds {
-  private static final Logger logger =
-      Logger.getLogger(XdsClientWrapperForServerSds.class.getName());
-
-  private static final TimeServiceResource timeServiceResource =
-      new TimeServiceResource("GrpcServerXdsClient");
-
-  private EnvoyServerProtoData.Listener curListener;
-  @SuppressWarnings("unused")
-  @Nullable private XdsClient xdsClient;
-  private final int port;
-  private ScheduledExecutorService timeService;
-  private XdsClient.ListenerWatcher listenerWatcher;
-  private boolean newServerApi;
-  @VisibleForTesting final Set<ServerWatcher> serverWatchers = new HashSet<>();
-
-  /**
-   * Creates a {@link XdsClientWrapperForServerSds}.
-   *
-   * @param port server's port for which listener config is needed.
-   */
-  public XdsClientWrapperForServerSds(int port) {
-    this.port = port;
-  }
-
-  public boolean hasXdsClient() {
-    return xdsClient != null;
-  }
-
-  /** Creates an XdsClient and starts a watch. */
-  public void createXdsClientAndStart() throws IOException {
-    checkState(xdsClient == null, "start() called more than once");
-    Bootstrapper.BootstrapInfo bootstrapInfo;
-    try {
-      bootstrapInfo = new BootstrapperImpl().bootstrap();
-      List<Bootstrapper.ServerInfo> serverList = bootstrapInfo.getServers();
-      if (serverList.isEmpty()) {
-        throw new XdsInitializationException("No management server provided by bootstrap");
-      }
-    } catch (XdsInitializationException e) {
-      throw new IOException(e);
-    }
-    Node node = bootstrapInfo.getNode();
-    Bootstrapper.ServerInfo serverInfo = bootstrapInfo.getServers().get(0);  // use first server
-    ManagedChannel channel =
-        Grpc.newChannelBuilder(serverInfo.getTarget(), serverInfo.getChannelCredentials())
-            .keepAliveTime(5, TimeUnit.MINUTES).build();
-    timeService = SharedResourceHolder.get(timeServiceResource);
-    newServerApi = serverInfo.isUseProtocolV3();
-    String grpcServerResourceId = bootstrapInfo.getGrpcServerResourceId();
-    if (newServerApi && grpcServerResourceId == null) {
-      throw new IOException("missing grpc_server_resource_name_id value in xds bootstrap");
-    }
-    XdsClient xdsClientImpl =
-        new ServerXdsClient(
-            channel,
-            serverInfo.isUseProtocolV3(),
-            node,
-            timeService,
-            new ExponentialBackoffPolicy.Provider(),
-            GrpcUtil.STOPWATCH_SUPPLIER,
-            "0.0.0.0",
-            grpcServerResourceId);
-    start(xdsClientImpl);
-  }
-
-  /** Accepts an XdsClient and starts a watch. */
-  @VisibleForTesting
-  public void start(XdsClient xdsClient) {
-    checkState(this.xdsClient == null, "start() called more than once");
-    checkNotNull(xdsClient, "xdsClient");
-    this.xdsClient = xdsClient;
-    this.listenerWatcher =
-        new XdsClient.ListenerWatcher() {
-          @Override
-          public void onListenerChanged(XdsClient.ListenerUpdate update) {
-            curListener = update.getListener();
-            reportSuccess();
-          }
-
-          @Override
-          public void onResourceDoesNotExist(String resourceName) {
-            logger.log(Level.WARNING, "Resource {0} is unavailable", resourceName);
-            curListener = null;
-            reportError(Status.NOT_FOUND.withDescription(resourceName).asException());
-          }
-
-          @Override
-          public void onError(Status error) {
-            logger.log(
-                Level.WARNING, "ListenerWatcher in XdsClientWrapperForServerSds: {0}", error);
-            reportError(error.asException());
-          }
-        };
-    xdsClient.watchListenerData(port, listenerWatcher);
-  }
-
-  /**
-   * Locates the best matching FilterChain to the channel from the current listener and if found
-   * returns the DownstreamTlsContext from that FilterChain, else null.
-   */
-  @Nullable
-  public DownstreamTlsContext getDownstreamTlsContext(Channel channel) {
-    if (curListener != null && channel != null) {
-      SocketAddress localAddress = channel.localAddress();
-      SocketAddress remoteAddress = channel.remoteAddress();
-      if (localAddress instanceof InetSocketAddress && remoteAddress instanceof InetSocketAddress) {
-        InetSocketAddress localInetAddr = (InetSocketAddress) localAddress;
-        InetSocketAddress remoteInetAddr = (InetSocketAddress) remoteAddress;
-        checkState(
-            port == localInetAddr.getPort(),
-            "Channel localAddress port does not match requested listener port");
-        return getDownstreamTlsContext(localInetAddr, remoteInetAddr);
-      }
-    }
-    return null;
-  }
-
-  /**
-   * Using the logic specified at
-   * https://www.envoyproxy.io/docs/envoy/latest/api-v2/api/v2/listener/listener_components.proto.html?highlight=filter%20chain#listener-filterchainmatch
-   * locate a matching filter and return the corresponding DownstreamTlsContext or else return one
-   * from default filter chain.
-   *
-   * @param localInetAddr dest address of the inbound connection
-   * @param remoteInetAddr source address of the inbound connection
-   */
-  private DownstreamTlsContext getDownstreamTlsContext(
-      InetSocketAddress localInetAddr, InetSocketAddress remoteInetAddr) {
-    List<FilterChain> filterChains = curListener.getFilterChains();
-
-    filterChains = filterOnDestinationPort(filterChains);
-    filterChains = filterOnIpAddress(filterChains, localInetAddr.getAddress(), true);
-    filterChains =
-        filterOnSourceType(filterChains, remoteInetAddr.getAddress(), localInetAddr.getAddress());
-    filterChains = filterOnIpAddress(filterChains, remoteInetAddr.getAddress(), false);
-    filterChains = filterOnSourcePort(filterChains, remoteInetAddr.getPort());
-
-    // if we get more than 1, we ignore filterChains and use the defaultFilerChain
-    // although spec not clear for that case
-    if (filterChains.size() == 1) {
-      return filterChains.get(0).getDownstreamTlsContext();
-    }
-    return curListener.getDefaultFilterChain().getDownstreamTlsContext();
-  }
-
-  // destination_port present => Always fail match
-  private static List<FilterChain> filterOnDestinationPort(List<FilterChain> filterChains) {
-    ArrayList<FilterChain> filtered = new ArrayList<>(filterChains.size());
-    for (FilterChain filterChain : filterChains) {
-      FilterChainMatch filterChainMatch = filterChain.getFilterChainMatch();
-
-      if (filterChainMatch.getDestinationPort() == UInt32Value.getDefaultInstance().getValue()) {
-        filtered.add(filterChain);
-      }
-    }
-    return filtered;
-  }
-
-  private static List<FilterChain> filterOnSourcePort(
-      List<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.getFilterChainMatch();
-
-      List<Integer> sourcePortsToMatch = filterChainMatch.getSourcePorts();
-      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 List<FilterChain> filterOnSourceType(
-      List<FilterChain> filterChains, InetAddress sourceAddress, InetAddress destAddress) {
-    ArrayList<FilterChain> filtered = new ArrayList<>(filterChains.size());
-    for (FilterChain filterChain : filterChains) {
-      FilterChainMatch filterChainMatch = filterChain.getFilterChainMatch();
-      EnvoyServerProtoData.ConnectionSourceType sourceType =
-          filterChainMatch.getConnectionSourceType();
-
-      boolean matching = false;
-      if (sourceType == EnvoyServerProtoData.ConnectionSourceType.SAME_IP_OR_LOOPBACK) {
-        matching =
-            sourceAddress.isLoopbackAddress()
-                || sourceAddress.isAnyLocalAddress()
-                || sourceAddress.equals(destAddress);
-      } else if (sourceType == EnvoyServerProtoData.ConnectionSourceType.EXTERNAL) {
-        matching = !sourceAddress.isLoopbackAddress() && !sourceAddress.isAnyLocalAddress();
-      } else { // ANY or null
-        matching = true;
-      }
-      if (matching) {
-        filtered.add(filterChain);
-      }
-    }
-    return filtered;
-  }
-
-  private static boolean isCidrMatching(byte[] cidrBytes, byte[] addressBytes, int prefixLen) {
-    BigInteger cidrInt = new BigInteger(cidrBytes);
-    BigInteger addrInt = new BigInteger(addressBytes);
-
-    int shiftAmount = 8 * cidrBytes.length - prefixLen;
-
-    cidrInt = cidrInt.shiftRight(shiftAmount);
-    addrInt = addrInt.shiftRight(shiftAmount);
-    return cidrInt.equals(addrInt);
-  }
-
-  private static class QueueElement {
-    FilterChain filterChain;
-    int indexOfMatchingPrefixRange;
-    int matchingPrefixLength;
-
-    public QueueElement(FilterChain filterChain, InetAddress address, boolean forDestination) {
-      this.filterChain = filterChain;
-      FilterChainMatch filterChainMatch = filterChain.getFilterChainMatch();
-      byte[] addressBytes = address.getAddress();
-      boolean isIPv6 = address instanceof Inet6Address;
-      List<CidrRange> cidrRanges =
-          forDestination
-              ? filterChainMatch.getPrefixRanges()
-              : filterChainMatch.getSourcePrefixRanges();
-      indexOfMatchingPrefixRange = -1;
-      if (cidrRanges.isEmpty()) { // if there is no CidrRange assume there is perfect match
-        matchingPrefixLength = isIPv6 ? 128 : 32;
-      } else {
-        matchingPrefixLength = 0;
-        int index = 0;
-        for (CidrRange cidrRange : cidrRanges) {
-          InetAddress cidrAddr = cidrRange.getAddressPrefix();
-          boolean cidrIsIpv6 = cidrAddr instanceof Inet6Address;
-          if (isIPv6 == cidrIsIpv6) {
-            byte[] cidrBytes = cidrAddr.getAddress();
-            int prefixLen = cidrRange.getPrefixLen();
-            if (isCidrMatching(cidrBytes, addressBytes, prefixLen)
-                && prefixLen > matchingPrefixLength) {
-              matchingPrefixLength = prefixLen;
-              indexOfMatchingPrefixRange = index;
-            }
-          }
-          index++;
-        }
-      }
-    }
-  }
-
-  private static final class QueueElementComparator implements Comparator<QueueElement> {
-
-    @Override
-    public int compare(QueueElement o1, QueueElement o2) {
-      // descending order for max heap
-      return o2.matchingPrefixLength - o1.matchingPrefixLength;
-    }
-
-    @Override
-    public boolean equals(Object obj) {
-      return obj instanceof QueueElementComparator;
-    }
-
-    @Override
-    public int hashCode() {
-      return super.hashCode();
-    }
-  }
-
-  // use prefix_ranges (CIDR) and get the most specific matches
-  private List<FilterChain> filterOnIpAddress(
-      List<FilterChain> filterChains, InetAddress address, boolean forDestination) {
-    PriorityQueue<QueueElement> heap = new PriorityQueue<>(10, new QueueElementComparator());
-
-    for (FilterChain filterChain : filterChains) {
-      QueueElement element = new QueueElement(filterChain, address, forDestination);
-
-      if (element.matchingPrefixLength > 0) {
-        heap.add(element);
-      }
-    }
-    // get the top ones
-    ArrayList<FilterChain> topOnes = new ArrayList<>(heap.size());
-    int topMatchingPrefixLen = -1;
-    while (!heap.isEmpty()) {
-      QueueElement element = heap.remove();
-      if (topMatchingPrefixLen == -1) {
-        topMatchingPrefixLen = element.matchingPrefixLength;
-      } else {
-        if (element.matchingPrefixLength < topMatchingPrefixLen) {
-          break;
-        }
-      }
-      topOnes.add(element.filterChain);
-    }
-    return topOnes;
-  }
-
-  /** Adds a {@link ServerWatcher} to the list. */
-  public void addServerWatcher(ServerWatcher serverWatcher) {
-    checkNotNull(serverWatcher, "serverWatcher");
-    synchronized (serverWatchers) {
-      serverWatchers.add(serverWatcher);
-    }
-    if (curListener != null) {
-      serverWatcher.onSuccess();
-    }
-  }
-
-  /** Removes a {@link ServerWatcher} from the list. */
-  public void removeServerWatcher(ServerWatcher serverWatcher) {
-    checkNotNull(serverWatcher, "serverWatcher");
-    synchronized (serverWatchers) {
-      serverWatchers.remove(serverWatcher);
-    }
-  }
-
-  private Set<ServerWatcher> getServerWatchers() {
-    synchronized (serverWatchers) {
-      return ImmutableSet.copyOf(serverWatchers);
-    }
-  }
-
-  private void reportError(Throwable throwable) {
-    for (ServerWatcher watcher : getServerWatchers()) {
-      watcher.onError(throwable);
-    }
-  }
-
-  private void reportSuccess() {
-    for (ServerWatcher watcher : getServerWatchers()) {
-      watcher.onSuccess();
-    }
-  }
-
-
-  @VisibleForTesting
-  XdsClient.ListenerWatcher getListenerWatcher() {
-    return listenerWatcher;
-  }
-
-  /** Watcher interface for the clients of this class. */
-  public interface ServerWatcher {
-
-    /** Called to report errors from the control plane including "not found". */
-    void onError(Throwable throwable);
-
-    /** Called to report successful receipt of server config. */
-    void onSuccess();
-  }
-
-  /** Shutdown this instance and release resources. */
-  public void shutdown() {
-    logger.log(Level.FINER, "Shutdown");
-    if (xdsClient != null) {
-      xdsClient.shutdown();
-      xdsClient = null;
-    }
-    if (timeService != null) {
-      timeService = SharedResourceHolder.release(timeServiceResource, timeService);
-    }
-  }
-
-  private static final class TimeServiceResource
-          implements SharedResourceHolder.Resource<ScheduledExecutorService> {
-
-    private final String name;
-
-    TimeServiceResource(String name) {
-      this.name = name;
-    }
-
-    @Override
-    public ScheduledExecutorService create() {
-      // Use Netty's DefaultThreadFactory in order to get the benefit of FastThreadLocal.
-      ThreadFactory threadFactory = new DefaultThreadFactory(name, /* daemon= */ true);
-      if (Epoll.isAvailable()) {
-        return new EpollEventLoopGroup(1, threadFactory);
-      } else {
-        return Executors.newSingleThreadScheduledExecutor(threadFactory);
-      }
-    }
-
-    @SuppressWarnings("FutureReturnValueIgnored")
-    @Override
-    public void close(ScheduledExecutorService instance) {
-      try {
-        if (instance instanceof EpollEventLoopGroup) {
-          ((EpollEventLoopGroup)instance).shutdownGracefully(0, 0, TimeUnit.SECONDS).sync();
-        } else {
-          instance.shutdown();
-        }
-      } catch (InterruptedException e) {
-        logger.log(Level.SEVERE, "Interrupted during shutdown", e);
-        Thread.currentThread().interrupt();
-      }
-    }
-  }
-}
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..10efc47be47
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/XdsClusterResource.java
@@ -0,0 +1,786 @@
+/*
+ * 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";
+  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 && transportSocket.getTypedConfig().is(
+        Http11ProxyUpstreamTransport.class))) {
+      return StructOrError.fromError(
+          "transport-socket with name " + transportSocket.getName() + " not supported.");
+    }
+
+    if (hasTransportSocket && isEnabledXdsHttpConnect && transportSocket.getTypedConfig().is(
+        Http11ProxyUpstreamTransport.class)) {
+      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..9dd77a400cd
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/XdsCredentialsRegistry.java
@@ -0,0 +1,192 @@
+/*
+ * 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.ServiceLoader;
+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,
+              ServiceLoader
+                .load(XdsCredentialsProvider.class, XdsCredentialsProvider.class.getClassLoader())
+                .iterator(),
+              XdsCredentialsRegistry::getHardCodedClasses,
+              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..a0af5974175
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/XdsDependencyManager.java
@@ -0,0 +1,947 @@
+/*
+ * 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.GrpcUtil;
+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 translatedStatus = GrpcUtil.statusWithDetails(
+            Status.Code.UNAVAILABLE,
+            "Error retrieving " + toContextString() + nodeInfo(),
+            update.getStatus());
+
+        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
index b11c7853473..ae5ac38b471 100644
--- a/xds/src/main/java/io/grpc/xds/XdsLbPolicies.java
+++ b/xds/src/main/java/io/grpc/xds/XdsLbPolicies.java
@@ -19,10 +19,10 @@
 final class XdsLbPolicies {
   static final String CLUSTER_MANAGER_POLICY_NAME = "cluster_manager_experimental";
   static final String CDS_POLICY_NAME = "cds_experimental";
-  static final String CLUSTER_RESOLVER_POLICY_NAME = "cluster_resolver_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..ccb88a8e543
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/XdsListenerResource.java
@@ -0,0 +1,654 @@
+/*
+ * 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, args);
+      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,
+      XdsResourceType.Args args) {
+    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"));
+    }
+
+    Filter.FilterConfigParseContext filterContext = Filter.FilterConfigParseContext.builder()
+        .bootstrapInfo(args.getBootstrapInfo())
+        .serverInfo(args.getServerInfo())
+        .build();
+    ConfigOrError<? extends FilterConfig> filterConfig =
+        provider.parseFilterConfig(rawConfig, filterContext);
+    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
index a106fc6b916..69b0b824433 100644
--- a/xds/src/main/java/io/grpc/xds/XdsNameResolver.java
+++ b/xds/src/main/java/io/grpc/xds/XdsNameResolver.java
@@ -18,22 +18,22 @@
 
 import static com.google.common.base.Preconditions.checkArgument;
 import static com.google.common.base.Preconditions.checkNotNull;
-import static java.util.concurrent.TimeUnit.NANOSECONDS;
+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.Supplier;
-import com.google.common.base.Suppliers;
+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.common.util.concurrent.MoreExecutors;
 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.Context;
-import io.grpc.Deadline;
+import io.grpc.ClientInterceptors;
 import io.grpc.ForwardingClientCall.SimpleForwardingClientCall;
 import io.grpc.ForwardingClientCallListener.SimpleForwardingClientCallListener;
 import io.grpc.InternalConfigSelector;
@@ -41,46 +41,46 @@
 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.DelayedClientCall;
 import io.grpc.internal.GrpcUtil;
 import io.grpc.internal.ObjectPool;
-import io.grpc.xds.HttpFault.FaultAbort;
-import io.grpc.xds.HttpFault.FaultDelay;
-import io.grpc.xds.HttpFault.FractionalPercent;
-import io.grpc.xds.Matchers.FractionMatcher;
-import io.grpc.xds.Matchers.HeaderMatcher;
-import io.grpc.xds.Matchers.PathMatcher;
+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.XdsClient.LdsResourceWatcher;
-import io.grpc.xds.XdsClient.LdsUpdate;
-import io.grpc.xds.XdsClient.RdsResourceWatcher;
-import io.grpc.xds.XdsClient.RdsUpdate;
-import io.grpc.xds.XdsLogger.XdsLogLevel;
 import io.grpc.xds.XdsNameResolverProvider.CallCounterProvider;
-import io.grpc.xds.XdsNameResolverProvider.XdsClientPoolFactory;
-import java.util.Collection;
+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.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.Executor;
 import java.util.concurrent.ScheduledExecutorService;
-import java.util.concurrent.ScheduledFuture;
-import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicInteger;
-import java.util.concurrent.atomic.AtomicLong;
+import java.util.function.Supplier;
 import javax.annotation.Nullable;
 
 /**
@@ -92,96 +92,176 @@
  * @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 =
-      Boolean.parseBoolean(System.getenv("GRPC_XDS_EXPERIMENTAL_ENABLE_TIMEOUT"));
-  @VisibleForTesting
-  static final Metadata.Key<String> DOWNSTREAM_NODE_KEY =
-      Metadata.Key.of("x-envoy-downstream-service-node", Metadata.ASCII_STRING_MARSHALLER);
-  @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);
-  @VisibleForTesting
-  static AtomicLong activeFaultInjectedStreamCounter = new AtomicLong();
+      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;
-  private final String authority;
+  @Nullable
+  private final String targetAuthority;
+  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 XdsClientPoolFactory xdsClientPoolFactory;
+  private final XdsClientPool xdsClientPool;
   private final ThreadSafeRandom random;
-  private final ConcurrentMap<String, AtomicInteger> clusterRefs = new ConcurrentHashMap<>();
+  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 volatile RoutingConfig routingConfig = RoutingConfig.empty;
+  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 ObjectPool<XdsClient> xdsClientPool;
   private XdsClient xdsClient;
   private CallCounterProvider callCounterProvider;
   private ResolveState resolveState;
 
-  XdsNameResolver(String name, ServiceConfigParser serviceConfigParser,
-      SynchronizationContext syncContext, ScheduledExecutorService scheduler) {
-    this(name, serviceConfigParser, syncContext, scheduler,
-        SharedXdsClientPoolProvider.getDefaultProvider(), ThreadSafeRandomImpl.instance);
+  /**
+   * Constructs a new instance.
+   *
+   * @param target the target URI to resolve
+   * @param targetAuthority the authority component of `target`, possibly the empty string, or null
+   *     if 'target' has no such component
+   */
+  XdsNameResolver(
+      String target, @Nullable String targetAuthority, String name,
+      @Nullable String overrideAuthority, ServiceConfigParser serviceConfigParser,
+      SynchronizationContext syncContext, ScheduledExecutorService scheduler,
+      @Nullable Map<String, ?> bootstrapOverride,
+      MetricRecorder metricRecorder, Args nameResolverArgs) {
+    this(target, targetAuthority, name, overrideAuthority, serviceConfigParser,
+        syncContext, scheduler,
+        bootstrapOverride == null
+          ? SharedXdsClientPoolProvider.getDefaultProvider()
+          : new SharedXdsClientPoolProvider(),
+        ThreadSafeRandomImpl.instance, FilterRegistry.getDefaultRegistry(), bootstrapOverride,
+        metricRecorder, nameResolverArgs);
   }
 
   @VisibleForTesting
-  XdsNameResolver(String name, ServiceConfigParser serviceConfigParser,
+  XdsNameResolver(
+      String target, @Nullable String targetAuthority, String name,
+      @Nullable String overrideAuthority, ServiceConfigParser serviceConfigParser,
       SynchronizationContext syncContext, ScheduledExecutorService scheduler,
-      XdsClientPoolFactory xdsClientPoolFactory, ThreadSafeRandom random) {
-    authority = GrpcUtil.checkAuthority(checkNotNull(name, "name"));
+      XdsClientPoolFactory xdsClientPoolFactory, ThreadSafeRandom random,
+      FilterRegistry filterRegistry, @Nullable Map<String, ?> bootstrapOverride,
+      MetricRecorder metricRecorder, Args nameResolverArgs) {
+    this.targetAuthority = targetAuthority;
+
+    // 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");
-    this.xdsClientPoolFactory = checkNotNull(xdsClientPoolFactory, "xdsClientPoolFactory");
+    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");
-    logger = XdsLogger.withLogId(InternalLogId.allocate("xds-resolver", name));
+    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 authority;
+    return encodedServiceAuthority;
   }
 
   @Override
   public void start(Listener2 listener) {
     this.listener = checkNotNull(listener, "listener");
     try {
-      xdsClientPool = xdsClientPoolFactory.getXdsClientPool();
+      xdsClient = xdsClientPool.getObject();
     } catch (Exception e) {
       listener.onError(
           Status.UNAVAILABLE.withDescription("Failed to initialize xDS").withCause(e));
       return;
     }
-    xdsClient = xdsClientPool.getObject();
+    BootstrapInfo bootstrapInfo = xdsClient.getBootstrapInfo();
+    String listenerNameTemplate;
+    if (targetAuthority == null || targetAuthority.isEmpty()) {
+      // Both https://github.com/grpc/proposal/blob/master/A27-xds-global-load-balancing.md and
+      // A47-xds-federation.md seem to treat an empty authority the same as an undefined one.
+      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();
+
+    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.stop();
+      resolveState.shutdown();
     }
     if (xdsClient != null) {
       xdsClient = xdsClientPool.returnObject(xdsClient);
@@ -189,31 +269,39 @@ public void shutdown() {
   }
 
   @VisibleForTesting
-  static Map<String, ?> generateServiceConfigWithMethodTimeoutConfig(long timeoutNano) {
-    String timeout = timeoutNano / 1_000_000_000.0 + "s";
-    Map<String, Object> methodConfig = new HashMap<>();
+  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()));
-    methodConfig.put("timeout", timeout);
-    return Collections.singletonMap(
-        "methodConfig", Collections.singletonList(Collections.unmodifiableMap(methodConfig)));
-  }
-
-  @VisibleForTesting
-  static Map<String, ?> generateServiceConfigWithLoadBalancingConfig(Collection<String> clusters) {
-    Map<String, Object> childPolicy = new HashMap<>();
-    for (String cluster : clusters) {
-      List<Map<String, Map<String, String>>> lbPolicy =
-          Collections.singletonList(
-              Collections.singletonMap(
-                  "cds_experimental", Collections.singletonMap("cluster", cluster)));
-      childPolicy.put(cluster, Collections.singletonMap("lbPolicy", lbPolicy));
+    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());
     }
-    return Collections.singletonMap("loadBalancingConfig",
-        Collections.singletonList(
-            Collections.singletonMap(
-                "cluster_manager_experimental", Collections.singletonMap(
-                    "childPolicy", Collections.unmodifiableMap(childPolicy)))));
+    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
@@ -221,18 +309,32 @@ XdsClient getXdsClient() {
     return xdsClient;
   }
 
-  private void updateResolutionResult() {
-    Map<String, ?> rawServiceConfig =
-        generateServiceConfigWithLoadBalancingConfig(clusterRefs.keySet());
+  // 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:\n{0}", new Gson().toJson(rawServiceConfig));
+          XdsLogLevel.INFO, "Generated service config: {0}", new Gson().toJson(rawServiceConfig));
     }
     ConfigOrError parsedServiceConfig = serviceConfigParser.parseServiceConfig(rawServiceConfig);
     Attributes attrs =
         Attributes.newBuilder()
-            .set(InternalXdsAttributes.XDS_CLIENT_POOL, xdsClientPool)
-            .set(InternalXdsAttributes.CALL_COUNTER_PROVIDER, callCounterProvider)
+            .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 =
@@ -240,48 +342,9 @@ private void updateResolutionResult() {
             .setAttributes(attrs)
             .setServiceConfig(parsedServiceConfig)
             .build();
-    listener.onResult(result);
-  }
-
-  @VisibleForTesting
-  @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;
-      }
+    if (!listener.onResult2(result).isOk()) {
+      resolveState.xdsDependencyManager.requestReresolution();
     }
-    return targetVirtualHost;
   }
 
   /**
@@ -347,28 +410,21 @@ static boolean matchHostName(String hostName, String pattern) {
   private final class ConfigSelector extends InternalConfigSelector {
     @Override
     public Result selectConfig(PickSubchannelArgs args) {
-      // Index ASCII headers by keys.
-      Map<String, Iterable<String>> asciiHeaders = new HashMap<>();
+      RoutingConfig routingCfg;
+      RouteData selectedRoute;
+      String cluster;
+      ClientInterceptor filters;
       Metadata headers = args.getHeaders();
-      for (String headerName : headers.keys()) {
-        if (headerName.endsWith(Metadata.BINARY_HEADER_SUFFIX)) {
-          continue;
-        }
-        Metadata.Key<String> key = Metadata.Key.of(headerName, Metadata.ASCII_STRING_MARSHALLER);
-        asciiHeaders.put(headerName, headers.getAll(key));
-      }
-      String cluster = null;
-      Route selectedRoute = null;
-      HttpFault selectedFaultConfig;
+      String path = "/" + args.getMethodDescriptor().getFullMethodName();
       do {
-        selectedFaultConfig = routingConfig.faultConfig;
-        for (Route route : routingConfig.routes) {
-          if (matchRoute(route.routeMatch(), "/" + args.getMethodDescriptor().getFullMethodName(),
-              asciiHeaders, random)) {
+        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;
-            if (routingConfig.applyFaultInjection && route.httpFault() != null) {
-              selectedFaultConfig = route.httpFault();
-            }
             break;
           }
         }
@@ -376,39 +432,56 @@ public Result selectConfig(PickSubchannelArgs args) {
           return Result.forError(
               Status.UNAVAILABLE.withDescription("Could not find xDS route matching RPC"));
         }
-        RouteAction action = selectedRoute.routeAction();
+        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 = action.cluster();
+          cluster = prefixedClusterName(action.cluster());
+          filters = selectedRoute.filterChoices.get(0);
         } else if (action.weightedClusters() != null) {
-          int totalWeight = 0;
+          // XdsRouteConfigureResource verifies the total weight will not be 0 or exceed uint32
+          long totalWeight = 0;
           for (ClusterWeight weightedCluster : action.weightedClusters()) {
             totalWeight += weightedCluster.weight();
           }
-          int select = random.nextInt(totalWeight);
-          int accumulator = 0;
-          for (ClusterWeight weightedCluster : action.weightedClusters()) {
+          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 = weightedCluster.name();
-              if (routingConfig.applyFaultInjection && weightedCluster.httpFault() != null) {
-                selectedFaultConfig = weightedCluster.httpFault();
-              }
+              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));
-      // TODO(chengyuanzhang): avoid service config generation and parsing for each call.
-      Map<String, ?> rawServiceConfig = Collections.emptyMap();
+
+      final RouteAction routeAction = selectedRoute.routeAction;
+      Long timeoutNanos = null;
       if (enableTimeout) {
-        Long timeoutNano = selectedRoute.routeAction().timeoutNano();
-        if (timeoutNano == null) {
-          timeoutNano = routingConfig.fallbackTimeoutNano;
+        timeoutNanos = routeAction.timeoutNano();
+        if (timeoutNanos == null) {
+          timeoutNanos = routingCfg.fallbackTimeoutNano;
         }
-        if (timeoutNano > 0) {
-          rawServiceConfig = generateServiceConfigWithMethodTimeoutConfig(timeoutNano);
+        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) {
@@ -418,116 +491,62 @@ public Result selectConfig(PickSubchannelArgs args) {
                 "Failed to parse service config (method config)"));
       }
       final String finalCluster = cluster;
-      if (selectedFaultConfig != null && selectedFaultConfig.maxActiveFaults() != null
-          && activeFaultInjectedStreamCounter.get() >= selectedFaultConfig.maxActiveFaults()) {
-        selectedFaultConfig = null;
-      }
-      if (selectedFaultConfig != null) {
-        if (!selectedFaultConfig.upstreamCluster().equals(cluster)) {
-          selectedFaultConfig = null;
-        } else if (!selectedFaultConfig.downstreamNodes().isEmpty()) {
-          String downstreamNode = headers.get(DOWNSTREAM_NODE_KEY);
-          if (downstreamNode == null
-              || !selectedFaultConfig.downstreamNodes().contains(downstreamNode)) {
-            selectedFaultConfig = null;
-          }
-        }
-      }
-      if (selectedFaultConfig != null
-          && !matchHeaders(selectedFaultConfig.headers(), asciiHeaders)) {
-        selectedFaultConfig = null;
-      }
-      Long delayNanos = null;
-      Status abortStatus = null;
-      if (selectedFaultConfig != null) {
-        if (selectedFaultConfig.faultDelay() != null) {
-          delayNanos = determineFaultDelayNanos(selectedFaultConfig.faultDelay(), headers);
-        }
-        if (selectedFaultConfig.faultAbort() != null) {
-          abortStatus = determineFaultAbortStatus(selectedFaultConfig.faultAbort(), headers);
-        }
-      }
-      final Long finalDelayNanos = delayNanos;
-      final Status finalAbortStatus = abortStatus;
+      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) {
-          final CallOptions callOptionsForCluster =
-              callOptions.withOption(CLUSTER_SELECTION_KEY, finalCluster);
-          Supplier<ClientCall<ReqT, RespT>> configApplyingCallSupplier =
-              new Supplier<ClientCall<ReqT, RespT>>() {
+          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 ClientCall<ReqT, RespT> get() {
-                  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);
-                    }
-                  };
+                public void onHeaders(Metadata headers) {
+                  committed = true;
+                  releaseCluster(finalCluster);
+                  delegate().onHeaders(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();
-          }
-          if (finalDelayNanos != null && finalAbortStatus != null) {
-            return new ActiveFaultCountingClientCall<>(
-                new DelayInjectedCall<>(
-                    finalDelayNanos, callExecutor, scheduler, callOptionsForCluster.getDeadline(),
-                    Suppliers.ofInstance(
-                        new FailingClientCall<ReqT, RespT>(finalAbortStatus, callExecutor))));
-          }
-          if (finalAbortStatus != null) {
-            return new ActiveFaultCountingClientCall<>(
-                new FailingClientCall<ReqT, RespT>(finalAbortStatus, callExecutor));
-          }
-          if (finalDelayNanos != null) {
-            return new ActiveFaultCountingClientCall<>(
-                new DelayInjectedCall<>(
-                    finalDelayNanos, callExecutor, scheduler, callOptionsForCluster.getDeadline(),
-                    configApplyingCallSupplier));
-          }
-          return configApplyingCallSupplier.get();
+                @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(new ClusterSelectionInterceptor())
+              .setInterceptor(combineInterceptors(
+                  ImmutableList.of(new ClusterSelectionInterceptor(), filters)))
               .build();
     }
 
     private boolean retainCluster(String cluster) {
-      AtomicInteger refCount = clusterRefs.get(cluster);
-      if (refCount == null) {
+      ClusterRefState clusterRefState = clusterRefs.get(cluster);
+      if (clusterRefState == null) {
         return false;
       }
+      AtomicInteger refCount = clusterRefState.refCount;
       int count;
       do {
         count = refCount.get();
@@ -539,519 +558,560 @@ private boolean retainCluster(String cluster) {
     }
 
     private void releaseCluster(final String cluster) {
-      int count = clusterRefs.get(cluster).decrementAndGet();
+      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).get() == 0) {
-              clusterRefs.remove(cluster);
-              updateResolutionResult();
+            if (clusterRefs.get(cluster).refCount.get() != 0) {
+              throw new AssertionError();
             }
-          }
-        });
-      }
-    }
-
-    @Nullable
-    private Long determineFaultDelayNanos(FaultDelay faultDelay, Metadata headers) {
-      Long delayNanos;
-      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 =
-                  FractionalPercent.create(delayPercentage, fractionalPercent.denominatorType());
+            clusterRefs.remove(cluster).close();
+            if (resolveState.lastConfigOrStatus.hasValue()) {
+              updateResolutionResult(resolveState.lastConfigOrStatus.getValue());
+            } else {
+              resolveState.cleanUpRoutes(resolveState.lastConfigOrStatus.getStatus());
             }
           }
-        } 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;
-      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 =
-                  FractionalPercent.create(abortPercentage, fractionalPercent.denominatorType());
+    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);
           }
-        } catch (NumberFormatException e) {
-          return null; // treated as header_abort not applicable
+        } else if (policy.type() == HashPolicy.Type.CHANNEL_ID) {
+          newHash = hashFunc.hashLong(randomChannelId);
         }
-      } else {
-        abortStatus = faultAbort.status();
-      }
-      if (random.nextInt(1_000_000) >= getRatePerMillion(fractionalPercent)) {
-        return null;
-      }
-      return abortStatus;
-    }
-  }
-
-  private static int getRatePerMillion(FractionalPercent percent) {
-    int numerator = percent.numerator();
-    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 forwarding client call that counts active fault injections.
-   */
-  private final class ActiveFaultCountingClientCall<ReqT, RespT> extends
-      SimpleForwardingClientCall<ReqT, RespT> {
-    ActiveFaultCountingClientCall(ClientCall<ReqT, RespT> faultInjectedDelegate) {
-      super(faultInjectedDelegate);
-      activeFaultInjectedStreamCounter.incrementAndGet();
-    }
-
-    @Override
-    public void start(Listener<RespT> listener, Metadata headers) {
-      listener = new SimpleForwardingClientCallListener<RespT>(listener) {
-        @Override
-        public void onClose(Status status, Metadata trailers) {
-          delegate().onClose(status, trailers);
-          activeFaultInjectedStreamCounter.decrementAndGet();
+        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;
         }
-      };
-      delegate().start(listener, headers);
-    }
-  }
-
-  /** A {@link DelayedClientCall} with a fixed delay. */
-  private static 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);
-      ScheduledFuture<?> task = scheduler.schedule(
-          new Runnable() {
-            @Override
-            public void run() {
-              setCall(callSupplier.get());
-            }
-          },
-          delayNanos,
-          NANOSECONDS);
-      synchronized (lock) {
-        if (cancelled) {
-          task.cancel(false);
-          return;
+        // 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;
         }
-        delayTask = task;
       }
+      return hash == null ? random.nextLong() : hash;
     }
+  }
 
+  static final class PassthroughClientInterceptor implements ClientInterceptor {
     @Override
-    protected void callCancelled() {
-      ScheduledFuture<?> savedDelayTask;
-      synchronized (lock) {
-        cancelled = true;
-        savedDelayTask = delayTask;
-      }
-      if (savedDelayTask != null) {
-        savedDelayTask.cancel(false);
-      }
+    public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
+        MethodDescriptor<ReqT, RespT> method, CallOptions callOptions, Channel next) {
+      return next.newCall(method, callOptions);
     }
   }
 
-  /** An implementation of {@link ClientCall} that fails when started. */
-  private static 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();
+  private static ClientInterceptor combineInterceptors(final List<ClientInterceptor> interceptors) {
+    if (interceptors.size() == 0) {
+      return new PassthroughClientInterceptor();
     }
-
-    @Override
-    public void start(final ClientCall.Listener<RespT> listener, Metadata headers) {
-      callExecutor.execute(
-          new Runnable() {
-            @Override
-            public void run() {
-              Context previous = context.attach();
-              try {
-                listener.onClose(error, new Metadata());
-              } finally {
-                context.detach(previous);
-              }
-            }
-          });
+    if (interceptors.size() == 1) {
+      return interceptors.get(0);
     }
-
-    @Override
-    public void request(int numMessages) {}
-
-    @Override
-    public void cancel(String message, Throwable cause) {}
-
-    @Override
-    public void halfClose() {}
-
-    @Override
-    public void sendMessage(ReqT message) {}
+    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);
+      }
+    };
   }
 
-  @VisibleForTesting
-  static boolean matchRoute(RouteMatch routeMatch, String fullMethodName,
-      Map<String, Iterable<String>> headers, ThreadSafeRandom random) {
-    if (!matchPath(routeMatch.pathMatcher(), fullMethodName)) {
-      return false;
+  @Nullable
+  private static String getHeaderValue(Metadata headers, String headerName) {
+    if (headerName.endsWith(Metadata.BINARY_HEADER_SUFFIX)) {
+      return null;
     }
-    if (!matchHeaders(routeMatch.headerMatchers(), headers)) {
-      return false;
+    if (headerName.equals("content-type")) {
+      return "application/grpc";
     }
-    FractionMatcher fraction = routeMatch.fractionMatcher();
-    return fraction == null || random.nextInt(fraction.denominator()) < fraction.numerator();
-  }
-
-  @VisibleForTesting
-  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().startsWith(pathMatcher.prefix().toLowerCase());
+    Metadata.Key<String> key;
+    try {
+      key = Metadata.Key.of(headerName, Metadata.ASCII_STRING_MARSHALLER);
+    } catch (IllegalArgumentException e) {
+      return null;
     }
-    return pathMatcher.regEx().matches(fullMethodName);
+    Iterable<String> values = headers.getAll(key);
+    return values == null ? null : Joiner.on(",").join(values);
   }
 
-  private static boolean matchHeaders(
-      List<HeaderMatcher> headerMatchers, Map<String, Iterable<String>> headers) {
-    for (HeaderMatcher headerMatcher : headerMatchers) {
-      Iterable<String> headerValues = headers.get(headerMatcher.name());
-      // Special cases for hiding headers: "grpc-previous-rpc-attempts".
-      if (headerMatcher.name().equals("grpc-previous-rpc-attempts")) {
-        headerValues = null;
-      }
-      // Special case for exposing headers: "content-type".
-      if (headerMatcher.name().equals("content-type")) {
-        headerValues = Collections.singletonList("application/grpc");
-      }
-      if (!matchHeader(headerMatcher, headerValues)) {
-        return false;
-      }
-    }
-    return true;
+  private static String prefixedClusterName(String name) {
+    return "cluster:" + name;
   }
 
-  @VisibleForTesting
-  static boolean matchHeader(HeaderMatcher headerMatcher,
-      @Nullable Iterable<String> headerValues) {
-    if (headerMatcher.present() != null) {
-      return (headerValues == null) == headerMatcher.present().equals(headerMatcher.inverted());
-    }
-    if (headerValues == null) {
-      return false;
-    }
-    String valueStr = Joiner.on(",").join(headerValues);
-    boolean baseMatch;
-    if (headerMatcher.exactValue() != null) {
-      baseMatch = headerMatcher.exactValue().equals(valueStr);
-    } else if (headerMatcher.safeRegEx() != null) {
-      baseMatch = headerMatcher.safeRegEx().matches(valueStr);
-    } else if (headerMatcher.range() != null) {
-      long numValue;
-      try {
-        numValue = Long.parseLong(valueStr);
-        baseMatch = numValue >= headerMatcher.range().start()
-            && numValue <= headerMatcher.range().end();
-      } catch (NumberFormatException ignored) {
-        baseMatch = false;
-      }
-    } else if (headerMatcher.prefix() != null) {
-      baseMatch = valueStr.startsWith(headerMatcher.prefix());
-    } else {
-      baseMatch = valueStr.endsWith(headerMatcher.suffix());
-    }
-    return baseMatch != headerMatcher.inverted();
+  private static String prefixedClusterSpecifierPluginName(String pluginName) {
+    return "cluster_specifier_plugin:" + pluginName;
   }
 
-  private class ResolveState implements LdsResourceWatcher {
+  class ResolveState implements XdsDependencyManager.XdsConfigWatcher {
     private final ConfigOrError emptyServiceConfig =
         serviceConfigParser.parseServiceConfig(Collections.<String, Object>emptyMap());
-    private final ResolutionResult emptyResult =
-        ResolutionResult.newBuilder()
-            .setServiceConfig(emptyServiceConfig)
-            // let channel take action for no config selector
-            .build();
+    private final String authority;
+    private final XdsDependencyManager xdsDependencyManager;
     private boolean stopped;
-    private Set<String> existingClusters;
-    @Nullable
-    private String rdsResource;
-    @Nullable
-    private RdsResourceWatcher rdsWatcher;
-    private long httpMaxStreamDurationNano;
-    private boolean applyFaultInjection;
     @Nullable
-    private HttpFault httpFilterFaultConfig;
-
-    @Override
-    public void onChanged(final LdsUpdate update) {
-      syncContext.execute(new Runnable() {
-        @Override
-        public void run() {
-          if (stopped) {
-            return;
-          }
-          logger.log(XdsLogLevel.INFO, "Receive LDS resource update: {0}", update);
-          httpMaxStreamDurationNano = update.httpMaxStreamDurationNano;
-          applyFaultInjection = update.hasFaultInjection;
-          httpFilterFaultConfig = applyFaultInjection ? update.httpFault : null;
-          List<VirtualHost> virtualHosts = update.virtualHosts;
-          String rdsName = update.rdsName;
-          if (rdsName != null && rdsName.equals(rdsResource)) {
-            return;
-          }
-          cleanUpRdsWatcher();
-          if (virtualHosts != null) {
-            updateRoutes(virtualHosts);
-          } else {
-            rdsResource = rdsName;
-            rdsWatcher = new RdsResourceWatcherImpl();
-            logger.log(XdsLogLevel.INFO, "Start watching RDS resource {0}", rdsResource);
-            xdsClient.watchRdsResource(rdsResource, rdsWatcher);
-          }
-        }
-      });
+    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);
     }
 
-    @Override
-    public void onError(final Status error) {
-      syncContext.execute(new Runnable() {
-        @Override
-        public void run() {
-          if (stopped) {
-            return;
-          }
-          logger.log(
-              XdsLogLevel.WARNING,
-              "Received error from xDS client {0}: {1}", xdsClient, error.getDescription());
-          listener.onError(error);
-        }
-      });
+    void start() {
+      xdsDependencyManager.start(this);
     }
 
-    @Override
-    public void onResourceDoesNotExist(final String resourceName) {
-      syncContext.execute(new Runnable() {
-        @Override
-        public void run() {
-          if (stopped) {
-            return;
-          }
-          logger.log(XdsLogLevel.INFO, "LDS resource {0} unavailable", resourceName);
-          cleanUpRdsWatcher();
-          listener.onResult(emptyResult);
-        }
-      });
+    void refresh() {
+      xdsDependencyManager.requestReresolution();
     }
 
-    private void start() {
-      logger.log(XdsLogLevel.INFO, "Start watching LDS resource {0}", authority);
-      xdsClient.watchLdsResource(authority, this);
-    }
+    private void shutdown() {
+      if (stopped) {
+        return;
+      }
 
-    private void stop() {
-      logger.log(XdsLogLevel.INFO, "Stop watching LDS resource {0}", authority);
       stopped = true;
-      cleanUpRdsWatcher();
-      xdsClient.cancelLdsResourceWatch(authority, this);
+      xdsDependencyManager.shutdown();
+      updateActiveFilters(null);
     }
 
-    private void updateRoutes(List<VirtualHost> virtualHosts) {
-      VirtualHost virtualHost = findVirtualHostForHostName(virtualHosts, authority);
-      if (virtualHost == null) {
-        logger.log(XdsLogLevel.WARNING,
-            "Failed to find virtual host matching hostname {0}", authority);
-        listener.onResult(emptyResult);
+    @Override
+    public void onUpdate(StatusOr<XdsConfig> updateOrStatus) {
+      if (stopped) {
         return;
       }
-      List<Route> routes = virtualHost.routes();
-      HttpFault faultConfig = httpFilterFaultConfig;
-      if (applyFaultInjection && virtualHost.httpFault() != null) {
-        faultConfig = virtualHost.httpFault();
+      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();
-        if (action.cluster() != null) {
-          clusters.add(action.cluster());
+        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) {
-          for (ClusterWeight weighedCluster : action.weightedClusters()) {
-            clusters.add(weighedCluster.name());
+          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.<String>emptySet() : Sets.difference(existingClusters, clusters);
+              ? Collections.emptySet() : Sets.difference(existingClusters, clusters);
       existingClusters = clusters;
-      boolean shouldUpdateResult = false;
       for (String cluster : addedClusters) {
         if (clusterRefs.containsKey(cluster)) {
-          clusterRefs.get(cluster).incrementAndGet();
+          clusterRefs.get(cluster).refCount.incrementAndGet();
         } else {
-          clusterRefs.put(cluster, new AtomicInteger(1));
+          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) {
-        updateResolutionResult();
+      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(
-          httpMaxStreamDurationNano, routes, applyFaultInjection, faultConfig);
-      shouldUpdateResult = false;
+      routingConfig = new RoutingConfig(xdsConfig, httpMaxStreamDurationNano, routesData.build());
       for (String cluster : deletedClusters) {
-        int count = clusterRefs.get(cluster).decrementAndGet();
+        int count = clusterRefs.get(cluster).refCount.decrementAndGet();
         if (count == 0) {
-          clusterRefs.remove(cluster);
+          clusterRefs.remove(cluster).close();
           shouldUpdateResult = true;
         }
       }
       if (shouldUpdateResult) {
-        updateResolutionResult();
+        updateResolutionResult(xdsConfig);
       }
     }
 
-    private void cleanUpRdsWatcher() {
-      if (rdsWatcher != null) {
-        logger.log(XdsLogLevel.INFO, "Stop watching RDS resource {0}", rdsResource);
-        xdsClient.cancelRdsResourceWatch(rdsResource, rdsWatcher);
-        rdsResource = null;
-        rdsWatcher = null;
+    private ClientInterceptor createFilters(
+        @Nullable List<NamedFilterConfig> filterConfigs,
+        VirtualHost virtualHost,
+        Route route,
+        @Nullable ClusterWeight weightedCluster) {
+      if (filterConfigs == null) {
+        return new PassthroughClientInterceptor();
       }
-    }
-
-    private class RdsResourceWatcherImpl implements RdsResourceWatcher {
 
-      @Override
-      public void onChanged(final RdsUpdate update) {
-        syncContext.execute(new Runnable() {
-          @Override
-          public void run() {
-            if (RdsResourceWatcherImpl.this != rdsWatcher) {
-              return;
-            }
-            updateRoutes(update.virtualHosts);
-          }
-        });
+      Map<String, FilterConfig> selectedOverrideConfigs =
+          new HashMap<>(virtualHost.filterConfigOverrides());
+      selectedOverrideConfigs.putAll(route.filterConfigOverrides());
+      if (weightedCluster != null) {
+        selectedOverrideConfigs.putAll(weightedCluster.filterConfigOverrides());
       }
 
-      @Override
-      public void onError(final Status error) {
-        syncContext.execute(new Runnable() {
-          @Override
-          public void run() {
-            if (RdsResourceWatcherImpl.this != rdsWatcher) {
-              return;
-            }
-            logger.log(
-                XdsLogLevel.WARNING,
-                "Received error from xDS client {0}: {1}", xdsClient, error.getDescription());
-            listener.onError(error);
-          }
-        });
+      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);
+        }
       }
 
-      @Override
-      public void onResourceDoesNotExist(final String resourceName) {
-        syncContext.execute(new Runnable() {
-          @Override
-          public void run() {
-            if (RdsResourceWatcherImpl.this != rdsWatcher) {
-              return;
-            }
-            logger.log(XdsLogLevel.INFO, "RDS resource {0} unavailable", resourceName);
-            listener.onResult(emptyResult);
+      // 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());
     }
   }
 
   /**
-   * Grouping of the list of usable routes and their corresponding fallback timeout value.
+   * VirtualHost-level configuration for request routing.
    */
   private static class RoutingConfig {
-    private final long fallbackTimeoutNano;
-    private final List<Route> routes;
-    private final boolean applyFaultInjection;
-    @Nullable
-    private final HttpFault faultConfig;
-
-    private static RoutingConfig empty =
-        new RoutingConfig(0L, Collections.<Route>emptyList(), false, null);
+    final XdsConfig xdsConfig;
+    final long fallbackTimeoutNano;
+    final ImmutableList<RouteData> routes;
+    final Status errorStatus;
 
     private RoutingConfig(
-        long fallbackTimeoutNano, List<Route> routes, boolean applyFaultInjection,
-        HttpFault faultConfig) {
+        XdsConfig xdsConfig, long fallbackTimeoutNano, ImmutableList<RouteData> routes) {
+      this.xdsConfig = checkNotNull(xdsConfig, "xdsConfig");
       this.fallbackTimeoutNano = fallbackTimeoutNano;
-      this.routes = routes;
-      this.applyFaultInjection = applyFaultInjection;
-      this.faultConfig = faultConfig;
+      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 MetricRecorder metricRecorder;
+    private ObjectPool<XdsClient> xdsClientPool;
+
+    BootstrappingXdsClientPool(
+        XdsClientPoolFactory xdsClientPoolFactory,
+        String target,
+        @Nullable Map<String, ?> bootstrapOverride,
+        MetricRecorder metricRecorder) {
+      this.xdsClientPoolFactory = checkNotNull(xdsClientPoolFactory, "xdsClientPoolFactory");
+      this.target = checkNotNull(target, "target");
+      this.bootstrapOverride = bootstrapOverride;
+      this.metricRecorder = checkNotNull(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
index bb51455f793..51b1ff49bf0 100644
--- a/xds/src/main/java/io/grpc/xds/XdsNameResolverProvider.java
+++ b/xds/src/main/java/io/grpc/xds/XdsNameResolverProvider.java
@@ -22,10 +22,16 @@
 import io.grpc.Internal;
 import io.grpc.NameResolver.Args;
 import io.grpc.NameResolverProvider;
-import io.grpc.internal.ObjectPool;
+import io.grpc.Uri;
+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;
 
 /**
@@ -40,12 +46,40 @@
  */
 @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())) {
+    if (scheme.equals(targetUri.getScheme())) {
       String targetPath = checkNotNull(targetUri.getPath(), "targetPath");
       Preconditions.checkArgument(
           targetPath.startsWith("/"),
@@ -53,15 +87,46 @@ public XdsNameResolver newNameResolver(URI targetUri, Args args) {
           targetPath,
           targetUri);
       String name = targetPath.substring(1);
-      return new XdsNameResolver(name, args.getServiceConfigParser(),
-          args.getSynchronizationContext(), args.getScheduledExecutorService());
+      // TODO(jdcormie): java.net.URI#getAuthority incorrectly returns null for both xds:///service
+      //  and xds:/service. This doesn't matter for now since XdsNameResolver treats them the same
+      //  anyway and all this code will go away once newNameResolver(io.grpc.Uri) launches.
+      String targetAuthority = targetUri.getAuthority();
+      return newNameResolver(targetUri.toString(), targetAuthority, name, args);
     }
     return null;
   }
 
+  @Override
+  public XdsNameResolver newNameResolver(Uri targetUri, Args args) {
+    if (scheme.equals(targetUri.getScheme())) {
+      Preconditions.checkArgument(
+          targetUri.isPathAbsolute(),
+          "the path component of the target (%s) must start with '/'",
+          targetUri);
+      return newNameResolver(
+          targetUri.toString(), targetUri.getAuthority(), targetUri.getPath().substring(1), args);
+    }
+    return null;
+  }
+
+  private XdsNameResolver newNameResolver(
+      String targetUri, String targetAuthority, String name, Args args) {
+    return new XdsNameResolver(
+        targetUri.toString(),
+        targetAuthority,
+        name,
+        args.getOverrideAuthority(),
+        args.getServiceConfigParser(),
+        args.getSynchronizationContext(),
+        args.getScheduledExecutorService(),
+        bootstrapOverride,
+        args.getMetricRecorder(),
+        args);
+  }
+
   @Override
   public String getDefaultScheme() {
-    return SCHEME;
+    return scheme;
   }
 
   @Override
@@ -76,10 +141,9 @@ protected int priority() {
     return 4;
   }
 
-  interface XdsClientPoolFactory {
-    void setBootstrapOverride(Map<String, ?> bootstrap);
-
-    ObjectPool<XdsClient> getXdsClientPool() throws XdsInitializationException;
+  @Override
+  public Collection<Class<? extends SocketAddress>> getProducedSocketAddressTypes() {
+    return Collections.singleton(InetSocketAddress.class);
   }
 
   /**
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..730d301c3ec
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/XdsRouteConfigureResource.java
@@ -0,0 +1,676 @@
+/*
+ * 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.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, args);
+    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,
+      XdsResourceType.Args args) {
+    Filter.FilterConfigParseContext context = Filter.FilterConfigParseContext.builder()
+        .bootstrapInfo(args.getBootstrapInfo())
+        .serverInfo(args.getServerInfo())
+        .build();
+    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, context);
+      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, args);
+    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()) {
+      try {
+        fractionMatch =
+            MatcherParser.parseFractionMatcher(proto.getRuntimeFraction().getDefaultValue());
+      } catch (IllegalArgumentException e) {
+        return StructOrError.fromError(e.getMessage());
+      }
+    }
+
+    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");
+    }
+  }
+
+
+
+  @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, args);
+          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, XdsResourceType.Args args) {
+    StructOrError<Map<String, Filter.FilterConfig>> overrideConfigs =
+        parseOverrideFilterConfigs(proto.getTypedPerFilterConfigMap(), filterRegistry, args);
+    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
index 99a04c514d0..4a4fb71aa84 100644
--- a/xds/src/main/java/io/grpc/xds/XdsServerBuilder.java
+++ b/xds/src/main/java/io/grpc/xds/XdsServerBuilder.java
@@ -16,10 +16,14 @@
 
 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;
@@ -28,22 +32,32 @@
 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.internal.sds.SdsProtocolNegotiators;
-import io.grpc.xds.internal.sds.ServerWrapperForXds;
+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 that will use SDS to set up SSL
- * with peers. Note, this is not ready to use yet.
+ * 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;
@@ -54,10 +68,11 @@ private XdsServerBuilder(NettyServerBuilder nettyDelegate, int port) {
   @Override
   @Internal
   protected ServerBuilder<?> delegate() {
+    checkState(!isServerBuilt.get(), "Server already built!");
     return delegate;
   }
 
-  /** Set the {@link XdsServingStatusListener}. */
+  /** Set the {@link XdsServingStatusListener} to receive "serving" and "not serving" states. */
   public XdsServerBuilder xdsServingStatusListener(
       XdsServingStatusListener xdsServingStatusListener) {
     this.xdsServingStatusListener =
@@ -66,42 +81,85 @@ public XdsServerBuilder xdsServingStatusListener(
   }
 
   /**
-   * Unsupported call. Users should only use {@link #forPort(int, ServerCredentials)}.
+   * 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)");
+            "Unsupported call - use forPort(int, ServerCredentials)");
   }
 
   /** Creates a gRPC server builder for the given port. */
   public static XdsServerBuilder forPort(int port, ServerCredentials serverCredentials) {
-    NettyServerBuilder nettyDelegate = NettyServerBuilder.forPort(port, 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() {
-    return buildServer(new XdsClientWrapperForServerSds(port));
+    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;
   }
 
   /**
-   * Creates a Server using the given xdsClient.
+   * Allows providing bootstrap override, useful for testing.
    */
-  @VisibleForTesting
-  ServerWrapperForXds buildServer(
-      XdsClientWrapperForServerSds xdsClient) {
-    checkState(isServerBuilt.compareAndSet(false, true), "Server already built!");
-    InternalNettyServerBuilder.eagAttributes(delegate, Attributes.newBuilder()
-        .set(SdsProtocolNegotiators.SERVER_XDS_CLIENT, xdsClient)
-        .build());
-    return new ServerWrapperForXds(delegate.build(), xdsClient, xdsServingStatusListener);
+  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;
   }
 
-  /** Watcher to receive error notifications from xDS control plane during {@code start()}. */
+  /**
+   * 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. */
@@ -113,29 +171,30 @@ public interface XdsServingStatusListener {
     void onNotServing(Throwable throwable);
   }
 
-  /** Default implementation that logs at WARNING level. */
+  /** Default implementation of {@link XdsServingStatusListener} that logs at WARNING level. */
   private static class DefaultListener implements XdsServingStatusListener {
-    XdsLogger xdsLogger;
-    boolean notServing;
+    private final Logger logger;
+    private final String prefix;
+    boolean notServingDueToError;
 
     DefaultListener(String prefix) {
-      xdsLogger = XdsLogger.withPrefix(prefix);
-      notServing = true;
+      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 (notServing) {
-        notServing = false;
-        xdsLogger.log(XdsLogger.XdsLogLevel.WARNING, "Entering serving state.");
+      if (notServingDueToError) {
+        notServingDueToError = false;
+        logger.warning("[" + prefix + "] Entering serving state.");
       }
     }
 
     @Override
     public void onNotServing(Throwable throwable) {
-      xdsLogger.log(XdsLogger.XdsLogLevel.WARNING, throwable.getMessage());
-      notServing = true;
+      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
index 65f5102308c..2212e7a1855 100644
--- a/xds/src/main/java/io/grpc/xds/XdsServerCredentials.java
+++ b/xds/src/main/java/io/grpc/xds/XdsServerCredentials.java
@@ -22,9 +22,9 @@
 import io.grpc.ServerCredentials;
 import io.grpc.netty.InternalNettyServerCredentials;
 import io.grpc.netty.InternalProtocolNegotiator;
-import io.grpc.xds.internal.sds.SdsProtocolNegotiators;
+import io.grpc.xds.internal.security.SecurityProtocolNegotiators;
 
-@ExperimentalApi("https://github.com/grpc/grpc-java/issues/7621")
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/7514")
 public class XdsServerCredentials {
   private XdsServerCredentials() {} // prevent instantiation
 
@@ -40,6 +40,6 @@ public static ServerCredentials create(ServerCredentials fallback) {
     InternalProtocolNegotiator.ServerFactory fallbackNegotiator =
         InternalNettyServerCredentials.toNegotiator(checkNotNull(fallback, "fallback"));
     return InternalNettyServerCredentials.create(
-        SdsProtocolNegotiators.serverProtocolNegotiatorFactory(fallbackNegotiator));
+        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/XdsSubchannelPickers.java b/xds/src/main/java/io/grpc/xds/XdsSubchannelPickers.java
deleted file mode 100644
index 5c2890c34ea..00000000000
--- a/xds/src/main/java/io/grpc/xds/XdsSubchannelPickers.java
+++ /dev/null
@@ -1,63 +0,0 @@
-/*
- * 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.MoreObjects;
-import io.grpc.LoadBalancer.PickResult;
-import io.grpc.LoadBalancer.PickSubchannelArgs;
-import io.grpc.LoadBalancer.SubchannelPicker;
-import io.grpc.Status;
-
-final class XdsSubchannelPickers {
-
-  private XdsSubchannelPickers() { /* DO NOT CALL ME */ }
-
-  static final SubchannelPicker BUFFER_PICKER = new SubchannelPicker() {
-    @Override
-    public PickResult pickSubchannel(PickSubchannelArgs args) {
-      return PickResult.withNoResult();
-    }
-
-    @Override
-    public String toString() {
-      return "BUFFER_PICKER";
-    }
-  };
-
-  static final class ErrorPicker extends SubchannelPicker {
-
-    private final Status error;
-
-    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();
-    }
-  }
-}
diff --git a/xds/src/main/java/io/grpc/xds/client/AllowedGrpcServices.java b/xds/src/main/java/io/grpc/xds/client/AllowedGrpcServices.java
new file mode 100644
index 00000000000..e2d77689fca
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/client/AllowedGrpcServices.java
@@ -0,0 +1,66 @@
+/*
+ * 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.xds.client;
+
+import com.google.auto.value.AutoValue;
+import com.google.common.collect.ImmutableMap;
+import io.grpc.CallCredentials;
+import io.grpc.Internal;
+import java.util.Map;
+import java.util.Optional;
+
+/**
+ * Wrapper for allowed gRPC services keyed by target URI.
+ */
+@Internal
+@AutoValue
+public abstract class AllowedGrpcServices {
+  public abstract ImmutableMap<String, AllowedGrpcService> services();
+
+  public static AllowedGrpcServices create(Map<String, AllowedGrpcService> services) {
+    return new AutoValue_AllowedGrpcServices(ImmutableMap.copyOf(services));
+  }
+
+  public static AllowedGrpcServices empty() {
+    return create(ImmutableMap.of());
+  }
+
+  /**
+   * Represents an allowed gRPC service configuration with call credentials.
+   */
+  @Internal
+  @AutoValue
+  public abstract static class AllowedGrpcService {
+    public abstract ConfiguredChannelCredentials configuredChannelCredentials();
+
+    public abstract Optional<CallCredentials> callCredentials();
+
+    public static Builder builder() {
+      return new AutoValue_AllowedGrpcServices_AllowedGrpcService.Builder();
+    }
+
+    @AutoValue.Builder
+    public abstract static class Builder {
+      public abstract Builder configuredChannelCredentials(
+          ConfiguredChannelCredentials credentials);
+
+      public abstract Builder callCredentials(CallCredentials callCredentials);
+
+      public abstract AllowedGrpcService build();
+    }
+  }
+}
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..b8d6444e3b3
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/client/Bootstrapper.java
@@ -0,0 +1,248 @@
+/*
+ * 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 java.util.Optional;
+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();
+
+    /**
+     * Parsed configuration for implementation-specific extensions.
+     * Returns an opaque object containing the parsed configuration.
+     */
+    public abstract Optional<Object> implSpecificObject();
+
+    @VisibleForTesting
+    public static Builder builder() {
+      return new AutoValue_Bootstrapper_BootstrapInfo.Builder()
+          .clientDefaultListenerResourceNameTemplate("%s")
+          .authorities(ImmutableMap.<String, AuthorityInfo>of())
+          .implSpecificObject(Optional.empty());
+    }
+
+    @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 Builder implSpecificObject(Optional<Object> implSpecificObject);
+
+      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..3f4ea8eb5c6
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/client/BootstrapperImpl.java
@@ -0,0 +1,324 @@
+/*
+ * 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;
+import java.util.Optional;
+import javax.annotation.Nullable;
+
+/**
+ * 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());
+    }
+
+    Map<String, ?> rawAllowedGrpcServices = JsonUtil.getObject(rawData, "allowed_grpc_services");
+    builder.implSpecificObject(parseImplSpecificObject(rawAllowedGrpcServices));
+
+    return builder;
+  }
+
+  protected Optional<Object> parseImplSpecificObject(
+      @Nullable Map<String, ?> rawAllowedGrpcServices)
+      throws XdsInitializationException {
+    return Optional.empty();
+  }
+
+  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/ConfiguredChannelCredentials.java b/xds/src/main/java/io/grpc/xds/client/ConfiguredChannelCredentials.java
new file mode 100644
index 00000000000..c6b9d774b4d
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/client/ConfiguredChannelCredentials.java
@@ -0,0 +1,48 @@
+/*
+ * 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 com.google.auto.value.AutoValue;
+import io.grpc.ChannelCredentials;
+import io.grpc.Internal;
+
+/**
+ * Composition of {@link ChannelCredentials} and {@link ChannelCredsConfig}.
+ */
+@Internal
+@AutoValue
+public abstract class ConfiguredChannelCredentials {
+  public abstract ChannelCredentials channelCredentials();
+
+  public abstract ChannelCredsConfig channelCredsConfig();
+
+  public static ConfiguredChannelCredentials create(ChannelCredentials creds,
+      ChannelCredsConfig config) {
+    return new AutoValue_ConfiguredChannelCredentials(creds, config);
+  }
+
+  /**
+   * Configuration for channel credentials.
+   */
+  @Internal
+  public interface ChannelCredsConfig {
+    /**
+     * Returns the type of the credentials.
+     */
+    String type();
+  }
+}
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..981db516e5b
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/client/ControlPlaneClient.java
@@ -0,0 +1,593 @@
+/*
+ * 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 && !adsStream.sentTypes.contains(resourceType)) {
+      // No subscription for this type on this server, and we have never sent a DiscoveryRequest
+      // of this type on the current stream — the server has no subscription state to clear.
+      //
+      // Per the ResourceStore contract in XdsClient.java, a null return means "no subscription";
+      // an empty collection means wildcard subscription, which is a real subscription and must
+      // not be skipped here.
+      //
+      // We track sent types per-stream rather than gating on `versions` because `versions` is
+      // only populated on ACK. If a watch is canceled after the initial DiscoveryRequest goes
+      // out but before any response is ACKed, `versions` would still have no entry for the
+      // type, and gating on it would suppress the empty unsubscribe — leaving the server with
+      // a stale subscription until the stream resets.
+      //
+      // Without this skip, sendDiscoveryRequests() iterates over every globally-subscribed
+      // resource type when a stream becomes ready and emits an empty DiscoveryRequest for types
+      // that have no subscription on this server. Per A47 (xDS Federation) servers may be
+      // authority-specific (e.g. an EDS-only control plane) and reject DiscoveryRequests for
+      // types they do not handle, tearing down the stream.
+      //
+      // Mirrors grpc-go's behavior in
+      // internal/xds/clients/xdsclient/ads_stream.go:sendExisting, which skips types with no
+      // subscription.
+      return;
+    }
+    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<>();
+    // Resource types for which a DiscoveryRequest has been sent on this stream. Used by
+    // adjustResourceSubscription() to decide whether an empty unsubscribe must be sent on the
+    // wire: the server only has subscription state to clear for types we have actually sent a
+    // request for on this stream. Cleared implicitly when the stream is replaced.
+    private final Set<XdsResourceType<?>> sentTypes = new HashSet<>();
+    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);
+      sentTypes.add(type);
+      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/EnvoyProtoData.java b/xds/src/main/java/io/grpc/xds/client/EnvoyProtoData.java
similarity index 81%
rename from xds/src/main/java/io/grpc/xds/EnvoyProtoData.java
rename to xds/src/main/java/io/grpc/xds/client/EnvoyProtoData.java
index 3fa822d26c6..e52fd8741e6 100644
--- a/xds/src/main/java/io/grpc/xds/EnvoyProtoData.java
+++ b/xds/src/main/java/io/grpc/xds/client/EnvoyProtoData.java
@@ -14,16 +14,18 @@
  * limitations under the License.
  */
 
-package io.grpc.xds;
+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;
@@ -45,8 +47,8 @@
  * gRPC. If the protobuf message contains invalid data, the conversion should fail and no object
  * should be instantiated.
  */
-// TODO(chengyuanzhang): put data types into smaller categories.
-final class EnvoyProtoData {
+@Internal
+public final class EnvoyProtoData {
 
   // Prevent instantiation.
   private EnvoyProtoData() {
@@ -129,7 +131,7 @@ public int hashCode() {
               userAgentVersion, clientFeatures);
     }
 
-    static final class Builder {
+    public static final class Builder {
       private String id = "";
       private String cluster = "";
       @Nullable
@@ -147,75 +149,86 @@ static final class Builder {
       private Builder() {
       }
 
-      Builder setId(String id) {
+      @VisibleForTesting
+      public Builder setId(String id) {
         this.id = checkNotNull(id, "id");
         return this;
       }
 
-      Builder setCluster(String cluster) {
+      @CanIgnoreReturnValue
+      public Builder setCluster(String cluster) {
         this.cluster = checkNotNull(cluster, "cluster");
         return this;
       }
 
-      Builder setMetadata(Map<String, ?> metadata) {
+      @CanIgnoreReturnValue
+      public Builder setMetadata(Map<String, ?> metadata) {
         this.metadata = checkNotNull(metadata, "metadata");
         return this;
       }
 
-      Builder setLocality(Locality locality) {
+      @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;
       }
 
-      Builder setBuildVersion(String buildVersion) {
+      @CanIgnoreReturnValue
+      public Builder setBuildVersion(String buildVersion) {
         this.buildVersion = checkNotNull(buildVersion, "buildVersion");
         return this;
       }
 
-      Builder setUserAgentName(String userAgentName) {
+      @CanIgnoreReturnValue
+      public Builder setUserAgentName(String userAgentName) {
         this.userAgentName = checkNotNull(userAgentName, "userAgentName");
         return this;
       }
 
-      Builder setUserAgentVersion(String userAgentVersion) {
+      @CanIgnoreReturnValue
+      public Builder setUserAgentVersion(String userAgentVersion) {
         this.userAgentVersion = checkNotNull(userAgentVersion, "userAgentVersion");
         return this;
       }
 
-      Builder addClientFeatures(String clientFeature) {
+      @CanIgnoreReturnValue
+      public Builder addClientFeatures(String clientFeature) {
         this.clientFeatures.add(checkNotNull(clientFeature, "clientFeature"));
         return this;
       }
 
-      Node build() {
+      public Node build() {
         return new Node(
             id, cluster, metadata, locality, listeningAddresses, buildVersion, userAgentName,
             userAgentVersion, clientFeatures);
       }
     }
 
-    static Builder newBuilder() {
+    public static Builder newBuilder() {
       return new Builder();
     }
 
-    Builder toBuilder() {
-      Builder builder = new Builder().setId(id).setCluster(cluster);
-      if (metadata != null) {
-        builder.setMetadata(metadata);
-      }
-      if (locality != null) {
-        builder.setLocality(locality);
-      }
+    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;
     }
 
-    String getId() {
+    public String getId() {
       return id;
     }
 
@@ -268,38 +281,6 @@ public io.envoyproxy.envoy.config.core.v3.Node toEnvoyProtoNode() {
       builder.addAllClientFeatures(clientFeatures);
       return builder.build();
     }
-
-    @SuppressWarnings("deprecation") // Deprecated v2 API setBuildVersion().
-    public io.envoyproxy.envoy.api.v2.core.Node toEnvoyProtoNodeV2() {
-      io.envoyproxy.envoy.api.v2.core.Node.Builder builder =
-          io.envoyproxy.envoy.api.v2.core.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.api.v2.core.Locality.newBuilder()
-                .setRegion(locality.region())
-                .setZone(locality.zone())
-                .setSubZone(locality.subZone()));
-      }
-      for (Address address : listeningAddresses) {
-        builder.addListeningAddresses(address.toEnvoyProtoAddressV2());
-      }
-      builder.setBuildVersion(buildVersion);
-      builder.setUserAgentName(userAgentName);
-      if (userAgentVersion != null) {
-        builder.setUserAgentVersion(userAgentVersion);
-      }
-      builder.addAllClientFeatures(clientFeatures);
-      return builder.build();
-    }
   }
 
   /**
@@ -358,13 +339,6 @@ io.envoyproxy.envoy.config.core.v3.Address toEnvoyProtoAddress() {
                   .setPortValue(port)).build();
     }
 
-    io.envoyproxy.envoy.api.v2.core.Address toEnvoyProtoAddressV2() {
-      return
-          io.envoyproxy.envoy.api.v2.core.Address.newBuilder().setSocketAddress(
-              io.envoyproxy.envoy.api.v2.core.SocketAddress.newBuilder().setAddress(address)
-                  .setPortValue(port)).build();
-    }
-
     @Override
     public String toString() {
       return MoreObjects.toStringHelper(this)
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/ReferenceCounted.java b/xds/src/main/java/io/grpc/xds/client/ReferenceCounted.java
similarity index 98%
rename from xds/src/main/java/io/grpc/xds/ReferenceCounted.java
rename to xds/src/main/java/io/grpc/xds/client/ReferenceCounted.java
index a67286ef53d..893b0358246 100644
--- a/xds/src/main/java/io/grpc/xds/ReferenceCounted.java
+++ b/xds/src/main/java/io/grpc/xds/client/ReferenceCounted.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.grpc.xds;
+package io.grpc.xds.client;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 import static com.google.common.base.Preconditions.checkState;
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/XdsInitializationException.java b/xds/src/main/java/io/grpc/xds/client/XdsInitializationException.java
similarity index 93%
rename from xds/src/main/java/io/grpc/xds/XdsInitializationException.java
rename to xds/src/main/java/io/grpc/xds/client/XdsInitializationException.java
index 6935840aedb..6d0408519ba 100644
--- a/xds/src/main/java/io/grpc/xds/XdsInitializationException.java
+++ b/xds/src/main/java/io/grpc/xds/client/XdsInitializationException.java
@@ -14,11 +14,14 @@
  * limitations under the License.
  */
 
-package io.grpc.xds;
+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;
 
diff --git a/xds/src/main/java/io/grpc/xds/XdsLogger.java b/xds/src/main/java/io/grpc/xds/client/XdsLogger.java
similarity index 77%
rename from xds/src/main/java/io/grpc/xds/XdsLogger.java
rename to xds/src/main/java/io/grpc/xds/client/XdsLogger.java
index 616602536f9..c71eceeffa1 100644
--- a/xds/src/main/java/io/grpc/xds/XdsLogger.java
+++ b/xds/src/main/java/io/grpc/xds/client/XdsLogger.java
@@ -14,9 +14,10 @@
  * limitations under the License.
  */
 
-package io.grpc.xds;
+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;
@@ -27,12 +28,13 @@
  * An xDS-specific logger for collecting xDS specific events. Information logged here goes
  * to the Java logger of this class.
  */
-final class XdsLogger {
-  private static final Logger logger = Logger.getLogger(XdsLogger.class.getName());
+@Internal
+public final class XdsLogger {
+  private static final Logger logger = Logger.getLogger("io.grpc.xds.XdsLogger");
 
   private final String prefix;
 
-  static XdsLogger withLogId(InternalLogId logId) {
+  public static XdsLogger withLogId(InternalLogId logId) {
     Preconditions.checkNotNull(logId, "logId");
     return new XdsLogger(logId.toString());
   }
@@ -45,7 +47,7 @@ private XdsLogger(String prefix) {
     this.prefix = Preconditions.checkNotNull(prefix, "prefix");
   }
 
-  boolean isLoggable(XdsLogLevel level) {
+  public boolean isLoggable(XdsLogLevel level) {
     Level javaLevel = toJavaLogLevel(level);
     return logger.isLoggable(javaLevel);
   }
@@ -55,7 +57,7 @@ void log(XdsLogLevel level, String msg) {
     logOnly(prefix, javaLevel, msg);
   }
 
-  void log(XdsLogLevel level, String messageFormat, Object... args) {
+  public void log(XdsLogLevel level, String messageFormat, Object... args) {
     Level javaLogLevel = toJavaLogLevel(level);
     if (logger.isLoggable(javaLogLevel)) {
       String msg = MessageFormat.format(messageFormat, args);
@@ -81,6 +83,10 @@ private static Level toJavaLogLevel(XdsLogLevel level) {
         return Level.FINE;
       case INFO:
         return Level.FINER;
+      case FORCE_INFO:
+        return Level.INFO;
+      case FORCE_WARNING:
+        return Level.WARNING;
       default:
         return Level.FINEST;
     }
@@ -89,6 +95,11 @@ private static Level toJavaLogLevel(XdsLogLevel level) {
   /**
    * 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 |
@@ -97,13 +108,17 @@ private static Level toJavaLogLevel(XdsLogLevel level) {
    * | INFO                | FINER             |
    * | WARNING             | FINE              |
    * | ERROR               | FINE              |
+   * | FORCE_INFO          | INFO              |
+   * | FORCE_WARNING       | WARNING           |
    * +---------------------+-------------------+
    * </pre>
    */
-  enum XdsLogLevel {
+  public enum XdsLogLevel {
     DEBUG,
     INFO,
     WARNING,
-    ERROR
+    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..91b77b05d01
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/internal/MatcherParser.java
@@ -0,0 +1,121 @@
+/*
+ * 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());
+    }
+  }
+
+  /** Translates envoy proto FractionalPercent to internal FractionMatcher. */
+  public static Matchers.FractionMatcher parseFractionMatcher(
+      io.envoyproxy.envoy.type.v3.FractionalPercent proto) {
+    int denominator;
+    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:
+        throw new IllegalArgumentException("Unknown denominator type: " + proto.getDenominator());
+    }
+    return Matchers.FractionMatcher.create(proto.getNumerator(), denominator);
+  }
+}
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/MetricReportUtils.java b/xds/src/main/java/io/grpc/xds/internal/MetricReportUtils.java
new file mode 100644
index 00000000000..4194cab76d3
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/internal/MetricReportUtils.java
@@ -0,0 +1,119 @@
+/*
+ * 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.xds.internal;
+
+import com.google.auto.value.AutoValue;
+import io.grpc.services.MetricReport;
+import java.util.Optional;
+import java.util.OptionalDouble;
+
+
+/**
+ * Utilities for parsing and resolving metrics from {@link MetricReport}.
+ */
+public final class MetricReportUtils {
+
+  private MetricReportUtils() {}
+
+  public enum MetricType {
+    CPU_UTILIZATION,
+    APPLICATION_UTILIZATION,
+    MEMORY_UTILIZATION,
+    UTILIZATION,
+    NAMED_METRICS,
+    INVALID
+  }
+
+  @AutoValue
+  public abstract static class ParsedMetricName {
+    public abstract MetricType getMetricType();
+
+    public abstract Optional<String> getKey();
+
+    public static ParsedMetricName create(MetricType metricType, Optional<String> key) {
+      return new AutoValue_MetricReportUtils_ParsedMetricName(metricType, key);
+    }
+
+    /**
+     * Pre-parses a custom metric name into a {@link ParsedMetricName}.
+     *
+     * @param name The custom metric name to parse.
+     * @return The parsed metric name.
+     */
+    public static ParsedMetricName parse(String name) {
+      if (name.equals("cpu_utilization")) {
+        return create(MetricType.CPU_UTILIZATION, Optional.empty());
+      }
+      if (name.equals("application_utilization")) {
+        return create(MetricType.APPLICATION_UTILIZATION, Optional.empty());
+      }
+      if (name.equals("mem_utilization")) {
+        return create(MetricType.MEMORY_UTILIZATION, Optional.empty());
+      }
+      if (name.startsWith("utilization.")) {
+        return create(MetricType.UTILIZATION, Optional.of(name.substring("utilization.".length())));
+      }
+      if (name.startsWith("named_metrics.")) {
+        return create(MetricType.NAMED_METRICS,
+            Optional.of(name.substring("named_metrics.".length())));
+      }
+      return create(MetricType.INVALID, Optional.empty());
+    }
+
+  }
+
+  /**
+   * Resolves a custom metric value for `parsedMetric`
+   * Returns OptionalDouble.empty() if the metric is absent or invalid.
+   *
+   * @param report The metric report to query.
+   * @param parsedMetric The parsed metric to lookup.
+   * @return The metric value wrapped in an OptionalDouble, or empty if absent.
+   */
+
+  public static OptionalDouble getMetricValue(MetricReport report, ParsedMetricName parsedMetric) {
+    switch (parsedMetric.getMetricType()) {
+      case CPU_UTILIZATION:
+        return OptionalDouble.of(report.getCpuUtilization());
+      case APPLICATION_UTILIZATION:
+        return OptionalDouble.of(report.getApplicationUtilization());
+      case MEMORY_UTILIZATION:
+        return OptionalDouble.of(report.getMemoryUtilization());
+      case UTILIZATION:
+        if (parsedMetric.getKey().isPresent()) {
+          String key = parsedMetric.getKey().get();
+          Double val = report.getUtilizationMetrics().get(key);
+          if (val != null) {
+            return OptionalDouble.of(val);
+          }
+        }
+        return OptionalDouble.empty();
+      case NAMED_METRICS:
+        if (parsedMetric.getKey().isPresent()) {
+          String key = parsedMetric.getKey().get();
+          Double val = report.getNamedMetrics().get(key);
+          if (val != null) {
+            return OptionalDouble.of(val);
+          }
+        }
+        return OptionalDouble.empty();
+      case INVALID:
+      default:
+        return OptionalDouble.empty();
+    }
+  }
+}
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/certprovider/CertProviderClientSslContextProvider.java b/xds/src/main/java/io/grpc/xds/internal/certprovider/CertProviderClientSslContextProvider.java
deleted file mode 100644
index 1dc7be1be33..00000000000
--- a/xds/src/main/java/io/grpc/xds/internal/certprovider/CertProviderClientSslContextProvider.java
+++ /dev/null
@@ -1,127 +0,0 @@
-/*
- * 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.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.envoyproxy.envoy.extensions.transport_sockets.tls.v3.CommonTlsContext.CombinedCertificateValidationContext;
-import io.grpc.Internal;
-import io.grpc.netty.GrpcSslContexts;
-import io.grpc.xds.Bootstrapper.CertificateProviderInfo;
-import io.grpc.xds.EnvoyServerProtoData.UpstreamTlsContext;
-import io.grpc.xds.internal.sds.trust.SdsTrustManagerFactory;
-import io.netty.handler.ssl.SslContextBuilder;
-import java.security.cert.CertStoreException;
-import java.security.cert.X509Certificate;
-import java.util.Map;
-
-/** A client SslContext provider using CertificateProviderInstance to fetch secrets. */
-@Internal
-public final class CertProviderClientSslContextProvider extends CertProviderSslContextProvider {
-
-  private CertProviderClientSslContextProvider(
-      Node node,
-      Map<String, CertificateProviderInfo> certProviders,
-      CommonTlsContext.CertificateProviderInstance certInstance,
-      CommonTlsContext.CertificateProviderInstance rootCertInstance,
-      CertificateValidationContext staticCertValidationContext,
-      UpstreamTlsContext upstreamTlsContext,
-      CertificateProviderStore certificateProviderStore) {
-    super(
-        node,
-        certProviders,
-        certInstance,
-        checkNotNull(rootCertInstance, "Client SSL requires rootCertInstance"),
-        staticCertValidationContext,
-        upstreamTlsContext,
-        certificateProviderStore);
-  }
-
-  @Override
-  protected final SslContextBuilder getSslContextBuilder(
-          CertificateValidationContext certificateValidationContextdationContext)
-      throws CertStoreException {
-    SslContextBuilder sslContextBuilder =
-        GrpcSslContexts.forClient()
-            .trustManager(
-                new SdsTrustManagerFactory(
-                    savedTrustedRoots.toArray(new X509Certificate[0]),
-                    certificateValidationContextdationContext));
-    if (isMtls()) {
-      sslContextBuilder.keyManager(savedKey, savedCertChain);
-    }
-    return sslContextBuilder;
-  }
-
-  /** Creates CertProviderClientSslContextProvider. */
-  @Internal
-  public static final class Factory {
-    private static final Factory DEFAULT_INSTANCE =
-        new Factory(CertificateProviderStore.getInstance());
-    private final CertificateProviderStore certificateProviderStore;
-
-    @VisibleForTesting public Factory(CertificateProviderStore certificateProviderStore) {
-      this.certificateProviderStore = certificateProviderStore;
-    }
-
-    public static Factory getInstance() {
-      return DEFAULT_INSTANCE;
-    }
-
-    /** Creates a {@link CertProviderClientSslContextProvider}. */
-    public CertProviderClientSslContextProvider getProvider(
-        UpstreamTlsContext upstreamTlsContext,
-        Node node,
-        Map<String, CertificateProviderInfo> certProviders) {
-      checkNotNull(upstreamTlsContext, "upstreamTlsContext");
-      CommonTlsContext commonTlsContext = upstreamTlsContext.getCommonTlsContext();
-      CommonTlsContext.CertificateProviderInstance rootCertInstance = null;
-      CertificateValidationContext staticCertValidationContext = null;
-      if (commonTlsContext.hasCombinedValidationContext()) {
-        CombinedCertificateValidationContext combinedValidationContext =
-            commonTlsContext.getCombinedValidationContext();
-        if (combinedValidationContext.hasValidationContextCertificateProviderInstance()) {
-          rootCertInstance =
-              combinedValidationContext.getValidationContextCertificateProviderInstance();
-        }
-        if (combinedValidationContext.hasDefaultValidationContext()) {
-          staticCertValidationContext = combinedValidationContext.getDefaultValidationContext();
-        }
-      } else if (commonTlsContext.hasValidationContextCertificateProviderInstance()) {
-        rootCertInstance = commonTlsContext.getValidationContextCertificateProviderInstance();
-      } else if (commonTlsContext.hasValidationContext()) {
-        staticCertValidationContext = commonTlsContext.getValidationContext();
-      }
-      CommonTlsContext.CertificateProviderInstance certInstance = null;
-      if (commonTlsContext.hasTlsCertificateCertificateProviderInstance()) {
-        certInstance = commonTlsContext.getTlsCertificateCertificateProviderInstance();
-      }
-      return new CertProviderClientSslContextProvider(
-          node,
-          certProviders,
-          certInstance,
-          rootCertInstance,
-          staticCertValidationContext,
-          upstreamTlsContext,
-          certificateProviderStore);
-    }
-  }
-}
diff --git a/xds/src/main/java/io/grpc/xds/internal/certprovider/CertProviderServerSslContextProvider.java b/xds/src/main/java/io/grpc/xds/internal/certprovider/CertProviderServerSslContextProvider.java
deleted file mode 100644
index 78e825f60fd..00000000000
--- a/xds/src/main/java/io/grpc/xds/internal/certprovider/CertProviderServerSslContextProvider.java
+++ /dev/null
@@ -1,130 +0,0 @@
-/*
- * 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.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.envoyproxy.envoy.extensions.transport_sockets.tls.v3.CommonTlsContext.CombinedCertificateValidationContext;
-import io.grpc.Internal;
-import io.grpc.netty.GrpcSslContexts;
-import io.grpc.xds.Bootstrapper.CertificateProviderInfo;
-import io.grpc.xds.EnvoyServerProtoData.DownstreamTlsContext;
-import io.grpc.xds.internal.sds.trust.SdsTrustManagerFactory;
-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.Map;
-
-/** A server SslContext provider using CertificateProviderInstance to fetch secrets. */
-@Internal
-public final class CertProviderServerSslContextProvider extends CertProviderSslContextProvider {
-
-  private CertProviderServerSslContextProvider(
-          Node node,
-          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 SslContextBuilder getSslContextBuilder(
-      CertificateValidationContext certificateValidationContextdationContext)
-      throws CertStoreException, CertificateException, IOException {
-    SslContextBuilder sslContextBuilder = SslContextBuilder.forServer(savedKey, savedCertChain);
-    setClientAuthValues(
-        sslContextBuilder,
-        isMtls()
-            ? new SdsTrustManagerFactory(
-                savedTrustedRoots.toArray(new X509Certificate[0]),
-                certificateValidationContextdationContext)
-            : null);
-    sslContextBuilder = GrpcSslContexts.configure(sslContextBuilder);
-    return sslContextBuilder;
-  }
-
-  /** Creates CertProviderServerSslContextProvider. */
-  @Internal
-  public static final class Factory {
-    private static final Factory DEFAULT_INSTANCE =
-        new Factory(CertificateProviderStore.getInstance());
-    private final CertificateProviderStore certificateProviderStore;
-
-    @VisibleForTesting public Factory(CertificateProviderStore certificateProviderStore) {
-      this.certificateProviderStore = certificateProviderStore;
-    }
-
-    public static Factory getInstance() {
-      return DEFAULT_INSTANCE;
-    }
-
-    /** Creates a {@link CertProviderServerSslContextProvider}. */
-    public CertProviderServerSslContextProvider getProvider(
-        DownstreamTlsContext downstreamTlsContext,
-        Node node,
-        Map<String, CertificateProviderInfo> certProviders) {
-      checkNotNull(downstreamTlsContext, "downstreamTlsContext");
-      CommonTlsContext commonTlsContext = downstreamTlsContext.getCommonTlsContext();
-      CommonTlsContext.CertificateProviderInstance rootCertInstance = null;
-      CertificateValidationContext staticCertValidationContext = null;
-      if (commonTlsContext.hasCombinedValidationContext()) {
-        CombinedCertificateValidationContext combinedValidationContext =
-            commonTlsContext.getCombinedValidationContext();
-        if (combinedValidationContext.hasValidationContextCertificateProviderInstance()) {
-          rootCertInstance =
-              combinedValidationContext.getValidationContextCertificateProviderInstance();
-        }
-        if (combinedValidationContext.hasDefaultValidationContext()) {
-          staticCertValidationContext = combinedValidationContext.getDefaultValidationContext();
-        }
-      } else if (commonTlsContext.hasValidationContextCertificateProviderInstance()) {
-        rootCertInstance = commonTlsContext.getValidationContextCertificateProviderInstance();
-      } else if (commonTlsContext.hasValidationContext()) {
-        staticCertValidationContext = commonTlsContext.getValidationContext();
-      }
-      CommonTlsContext.CertificateProviderInstance certInstance = null;
-      if (commonTlsContext.hasTlsCertificateCertificateProviderInstance()) {
-        certInstance = commonTlsContext.getTlsCertificateCertificateProviderInstance();
-      }
-      return new CertProviderServerSslContextProvider(
-          node,
-          certProviders,
-          certInstance,
-          rootCertInstance,
-          staticCertValidationContext,
-          downstreamTlsContext,
-          certificateProviderStore);
-    }
-  }
-}
diff --git a/xds/src/main/java/io/grpc/xds/internal/certprovider/CertProviderSslContextProvider.java b/xds/src/main/java/io/grpc/xds/internal/certprovider/CertProviderSslContextProvider.java
deleted file mode 100644
index eef5ee551e7..00000000000
--- a/xds/src/main/java/io/grpc/xds/internal/certprovider/CertProviderSslContextProvider.java
+++ /dev/null
@@ -1,155 +0,0 @@
-/*
- * 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.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.CertificateProviderInstance;
-import io.grpc.xds.Bootstrapper.CertificateProviderInfo;
-import io.grpc.xds.EnvoyServerProtoData.BaseTlsContext;
-import io.grpc.xds.internal.sds.DynamicSslContextProvider;
-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 CertificateProviderStore.Handle certHandle;
-  @Nullable private final CertificateProviderStore.Handle rootCertHandle;
-  @Nullable private final CertificateProviderInstance certInstance;
-  @Nullable private final CertificateProviderInstance rootCertInstance;
-  @Nullable protected PrivateKey savedKey;
-  @Nullable protected List<X509Certificate> savedCertChain;
-  @Nullable protected List<X509Certificate> savedTrustedRoots;
-
-  protected CertProviderSslContextProvider(
-      Node node,
-      Map<String, CertificateProviderInfo> certProviders,
-      CertificateProviderInstance certInstance,
-      CertificateProviderInstance rootCertInstance,
-      CertificateValidationContext staticCertValidationContext,
-      BaseTlsContext tlsContext,
-      CertificateProviderStore certificateProviderStore) {
-    super(tlsContext, staticCertValidationContext);
-    this.certInstance = certInstance;
-    this.rootCertInstance = rootCertInstance;
-    String certInstanceName = null;
-    if (certInstance != null && certInstance.isInitialized()) {
-      certInstanceName = certInstance.getInstanceName();
-      CertificateProviderInfo certProviderInstanceConfig =
-          getCertProviderConfig(certProviders, certInstanceName);
-      certHandle =
-          certificateProviderStore.createOrGetProvider(
-              certInstance.getCertificateName(),
-              certProviderInstanceConfig.getPluginName(),
-              certProviderInstanceConfig.getConfig(),
-              this,
-              true);
-    } else {
-      certHandle = null;
-    }
-    if (rootCertInstance != null
-        && rootCertInstance.isInitialized()
-        && !rootCertInstance.getInstanceName().equals(certInstanceName)) {
-      CertificateProviderInfo certProviderInstanceConfig =
-          getCertProviderConfig(certProviders, rootCertInstance.getInstanceName());
-      rootCertHandle =
-          certificateProviderStore.createOrGetProvider(
-              rootCertInstance.getCertificateName(),
-              certProviderInstanceConfig.getPluginName(),
-              certProviderInstanceConfig.getConfig(),
-              this,
-              true);
-    } else {
-      rootCertHandle = null;
-    }
-  }
-
-  private static CertificateProviderInfo getCertProviderConfig(
-      Map<String, CertificateProviderInfo> certProviders, String pluginInstanceName) {
-    return certProviders.get(pluginInstanceName);
-  }
-
-  @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();
-  }
-
-  private void updateSslContextWhenReady() {
-    if (isMtls()) {
-      if (savedKey != null && savedTrustedRoots != null) {
-        updateSslContext();
-        clearKeysAndCerts();
-      }
-    } else if (isClientSideTls()) {
-      if (savedTrustedRoots != null) {
-        updateSslContext();
-        clearKeysAndCerts();
-      }
-    } else if (isServerSideTls()) {
-      if (savedKey != null) {
-        updateSslContext();
-        clearKeysAndCerts();
-      }
-    }
-  }
-
-  private void clearKeysAndCerts() {
-    savedKey = null;
-    savedTrustedRoots = null;
-    savedCertChain = null;
-  }
-
-  protected final boolean isMtls() {
-    return certInstance != null && rootCertInstance != null;
-  }
-
-  protected final boolean isClientSideTls() {
-    return rootCertInstance != null && certInstance == null;
-  }
-
-  protected final boolean isServerSideTls() {
-    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();
-    }
-  }
-}
diff --git a/xds/src/main/java/io/grpc/xds/internal/certprovider/DynamicReloadingCertificateProvider.java b/xds/src/main/java/io/grpc/xds/internal/certprovider/DynamicReloadingCertificateProvider.java
deleted file mode 100644
index af7324f2581..00000000000
--- a/xds/src/main/java/io/grpc/xds/internal/certprovider/DynamicReloadingCertificateProvider.java
+++ /dev/null
@@ -1,225 +0,0 @@
-/*
- * 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.certprovider;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-import com.google.common.annotations.VisibleForTesting;
-import io.grpc.InternalLogId;
-import io.grpc.Status;
-import io.grpc.SynchronizationContext;
-import io.grpc.internal.TimeProvider;
-import io.grpc.xds.internal.sds.trust.CertificateUtils;
-import java.io.File;
-import java.io.FileInputStream;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.nio.file.Paths;
-import java.security.PrivateKey;
-import java.security.cert.X509Certificate;
-import java.util.Arrays;
-import java.util.concurrent.ScheduledExecutorService;
-import java.util.concurrent.TimeUnit;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-
-/** Implementation of {@link CertificateProvider} for dynamic reloading cert provider. */
-final class DynamicReloadingCertificateProvider extends CertificateProvider {
-  private static final Logger logger =
-      Logger.getLogger(DynamicReloadingCertificateProvider.class.getName());
-
-  private final SynchronizationContext syncContext;
-  private final ScheduledExecutorService scheduledExecutorService;
-  private final TimeProvider timeProvider;
-  private final Path directory;
-  private final String certFile;
-  private final String privateKeyFile;
-  private final String trustFile;
-  private final long refreshIntervalInSeconds;
-  @VisibleForTesting SynchronizationContext.ScheduledHandle scheduledHandle;
-  private Path lastModifiedTarget;
-
-  DynamicReloadingCertificateProvider(
-      DistributorWatcher watcher,
-      boolean notifyCertUpdates,
-      String directory,
-      String certFile,
-      String privateKeyFile,
-      String trustFile,
-      long refreshIntervalInSeconds,
-      ScheduledExecutorService scheduledExecutorService,
-      TimeProvider timeProvider) {
-    super(watcher, notifyCertUpdates);
-    this.scheduledExecutorService =
-        checkNotNull(scheduledExecutorService, "scheduledExecutorService");
-    this.timeProvider = checkNotNull(timeProvider, "timeProvider");
-    this.directory = Paths.get(checkNotNull(directory, "diretory"));
-    this.certFile = checkNotNull(certFile, "certFile");
-    this.privateKeyFile = checkNotNull(privateKeyFile, "privateKeyFile");
-    this.trustFile = checkNotNull(trustFile, "trustFile");
-    this.refreshIntervalInSeconds = refreshIntervalInSeconds;
-    this.syncContext = createSynchronizationContext(directory);
-  }
-
-  private SynchronizationContext createSynchronizationContext(String details) {
-    final InternalLogId logId =
-        InternalLogId.allocate("DynamicReloadingCertificateProvider", details);
-    return new SynchronizationContext(
-        new Thread.UncaughtExceptionHandler() {
-          private boolean panicMode;
-
-          @Override
-          public void uncaughtException(Thread t, Throwable e) {
-            logger.log(
-                Level.SEVERE,
-                "[" + logId + "] Uncaught exception in the SynchronizationContext. Panic!",
-                e);
-            panic(e);
-          }
-
-          void panic(final Throwable t) {
-            if (panicMode) {
-              // Preserve the first panic information
-              return;
-            }
-            panicMode = true;
-            close();
-          }
-        });
-  }
-
-  @Override
-  public void start() {
-    scheduleNextRefreshCertificate(/* delayInSeconds= */0);
-  }
-
-  @Override
-  public void close() {
-    if (scheduledHandle != null) {
-      scheduledHandle.cancel();
-      scheduledHandle = null;
-    }
-    getWatcher().close();
-  }
-
-  private void scheduleNextRefreshCertificate(long delayInSeconds) {
-    RefreshCertificateTask runnable = new RefreshCertificateTask();
-    scheduledHandle =
-        syncContext.schedule(runnable, delayInSeconds, TimeUnit.SECONDS, scheduledExecutorService);
-  }
-
-  @VisibleForTesting
-  void checkAndReloadCertificates() {
-    try {
-      Path targetPath = Files.readSymbolicLink(directory);
-      if (targetPath.equals(lastModifiedTarget)) {
-        return;
-      }
-      try (FileInputStream privateKeyStream =
-              new FileInputStream(new File(targetPath.toFile(), privateKeyFile));
-          FileInputStream certsStream =
-              new FileInputStream(new File(targetPath.toFile(), certFile));
-          FileInputStream caCertsStream =
-              new FileInputStream(new File(targetPath.toFile(), trustFile))) {
-        PrivateKey privateKey = CertificateUtils.getPrivateKey(privateKeyStream);
-        X509Certificate[] certs = CertificateUtils.toX509Certificates(certsStream);
-        X509Certificate[] caCerts = CertificateUtils.toX509Certificates(caCertsStream);
-        getWatcher().updateCertificate(privateKey, Arrays.asList(certs));
-        getWatcher().updateTrustedRoots(Arrays.asList(caCerts));
-      }
-      lastModifiedTarget = targetPath;
-    } catch (Throwable t) {
-      generateErrorIfCurrentCertExpired(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());
-  }
-
-  @VisibleForTesting
-  class RefreshCertificateTask implements Runnable {
-    @Override
-    public void run() {
-      checkAndReloadCertificates();
-    }
-  }
-
-  abstract static class Factory {
-    private static final Factory DEFAULT_INSTANCE =
-        new Factory() {
-          @Override
-          DynamicReloadingCertificateProvider create(
-              DistributorWatcher watcher,
-              boolean notifyCertUpdates,
-              String directory,
-              String certFile,
-              String privateKeyFile,
-              String trustFile,
-              long refreshIntervalInSeconds,
-              ScheduledExecutorService scheduledExecutorService,
-              TimeProvider timeProvider) {
-            return new DynamicReloadingCertificateProvider(
-                watcher,
-                notifyCertUpdates,
-                directory,
-                certFile,
-                privateKeyFile,
-                trustFile,
-                refreshIntervalInSeconds,
-                scheduledExecutorService,
-                timeProvider);
-          }
-        };
-
-    static Factory getInstance() {
-      return DEFAULT_INSTANCE;
-    }
-
-    abstract DynamicReloadingCertificateProvider create(
-        DistributorWatcher watcher,
-        boolean notifyCertUpdates,
-        String directory,
-        String certFile,
-        String privateKeyFile,
-        String trustFile,
-        long refreshIntervalInSeconds,
-        ScheduledExecutorService scheduledExecutorService,
-        TimeProvider timeProvider);
-  }
-}
diff --git a/xds/src/main/java/io/grpc/xds/internal/certprovider/DynamicReloadingCertificateProviderProvider.java b/xds/src/main/java/io/grpc/xds/internal/certprovider/DynamicReloadingCertificateProviderProvider.java
deleted file mode 100644
index 0d1cf509220..00000000000
--- a/xds/src/main/java/io/grpc/xds/internal/certprovider/DynamicReloadingCertificateProviderProvider.java
+++ /dev/null
@@ -1,136 +0,0 @@
-/*
- * 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.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 io.grpc.internal.JsonUtil;
-import io.grpc.internal.TimeProvider;
-import java.util.Map;
-import java.util.concurrent.Executors;
-import java.util.concurrent.ScheduledExecutorService;
-
-/**
- * Provider of {@link DynamicReloadingCertificateProvider}s.
- */
-final class DynamicReloadingCertificateProviderProvider implements CertificateProviderProvider {
-
-  private static final String DIRECTORY_KEY = "directory";
-  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 REFRESH_INTERVAL_KEY = "refresh-interval";
-
-  @VisibleForTesting static final long REFRESH_INTERVAL_DEFAULT = 600L;
-
-
-  static final String DYNAMIC_RELOADING_PROVIDER_NAME = "gke-cas-certs";
-
-  final DynamicReloadingCertificateProvider.Factory dynamicReloadingCertificateProviderFactory;
-  private final ScheduledExecutorServiceFactory scheduledExecutorServiceFactory;
-  private final TimeProvider timeProvider;
-
-  DynamicReloadingCertificateProviderProvider() {
-    this(
-        DynamicReloadingCertificateProvider.Factory.getInstance(),
-        ScheduledExecutorServiceFactory.DEFAULT_INSTANCE,
-        TimeProvider.SYSTEM_TIME_PROVIDER);
-  }
-
-  @VisibleForTesting
-  DynamicReloadingCertificateProviderProvider(
-      DynamicReloadingCertificateProvider.Factory dynamicReloadingCertificateProviderFactory,
-      ScheduledExecutorServiceFactory scheduledExecutorServiceFactory,
-      TimeProvider timeProvider) {
-    this.dynamicReloadingCertificateProviderFactory = dynamicReloadingCertificateProviderFactory;
-    this.scheduledExecutorServiceFactory = scheduledExecutorServiceFactory;
-    this.timeProvider = timeProvider;
-  }
-
-  @Override
-  public String getName() {
-    return DYNAMIC_RELOADING_PROVIDER_NAME;
-  }
-
-  @Override
-  public CertificateProvider createCertificateProvider(
-      Object config, CertificateProvider.DistributorWatcher watcher, boolean notifyCertUpdates) {
-
-    Config configObj = validateAndTranslateConfig(config);
-    return dynamicReloadingCertificateProviderFactory.create(
-        watcher,
-        notifyCertUpdates,
-        configObj.directory,
-        configObj.certFile,
-        configObj.keyFile,
-        configObj.rootFile,
-        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.directory = checkForNullAndGet(map, DIRECTORY_KEY);
-    configObj.certFile = checkForNullAndGet(map, CERT_FILE_KEY);
-    configObj.keyFile = checkForNullAndGet(map, KEY_FILE_KEY);
-    configObj.rootFile = checkForNullAndGet(map, ROOT_FILE_KEY);
-    configObj.refrehInterval = JsonUtil.getNumberAsLong(map, REFRESH_INTERVAL_KEY);
-    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("dynamicReloading" + "-%d")
-                    .setDaemon(true)
-                    .build());
-          }
-        };
-
-    abstract ScheduledExecutorService create();
-  }
-
-  /** POJO class for storing various config values. */
-  @VisibleForTesting
-  static class Config {
-    String directory;
-    String certFile;
-    String keyFile;
-    String rootFile;
-    Long refrehInterval;
-  }
-}
diff --git a/xds/src/main/java/io/grpc/xds/internal/certprovider/FileWatcherCertificateProvider.java b/xds/src/main/java/io/grpc/xds/internal/certprovider/FileWatcherCertificateProvider.java
deleted file mode 100644
index 6580185794c..00000000000
--- a/xds/src/main/java/io/grpc/xds/internal/certprovider/FileWatcherCertificateProvider.java
+++ /dev/null
@@ -1,249 +0,0 @@
-/*
- * 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.certprovider;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-import com.google.common.annotations.VisibleForTesting;
-import io.grpc.InternalLogId;
-import io.grpc.Status;
-import io.grpc.SynchronizationContext;
-import io.grpc.internal.TimeProvider;
-import io.grpc.xds.internal.sds.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.concurrent.ScheduledExecutorService;
-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 {
-  private static final Logger logger =
-      Logger.getLogger(FileWatcherCertificateProvider.class.getName());
-
-  private final SynchronizationContext syncContext;
-  private final ScheduledExecutorService scheduledExecutorService;
-  private final TimeProvider timeProvider;
-  private final Path certFile;
-  private final Path keyFile;
-  private final Path trustFile;
-  private final long refreshIntervalInSeconds;
-  @VisibleForTesting SynchronizationContext.ScheduledHandle scheduledHandle;
-  private FileTime lastModifiedTimeCert;
-  private FileTime lastModifiedTimeKey;
-  private FileTime lastModifiedTimeRoot;
-
-  FileWatcherCertificateProvider(
-      DistributorWatcher watcher,
-      boolean notifyCertUpdates,
-      String certFile,
-      String keyFile,
-      String trustFile,
-      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"));
-    this.trustFile = Paths.get(checkNotNull(trustFile, "trustFile"));
-    this.refreshIntervalInSeconds = refreshIntervalInSeconds;
-    this.syncContext = createSynchronizationContext(certFile);
-  }
-
-  private SynchronizationContext createSynchronizationContext(String details) {
-    final InternalLogId logId =
-        InternalLogId.allocate("DynamicReloadingCertificateProvider", details);
-    return new SynchronizationContext(
-        new Thread.UncaughtExceptionHandler() {
-          private boolean panicMode;
-
-          @Override
-          public void uncaughtException(Thread t, Throwable e) {
-            logger.log(
-                Level.SEVERE,
-                "[" + logId + "] Uncaught exception in the SynchronizationContext. Panic!",
-                e);
-            panic(e);
-          }
-
-          void panic(final Throwable t) {
-            if (panicMode) {
-              // Preserve the first panic information
-              return;
-            }
-            panicMode = true;
-            close();
-          }
-        });
-  }
-
-  @Override
-  public void start() {
-    scheduleNextRefreshCertificate(/* delayInSeconds= */0);
-  }
-
-  @Override
-  public void close() {
-    if (scheduledHandle != null) {
-      scheduledHandle.cancel();
-      scheduledHandle = null;
-    }
-    getWatcher().close();
-  }
-
-  private void scheduleNextRefreshCertificate(long delayInSeconds) {
-    RefreshCertificateTask runnable = new RefreshCertificateTask();
-    scheduledHandle =
-        syncContext.schedule(runnable, delayInSeconds, TimeUnit.SECONDS, scheduledExecutorService);
-  }
-
-  @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)) {
-            return;
-          }
-          if (!currentKeyTime2.equals(currentKeyTime)) {
-            return;
-          }
-          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 {
-        FileTime currentRootTime = Files.getLastModifiedTime(trustFile);
-        if (currentRootTime.equals(lastModifiedTimeRoot)) {
-          return;
-        }
-        byte[] rootFileContents = Files.readAllBytes(trustFile);
-        FileTime currentRootTime2 = Files.getLastModifiedTime(trustFile);
-        if (!currentRootTime2.equals(currentRootTime)) {
-          return;
-        }
-        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());
-  }
-
-  @VisibleForTesting
-  class RefreshCertificateTask implements Runnable {
-    @Override
-    public void run() {
-      checkAndReloadCertificates();
-    }
-  }
-
-  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,
-              long refreshIntervalInSeconds,
-              ScheduledExecutorService scheduledExecutorService,
-              TimeProvider timeProvider) {
-            return new FileWatcherCertificateProvider(
-                watcher,
-                notifyCertUpdates,
-                certFile,
-                keyFile,
-                trustFile,
-                refreshIntervalInSeconds,
-                scheduledExecutorService,
-                timeProvider);
-          }
-        };
-
-    static Factory getInstance() {
-      return DEFAULT_INSTANCE;
-    }
-
-    abstract FileWatcherCertificateProvider create(
-        DistributorWatcher watcher,
-        boolean notifyCertUpdates,
-        String certFile,
-        String keyFile,
-        String trustFile,
-        long refreshIntervalInSeconds,
-        ScheduledExecutorService scheduledExecutorService,
-        TimeProvider timeProvider);
-  }
-}
diff --git a/xds/src/main/java/io/grpc/xds/internal/certprovider/MeshCaCertificateProvider.java b/xds/src/main/java/io/grpc/xds/internal/certprovider/MeshCaCertificateProvider.java
deleted file mode 100644
index dee649a613e..00000000000
--- a/xds/src/main/java/io/grpc/xds/internal/certprovider/MeshCaCertificateProvider.java
+++ /dev/null
@@ -1,500 +0,0 @@
-/*
- * 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.certprovider;
-
-import static com.google.common.base.Preconditions.checkArgument;
-import static com.google.common.base.Preconditions.checkNotNull;
-import static io.grpc.Status.Code.ABORTED;
-import static io.grpc.Status.Code.CANCELLED;
-import static io.grpc.Status.Code.DEADLINE_EXCEEDED;
-import static io.grpc.Status.Code.INTERNAL;
-import static io.grpc.Status.Code.RESOURCE_EXHAUSTED;
-import static io.grpc.Status.Code.UNAVAILABLE;
-import static io.grpc.Status.Code.UNKNOWN;
-import static java.nio.charset.StandardCharsets.UTF_8;
-
-import com.google.auth.oauth2.GoogleCredentials;
-import com.google.common.annotations.VisibleForTesting;
-import com.google.common.collect.ImmutableList;
-import com.google.protobuf.Duration;
-import com.google.security.meshca.v1.MeshCertificateRequest;
-import com.google.security.meshca.v1.MeshCertificateResponse;
-import com.google.security.meshca.v1.MeshCertificateServiceGrpc;
-import io.grpc.CallOptions;
-import io.grpc.Channel;
-import io.grpc.ClientCall;
-import io.grpc.ClientInterceptor;
-import io.grpc.ForwardingClientCall;
-import io.grpc.Grpc;
-import io.grpc.InternalLogId;
-import io.grpc.ManagedChannel;
-import io.grpc.Metadata;
-import io.grpc.MethodDescriptor;
-import io.grpc.Status;
-import io.grpc.SynchronizationContext;
-import io.grpc.TlsChannelCredentials;
-import io.grpc.auth.MoreCallCredentials;
-import io.grpc.internal.BackoffPolicy;
-import io.grpc.internal.TimeProvider;
-import io.grpc.xds.internal.sds.trust.CertificateUtils;
-import java.io.ByteArrayInputStream;
-import java.io.IOException;
-import java.io.StringWriter;
-import java.security.KeyPair;
-import java.security.KeyPairGenerator;
-import java.security.NoSuchAlgorithmException;
-import java.security.cert.CertificateException;
-import java.security.cert.X509Certificate;
-import java.util.ArrayList;
-import java.util.EnumSet;
-import java.util.List;
-import java.util.UUID;
-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;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-import javax.security.auth.x500.X500Principal;
-import org.bouncycastle.openssl.jcajce.JcaPEMWriter;
-import org.bouncycastle.operator.ContentSigner;
-import org.bouncycastle.operator.OperatorCreationException;
-import org.bouncycastle.operator.jcajce.JcaContentSignerBuilder;
-import org.bouncycastle.pkcs.PKCS10CertificationRequest;
-import org.bouncycastle.pkcs.PKCS10CertificationRequestBuilder;
-import org.bouncycastle.pkcs.jcajce.JcaPKCS10CertificationRequestBuilder;
-import org.bouncycastle.util.io.pem.PemObject;
-
-/** Implementation of {@link CertificateProvider} for the Google Mesh CA. */
-final class MeshCaCertificateProvider extends CertificateProvider {
-  private static final Logger logger = Logger.getLogger(MeshCaCertificateProvider.class.getName());
-
-  MeshCaCertificateProvider(
-      DistributorWatcher watcher,
-      boolean notifyCertUpdates,
-      String meshCaUrl,
-      String zone,
-      long validitySeconds,
-      int keySize,
-      String unused, //TODO(sanjaypujare): to remove during refactoring
-      String signatureAlg, MeshCaChannelFactory meshCaChannelFactory,
-      BackoffPolicy.Provider backoffPolicyProvider,
-      long renewalGracePeriodSeconds,
-      int maxRetryAttempts,
-      GoogleCredentials oauth2Creds,
-      ScheduledExecutorService scheduledExecutorService,
-      TimeProvider timeProvider,
-      long rpcTimeoutMillis) {
-    super(watcher, notifyCertUpdates);
-    this.meshCaUrl = checkNotNull(meshCaUrl, "meshCaUrl");
-    checkArgument(
-        validitySeconds > INITIAL_DELAY_SECONDS,
-        "validitySeconds must be greater than " + INITIAL_DELAY_SECONDS);
-    this.validitySeconds = validitySeconds;
-    this.keySize = keySize;
-    this.signatureAlg = checkNotNull(signatureAlg, "signatureAlg");
-    this.meshCaChannelFactory = checkNotNull(meshCaChannelFactory, "meshCaChannelFactory");
-    this.backoffPolicyProvider = checkNotNull(backoffPolicyProvider, "backoffPolicyProvider");
-    checkArgument(
-        renewalGracePeriodSeconds > 0L && renewalGracePeriodSeconds < validitySeconds,
-        "renewalGracePeriodSeconds should be between 0 and " + validitySeconds);
-    this.renewalGracePeriodSeconds = renewalGracePeriodSeconds;
-    checkArgument(maxRetryAttempts >= 0, "maxRetryAttempts must be >= 0");
-    this.maxRetryAttempts = maxRetryAttempts;
-    this.oauth2Creds = checkNotNull(oauth2Creds, "oauth2Creds");
-    this.scheduledExecutorService =
-        checkNotNull(scheduledExecutorService, "scheduledExecutorService");
-    this.timeProvider = checkNotNull(timeProvider, "timeProvider");
-    this.headerInterceptor = new ZoneInfoClientInterceptor(checkNotNull(zone, "zone"));
-    this.syncContext = createSynchronizationContext(meshCaUrl);
-    this.rpcTimeoutMillis = rpcTimeoutMillis;
-  }
-
-  private SynchronizationContext createSynchronizationContext(String details) {
-    final InternalLogId logId = InternalLogId.allocate("MeshCaCertificateProvider", details);
-    return new SynchronizationContext(
-        new Thread.UncaughtExceptionHandler() {
-          private boolean panicMode;
-
-          @Override
-          public void uncaughtException(Thread t, Throwable e) {
-            logger.log(
-                Level.SEVERE,
-                "[" + logId + "] Uncaught exception in the SynchronizationContext. Panic!",
-                e);
-            panic(e);
-          }
-
-          void panic(final Throwable t) {
-            if (panicMode) {
-              // Preserve the first panic information
-              return;
-            }
-            panicMode = true;
-            close();
-          }
-        });
-  }
-
-  @Override
-  public void start() {
-    scheduleNextRefreshCertificate(INITIAL_DELAY_SECONDS);
-  }
-
-  @Override
-  public void close() {
-    if (scheduledHandle != null) {
-      scheduledHandle.cancel();
-      scheduledHandle = null;
-    }
-    getWatcher().close();
-  }
-
-  private void scheduleNextRefreshCertificate(long delayInSeconds) {
-    if (scheduledHandle != null && scheduledHandle.isPending()) {
-      logger.log(Level.SEVERE, "Pending task found: inconsistent state in scheduledHandle!");
-      scheduledHandle.cancel();
-    }
-    RefreshCertificateTask runnable = new RefreshCertificateTask();
-    scheduledHandle = syncContext.schedule(
-            runnable, delayInSeconds, TimeUnit.SECONDS, scheduledExecutorService);
-  }
-
-  @VisibleForTesting
-  void refreshCertificate()
-      throws NoSuchAlgorithmException, IOException, OperatorCreationException {
-    long refreshDelaySeconds = computeRefreshSecondsFromCurrentCertExpiry();
-    ManagedChannel channel = meshCaChannelFactory.createChannel(meshCaUrl);
-    try {
-      String uniqueReqIdForAllRetries = UUID.randomUUID().toString();
-      Duration duration = Duration.newBuilder().setSeconds(validitySeconds).build();
-      KeyPair keyPair = generateKeyPair();
-      String csr = generateCsr(keyPair);
-      MeshCertificateServiceGrpc.MeshCertificateServiceBlockingStub stub =
-          createStubToMeshCa(channel);
-      List<X509Certificate> x509Chain = makeRequestWithRetries(stub, uniqueReqIdForAllRetries,
-          duration, csr);
-      if (x509Chain != null) {
-        refreshDelaySeconds =
-            computeDelaySecondsToCertExpiry(x509Chain.get(0)) - renewalGracePeriodSeconds;
-        getWatcher().updateCertificate(keyPair.getPrivate(), x509Chain);
-        getWatcher().updateTrustedRoots(ImmutableList.of(x509Chain.get(x509Chain.size() - 1)));
-      }
-    } finally {
-      shutdownChannel(channel);
-      scheduleNextRefreshCertificate(refreshDelaySeconds);
-    }
-  }
-
-  private MeshCertificateServiceGrpc.MeshCertificateServiceBlockingStub createStubToMeshCa(
-      ManagedChannel channel) {
-    return MeshCertificateServiceGrpc
-        .newBlockingStub(channel)
-        .withCallCredentials(MoreCallCredentials.from(oauth2Creds))
-        .withInterceptors(headerInterceptor);
-  }
-
-  private List<X509Certificate> makeRequestWithRetries(
-      MeshCertificateServiceGrpc.MeshCertificateServiceBlockingStub stub,
-      String reqId,
-      Duration duration,
-      String csr) {
-    MeshCertificateRequest request =
-        MeshCertificateRequest.newBuilder()
-            .setValidity(duration)
-            .setCsr(csr)
-            .setRequestId(reqId)
-            .build();
-
-    BackoffPolicy backoffPolicy = backoffPolicyProvider.get();
-    Throwable lastException = null;
-    for (int i = 0; i <= maxRetryAttempts; i++) {
-      try {
-        MeshCertificateResponse response =
-            stub.withDeadlineAfter(rpcTimeoutMillis, TimeUnit.MILLISECONDS)
-                .createCertificate(request);
-        return getX509CertificatesFromResponse(response);
-      } catch (Throwable t) {
-        if (!retriable(t)) {
-          generateErrorIfCurrentCertExpired(t);
-          return null;
-        }
-        lastException = t;
-        sleepForNanos(backoffPolicy.nextBackoffNanos());
-      }
-    }
-    generateErrorIfCurrentCertExpired(lastException);
-    return null;
-  }
-
-  private void sleepForNanos(long nanos) {
-    ScheduledFuture<?> future = scheduledExecutorService.schedule(new Runnable() {
-      @Override
-      public void run() {
-        // do nothing
-      }
-    }, nanos, TimeUnit.NANOSECONDS);
-    try {
-      future.get(nanos, TimeUnit.NANOSECONDS);
-    } catch (InterruptedException ie) {
-      logger.log(Level.SEVERE, "Inside sleep", ie);
-      Thread.currentThread().interrupt();
-    } catch (ExecutionException | TimeoutException ex) {
-      logger.log(Level.SEVERE, "Inside sleep", ex);
-    }
-  }
-
-  private static boolean retriable(Throwable t) {
-    return RETRIABLE_CODES.contains(Status.fromThrowable(t).getCode());
-  }
-
-  private void generateErrorIfCurrentCertExpired(Throwable t) {
-    X509Certificate currentCert = getWatcher().getLastIdentityCert();
-    if (currentCert != null) {
-      long delaySeconds = computeDelaySecondsToCertExpiry(currentCert);
-      if (delaySeconds > INITIAL_DELAY_SECONDS) {
-        return;
-      }
-      getWatcher().clearValues();
-    }
-    getWatcher().onError(Status.fromThrowable(t));
-  }
-
-  private KeyPair generateKeyPair() throws NoSuchAlgorithmException {
-    KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
-    keyPairGenerator.initialize(keySize);
-    return keyPairGenerator.generateKeyPair();
-  }
-
-  private String generateCsr(KeyPair pair) throws IOException, OperatorCreationException {
-    PKCS10CertificationRequestBuilder p10Builder =
-        new JcaPKCS10CertificationRequestBuilder(
-            new X500Principal("CN=EXAMPLE.COM"), pair.getPublic());
-    JcaContentSignerBuilder csBuilder = new JcaContentSignerBuilder(signatureAlg);
-    ContentSigner signer = csBuilder.build(pair.getPrivate());
-    PKCS10CertificationRequest csr = p10Builder.build(signer);
-    PemObject pemObject = new PemObject("NEW CERTIFICATE REQUEST", csr.getEncoded());
-    try (StringWriter str = new StringWriter()) {
-      try (JcaPEMWriter pemWriter = new JcaPEMWriter(str)) {
-        pemWriter.writeObject(pemObject);
-      }
-      return str.toString();
-    }
-  }
-
-  /** Compute refresh interval as half of interval to current cert expiry. */
-  private long computeRefreshSecondsFromCurrentCertExpiry() {
-    X509Certificate lastCert = getWatcher().getLastIdentityCert();
-    if (lastCert == null) {
-      return INITIAL_DELAY_SECONDS;
-    }
-    long delayToCertExpirySeconds = computeDelaySecondsToCertExpiry(lastCert) / 2;
-    return Math.max(delayToCertExpirySeconds, INITIAL_DELAY_SECONDS);
-  }
-
-  @SuppressWarnings("JdkObsolete")
-  private long computeDelaySecondsToCertExpiry(X509Certificate lastCert) {
-    checkNotNull(lastCert, "lastCert");
-    return TimeUnit.NANOSECONDS.toSeconds(
-        TimeUnit.MILLISECONDS.toNanos(lastCert.getNotAfter().getTime()) - timeProvider
-            .currentTimeNanos());
-  }
-
-  private static void shutdownChannel(ManagedChannel channel) {
-    channel.shutdown();
-    try {
-      channel.awaitTermination(10, TimeUnit.SECONDS);
-    } catch (InterruptedException ex) {
-      logger.log(Level.SEVERE, "awaiting channel Termination", ex);
-      channel.shutdownNow();
-      Thread.currentThread().interrupt();
-    }
-  }
-
-  private List<X509Certificate> getX509CertificatesFromResponse(
-      MeshCertificateResponse response) throws CertificateException, IOException {
-    List<String> certChain = response.getCertChainList();
-    List<X509Certificate> x509Chain = new ArrayList<>(certChain.size());
-    for (String certString : certChain) {
-      try (ByteArrayInputStream bais = new ByteArrayInputStream(certString.getBytes(UTF_8))) {
-        x509Chain.add(CertificateUtils.toX509Certificate(bais));
-      }
-    }
-    return x509Chain;
-  }
-
-  @VisibleForTesting
-  class RefreshCertificateTask implements Runnable {
-    @Override
-    public void run() {
-      try {
-        refreshCertificate();
-      } catch (NoSuchAlgorithmException | OperatorCreationException | IOException ex) {
-        logger.log(Level.SEVERE, "refreshing certificate", ex);
-      }
-    }
-  }
-
-  /** Factory for creating channels to MeshCA sever. */
-  abstract static class MeshCaChannelFactory {
-
-    private static final MeshCaChannelFactory DEFAULT_INSTANCE =
-        new MeshCaChannelFactory() {
-
-          /** Creates a channel to the URL in the given list. */
-          @Override
-          ManagedChannel createChannel(String serverUri) {
-            checkArgument(serverUri != null && !serverUri.isEmpty(), "serverUri is null/empty!");
-            logger.log(Level.INFO, "Creating channel to {0}", serverUri);
-
-            return Grpc.newChannelBuilder(serverUri, TlsChannelCredentials.create())
-                .keepAliveTime(1, TimeUnit.MINUTES)
-                .build();
-          }
-        };
-
-    static MeshCaChannelFactory getInstance() {
-      return DEFAULT_INSTANCE;
-    }
-
-    /**
-     * Creates a channel to the server.
-     */
-    abstract ManagedChannel createChannel(String serverUri);
-  }
-
-  /** Factory for creating channels to MeshCA sever. */
-  abstract static class Factory {
-    private static final Factory DEFAULT_INSTANCE =
-        new Factory() {
-
-          @Override
-          MeshCaCertificateProvider create(
-              DistributorWatcher watcher,
-              boolean notifyCertUpdates,
-              String meshCaUrl,
-              String zone,
-              long validitySeconds,
-              int keySize,
-              String alg,
-              String signatureAlg,
-              MeshCaChannelFactory meshCaChannelFactory,
-              BackoffPolicy.Provider backoffPolicyProvider,
-              long renewalGracePeriodSeconds,
-              int maxRetryAttempts,
-              GoogleCredentials oauth2Creds,
-              ScheduledExecutorService scheduledExecutorService,
-              TimeProvider timeProvider,
-              long rpcTimeoutMillis) {
-            return new MeshCaCertificateProvider(
-                watcher,
-                notifyCertUpdates,
-                meshCaUrl,
-                zone,
-                validitySeconds,
-                keySize,
-                alg,
-                signatureAlg,
-                meshCaChannelFactory,
-                backoffPolicyProvider,
-                renewalGracePeriodSeconds,
-                maxRetryAttempts,
-                oauth2Creds,
-                scheduledExecutorService,
-                timeProvider,
-                rpcTimeoutMillis);
-          }
-        };
-
-    static Factory getInstance() {
-      return DEFAULT_INSTANCE;
-    }
-
-    abstract MeshCaCertificateProvider create(
-        DistributorWatcher watcher,
-        boolean notifyCertUpdates,
-        String meshCaUrl,
-        String zone,
-        long validitySeconds,
-        int keySize,
-        String alg,
-        String signatureAlg,
-        MeshCaChannelFactory meshCaChannelFactory,
-        BackoffPolicy.Provider backoffPolicyProvider,
-        long renewalGracePeriodSeconds,
-        int maxRetryAttempts,
-        GoogleCredentials oauth2Creds,
-        ScheduledExecutorService scheduledExecutorService,
-        TimeProvider timeProvider,
-        long rpcTimeoutMillis);
-  }
-
-  private class ZoneInfoClientInterceptor implements ClientInterceptor {
-    private final String zone;
-
-    ZoneInfoClientInterceptor(String zone) {
-      this.zone = zone;
-    }
-
-    @Override
-    public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
-        MethodDescriptor<ReqT, RespT> method, CallOptions callOptions, Channel next) {
-      return new ForwardingClientCall.SimpleForwardingClientCall<ReqT, RespT>(
-          next.newCall(method, callOptions)) {
-
-        @Override
-        public void start(Listener<RespT> responseListener, Metadata headers) {
-          headers.put(KEY_FOR_ZONE_INFO, "location=locations/" + zone);
-          super.start(responseListener, headers);
-        }
-      };
-    }
-  }
-
-  @VisibleForTesting
-  static final Metadata.Key<String> KEY_FOR_ZONE_INFO =
-      Metadata.Key.of("x-goog-request-params", Metadata.ASCII_STRING_MARSHALLER);
-  @VisibleForTesting
-  static final long INITIAL_DELAY_SECONDS = 4L;
-
-  private static final EnumSet<Status.Code> RETRIABLE_CODES =
-      EnumSet.of(
-          CANCELLED,
-          UNKNOWN,
-          DEADLINE_EXCEEDED,
-          RESOURCE_EXHAUSTED,
-          ABORTED,
-          INTERNAL,
-          UNAVAILABLE);
-
-  private final SynchronizationContext syncContext;
-  private final ScheduledExecutorService scheduledExecutorService;
-  private final int maxRetryAttempts;
-  private final ZoneInfoClientInterceptor headerInterceptor;
-  private final BackoffPolicy.Provider backoffPolicyProvider;
-  private final String meshCaUrl;
-  private final long validitySeconds;
-  private final long renewalGracePeriodSeconds;
-  private final int keySize;
-  private final String signatureAlg;
-  private final GoogleCredentials oauth2Creds;
-  private final TimeProvider timeProvider;
-  private final MeshCaChannelFactory meshCaChannelFactory;
-  @VisibleForTesting SynchronizationContext.ScheduledHandle scheduledHandle;
-  private final long rpcTimeoutMillis;
-}
diff --git a/xds/src/main/java/io/grpc/xds/internal/certprovider/MeshCaCertificateProviderProvider.java b/xds/src/main/java/io/grpc/xds/internal/certprovider/MeshCaCertificateProviderProvider.java
deleted file mode 100644
index a605f15ae62..00000000000
--- a/xds/src/main/java/io/grpc/xds/internal/certprovider/MeshCaCertificateProviderProvider.java
+++ /dev/null
@@ -1,286 +0,0 @@
-/*
- * 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.certprovider;
-
-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.JsonUtil.getObject;
-
-import com.google.common.annotations.VisibleForTesting;
-import com.google.common.util.concurrent.ThreadFactoryBuilder;
-import io.grpc.internal.BackoffPolicy;
-import io.grpc.internal.ExponentialBackoffPolicy;
-import io.grpc.internal.JsonUtil;
-import io.grpc.internal.TimeProvider;
-import io.grpc.xds.internal.sts.StsCredentials;
-import java.util.List;
-import java.util.Map;
-import java.util.concurrent.Executors;
-import java.util.concurrent.ScheduledExecutorService;
-import java.util.concurrent.TimeUnit;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-
-/**
- * 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.
- */
-final class MeshCaCertificateProviderProvider implements CertificateProviderProvider {
-
-  private static final String SERVER_CONFIG_KEY = "server";
-  private static final String MESHCA_URL_KEY = "target_uri";
-  private static final String RPC_TIMEOUT_SECONDS_KEY = "time_out";
-  private static final String GKECLUSTER_URL_KEY = "location";
-  private static final String CERT_VALIDITY_SECONDS_KEY = "certificate_lifetime";
-  private static final String RENEWAL_GRACE_PERIOD_SECONDS_KEY = "renewal_grace_period";
-  private static final String KEY_ALGO_KEY = "key_type";  // aka keyType
-  private static final String KEY_SIZE_KEY = "key_size";
-  private static final String STS_SERVICE_KEY = "sts_service";
-  private static final String TOKEN_EXCHANGE_SERVICE_KEY = "token_exchange_service";
-  private static final String GKE_SA_JWT_LOCATION_KEY = "subject_token_path";
-
-  @VisibleForTesting static final String MESHCA_URL_DEFAULT = "meshca.googleapis.com";
-  @VisibleForTesting static final long RPC_TIMEOUT_SECONDS_DEFAULT = 5L;
-  @VisibleForTesting static final long CERT_VALIDITY_SECONDS_DEFAULT = 9L * 3600L;
-  @VisibleForTesting static final long RENEWAL_GRACE_PERIOD_SECONDS_DEFAULT = 1L * 3600L;
-  @VisibleForTesting static final String KEY_ALGO_DEFAULT = "RSA";  // aka keyType
-  @VisibleForTesting static final int KEY_SIZE_DEFAULT = 2048;
-  @VisibleForTesting static final String SIGNATURE_ALGO_DEFAULT = "SHA256withRSA";
-  @VisibleForTesting static final int MAX_RETRY_ATTEMPTS_DEFAULT = 3;
-  @VisibleForTesting
-  static final String STS_URL_DEFAULT = "https://securetoken.googleapis.com/v1/identitybindingtoken";
-
-  @VisibleForTesting
-  static final long RPC_TIMEOUT_SECONDS = 10L;
-
-  private static final Pattern CLUSTER_URL_PATTERN = Pattern
-      .compile(".*/projects/(.*)/(?:locations|zones)/(.*)/clusters/.*");
-
-  private static final String TRUST_DOMAIN_SUFFIX = ".svc.id.goog";
-  private static final String AUDIENCE_PREFIX = "identitynamespace:";
-  static final String MESH_CA_NAME = "meshCA";
-
-  final StsCredentials.Factory stsCredentialsFactory;
-  final MeshCaCertificateProvider.MeshCaChannelFactory meshCaChannelFactory;
-  final BackoffPolicy.Provider backoffPolicyProvider;
-  final MeshCaCertificateProvider.Factory meshCaCertificateProviderFactory;
-  final ScheduledExecutorServiceFactory scheduledExecutorServiceFactory;
-  final TimeProvider timeProvider;
-
-  MeshCaCertificateProviderProvider() {
-    this(
-        StsCredentials.Factory.getInstance(),
-        MeshCaCertificateProvider.MeshCaChannelFactory.getInstance(),
-        new ExponentialBackoffPolicy.Provider(),
-        MeshCaCertificateProvider.Factory.getInstance(),
-        ScheduledExecutorServiceFactory.DEFAULT_INSTANCE,
-        TimeProvider.SYSTEM_TIME_PROVIDER);
-  }
-
-  @VisibleForTesting
-  MeshCaCertificateProviderProvider(
-      StsCredentials.Factory stsCredentialsFactory,
-      MeshCaCertificateProvider.MeshCaChannelFactory meshCaChannelFactory,
-      BackoffPolicy.Provider backoffPolicyProvider,
-      MeshCaCertificateProvider.Factory meshCaCertificateProviderFactory,
-      ScheduledExecutorServiceFactory scheduledExecutorServiceFactory,
-      TimeProvider timeProvider) {
-    this.stsCredentialsFactory = stsCredentialsFactory;
-    this.meshCaChannelFactory = meshCaChannelFactory;
-    this.backoffPolicyProvider = backoffPolicyProvider;
-    this.meshCaCertificateProviderFactory = meshCaCertificateProviderFactory;
-    this.scheduledExecutorServiceFactory = scheduledExecutorServiceFactory;
-    this.timeProvider = timeProvider;
-  }
-
-  @Override
-  public String getName() {
-    return MESH_CA_NAME;
-  }
-
-  @Override
-  public CertificateProvider createCertificateProvider(
-      Object config, CertificateProvider.DistributorWatcher watcher, boolean notifyCertUpdates) {
-
-    Config configObj = validateAndTranslateConfig(config);
-
-    // Construct audience from project and gkeClusterUrl
-    String audience =
-        AUDIENCE_PREFIX + configObj.project + TRUST_DOMAIN_SUFFIX + ":" + configObj.gkeClusterUrl;
-    StsCredentials stsCredentials = stsCredentialsFactory
-        .create(configObj.stsUrl, audience, configObj.gkeSaJwtLocation);
-
-    return meshCaCertificateProviderFactory.create(
-        watcher,
-        notifyCertUpdates,
-        configObj.meshCaUrl,
-        configObj.zone,
-        configObj.certValiditySeconds,
-        configObj.keySize,
-        configObj.keyAlgo,
-        configObj.signatureAlgo,
-        meshCaChannelFactory,
-        backoffPolicyProvider,
-        configObj.renewalGracePeriodSeconds,
-        configObj.maxRetryAttempts,
-        stsCredentials,
-        scheduledExecutorServiceFactory.create(configObj.meshCaUrl),
-        timeProvider,
-        TimeUnit.SECONDS.toMillis(RPC_TIMEOUT_SECONDS));
-  }
-
-  private static Config validateAndTranslateConfig(Object config) {
-    // TODO(sanjaypujare): add support for string, struct proto etc
-    checkArgument(config instanceof Map, "Only Map supported for config");
-    @SuppressWarnings("unchecked") Map<String, ?> map = (Map<String, ?>)config;
-
-    Config configObj = new Config();
-    extractMeshCaServerConfig(configObj, getObject(map, SERVER_CONFIG_KEY));
-    configObj.certValiditySeconds =
-        getSeconds(
-            JsonUtil.getObject(map, CERT_VALIDITY_SECONDS_KEY), CERT_VALIDITY_SECONDS_DEFAULT);
-    configObj.renewalGracePeriodSeconds =
-        getSeconds(
-            JsonUtil.getObject(map, RENEWAL_GRACE_PERIOD_SECONDS_KEY),
-            RENEWAL_GRACE_PERIOD_SECONDS_DEFAULT);
-    String keyType = JsonUtil.getString(map, KEY_ALGO_KEY);
-    checkArgument(
-        keyType == null || keyType.equals(KEY_ALGO_DEFAULT), "key_type can only be null or 'RSA'");
-    // TODO: remove signatureAlgo, keyType (or keyAlgo), maxRetryAttempts
-    configObj.maxRetryAttempts = MAX_RETRY_ATTEMPTS_DEFAULT;
-    configObj.keyAlgo = KEY_ALGO_DEFAULT;
-    configObj.signatureAlgo = SIGNATURE_ALGO_DEFAULT;
-    configObj.keySize = JsonUtil.getNumberAsInteger(map, KEY_SIZE_KEY);
-    if (configObj.keySize == null) {
-      configObj.keySize = KEY_SIZE_DEFAULT;
-    }
-    configObj.gkeClusterUrl =
-            checkNotNull(JsonUtil.getString(map, GKECLUSTER_URL_KEY),
-                    "'location' is required in the config");
-    parseProjectAndZone(configObj.gkeClusterUrl, configObj);
-    return configObj;
-  }
-
-  private static void extractMeshCaServerConfig(Config configObj, Map<String, ?> serverConfig) {
-    // init with defaults
-    configObj.meshCaUrl = MESHCA_URL_DEFAULT;
-    configObj.rpcTimeoutSeconds = RPC_TIMEOUT_SECONDS_DEFAULT;
-    configObj.stsUrl = STS_URL_DEFAULT;
-    if (serverConfig != null) {
-      checkArgument(
-          "GRPC".equals(JsonUtil.getString(serverConfig, "api_type")),
-          "Only GRPC api_type supported");
-      List<Map<String, ?>> grpcServices =
-          checkNotNull(
-              JsonUtil.getListOfObjects(serverConfig, "grpc_services"), "grpc_services not found");
-      for (Map<String, ?> grpcService : grpcServices) {
-        Map<String, ?> googleGrpcConfig = JsonUtil.getObject(grpcService, "google_grpc");
-        if (googleGrpcConfig != null) {
-          String value = JsonUtil.getString(googleGrpcConfig, MESHCA_URL_KEY);
-          if (value != null) {
-            configObj.meshCaUrl = value;
-          }
-          Map<String, ?> channelCreds =
-                  JsonUtil.getObject(googleGrpcConfig, "channel_credentials");
-          if (channelCreds != null) {
-            Map<String, ?> googleDefaultChannelCreds =
-                checkNotNull(
-                    JsonUtil.getObject(channelCreds, "google_default"),
-                    "channel_credentials need to be google_default!");
-            checkArgument(
-                googleDefaultChannelCreds.isEmpty(),
-                "google_default credentials contain illegal value");
-          }
-          List<Map<String, ?>> callCreds =
-              JsonUtil.getListOfObjects(googleGrpcConfig, "call_credentials");
-          for (Map<String, ?> callCred : callCreds) {
-            Map<String, ?> stsCreds = JsonUtil.getObject(callCred, STS_SERVICE_KEY);
-            if (stsCreds != null) {
-              value = JsonUtil.getString(stsCreds, TOKEN_EXCHANGE_SERVICE_KEY);
-              if (value != null) {
-                configObj.stsUrl = value;
-              }
-              configObj.gkeSaJwtLocation = JsonUtil.getString(stsCreds, GKE_SA_JWT_LOCATION_KEY);
-            }
-          }
-          configObj.rpcTimeoutSeconds =
-              getSeconds(
-                  JsonUtil.getObject(grpcService, RPC_TIMEOUT_SECONDS_KEY),
-                  RPC_TIMEOUT_SECONDS_DEFAULT);
-        }
-      }
-    }
-    // check required value(s)
-    checkNotNull(configObj.gkeSaJwtLocation, "'subject_token_path' is required in the config");
-  }
-
-  private static Long getSeconds(Map<String,?> duration, long defaultValue) {
-    if (duration != null) {
-      return JsonUtil.getNumberAsLong(duration, "seconds");
-    }
-    return defaultValue;
-  }
-
-  private static void parseProjectAndZone(String gkeClusterUrl, Config configObj) {
-    Matcher matcher = CLUSTER_URL_PATTERN.matcher(gkeClusterUrl);
-    checkState(matcher.find(), "gkeClusterUrl does not have correct format");
-    checkState(matcher.groupCount() == 2, "gkeClusterUrl does not have project and location parts");
-    configObj.project = matcher.group(1);
-    configObj.zone = matcher.group(2);
-  }
-
-  abstract static class ScheduledExecutorServiceFactory {
-
-    private static final ScheduledExecutorServiceFactory DEFAULT_INSTANCE =
-        new ScheduledExecutorServiceFactory() {
-
-          @Override
-          ScheduledExecutorService create(String serverUri) {
-            return Executors.newSingleThreadScheduledExecutor(
-                new ThreadFactoryBuilder()
-                    .setNameFormat("meshca-" + serverUri + "-%d")
-                    .setDaemon(true)
-                    .build());
-          }
-        };
-
-    static ScheduledExecutorServiceFactory getInstance() {
-      return DEFAULT_INSTANCE;
-    }
-
-    abstract ScheduledExecutorService create(String serverUri);
-  }
-
-  /** POJO class for storing various config values. */
-  @VisibleForTesting
-  static class Config {
-    String meshCaUrl;
-    Long rpcTimeoutSeconds;
-    String gkeClusterUrl;
-    Long certValiditySeconds;
-    Long renewalGracePeriodSeconds;
-    String keyAlgo;   // aka keyType
-    Integer keySize;
-    String signatureAlgo;
-    Integer maxRetryAttempts;
-    String stsUrl;
-    String gkeSaJwtLocation;
-    String zone;
-    String project;
-  }
-}
diff --git a/xds/src/main/java/io/grpc/xds/internal/extauthz/ExtAuthzConfig.java b/xds/src/main/java/io/grpc/xds/internal/extauthz/ExtAuthzConfig.java
new file mode 100644
index 00000000000..5aeb44c6e2a
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/internal/extauthz/ExtAuthzConfig.java
@@ -0,0 +1,145 @@
+/*
+ * 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.extauthz;
+
+import com.google.auto.value.AutoValue;
+import com.google.common.collect.ImmutableList;
+import io.grpc.Status;
+import io.grpc.xds.internal.Matchers;
+import io.grpc.xds.internal.grpcservice.GrpcServiceConfig;
+import io.grpc.xds.internal.headermutations.HeaderMutationRulesConfig;
+import java.util.Optional;
+
+/**
+ * Represents the configuration for the external authorization (ext_authz) filter. This class
+ * encapsulates the settings defined in the
+ * {@link io.envoyproxy.envoy.extensions.filters.http.ext_authz.v3.ExtAuthz} proto, providing a
+ * structured, immutable representation for use within gRPC. It includes configurations for the gRPC
+ * service used for authorization, header mutation rules, and other filter behaviors.
+ */
+@AutoValue
+public abstract class ExtAuthzConfig {
+
+  /** Creates a new builder for creating {@link ExtAuthzConfig} instances. */
+  public static Builder builder() {
+    return new AutoValue_ExtAuthzConfig.Builder().allowedHeaders(ImmutableList.of())
+        .disallowedHeaders(ImmutableList.of()).statusOnError(Status.PERMISSION_DENIED)
+        .filterEnabled(Matchers.FractionMatcher.create(100, 100));
+  }
+
+  /**
+   * The gRPC service configuration for the external authorization service. This is a required
+   * field.
+   *
+   * @see ExtAuthz#getGrpcService()
+   */
+  public abstract GrpcServiceConfig grpcService();
+
+  /**
+   * Changes the filter's behavior on errors from the authorization service. If {@code true}, the
+   * filter will accept the request even if the authorization service fails or returns an error.
+   *
+   * @see ExtAuthz#getFailureModeAllow()
+   */
+  public abstract boolean failureModeAllow();
+
+  /**
+   * Determines if the {@code x-envoy-auth-failure-mode-allowed} header is added to the request when
+   * {@link #failureModeAllow()} is true.
+   *
+   * @see ExtAuthz#getFailureModeAllowHeaderAdd()
+   */
+  public abstract boolean failureModeAllowHeaderAdd();
+
+  /**
+   * Specifies if the peer certificate is sent to the external authorization service.
+   *
+   * @see ExtAuthz#getIncludePeerCertificate()
+   */
+  public abstract boolean includePeerCertificate();
+
+  /**
+   * The gRPC status returned to the client when the authorization server returns an error or is
+   * unreachable. Defaults to {@code PERMISSION_DENIED}.
+   *
+   * @see io.envoyproxy.envoy.extensions.filters.http.ext_authz.v3.ExtAuthz#getStatusOnError()
+   */
+  public abstract Status statusOnError();
+
+  /**
+   * Specifies whether to deny requests when the filter is disabled. Defaults to {@code false}.
+   *
+   * @see ExtAuthz#getDenyAtDisable()
+   */
+  public abstract boolean denyAtDisable();
+
+  /**
+   * The fraction of requests that will be checked by the authorization service. Defaults to all
+   * requests.
+   *
+   * @see ExtAuthz#getFilterEnabled()
+   */
+  public abstract Matchers.FractionMatcher filterEnabled();
+
+  /**
+   * Specifies which request headers are sent to the authorization service. If empty, all headers
+   * are sent.
+   *
+   * @see ExtAuthz#getAllowedHeaders()
+   */
+  public abstract ImmutableList<Matchers.StringMatcher> allowedHeaders();
+
+  /**
+   * Specifies which request headers are not sent to the authorization service. This overrides
+   * {@link #allowedHeaders()}.
+   *
+   * @see ExtAuthz#getDisallowedHeaders()
+   */
+  public abstract ImmutableList<Matchers.StringMatcher> disallowedHeaders();
+
+  /**
+   * Rules for what modifications an ext_authz server may make to request headers.
+   *
+   * @see ExtAuthz#getDecoderHeaderMutationRules()
+   */
+  public abstract Optional<HeaderMutationRulesConfig> decoderHeaderMutationRules();
+
+  @AutoValue.Builder
+  public abstract static class Builder {
+    public abstract Builder grpcService(GrpcServiceConfig grpcService);
+
+    public abstract Builder failureModeAllow(boolean failureModeAllow);
+
+    public abstract Builder failureModeAllowHeaderAdd(boolean failureModeAllowHeaderAdd);
+
+    public abstract Builder includePeerCertificate(boolean includePeerCertificate);
+
+    public abstract Builder statusOnError(Status statusOnError);
+
+    public abstract Builder denyAtDisable(boolean denyAtDisable);
+
+    public abstract Builder filterEnabled(Matchers.FractionMatcher filterEnabled);
+
+    public abstract Builder allowedHeaders(Iterable<Matchers.StringMatcher> allowedHeaders);
+
+    public abstract Builder disallowedHeaders(Iterable<Matchers.StringMatcher> disallowedHeaders);
+
+    public abstract Builder decoderHeaderMutationRules(HeaderMutationRulesConfig rules);
+
+    public abstract ExtAuthzConfig build();
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/internal/extauthz/ExtAuthzParseException.java b/xds/src/main/java/io/grpc/xds/internal/extauthz/ExtAuthzParseException.java
new file mode 100644
index 00000000000..78edea5c305
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/internal/extauthz/ExtAuthzParseException.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.xds.internal.extauthz;
+
+/**
+ * A custom exception for signaling errors during the parsing of external authorization
+ * (ext_authz) configurations.
+ */
+public class ExtAuthzParseException extends Exception {
+
+  private static final long serialVersionUID = 0L;
+
+  public ExtAuthzParseException(String message) {
+    super(message);
+  }
+
+  public ExtAuthzParseException(String message, Throwable cause) {
+    super(message, cause);
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/internal/grpcservice/GrpcServiceConfig.java b/xds/src/main/java/io/grpc/xds/internal/grpcservice/GrpcServiceConfig.java
new file mode 100644
index 00000000000..cefc235e9eb
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/internal/grpcservice/GrpcServiceConfig.java
@@ -0,0 +1,87 @@
+/*
+ * 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.grpcservice;
+
+import com.google.auto.value.AutoValue;
+import com.google.common.collect.ImmutableList;
+import io.grpc.CallCredentials;
+import io.grpc.xds.client.ConfiguredChannelCredentials;
+import java.time.Duration;
+import java.util.Optional;
+
+
+/**
+ * This class encapsulates the configuration for a gRPC service, including target URI, credentials,
+ * and other settings. This class is immutable and uses the AutoValue library for its
+ * implementation.
+ */
+@AutoValue
+public abstract class GrpcServiceConfig {
+
+  public static Builder builder() {
+    return new AutoValue_GrpcServiceConfig.Builder();
+  }
+
+  public abstract GoogleGrpcConfig googleGrpc();
+
+  public abstract Optional<Duration> timeout();
+
+  public abstract ImmutableList<HeaderValue> initialMetadata();
+
+  @AutoValue.Builder
+  public abstract static class Builder {
+    public abstract Builder googleGrpc(GoogleGrpcConfig googleGrpc);
+
+    public abstract Builder timeout(Duration timeout);
+
+    public abstract Builder initialMetadata(ImmutableList<HeaderValue> initialMetadata);
+
+    public abstract GrpcServiceConfig build();
+  }
+
+  /**
+   * This class encapsulates settings specific to Google's gRPC implementation, such as target URI
+   * and credentials.
+   */
+  @AutoValue
+  public abstract static class GoogleGrpcConfig {
+
+    public static Builder builder() {
+      return new AutoValue_GrpcServiceConfig_GoogleGrpcConfig.Builder();
+    }
+
+    public abstract String target();
+
+    public abstract ConfiguredChannelCredentials configuredChannelCredentials();
+
+    public abstract Optional<CallCredentials> callCredentials();
+
+    @AutoValue.Builder
+    public abstract static class Builder {
+      public abstract Builder target(String target);
+
+      public abstract Builder configuredChannelCredentials(
+          ConfiguredChannelCredentials channelCredentials);
+
+      public abstract Builder callCredentials(CallCredentials callCredentials);
+
+      public abstract GoogleGrpcConfig build();
+    }
+  }
+
+
+}
diff --git a/xds/src/main/java/io/grpc/xds/internal/grpcservice/GrpcServiceParseException.java b/xds/src/main/java/io/grpc/xds/internal/grpcservice/GrpcServiceParseException.java
new file mode 100644
index 00000000000..319ad3d07e3
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/internal/grpcservice/GrpcServiceParseException.java
@@ -0,0 +1,33 @@
+/*
+ * 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.grpcservice;
+
+/**
+ * Exception thrown when there is an error parsing the gRPC service config.
+ */
+public class GrpcServiceParseException extends Exception {
+
+  private static final long serialVersionUID = 1L;
+
+  public GrpcServiceParseException(String message) {
+    super(message);
+  }
+
+  public GrpcServiceParseException(String message, Throwable cause) {
+    super(message, cause);
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/internal/grpcservice/HeaderValue.java b/xds/src/main/java/io/grpc/xds/internal/grpcservice/HeaderValue.java
new file mode 100644
index 00000000000..1b7bb283744
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/internal/grpcservice/HeaderValue.java
@@ -0,0 +1,44 @@
+/*
+ * 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.grpcservice;
+
+import com.google.auto.value.AutoValue;
+import com.google.protobuf.ByteString;
+import java.util.Optional;
+
+/**
+ * Represents a header to be mutated or added as part of xDS configuration.
+ * Avoids direct dependency on Envoy's proto objects while providing an immutable representation.
+ */
+@AutoValue
+public abstract class HeaderValue {
+
+  public static HeaderValue create(String key, String value) {
+    return new AutoValue_HeaderValue(key, Optional.of(value), Optional.empty());
+  }
+
+  public static HeaderValue create(String key, ByteString rawValue) {
+    return new AutoValue_HeaderValue(key, Optional.empty(), Optional.of(rawValue));
+  }
+
+
+  public abstract String key();
+
+  public abstract Optional<String> value();
+
+  public abstract Optional<ByteString> rawValue();
+}
diff --git a/xds/src/main/java/io/grpc/xds/internal/grpcservice/HeaderValueValidationUtils.java b/xds/src/main/java/io/grpc/xds/internal/grpcservice/HeaderValueValidationUtils.java
new file mode 100644
index 00000000000..ff0df11bdc5
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/internal/grpcservice/HeaderValueValidationUtils.java
@@ -0,0 +1,67 @@
+/*
+ * 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.grpcservice;
+
+import java.util.Locale;
+
+/**
+ * Utility class for validating HTTP headers.
+ */
+public final class HeaderValueValidationUtils {
+  public static final int MAX_HEADER_LENGTH = 16384;
+
+  private HeaderValueValidationUtils() {}
+
+  /**
+   * Returns true if the header key is disallowed for mutations or validation.
+   *
+   * @param key The header key (e.g., "content-type")
+   */
+  public static boolean isDisallowed(String key) {
+    if (key.isEmpty() || key.length() > MAX_HEADER_LENGTH) {
+      return true;
+    }
+    if (!key.equals(key.toLowerCase(Locale.ROOT))) {
+      return true;
+    }
+    if (key.startsWith("grpc-")) {
+      return true;
+    }
+    if (key.startsWith(":") || key.equals("host")) {
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Returns true if the header value is disallowed.
+   *
+   * @param header The HeaderValue containing key and values
+   */
+  public static boolean isDisallowed(HeaderValue header) {
+    if (isDisallowed(header.key())) {
+      return true;
+    }
+    if (header.value().isPresent() && header.value().get().length() > MAX_HEADER_LENGTH) {
+      return true;
+    }
+    if (header.rawValue().isPresent() && header.rawValue().get().size() > MAX_HEADER_LENGTH) {
+      return true;
+    }
+    return false;
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/internal/headermutations/HeaderMutationDisallowedException.java b/xds/src/main/java/io/grpc/xds/internal/headermutations/HeaderMutationDisallowedException.java
new file mode 100644
index 00000000000..b8d4eb582fb
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/internal/headermutations/HeaderMutationDisallowedException.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.xds.internal.headermutations;
+
+import io.grpc.Status;
+import io.grpc.StatusException;
+
+/**
+ * Exception thrown when a header mutation is disallowed.
+ */
+public final class HeaderMutationDisallowedException extends StatusException {
+
+  private static final long serialVersionUID = 1L;
+
+  public HeaderMutationDisallowedException(String message) {
+    super(Status.INTERNAL.withDescription(message));
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/internal/headermutations/HeaderMutationFilter.java b/xds/src/main/java/io/grpc/xds/internal/headermutations/HeaderMutationFilter.java
new file mode 100644
index 00000000000..35cab17d928
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/internal/headermutations/HeaderMutationFilter.java
@@ -0,0 +1,114 @@
+/*
+ * 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.headermutations;
+
+import com.google.common.collect.ImmutableList;
+import io.grpc.xds.internal.grpcservice.HeaderValueValidationUtils;
+import java.util.Collection;
+import java.util.Optional;
+import java.util.function.Predicate;
+
+/**
+ * The HeaderMutationFilter class is responsible for filtering header mutations based on a given set
+ * of rules.
+ */
+public class HeaderMutationFilter {
+  private final Optional<HeaderMutationRulesConfig> mutationRules;
+
+
+
+  public HeaderMutationFilter(Optional<HeaderMutationRulesConfig> mutationRules) {
+    this.mutationRules = mutationRules;
+  }
+
+  /**
+   * Filters the given header mutations based on the configured rules and returns the allowed
+   * mutations.
+   *
+   * @param mutations The header mutations to filter
+   * @return The allowed header mutations.
+   * @throws HeaderMutationDisallowedException if a disallowed mutation is encountered and the rules
+   *         specify that this should be an error.
+   */
+  public HeaderMutations filter(HeaderMutations mutations)
+      throws HeaderMutationDisallowedException {
+    ImmutableList<HeaderValueOption> allowedHeaders =
+        filterCollection(mutations.headers(), this::isDisallowed, this::isHeaderMutationAllowed);
+    ImmutableList<String> allowedHeadersToRemove =
+        filterCollection(mutations.headersToRemove(), this::isDisallowed,
+                this::isHeaderMutationAllowed);
+    return HeaderMutations.create(allowedHeaders, allowedHeadersToRemove);
+  }
+
+  /**
+   * A generic helper to filter a collection based on a predicate.
+   */
+  private <T> ImmutableList<T> filterCollection(Collection<T> items,
+      Predicate<T> isIgnoredPredicate, Predicate<T> isAllowedPredicate)
+      throws HeaderMutationDisallowedException {
+    ImmutableList.Builder<T> allowed = ImmutableList.builder();
+    for (T item : items) {
+      boolean isIgnored = isIgnoredPredicate.test(item);
+      boolean isAllowed = isAllowedPredicate.test(item);
+
+      // TODO(sauravzg): The specification is ambiguous regarding whether system headers
+      // should be silently ignored or trigger an error when disallowIsError is enabled.
+      // We default to triggering errors matching Envoy's implementation.
+      // Ref: https://github.com/grpc/proposal/pull/481#discussion_r3124453674
+      if (!isIgnored && isAllowed) {
+        allowed.add(item);
+      } else if (disallowIsError()) {
+        throw new HeaderMutationDisallowedException("Header mutation disallowed");
+      }
+    }
+    return allowed.build();
+  }
+
+  private boolean isDisallowed(String key) {
+    return HeaderValueValidationUtils.isDisallowed(key);
+  }
+
+  private boolean isDisallowed(HeaderValueOption option) {
+    return HeaderValueValidationUtils.isDisallowed(option.header());
+  }
+
+  private boolean isHeaderMutationAllowed(HeaderValueOption option) {
+    return isHeaderMutationAllowed(option.header().key());
+  }
+
+  private boolean isHeaderMutationAllowed(String headerName) {
+    return mutationRules.map(rules -> isHeaderMutationAllowed(headerName, rules))
+        .orElse(true);
+  }
+
+  private boolean isHeaderMutationAllowed(String headerName,
+          HeaderMutationRulesConfig rules) {
+    if (rules.disallowExpression().isPresent()
+        && rules.disallowExpression().get().matcher(headerName).matches()) {
+      return false;
+    }
+    if (rules.allowExpression().isPresent()
+        && rules.allowExpression().get().matcher(headerName).matches()) {
+      return true;
+    }
+    return !rules.disallowAll();
+  }
+
+  private boolean disallowIsError() {
+    return mutationRules.map(HeaderMutationRulesConfig::disallowIsError).orElse(false);
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/internal/headermutations/HeaderMutationRulesConfig.java b/xds/src/main/java/io/grpc/xds/internal/headermutations/HeaderMutationRulesConfig.java
new file mode 100644
index 00000000000..b16ec7948ed
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/internal/headermutations/HeaderMutationRulesConfig.java
@@ -0,0 +1,77 @@
+/*
+ * 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.headermutations;
+
+import com.google.auto.value.AutoValue;
+import com.google.re2j.Pattern;
+import io.envoyproxy.envoy.config.common.mutation_rules.v3.HeaderMutationRules;
+import java.util.Optional;
+
+/**
+ * Represents the configuration for header mutation rules, as defined in the
+ * {@link io.envoyproxy.envoy.config.common.mutation_rules.v3.HeaderMutationRules} proto.
+ */
+@AutoValue
+public abstract class HeaderMutationRulesConfig {
+  /** Creates a new builder for creating {@link HeaderMutationRulesConfig} instances. */
+  public static Builder builder() {
+    return new AutoValue_HeaderMutationRulesConfig.Builder().disallowAll(false)
+        .disallowIsError(false);
+  }
+
+  /**
+   * If set, allows any header that matches this regular expression.
+   *
+   * @see HeaderMutationRules#getAllowExpression()
+   */
+  public abstract Optional<Pattern> allowExpression();
+
+  /**
+   * If set, disallows any header that matches this regular expression.
+   *
+   * @see HeaderMutationRules#getDisallowExpression()
+   */
+  public abstract Optional<Pattern> disallowExpression();
+
+  /**
+   * If true, disallows all header mutations.
+   *
+   * @see HeaderMutationRules#getDisallowAll()
+   */
+  public abstract boolean disallowAll();
+
+  /**
+   * If true, a disallowed header mutation will result in an error instead of being ignored.
+   *
+   * @see HeaderMutationRules#getDisallowIsError()
+   */
+  public abstract boolean disallowIsError();
+
+
+  @AutoValue.Builder
+  public abstract static class Builder {
+    public abstract Builder allowExpression(Pattern matcher);
+
+    public abstract Builder disallowExpression(Pattern matcher);
+
+    public abstract Builder disallowAll(boolean disallowAll);
+
+    public abstract Builder disallowIsError(boolean disallowIsError);
+
+    public abstract HeaderMutationRulesConfig build();
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/internal/headermutations/HeaderMutationRulesParseException.java b/xds/src/main/java/io/grpc/xds/internal/headermutations/HeaderMutationRulesParseException.java
new file mode 100644
index 00000000000..3782e84a54b
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/internal/headermutations/HeaderMutationRulesParseException.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.xds.internal.headermutations;
+
+/**
+ * Exception thrown when parsing header mutation rules fails.
+ */
+public final class HeaderMutationRulesParseException extends Exception {
+  private static final long serialVersionUID = 1L;
+
+  public HeaderMutationRulesParseException(String message) {
+    super(message);
+  }
+
+  public HeaderMutationRulesParseException(String message, Throwable cause) {
+    super(message, cause);
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/internal/headermutations/HeaderMutationRulesParser.java b/xds/src/main/java/io/grpc/xds/internal/headermutations/HeaderMutationRulesParser.java
new file mode 100644
index 00000000000..f6bb2ec508d
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/internal/headermutations/HeaderMutationRulesParser.java
@@ -0,0 +1,55 @@
+/*
+ * 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.headermutations;
+
+import com.google.re2j.Pattern;
+import com.google.re2j.PatternSyntaxException;
+import io.envoyproxy.envoy.config.common.mutation_rules.v3.HeaderMutationRules;
+
+/**
+ * Parser for {@link io.envoyproxy.envoy.config.common.mutation_rules.v3.HeaderMutationRules}.
+ */
+public final class HeaderMutationRulesParser {
+
+  private HeaderMutationRulesParser() {}
+
+  public static HeaderMutationRulesConfig parse(HeaderMutationRules proto)
+      throws HeaderMutationRulesParseException {
+    HeaderMutationRulesConfig.Builder builder = HeaderMutationRulesConfig.builder();
+    builder.disallowAll(proto.getDisallowAll().getValue());
+    builder.disallowIsError(proto.getDisallowIsError().getValue());
+    if (proto.hasAllowExpression()) {
+      builder.allowExpression(
+          parseRegex(proto.getAllowExpression().getRegex(), "allow_expression"));
+    }
+    if (proto.hasDisallowExpression()) {
+      builder.disallowExpression(
+          parseRegex(proto.getDisallowExpression().getRegex(), "disallow_expression"));
+    }
+    return builder.build();
+  }
+
+  private static Pattern parseRegex(String regex, String fieldName)
+      throws HeaderMutationRulesParseException {
+    try {
+      return Pattern.compile(regex);
+    } catch (PatternSyntaxException e) {
+      throw new HeaderMutationRulesParseException(
+          "Invalid regex pattern for " + fieldName + ": " + e.getMessage(), e);
+    }
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/internal/headermutations/HeaderMutations.java b/xds/src/main/java/io/grpc/xds/internal/headermutations/HeaderMutations.java
new file mode 100644
index 00000000000..a456413c899
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/internal/headermutations/HeaderMutations.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.xds.internal.headermutations;
+
+import com.google.auto.value.AutoValue;
+import com.google.common.collect.ImmutableList;
+
+/** A collection of header mutations. */
+@AutoValue
+public abstract class HeaderMutations {
+
+  public static HeaderMutations create(ImmutableList<HeaderValueOption> headers,
+      ImmutableList<String> headersToRemove) {
+    return new AutoValue_HeaderMutations(headers, headersToRemove);
+  }
+
+  public abstract ImmutableList<HeaderValueOption> headers();
+
+  public abstract ImmutableList<String> headersToRemove();
+}
diff --git a/xds/src/main/java/io/grpc/xds/internal/headermutations/HeaderMutator.java b/xds/src/main/java/io/grpc/xds/internal/headermutations/HeaderMutator.java
new file mode 100644
index 00000000000..e6cdc126f22
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/internal/headermutations/HeaderMutator.java
@@ -0,0 +1,123 @@
+/*
+ * 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.headermutations;
+
+
+import io.grpc.Metadata;
+import io.grpc.xds.internal.grpcservice.HeaderValue;
+import io.grpc.xds.internal.headermutations.HeaderValueOption.HeaderAppendAction;
+import java.util.logging.Logger;
+
+/**
+ * The HeaderMutator provides methods to apply header mutations to a given set of headers based on a
+ * given set of rules.
+ */
+public class HeaderMutator {
+
+  private static final Logger logger = Logger.getLogger(HeaderMutator.class.getName());
+
+  /**
+   * Creates a new instance of {@code HeaderMutator}.
+   */
+  public static HeaderMutator create() {
+    return new HeaderMutator();
+  }
+
+  HeaderMutator() {}
+
+  /**
+   * Applies the given header mutations to the provided metadata headers.
+   *
+   * @param mutations The header mutations to apply.
+   * @param headers The metadata headers to which the mutations will be applied.
+   */
+  public void applyMutations(final HeaderMutations mutations, Metadata headers) {
+    // TODO(sauravzg): The specification is not clear on order of header removals and additions.
+    // in case of conflicts. Copying the order from Envoy here, which does removals at the end.
+    applyHeaderUpdates(mutations.headers(), headers);
+    for (String headerToRemove : mutations.headersToRemove()) {
+      Metadata.Key<?> key = headerToRemove.endsWith(Metadata.BINARY_HEADER_SUFFIX)
+          ? Metadata.Key.of(headerToRemove, Metadata.BINARY_BYTE_MARSHALLER)
+          : Metadata.Key.of(headerToRemove, Metadata.ASCII_STRING_MARSHALLER);
+      headers.discardAll(key);
+    }
+  }
+
+  private void applyHeaderUpdates(final Iterable<HeaderValueOption> headerOptions,
+      Metadata headers) {
+    for (HeaderValueOption headerOption : headerOptions) {
+      updateHeader(headerOption, headers);
+    }
+  }
+
+  private void updateHeader(final HeaderValueOption option, Metadata mutableHeaders) {
+    HeaderValue header = option.header();
+    HeaderAppendAction action = option.appendAction();
+    boolean keepEmptyValue = option.keepEmptyValue();
+
+    if (header.key().endsWith(Metadata.BINARY_HEADER_SUFFIX)) {
+      if (header.rawValue().isPresent()) {
+        byte[] value = header.rawValue().get().toByteArray();
+        if (value.length > 0 || keepEmptyValue) {
+          updateHeader(action, Metadata.Key.of(header.key(), Metadata.BINARY_BYTE_MARSHALLER),
+                  value, mutableHeaders);
+        }
+      } else {
+        logger.fine("Missing binary rawValue for header: " + header.key());
+      }
+    } else {
+      if (header.value().isPresent()) {
+        String value = header.value().get();
+        if (!value.isEmpty() || keepEmptyValue) {
+          updateHeader(action, Metadata.Key.of(header.key(), Metadata.ASCII_STRING_MARSHALLER),
+                  value, mutableHeaders);
+        }
+      } else {
+        logger.fine("Missing value for header: " + header.key());
+      }
+    }
+  }
+
+  private <T> void updateHeader(final HeaderAppendAction action, final Metadata.Key<T> key,
+      final T value, Metadata mutableHeaders) {
+    switch (action) {
+      case APPEND_IF_EXISTS_OR_ADD:
+        mutableHeaders.put(key, value);
+        break;
+      case ADD_IF_ABSENT:
+        if (!mutableHeaders.containsKey(key)) {
+          mutableHeaders.put(key, value);
+        }
+        break;
+      case OVERWRITE_IF_EXISTS_OR_ADD:
+        mutableHeaders.discardAll(key);
+        mutableHeaders.put(key, value);
+        break;
+      case OVERWRITE_IF_EXISTS:
+        if (mutableHeaders.containsKey(key)) {
+          mutableHeaders.discardAll(key);
+          mutableHeaders.put(key, value);
+        }
+        break;
+
+      default:
+        // Should be unreachable unless there's a proto schema mismatch.
+        logger.fine("Unknown HeaderAppendAction: " + action);
+    }
+  }
+}
+
diff --git a/xds/src/main/java/io/grpc/xds/internal/headermutations/HeaderValueOption.java b/xds/src/main/java/io/grpc/xds/internal/headermutations/HeaderValueOption.java
new file mode 100644
index 00000000000..6cb96da864d
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/internal/headermutations/HeaderValueOption.java
@@ -0,0 +1,50 @@
+/*
+ * 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.xds.internal.headermutations;
+
+import com.google.auto.value.AutoValue;
+import io.grpc.xds.internal.grpcservice.HeaderValue;
+
+/**
+ * Represents a header option to be appended or mutated as part of xDS configuration.
+ * Avoids direct dependency on Envoy's proto objects.
+ */
+@AutoValue
+public abstract class HeaderValueOption {
+
+  public static HeaderValueOption create(
+      HeaderValue header, HeaderAppendAction appendAction, boolean keepEmptyValue) {
+    return new AutoValue_HeaderValueOption(header, appendAction, keepEmptyValue);
+  }
+
+  public abstract HeaderValue header();
+
+  public abstract HeaderAppendAction appendAction();
+
+  public abstract boolean keepEmptyValue();
+
+  /**
+   * Defines the action to take when appending headers.
+   * Mirrors io.envoyproxy.envoy.config.core.v3.HeaderValueOption.HeaderAppendAction.
+   */
+  public enum HeaderAppendAction {
+    APPEND_IF_EXISTS_OR_ADD,
+    ADD_IF_ABSENT,
+    OVERWRITE_IF_EXISTS_OR_ADD,
+    OVERWRITE_IF_EXISTS
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/internal/rbac/engine/AuthorizationDecision.java b/xds/src/main/java/io/grpc/xds/internal/rbac/engine/AuthorizationDecision.java
deleted file mode 100644
index 43f69dc6bf1..00000000000
--- a/xds/src/main/java/io/grpc/xds/internal/rbac/engine/AuthorizationDecision.java
+++ /dev/null
@@ -1,91 +0,0 @@
-/*
- * 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.rbac.engine;
-
-import com.google.common.collect.ImmutableList;
-import java.lang.StringBuilder;
-import java.util.List;
-
-/** 
- * The AuthorizationDecision class holds authorization decision 
- * returned by CEL-based Authorization Engine. 
- */
-public class AuthorizationDecision {
-  /** Output represents the possible decisions generated by CEL-based Authorization Engine.*/
-  public enum Output {
-    /** 
-     * ALLOW indicates that CEL Evaluate Engine 
-     * had authorized the gRPC call and allowed the gRPC call to go through.
-     */
-    ALLOW,
-    /** 
-     * DENY indicates that CEL Evaluate Engine 
-     * had authorized the gRPC call and denied the gRPC call from going through.
-     */
-    DENY,
-    /** 
-     * UNKNOWN indicates that CEL Evaluate Engine 
-     * did not have enough information to authorize the gRPC call. 
-     * */
-    UNKNOWN,
-  }
-
-  private final Output decision;
-  private final ImmutableList<String> policyNames;
-
-  /**
-   * Creates a new authorization decision using the input {@code decision} 
-   * for resolving authorization decision
-   * and {@code policyNames} for resolving authorization context.
-   */
-  public AuthorizationDecision(Output decision, List<String> policyNames) {
-    this.decision = decision;
-    this.policyNames = ImmutableList.copyOf(policyNames);
-  }
-
-  /** Returns the authorization decision. */
-  public Output getDecision() {
-    return this.decision;
-  }
-
-  /** Returns the policy list. */
-  public ImmutableList<String> getPolicyNames() {
-    return this.policyNames;
-  }
-
-  @Override
-  public String toString() {
-    StringBuilder authzStr = new StringBuilder();
-    switch (this.decision) {
-      case ALLOW:
-        authzStr.append("Authorization Decision: ALLOW. \n");
-        break;
-      case DENY:
-        authzStr.append("Authorization Decision: DENY. \n");
-        break;
-      case UNKNOWN:
-        authzStr.append("Authorization Decision: UNKNOWN. \n");
-        break;
-      default:
-        break;
-    }
-    for (String policyName : this.policyNames) {
-      authzStr.append(policyName).append("; \n");
-    }
-    return authzStr.toString();
-  }
-}
diff --git a/xds/src/main/java/io/grpc/xds/internal/rbac/engine/AuthorizationEngine.java b/xds/src/main/java/io/grpc/xds/internal/rbac/engine/AuthorizationEngine.java
deleted file mode 100644
index 9ed439953a6..00000000000
--- a/xds/src/main/java/io/grpc/xds/internal/rbac/engine/AuthorizationEngine.java
+++ /dev/null
@@ -1,214 +0,0 @@
-/*
- * 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.rbac.engine;
-
-import static com.google.common.base.Preconditions.checkArgument;
-import static com.google.common.base.Preconditions.checkNotNull;
-
-import com.google.api.expr.v1alpha1.Expr;
-import com.google.common.collect.ImmutableMap;
-import com.google.protobuf.Descriptors.Descriptor;
-import io.envoyproxy.envoy.config.rbac.v2.Policy;
-import io.envoyproxy.envoy.config.rbac.v2.RBAC;
-import io.envoyproxy.envoy.config.rbac.v2.RBAC.Action;
-import io.grpc.xds.internal.rbac.engine.cel.Activation;
-import io.grpc.xds.internal.rbac.engine.cel.DefaultDispatcher;
-import io.grpc.xds.internal.rbac.engine.cel.DefaultInterpreter;
-import io.grpc.xds.internal.rbac.engine.cel.DescriptorMessageProvider;
-import io.grpc.xds.internal.rbac.engine.cel.Dispatcher;
-import io.grpc.xds.internal.rbac.engine.cel.IncompleteData;
-import io.grpc.xds.internal.rbac.engine.cel.Interpretable;
-import io.grpc.xds.internal.rbac.engine.cel.Interpreter;
-import io.grpc.xds.internal.rbac.engine.cel.InterpreterException;
-import io.grpc.xds.internal.rbac.engine.cel.RuntimeTypeProvider;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-
-/**
- * CEL-based Authorization Engine is part of the authorization framework in gRPC.
- * CEL-based Authorization Engine takes one or two Envoy RBAC policies as input
- * and uses CEL library to evaluate the condition field 
- * inside each RBAC policy based on the provided Envoy Attributes. 
- * CEL-based Authorization Engine will generate an authorization decision which
- * could be ALLOW, DENY or UNKNOWN.
- * 
- * <p>Use as in:
- * 
- * <pre>
- *  AuthorizationEngine engine = new AuthorizationEngine(rbacPolicy);
- *  AuthorizationDecision result = engine.evaluate(new EvaluateArgs(call, headers));
- * </pre>
- */
-public class AuthorizationEngine {
-  /**
-   * RbacEngine is an inner class that holds RBAC action 
-   * and a list of conditions in RBAC policy.
-   */
-  private static class RbacEngine {
-    @SuppressWarnings("UnusedVariable")
-    private final Action action;
-    private final ImmutableMap<String, Expr> conditions;
-
-    public RbacEngine(Action action, ImmutableMap<String, Expr> conditions) {
-      this.action = checkNotNull(action);
-      this.conditions = checkNotNull(conditions);
-    }
-  }
-
-  private static final Logger log = Logger.getLogger(AuthorizationEngine.class.getName());
-  private final RbacEngine allowEngine;
-  private final RbacEngine denyEngine;
-
-  /**
-   * Creates a CEL-based Authorization Engine from one Envoy RBAC policy.
-   * @param rbacPolicy input Envoy RBAC policy.
-   */
-  public AuthorizationEngine(RBAC rbacPolicy) {
-    Map<String, Expr> conditions = new LinkedHashMap<>();
-    for (Map.Entry<String, Policy> policy: rbacPolicy.getPoliciesMap().entrySet()) {
-      conditions.put(policy.getKey(), policy.getValue().getCondition());
-    }
-    allowEngine = (rbacPolicy.getAction() == Action.ALLOW) 
-        ? new RbacEngine(Action.ALLOW, ImmutableMap.copyOf(conditions)) : null; 
-    denyEngine = (rbacPolicy.getAction() == Action.DENY) 
-        ? new RbacEngine(Action.DENY, ImmutableMap.copyOf(conditions)) : null; 
-  }
-
-  /**
-   * Creates a CEL-based Authorization Engine from two Envoy RBAC policies.
-   * When it takes two RBAC policies, 
-   * the order has to be a DENY policy followed by an ALLOW policy.
-   * @param denyPolicy input Envoy RBAC policy with DENY action.
-   * @param allowPolicy input Envoy RBAC policy with ALLOW action.
-   * @throws IllegalArgumentException if the user inputs an invalid RBAC list.
-   */
-  public AuthorizationEngine(RBAC denyPolicy, RBAC allowPolicy) {
-    checkArgument(
-        denyPolicy.getAction() == Action.DENY && allowPolicy.getAction() == Action.ALLOW,
-        "Invalid RBAC list, " 
-        + "must provide a RBAC with DENY action followed by a RBAC with ALLOW action. ");
-    Map<String, Expr> denyConditions = new LinkedHashMap<>();
-    for (Map.Entry<String, Policy> policy: denyPolicy.getPoliciesMap().entrySet()) {
-      denyConditions.put(policy.getKey(), policy.getValue().getCondition());
-    }
-    denyEngine = new RbacEngine(Action.DENY, ImmutableMap.copyOf(denyConditions));
-    Map<String, Expr> allowConditions = new LinkedHashMap<>();
-    for (Map.Entry<String, Policy> policy: allowPolicy.getPoliciesMap().entrySet()) {
-      allowConditions.put(policy.getKey(), policy.getValue().getCondition());
-    }
-    allowEngine = new RbacEngine(Action.ALLOW, ImmutableMap.copyOf(allowConditions));   
-  }
-
-  /**
-   * The evaluate function performs the core authorization mechanism 
-   * of CEL-based Authorization Engine.
-   * It determines whether a gRPC call is allowed, denied, or unable to be decided.
-   * @param args evaluate argument that is used to evaluate the RBAC conditions.
-   * @return an AuthorizationDecision generated by CEL-based Authorization Engine.
-   */
-  public AuthorizationDecision evaluate(EvaluateArgs args) {
-    List<String> unknownPolicyNames = new ArrayList<>();
-    // Set up activation used in CEL library's eval function.
-    Activation activation = Activation.copyOf(args.generateEnvoyAttributes());
-    // Iterate through denyEngine's map.
-    // If there is match, immediately return DENY. 
-    // If there are unknown conditions, return UNKNOWN. 
-    // If all non-match, then iterate through allowEngine.
-    if (denyEngine != null) {
-      AuthorizationDecision authzDecision = evaluateEngine(denyEngine.conditions.entrySet(), 
-          AuthorizationDecision.Output.DENY, unknownPolicyNames, activation);
-      if (authzDecision != null) {
-        return authzDecision;
-      }
-      if (!unknownPolicyNames.isEmpty()) {
-        return new AuthorizationDecision(
-            AuthorizationDecision.Output.UNKNOWN, unknownPolicyNames);
-      }
-    }
-    // Once we enter allowEngine, if there is a match, immediately return ALLOW. 
-    // In the end of iteration, if there are unknown conditions, return UNKNOWN.
-    // If all non-match, return DENY.
-    if (allowEngine != null) {
-      AuthorizationDecision authzDecision = evaluateEngine(allowEngine.conditions.entrySet(), 
-          AuthorizationDecision.Output.ALLOW, unknownPolicyNames, activation);
-      if (authzDecision != null) {
-        return authzDecision;
-      }
-      if (!unknownPolicyNames.isEmpty()) {
-        return new AuthorizationDecision(
-            AuthorizationDecision.Output.UNKNOWN, unknownPolicyNames);
-      }
-    }
-    // Return ALLOW if it only has a denyEngine and it’s unmatched.
-    if (this.allowEngine == null && this.denyEngine != null) {
-      return new AuthorizationDecision(
-          AuthorizationDecision.Output.ALLOW, new ArrayList<String>());
-    }
-    // Return DENY if none of denyEngine and allowEngine matched, 
-    // or the single allowEngine is unmatched when there is only one allowEngine.
-    return new AuthorizationDecision(AuthorizationDecision.Output.DENY, new ArrayList<String>());
-  }
-
-  /** Evaluate a single RbacEngine. */
-  protected AuthorizationDecision evaluateEngine(Set<Map.Entry<String, Expr>> entrySet, 
-      AuthorizationDecision.Output decision, List<String> unknownPolicyNames, 
-      Activation activation) {
-    for (Map.Entry<String, Expr> condition : entrySet) {
-      try {
-        if (matches(condition.getValue(), activation)) {
-          return new AuthorizationDecision(decision, 
-              new ArrayList<String>(Arrays.asList(new String[] {condition.getKey()})));
-        }
-      } catch (InterpreterException e) {
-        unknownPolicyNames.add(condition.getKey());
-      }
-    }
-    return null;
-  }
-
-  /** Evaluate if a condition matches the given Enovy Attributes using CEL library. */
-  protected boolean matches(Expr condition, Activation activation) throws InterpreterException {
-    // Set up interpretable used in CEL library's eval function.
-    List<Descriptor> descriptors = new ArrayList<>();
-    RuntimeTypeProvider messageProvider = DescriptorMessageProvider.dynamicMessages(descriptors);
-    Dispatcher dispatcher = DefaultDispatcher.create();
-    Interpreter interpreter = new DefaultInterpreter(messageProvider, dispatcher);
-    Interpretable interpretable = interpreter.createInterpretable(condition);
-    // Parse the generated result object to a boolean variable.
-    try {
-      Object result = interpretable.eval(activation);
-      if (result instanceof Boolean) {
-        return Boolean.parseBoolean(result.toString());
-      }
-      // Throw an InterpreterException if there are missing Envoy Attributes.
-      if (result instanceof IncompleteData) {
-        throw new InterpreterException.Builder("Envoy Attributes gotten are incomplete.").build(); 
-      }
-    } catch (InterpreterException e) {
-      // If any InterpreterExceptions are catched, throw it and log the error.
-      log.log(Level.WARNING, e.toString(), e);
-      throw e;
-    }
-    return false;
-  }
-}
diff --git a/xds/src/main/java/io/grpc/xds/internal/rbac/engine/EvaluateArgs.java b/xds/src/main/java/io/grpc/xds/internal/rbac/engine/EvaluateArgs.java
deleted file mode 100644
index 35945a21026..00000000000
--- a/xds/src/main/java/io/grpc/xds/internal/rbac/engine/EvaluateArgs.java
+++ /dev/null
@@ -1,123 +0,0 @@
-/*
- * 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.rbac.engine;
-
-import com.google.common.collect.ImmutableMap;
-import io.grpc.Grpc;
-import io.grpc.Metadata;
-import io.grpc.ServerCall;
-
-/** The EvaluateArgs class holds evaluate arguments used in CEL-based Authorization Engine. */
-public class EvaluateArgs {
-  private final Metadata headers;
-  private final ServerCall<?, ?> call;
-
-  /**
-   * Creates a new EvaluateArgs using the input {@code headers} for resolving headers
-   * and {@code call} for resolving gRPC call.
-   */
-  public EvaluateArgs(Metadata headers, ServerCall<?, ?> call) {
-    this.headers = headers;
-    this.call = call;
-  }
-
-  /** Extract the request.url_path field. */
-  protected String getRequestUrlPath() {
-    String requestUrlPath = this.call.getMethodDescriptor().getFullMethodName();
-    return requestUrlPath;
-  }
-
-  /** Extract the request.host field. */
-  protected String getRequestHost() {
-    String requestHost = this.call.getAuthority();
-    return requestHost;
-  }
-
-  /** Extract the request.method field. */
-  protected String getRequestMethod() {
-    // TODO(@zhenlian): confirm extraction for request.method.
-    String requestMethod = this.call.getMethodDescriptor().getServiceName();
-    return requestMethod;
-  }
-
-  /** Extract the request.headers field. */
-  protected Metadata getRequestHeaders() {
-    // TODO(@zhenlian): convert request.headers from Metadata to a String Map.
-    Metadata requestHeaders = this.headers;
-    return requestHeaders;
-  }
-
-  /** Extract the source.address field. */
-  protected String getSourceAddress() {
-    String sourceAddress = 
-        this.call.getAttributes().get(Grpc.TRANSPORT_ATTR_REMOTE_ADDR).toString();
-    return sourceAddress;
-  }
-
-  /** Extract the source.port field. */
-  protected int getSourcePort() {
-    // TODO(@zhenlian): fill out extraction for source.port.
-    int sourcePort = 0;
-    return sourcePort;
-  }
-
-  /** Extract the destination.address field. */
-  protected String getDestinationAddress() {
-    String destinationAddress = 
-        this.call.getAttributes().get(Grpc.TRANSPORT_ATTR_LOCAL_ADDR).toString();
-    return destinationAddress;
-  }
-
-  /** Extract the destination.port field. */
-  protected int getDestinationPort() {
-    // TODO(@zhenlian): fill out extraction for destination.port.
-    int destinationPort = 0;
-    return destinationPort;
-  }
-
-  /** Extract the connection.uri_san_peer_certificate field. */
-  protected String getConnectionUriSanPeerCertificate() {
-    // TODO(@zhenlian): fill out extraction for connection.uri_san_peer_certificate.
-    String connectionUriSanPeerCertificate = "placeholder";
-    return connectionUriSanPeerCertificate;
-  }
-
-  /** Extract the source.principal field. */
-  protected String getSourcePrincipal() {
-    // TODO(@zhenlian): fill out extraction for source.principal.
-    String sourcePrincipal = "placeholder";
-    return sourcePrincipal;
-  }
-
-  /** Extract Envoy Attributes from EvaluateArgs. */
-  public ImmutableMap<String, Object> generateEnvoyAttributes() {
-    ImmutableMap<String, Object> attributes = ImmutableMap.<String, Object>builder()
-        .put("request.url_path", this.getRequestUrlPath())
-        .put("request.host", this.getRequestHost())
-        .put("request.method", this.getRequestMethod())
-        .put("request.headers", this.getRequestHeaders())
-        .put("source.address", this.getSourceAddress())
-        .put("source.port", this.getSourcePort())
-        .put("destination.address", this.getDestinationAddress())
-        .put("destination.port", this.getDestinationPort())
-        .put("connection.uri_san_peer_certificate", 
-            this.getConnectionUriSanPeerCertificate())
-        .put("source.principal", this.getSourcePrincipal())
-        .build();
-    return attributes;
-  }
-}
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/rbac/engine/cel/Activation.java b/xds/src/main/java/io/grpc/xds/internal/rbac/engine/cel/Activation.java
deleted file mode 100644
index 6e306f8f864..00000000000
--- a/xds/src/main/java/io/grpc/xds/internal/rbac/engine/cel/Activation.java
+++ /dev/null
@@ -1,51 +0,0 @@
-/*
- * 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.rbac.engine.cel;
-
-import com.google.common.collect.ImmutableMap;
-import java.util.Map;
-import javax.annotation.Nullable;
-  
-/**
- * Binds names to values.
- * 
- * <p>This is a Java stub for evaluating Common Expression Language (CEL). 
- * More information about CEL can be found in https://github.com/google/cel-spec. 
- * Once Java CEL has been open-sourced, this stub will be removed.
- */
-public abstract class Activation {
-  /** Resolves the given name to its value. Returns null if resolution fails. */
-  @Nullable
-  public abstract Object resolve(String name);
-
-  /** Creates an immutable binder using the provided mapping. */
-  public static Activation copyOf(Map<String, ?> map) {
-    final ImmutableMap<String, Object> copy = ImmutableMap.copyOf(map);
-    return new Activation() {
-      @Nullable
-      @Override
-      public Object resolve(String name) {
-        return copy.get(name);
-      }
-
-      @Override
-      public String toString() {
-        return copy.toString();
-      }
-    };
-  }
-}
diff --git a/xds/src/main/java/io/grpc/xds/internal/rbac/engine/cel/DefaultDispatcher.java b/xds/src/main/java/io/grpc/xds/internal/rbac/engine/cel/DefaultDispatcher.java
deleted file mode 100644
index 6b90784e1ba..00000000000
--- a/xds/src/main/java/io/grpc/xds/internal/rbac/engine/cel/DefaultDispatcher.java
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
- * 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.rbac.engine.cel;
-
-import java.lang.String;
-import java.util.List;
-
-/**
- * Default implementation of {@link Dispatcher}.
- * 
- * <p>This is a Java stub for evaluating Common Expression Language (CEL). 
- * More information about CEL can be found in https://github.com/google/cel-spec. 
- * Once Java CEL has been open-sourced, this stub will be removed.
- */
-public class DefaultDispatcher implements Dispatcher {
-  /** Creates a new dispatcher with all standard functions. */
-  public static DefaultDispatcher create() {
-    return new DefaultDispatcher();
-  }
-
-  @Override
-  public Object dispatch(Metadata metadata, long exprId, 
-      String functionName, List<String> overloadIds, Object[] args) 
-      throws InterpreterException {
-    return new Object();
-  }
-}
diff --git a/xds/src/main/java/io/grpc/xds/internal/rbac/engine/cel/DefaultInterpreter.java b/xds/src/main/java/io/grpc/xds/internal/rbac/engine/cel/DefaultInterpreter.java
deleted file mode 100644
index 4d33c28b7f1..00000000000
--- a/xds/src/main/java/io/grpc/xds/internal/rbac/engine/cel/DefaultInterpreter.java
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
- * 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.rbac.engine.cel;
-
-import com.google.api.expr.v1alpha1.Expr;
-
-/**
- * Default implementation of {@link Interpreter}.
- * 
- * <p>This is a Java stub for evaluating Common Expression Language (CEL). 
- * More information about CEL can be found in https://github.com/google/cel-spec. 
- * Once Java CEL has been open-sourced, this stub will be removed.
- */
-public class DefaultInterpreter implements Interpreter {
-  /**
-  * Creates a new interpreter
-  * @param typeProvider object which allows to construct and inspect messages.
-  * @param dispatcher a method dispatcher.
-  */
-  public DefaultInterpreter(RuntimeTypeProvider typeProvider, Dispatcher dispatcher) {}  
-  
-  @Override
-  public Interpretable createInterpretable(Expr expr) 
-      throws InterpreterException {
-    return new DefaultInterpretable(expr);
-  }
-
-  private static class DefaultInterpretable implements Interpretable {
-    /**
-    * Creates a new interpretable.
-    * @param expr a Cel expression.
-    */
-    public DefaultInterpretable(Expr expr) {}
-
-    @Override
-    public Object eval(Activation activation) throws InterpreterException {
-      return new Object();
-    }
-  }
-}
diff --git a/xds/src/main/java/io/grpc/xds/internal/rbac/engine/cel/DescriptorMessageProvider.java b/xds/src/main/java/io/grpc/xds/internal/rbac/engine/cel/DescriptorMessageProvider.java
deleted file mode 100644
index 66025a84f8b..00000000000
--- a/xds/src/main/java/io/grpc/xds/internal/rbac/engine/cel/DescriptorMessageProvider.java
+++ /dev/null
@@ -1,36 +0,0 @@
-/*
- * 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.rbac.engine.cel;
-
-import com.google.protobuf.Descriptors.Descriptor;
-
-/**
- * An implementation of {@link RuntimeTypeProvider} which relies on proto descriptors.
- * 
- * <p>This is a Java stub for evaluating Common Expression Language (CEL). 
- * More information about CEL can be found in https://github.com/google/cel-spec. 
- * Once Java CEL has been open-sourced, this stub will be removed.
- */
-public class DescriptorMessageProvider implements RuntimeTypeProvider {
-  /**
-   * Creates a new message provider that provides only {@link DynamicMessage DynamicMessages} for
-   * the specified descriptors.
-   */
-  public static DescriptorMessageProvider dynamicMessages(Iterable<Descriptor> descriptors) {
-    return new DescriptorMessageProvider();
-  }
-}
diff --git a/xds/src/main/java/io/grpc/xds/internal/rbac/engine/cel/Dispatcher.java b/xds/src/main/java/io/grpc/xds/internal/rbac/engine/cel/Dispatcher.java
deleted file mode 100644
index 9e1536b79a8..00000000000
--- a/xds/src/main/java/io/grpc/xds/internal/rbac/engine/cel/Dispatcher.java
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
- * 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.rbac.engine.cel;
-
-import java.util.List;
-
-/**
- * Determines an appropriate function and invokes it.
- * 
- * <p>This is a Java stub for evaluating Common Expression Language (CEL). 
- * More information about CEL can be found in https://github.com/google/cel-spec. 
- * Once Java CEL has been open-sourced, this stub will be removed.
- */
-public interface Dispatcher {
-  /**
-   * Invokes a function based on given parameters.
-   *
-   * @param metadata Metadata used for error reporting.
-   * @param exprId Expression identifier which can be used together with {@code metadata} to get
-   *     information about the dispatch target for error reporting.
-   * @param functionName the logical name of the function being invoked.
-   * @param overloadIds A list of function overload ids. The dispatcher selects the unique overload
-   *     from this list with matching arguments.
-   * @param args The arguments to pass to the function.
-   * @return The result of the function call.
-   * @throws InterpreterException if something goes wrong.
-   */
-  Object dispatch(
-      Metadata metadata, long exprId, String functionName, List<String> overloadIds, Object[] args)
-      throws InterpreterException;
-}
diff --git a/xds/src/main/java/io/grpc/xds/internal/rbac/engine/cel/IncompleteData.java b/xds/src/main/java/io/grpc/xds/internal/rbac/engine/cel/IncompleteData.java
deleted file mode 100644
index 7de8d4282bb..00000000000
--- a/xds/src/main/java/io/grpc/xds/internal/rbac/engine/cel/IncompleteData.java
+++ /dev/null
@@ -1,27 +0,0 @@
-/*
- * 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.rbac.engine.cel;
-
-/**
- * Interpreter returns an instance of {@code IncompleteData} if 
- * an object is an instance of {@link PartialMessage}.
- * 
- * <p>This is a Java stub for evaluating Common Expression Language (CEL). 
- * More information about CEL can be found in https://github.com/google/cel-spec. 
- * Once Java CEL has been open-sourced, this stub will be removed.
- */
-public interface IncompleteData {}
diff --git a/xds/src/main/java/io/grpc/xds/internal/rbac/engine/cel/Interpretable.java b/xds/src/main/java/io/grpc/xds/internal/rbac/engine/cel/Interpretable.java
deleted file mode 100644
index 49c102ff496..00000000000
--- a/xds/src/main/java/io/grpc/xds/internal/rbac/engine/cel/Interpretable.java
+++ /dev/null
@@ -1,29 +0,0 @@
-/*
- * 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.rbac.engine.cel;
-
-/**
- * Represent an expression which can be interpreted repeatedly using a given activation.
- * 
- * <p>This is a Java stub for evaluating Common Expression Language (CEL). 
- * More information about CEL can be found in https://github.com/google/cel-spec. 
- * Once Java CEL has been open-sourced, this stub will be removed.
- */
-public interface Interpretable {
-  /** Runs interpretation with the given activation which supplies name/value bindings. */
-  Object eval(Activation activation) throws InterpreterException;
-}
diff --git a/xds/src/main/java/io/grpc/xds/internal/rbac/engine/cel/Interpreter.java b/xds/src/main/java/io/grpc/xds/internal/rbac/engine/cel/Interpreter.java
deleted file mode 100644
index 919bbe2f450..00000000000
--- a/xds/src/main/java/io/grpc/xds/internal/rbac/engine/cel/Interpreter.java
+++ /dev/null
@@ -1,31 +0,0 @@
-/*
- * 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.rbac.engine.cel;
-
-import com.google.api.expr.v1alpha1.Expr;
-
-/**
- * Interface to a CEL interpreter.
- * 
- * <p>This is a Java stub for evaluating Common Expression Language (CEL). 
- * More information about CEL can be found in https://github.com/google/cel-spec. 
- * Once Java CEL has been open-sourced, this stub will be removed.
- */
-public interface Interpreter {
-  /** Creates an interpretable for the given expression. */
-  Interpretable createInterpretable(Expr expr) throws InterpreterException;
-}
diff --git a/xds/src/main/java/io/grpc/xds/internal/rbac/engine/cel/InterpreterException.java b/xds/src/main/java/io/grpc/xds/internal/rbac/engine/cel/InterpreterException.java
deleted file mode 100644
index e1768a984d4..00000000000
--- a/xds/src/main/java/io/grpc/xds/internal/rbac/engine/cel/InterpreterException.java
+++ /dev/null
@@ -1,53 +0,0 @@
-/*
- * 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.rbac.engine.cel;
-
-import java.lang.Exception;
-import javax.annotation.Nullable;
-
-/**
- * An exception produced during interpretation of expressions.
- * 
- * <p>This is a Java stub for evaluating Common Expression Language (CEL). 
- * More information about CEL can be found in https://github.com/google/cel-spec. 
- * Once Java CEL has been open-sourced, this stub will be removed.
- */
-@SuppressWarnings("serial")
-public class InterpreterException extends Exception {
-  /** Builder for InterpreterException. */
-  public static class Builder {
-    @Nullable private String message;
-    @Nullable private String location;
-    private int position;
-    private Throwable cause;
-
-    public Builder(String message, Object... args) {}
-
-    /** Build function for InterpreterException. */
-    public InterpreterException build() {
-      return new InterpreterException(
-          String.format(
-              "evaluation error%s: %s",
-              location != null ? " at " + location + ":" + position : "", message),
-          cause);
-    }
-  }
-
-  private InterpreterException(String message, Throwable cause) {
-    super(message, cause);
-  }
-}
diff --git a/xds/src/main/java/io/grpc/xds/internal/rbac/engine/cel/Metadata.java b/xds/src/main/java/io/grpc/xds/internal/rbac/engine/cel/Metadata.java
deleted file mode 100644
index e4e961b065c..00000000000
--- a/xds/src/main/java/io/grpc/xds/internal/rbac/engine/cel/Metadata.java
+++ /dev/null
@@ -1,37 +0,0 @@
-/*
- * 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.rbac.engine.cel;
-
-import java.lang.String;
-
-/**
- * An interface which provides metadata for syntax nodes.
- * 
- * <p>This is a Java stub for evaluating Common Expression Language (CEL). 
- * More information about CEL can be found in https://github.com/google/cel-spec. 
- * Once Java CEL has been open-sourced, this stub will be removed.
- */
-public interface Metadata {
-  /** Returns the location (like a filename) of the interpreted expression. */
-  String getLocation();
-
-  /**
-   * Returns the character position of the node in the source. 
-   * This is a 0-based character offset. 
-   */
-  int getPosition(long exprId);
-}
diff --git a/xds/src/main/java/io/grpc/xds/internal/rbac/engine/cel/RuntimeTypeProvider.java b/xds/src/main/java/io/grpc/xds/internal/rbac/engine/cel/RuntimeTypeProvider.java
deleted file mode 100644
index fbddb29ef48..00000000000
--- a/xds/src/main/java/io/grpc/xds/internal/rbac/engine/cel/RuntimeTypeProvider.java
+++ /dev/null
@@ -1,27 +0,0 @@
-/*
- * 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.rbac.engine.cel;
-
-/**
- * The {@code RuntimeTypeProvider} is a combination of the MessageProvider 
- * and TypeResolver interfaces.
- * 
- * <p>This is a Java stub for evaluating Common Expression Language (CEL). 
- * More information about CEL can be found in https://github.com/google/cel-spec. 
- * Once Java CEL has been open-sourced, this stub will be removed.
- */
-public interface RuntimeTypeProvider {}
diff --git a/xds/src/main/java/io/grpc/xds/internal/sds/ClientSslContextProviderFactory.java b/xds/src/main/java/io/grpc/xds/internal/sds/ClientSslContextProviderFactory.java
deleted file mode 100644
index db031b6a820..00000000000
--- a/xds/src/main/java/io/grpc/xds/internal/sds/ClientSslContextProviderFactory.java
+++ /dev/null
@@ -1,85 +0,0 @@
-/*
- * 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.sds;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-import com.google.common.util.concurrent.ThreadFactoryBuilder;
-import io.grpc.xds.Bootstrapper;
-import io.grpc.xds.EnvoyServerProtoData.UpstreamTlsContext;
-import io.grpc.xds.XdsInitializationException;
-import io.grpc.xds.internal.certprovider.CertProviderClientSslContextProvider;
-import io.grpc.xds.internal.sds.ReferenceCountingMap.ValueFactory;
-import java.util.concurrent.Executors;
-
-/** Factory to create client-side SslContextProvider from UpstreamTlsContext. */
-final class ClientSslContextProviderFactory
-    implements ValueFactory<UpstreamTlsContext, SslContextProvider> {
-
-  private final Bootstrapper bootstrapper;
-  private final CertProviderClientSslContextProvider.Factory
-      certProviderClientSslContextProviderFactory;
-
-  ClientSslContextProviderFactory(Bootstrapper bootstrapper) {
-    this(bootstrapper, CertProviderClientSslContextProvider.Factory.getInstance());
-  }
-
-  ClientSslContextProviderFactory(
-      Bootstrapper bootstrapper, CertProviderClientSslContextProvider.Factory factory) {
-    this.bootstrapper = bootstrapper;
-    this.certProviderClientSslContextProviderFactory = factory;
-  }
-
-  /** Creates an SslContextProvider from the given UpstreamTlsContext. */
-  @Override
-  public SslContextProvider create(UpstreamTlsContext upstreamTlsContext) {
-    checkNotNull(upstreamTlsContext, "upstreamTlsContext");
-    checkNotNull(
-        upstreamTlsContext.getCommonTlsContext(),
-        "upstreamTlsContext should have CommonTlsContext");
-    if (CommonTlsContextUtil.hasCertProviderInstance(
-            upstreamTlsContext.getCommonTlsContext())) {
-      try {
-        Bootstrapper.BootstrapInfo bootstrapInfo = bootstrapper.bootstrap();
-        return certProviderClientSslContextProviderFactory.getProvider(
-                upstreamTlsContext,
-                bootstrapInfo.getNode().toEnvoyProtoNode(),
-                bootstrapInfo.getCertProviders());
-      } catch (XdsInitializationException e) {
-        throw new RuntimeException(e);
-      }
-    } else if (CommonTlsContextUtil.hasAllSecretsUsingFilename(
-        upstreamTlsContext.getCommonTlsContext())) {
-      return SecretVolumeClientSslContextProvider.getProvider(upstreamTlsContext);
-    } else if (CommonTlsContextUtil.hasAllSecretsUsingSds(
-        upstreamTlsContext.getCommonTlsContext())) {
-      try {
-        return SdsClientSslContextProvider.getProvider(
-            upstreamTlsContext,
-            bootstrapper.bootstrap().getNode().toEnvoyProtoNodeV2(),
-            Executors.newSingleThreadExecutor(new ThreadFactoryBuilder()
-                .setNameFormat("client-sds-sslcontext-provider-%d")
-                .setDaemon(true)
-                .build()),
-            /* channelExecutor= */ null);
-      } catch (XdsInitializationException e) {
-        throw new RuntimeException(e);
-      }
-    }
-    throw new UnsupportedOperationException("Unsupported configurations in UpstreamTlsContext!");
-  }
-}
diff --git a/xds/src/main/java/io/grpc/xds/internal/sds/CommonTlsContextUtil.java b/xds/src/main/java/io/grpc/xds/internal/sds/CommonTlsContextUtil.java
deleted file mode 100644
index 5ffb356e187..00000000000
--- a/xds/src/main/java/io/grpc/xds/internal/sds/CommonTlsContextUtil.java
+++ /dev/null
@@ -1,113 +0,0 @@
-/*
- * 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.sds;
-
-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 io.envoyproxy.envoy.config.core.v3.DataSource.SpecifierCase;
-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.CommonTlsContext.ValidationContextTypeCase;
-import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.TlsCertificate;
-import javax.annotation.Nullable;
-
-/** Class for utility functions for {@link CommonTlsContext}. */
-final class CommonTlsContextUtil {
-
-  private CommonTlsContextUtil() {}
-
-  /** Returns true only if given CommonTlsContext uses no SdsSecretConfigs. */
-  static boolean hasAllSecretsUsingFilename(CommonTlsContext commonTlsContext) {
-    return commonTlsContext != null
-        && (commonTlsContext.getTlsCertificatesCount() > 0
-            || commonTlsContext.hasValidationContext());
-  }
-
-  /** Returns true only if given CommonTlsContext uses only SdsSecretConfigs. */
-  static boolean hasAllSecretsUsingSds(CommonTlsContext commonTlsContext) {
-    return commonTlsContext != null
-        && (commonTlsContext.getTlsCertificateSdsSecretConfigsCount() > 0
-            || commonTlsContext.hasValidationContextSdsSecretConfig());
-  }
-
-  static boolean hasCertProviderInstance(CommonTlsContext commonTlsContext) {
-    return commonTlsContext != null
-        && (commonTlsContext.hasTlsCertificateCertificateProviderInstance()
-            || hasCertProviderValidationContext(commonTlsContext));
-  }
-
-  private static boolean hasCertProviderValidationContext(CommonTlsContext commonTlsContext) {
-    if (commonTlsContext.hasCombinedValidationContext()) {
-      CombinedCertificateValidationContext combinedCertificateValidationContext =
-          commonTlsContext.getCombinedValidationContext();
-      return combinedCertificateValidationContext.hasValidationContextCertificateProviderInstance();
-    }
-    return commonTlsContext.hasValidationContextCertificateProviderInstance();
-  }
-
-  @Nullable
-  static CertificateValidationContext getCertificateValidationContext(
-      CommonTlsContext commonTlsContext) {
-    checkNotNull(commonTlsContext, "commonTlsContext");
-    ValidationContextTypeCase type = commonTlsContext.getValidationContextTypeCase();
-    checkState(
-        type == ValidationContextTypeCase.VALIDATION_CONTEXT
-            || type == ValidationContextTypeCase.VALIDATIONCONTEXTTYPE_NOT_SET,
-        "incorrect ValidationContextTypeCase");
-    return type == ValidationContextTypeCase.VALIDATION_CONTEXT
-        ? commonTlsContext.getValidationContext()
-        : null;
-  }
-
-  @Nullable
-  static CertificateValidationContext validateCertificateContext(
-      @Nullable CertificateValidationContext certContext, boolean optional) {
-    if (certContext == null || !certContext.hasTrustedCa()) {
-      checkArgument(optional, "certContext is required");
-      return null;
-    }
-    checkArgument(
-        certContext.getTrustedCa().getSpecifierCase() == SpecifierCase.FILENAME,
-        "filename expected");
-    return certContext;
-  }
-
-  @Nullable
-  static TlsCertificate validateTlsCertificate(
-      @Nullable TlsCertificate tlsCertificate, boolean optional) {
-    if (tlsCertificate == null) {
-      checkArgument(optional, "tlsCertificate is required");
-      return null;
-    }
-    if (optional
-        && (tlsCertificate.getPrivateKey().getSpecifierCase() == SpecifierCase.SPECIFIER_NOT_SET)
-        && (tlsCertificate.getCertificateChain().getSpecifierCase()
-            == SpecifierCase.SPECIFIER_NOT_SET)) {
-      return null;
-    }
-    checkArgument(
-        tlsCertificate.getPrivateKey().getSpecifierCase() == SpecifierCase.FILENAME,
-        "filename expected");
-    checkArgument(
-        tlsCertificate.getCertificateChain().getSpecifierCase() == SpecifierCase.FILENAME,
-        "filename expected");
-    return tlsCertificate;
-  }
-}
diff --git a/xds/src/main/java/io/grpc/xds/internal/sds/DynamicSslContextProvider.java b/xds/src/main/java/io/grpc/xds/internal/sds/DynamicSslContextProvider.java
deleted file mode 100644
index c75347c1f5e..00000000000
--- a/xds/src/main/java/io/grpc/xds/internal/sds/DynamicSslContextProvider.java
+++ /dev/null
@@ -1,143 +0,0 @@
-/*
- * 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.sds;
-
-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.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.ArrayList;
-import java.util.List;
-import javax.annotation.Nullable;
-
-/** Base class for dynamic {@link SslContextProvider}s. */
-public abstract class DynamicSslContextProvider extends SslContextProvider {
-
-  protected final List<Callback> pendingCallbacks = new ArrayList<>();
-  @Nullable protected final CertificateValidationContext staticCertificateValidationContext;
-  @Nullable protected SslContext sslContext;
-
-  protected DynamicSslContextProvider(
-      BaseTlsContext tlsContext, CertificateValidationContext staticCertValidationContext) {
-    super(tlsContext);
-    this.staticCertificateValidationContext = staticCertValidationContext;
-  }
-
-  @Nullable
-  public SslContext getSslContext() {
-    return sslContext;
-  }
-
-  protected abstract CertificateValidationContext generateCertificateValidationContext();
-
-  /** Gets a server or client side SslContextBuilder. */
-  protected abstract SslContextBuilder getSslContextBuilder(
-      CertificateValidationContext certificateValidationContext)
-      throws CertificateException, IOException, CertStoreException;
-
-  // this gets called only when requested secrets are ready...
-  protected final void updateSslContext() {
-    try {
-      CertificateValidationContext localCertValidationContext =
-          generateCertificateValidationContext();
-      SslContextBuilder sslContextBuilder = getSslContextBuilder(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);
-        sslContextBuilder.applicationProtocolConfig(apn);
-      }
-      List<Callback> pendingCallbacksCopy;
-      SslContext sslContextCopy;
-      synchronized (pendingCallbacks) {
-        sslContext = sslContextBuilder.build();
-        sslContextCopy = sslContext;
-        pendingCallbacksCopy = clonePendingCallbacksAndClear();
-      }
-      makePendingCallbacks(sslContextCopy, pendingCallbacksCopy);
-    } catch (Exception e) {
-      onError(Status.fromThrowable(e));
-      throw new RuntimeException(e);
-    }
-  }
-
-  protected final void callPerformCallback(
-          Callback callback, final SslContext sslContextCopy) {
-    performCallback(
-        new SslContextGetter() {
-          @Override
-          public SslContext get() {
-            return sslContextCopy;
-          }
-        },
-        callback
-    );
-  }
-
-  @Override
-  public final void addCallback(Callback callback) {
-    checkNotNull(callback, "callback");
-    // if there is a computed sslContext just send it
-    SslContext sslContextCopy = null;
-    synchronized (pendingCallbacks) {
-      if (sslContext != null) {
-        sslContextCopy = sslContext;
-      } else {
-        pendingCallbacks.add(callback);
-      }
-    }
-    if (sslContextCopy != null) {
-      callPerformCallback(callback, sslContextCopy);
-    }
-  }
-
-  private final void makePendingCallbacks(
-      SslContext sslContextCopy, List<Callback> pendingCallbacksCopy) {
-    for (Callback callback : pendingCallbacksCopy) {
-      callPerformCallback(callback, sslContextCopy);
-    }
-  }
-
-  /** 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/sds/FileBasedPluginCredential.java b/xds/src/main/java/io/grpc/xds/internal/sds/FileBasedPluginCredential.java
deleted file mode 100644
index c022c523273..00000000000
--- a/xds/src/main/java/io/grpc/xds/internal/sds/FileBasedPluginCredential.java
+++ /dev/null
@@ -1,138 +0,0 @@
-/*
- * 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.sds;
-
-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.io.Files;
-import com.google.protobuf.Struct;
-import com.google.protobuf.Value;
-// TODO(sanjaypujare): remove dependency on envoy data types.
-import io.envoyproxy.envoy.api.v2.core.DataSource;
-import io.envoyproxy.envoy.api.v2.core.GrpcService.GoogleGrpc.CallCredentials.MetadataCredentialsFromPlugin;
-import io.envoyproxy.envoy.config.core.v3.GrpcService.GoogleGrpc;
-import io.grpc.CallCredentials;
-import io.grpc.Metadata;
-import io.grpc.Status;
-import java.io.File;
-import java.io.IOException;
-import java.nio.charset.StandardCharsets;
-import java.util.concurrent.Executor;
-import javax.annotation.Nullable;
-
-/** Implements file based Google GRPC call cred needed by SDS server. */
-final class FileBasedPluginCredential extends CallCredentials {
-
-  public static final String PLUGIN_NAME = "envoy.grpc_credentials.file_based_metadata";
-  public static final String HEADER_KEY = "header_key";
-  public static final String HEADER_PREFIX = "header_prefix";
-  public static final String SECRET_DATA = "secret_data";
-  public static final String FILENAME = "filename";
-  public static final String DEFAULT_HEADER_KEY = "authorization";
-
-  @VisibleForTesting final String headerKey;
-  @VisibleForTesting final String headerPrefix;
-  @VisibleForTesting final DataSource secretData;
-
-  FileBasedPluginCredential(MetadataCredentialsFromPlugin metadataCredentialsFromPlugin) {
-    checkNotNull(metadataCredentialsFromPlugin, "metadataCredentialsFromPlugin");
-    checkArgument(
-            PLUGIN_NAME.equals(metadataCredentialsFromPlugin.getName()),
-            "plugin name should be %s", PLUGIN_NAME);
-    checkArgument(metadataCredentialsFromPlugin.hasConfig(),
-            "typed_config not supported");
-
-    Struct configStruct = metadataCredentialsFromPlugin.getConfig();
-
-    if (configStruct.containsFields(HEADER_KEY)) {
-      Value value = configStruct.getFieldsOrThrow(HEADER_KEY);
-      headerKey = value.getStringValue();
-    } else {
-      headerKey = DEFAULT_HEADER_KEY;
-    }
-    if (configStruct.containsFields(HEADER_PREFIX)) {
-      Value value = configStruct.getFieldsOrThrow(HEADER_PREFIX);
-      headerPrefix = value.getStringValue();
-    } else {
-      headerPrefix = "";
-    }
-    Value value = configStruct.getFieldsOrThrow(SECRET_DATA);
-    checkState(value.hasStructValue(), "expected struct value for %s", SECRET_DATA);
-    secretData = buildDataSourceFromConfigStruct(value.getStructValue());
-  }
-
-  FileBasedPluginCredential(
-      GoogleGrpc.CallCredentials.MetadataCredentialsFromPlugin metadataCredentialsFromPlugin) {
-    checkNotNull(metadataCredentialsFromPlugin, "metadataCredentialsFromPlugin");
-    checkArgument(
-        PLUGIN_NAME.equals(metadataCredentialsFromPlugin.getName()),
-        "plugin name should be %s", PLUGIN_NAME);
-
-    // FIXME(#7166): real implementation
-    headerKey = DEFAULT_HEADER_KEY;
-    headerPrefix = "";
-    secretData = null;
-  }
-
-  private static DataSource buildDataSourceFromConfigStruct(Struct secretValueStruct) {
-    checkNotNull(secretValueStruct, "secretValueStruct");
-    if (secretValueStruct.containsFields(FILENAME)) {
-      Value value = secretValueStruct.getFieldsOrThrow(FILENAME);
-      return DataSource.newBuilder().setFilename(value.getStringValue()).build();
-    } else {
-      throw new UnsupportedOperationException("only secret_data of filename type supported");
-    }
-  }
-
-  @Override
-  public void applyRequestMetadata(
-      @Nullable RequestInfo requestInfo, Executor appExecutor, final MetadataApplier applier) {
-    appExecutor.execute(
-        new Runnable() {
-          @Override
-          public void run() {
-            try {
-              Metadata headers = new Metadata();
-              String headerValue =
-                  headerPrefix
-                      + Files.asCharSource(
-                              new File(secretData.getFilename()), StandardCharsets.UTF_8)
-                          .read();
-
-              if (headerKey.endsWith(Metadata.BINARY_HEADER_SUFFIX)) {
-                Metadata.Key<byte[]> metadataHeaderKey =
-                    Metadata.Key.of(headerKey, Metadata.BINARY_BYTE_MARSHALLER);
-                headers.put(metadataHeaderKey, headerValue.getBytes(StandardCharsets.UTF_8));
-              } else {
-                Metadata.Key<String> metadataHeaderKey =
-                    Metadata.Key.of(headerKey, Metadata.ASCII_STRING_MARSHALLER);
-                headers.put(metadataHeaderKey, headerValue);
-              }
-              applier.apply(headers);
-            } catch (IOException e) {
-              applier.fail(Status.fromThrowable(e));
-            }
-          }
-        });
-  }
-
-  @Override
-  public void thisUsesUnstableApi() {}
-}
diff --git a/xds/src/main/java/io/grpc/xds/internal/sds/SdsClient.java b/xds/src/main/java/io/grpc/xds/internal/sds/SdsClient.java
deleted file mode 100644
index bc86d9b8647..00000000000
--- a/xds/src/main/java/io/grpc/xds/internal/sds/SdsClient.java
+++ /dev/null
@@ -1,447 +0,0 @@
-/*
- * 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.sds;
-
-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 com.google.protobuf.Any;
-import com.google.protobuf.InvalidProtocolBufferException;
-import com.google.protobuf.Struct;
-import com.google.protobuf.Value;
-import io.envoyproxy.envoy.api.v2.DiscoveryRequest;
-import io.envoyproxy.envoy.api.v2.DiscoveryResponse;
-import io.envoyproxy.envoy.api.v2.core.Node;
-import io.envoyproxy.envoy.config.core.v3.ApiConfigSource;
-import io.envoyproxy.envoy.config.core.v3.ApiConfigSource.ApiType;
-import io.envoyproxy.envoy.config.core.v3.ConfigSource;
-import io.envoyproxy.envoy.config.core.v3.GrpcService;
-import io.envoyproxy.envoy.config.core.v3.GrpcService.GoogleGrpc;
-import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.SdsSecretConfig;
-import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.Secret;
-import io.envoyproxy.envoy.service.discovery.v2.SecretDiscoveryServiceGrpc;
-import io.envoyproxy.envoy.service.discovery.v2.SecretDiscoveryServiceGrpc.SecretDiscoveryServiceStub;
-import io.grpc.CallCredentials;
-import io.grpc.ManagedChannel;
-import io.grpc.Status;
-import io.grpc.inprocess.InProcessChannelBuilder;
-import io.grpc.internal.SharedResourceHolder;
-import io.grpc.internal.SharedResourceHolder.Resource;
-import io.grpc.netty.NettyChannelBuilder;
-import io.grpc.stub.StreamObserver;
-import io.netty.channel.EventLoopGroup;
-import io.netty.channel.epoll.Epoll;
-import io.netty.channel.epoll.EpollDomainSocketChannel;
-import io.netty.channel.epoll.EpollEventLoopGroup;
-import io.netty.channel.unix.DomainSocketAddress;
-import io.netty.util.concurrent.DefaultThreadFactory;
-import java.util.List;
-import java.util.concurrent.Executor;
-import java.util.concurrent.ThreadFactory;
-import java.util.concurrent.TimeUnit;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-import javax.annotation.concurrent.NotThreadSafe;
-
-/**
- * SDS client used by an {@link SslContextProvider} to get SDS updates from the SDS server. This is
- * most likely a temporary implementation until merged with the XdsClient.
- */
-// TODO(sanjaypujare): once XdsClientImpl is ready, merge with it and add retry logic
-@NotThreadSafe
-final class SdsClient {
-  private static final Logger logger = Logger.getLogger(SdsClient.class.getName());
-  private static final String SECRET_TYPE_URL = "type.googleapis.com/envoy.api.v2.auth.Secret";
-  private static final EventLoopGroupResource eventLoopGroupResource =
-      Epoll.isAvailable() ? new EventLoopGroupResource("SdsClient") : null;
-
-  private SecretWatcher watcher;
-  private final SdsSecretConfig sdsSecretConfig;
-  private final Node clientNode;
-  private final Executor watcherExecutor;
-  private final CallCredentials callCredentials;
-  private EventLoopGroup eventLoopGroup;
-  private ManagedChannel channel;
-  private SecretDiscoveryServiceStub secretDiscoveryServiceStub;
-  private ResponseObserver responseObserver;
-  private StreamObserver<DiscoveryRequest> requestObserver;
-  private DiscoveryResponse lastResponse;
-
-  /** Factory for creating SdsClient based on input params and for unit tests. */
-  static class Factory {
-
-    /** Creates an SdsClient after figuring out channel to use. */
-    static SdsClient createSdsClient(
-        SdsSecretConfig sdsSecretConfig,
-        Node node,
-        Executor watcherExecutor,
-        Executor channelExecutor) {
-      ChannelInfo channelInfo = extractChannelInfo(sdsSecretConfig.getSdsConfig());
-      String targetUri = channelInfo.targetUri;
-      String channelType = channelInfo.channelType;
-      if (channelType != null && channelType.startsWith("inproc")) {
-        ManagedChannel channel =
-            InProcessChannelBuilder.forName(targetUri).executor(channelExecutor).build();
-        return new SdsClient(
-            sdsSecretConfig,
-            node,
-            watcherExecutor,
-            channel,
-            /* eventLoopGroup= */ null,
-            channelInfo.callCredentials);
-      }
-      NettyChannelBuilder builder;
-      EventLoopGroup eventLoopGroup = null;
-      if (targetUri.startsWith("unix:")) {
-        checkState(Epoll.isAvailable(), "Epoll is not available");
-        eventLoopGroup = SharedResourceHolder.get(eventLoopGroupResource);
-        builder =
-            NettyChannelBuilder.forAddress(new DomainSocketAddress(targetUri.substring(5)))
-                .eventLoopGroup(eventLoopGroup)
-                .channelType(EpollDomainSocketChannel.class);
-      } else {
-        builder = NettyChannelBuilder.forTarget(targetUri);
-      }
-      builder = builder.usePlaintext();
-      if (channelExecutor != null) {
-        builder = builder.executor(channelExecutor);
-      }
-      ManagedChannel channel = builder.build();
-      return new SdsClient(
-          sdsSecretConfig,
-          node,
-          watcherExecutor,
-          channel,
-          eventLoopGroup,
-          channelInfo.callCredentials);
-    }
-
-    @VisibleForTesting
-    static ChannelInfo extractChannelInfo(ConfigSource configSource) {
-      checkNotNull(configSource, "configSource");
-      checkArgument(
-          configSource.hasApiConfigSource(), "only configSource with ApiConfigSource supported");
-      ApiConfigSource apiConfigSource = configSource.getApiConfigSource();
-      checkArgument(
-          ApiType.GRPC.equals(apiConfigSource.getApiType()),
-          "only GRPC ApiConfigSource type supported");
-      checkArgument(
-          apiConfigSource.getGrpcServicesCount() == 1,
-          "expecting exactly 1 GrpcService in ApiConfigSource");
-      GrpcService grpcService = apiConfigSource.getGrpcServices(0);
-      checkArgument(
-          grpcService.hasGoogleGrpc() && !grpcService.hasEnvoyGrpc(),
-          "only GoogleGrpc expected in GrpcService");
-      GoogleGrpc googleGrpc = grpcService.getGoogleGrpc();
-      CallCredentials callCredentials = getVerifiedCredentials(googleGrpc);
-      String targetUri = googleGrpc.getTargetUri();
-      String channelType = null;
-      if (googleGrpc.hasConfig()) {
-        Struct struct = googleGrpc.getConfig();
-        Value value = struct.getFieldsMap().get("channelType");
-        channelType = value.getStringValue();
-      }
-      checkArgument(!Strings.isNullOrEmpty(targetUri), "targetUri in GoogleGrpc is empty!");
-      return new ChannelInfo(targetUri, channelType, callCredentials);
-    }
-
-    private static CallCredentials getVerifiedCredentials(GoogleGrpc googleGrpc) {
-      final String credentialsFactoryName = googleGrpc.getCredentialsFactoryName();
-      if (credentialsFactoryName.isEmpty()) {
-        // without factory name, no creds expected
-        checkArgument(
-            !googleGrpc.hasChannelCredentials() && googleGrpc.getCallCredentialsCount() == 0,
-            "No credentials supported in GoogleGrpc");
-        logger.warning("No CallCredentials specified.");
-        return null;
-      }
-      checkArgument(
-          credentialsFactoryName.equals(FileBasedPluginCredential.PLUGIN_NAME),
-          "factory name should be %s", FileBasedPluginCredential.PLUGIN_NAME);
-      if (googleGrpc.hasChannelCredentials()) {
-        checkArgument(
-            googleGrpc.getChannelCredentials().hasLocalCredentials(),
-            "only GoogleLocalCredentials supported");
-      }
-      if (googleGrpc.getCallCredentialsCount() > 0) {
-        checkArgument(
-            googleGrpc.getCallCredentialsCount() == 1,
-            "Exactly one CallCredential expected in GoogleGrpc");
-        GoogleGrpc.CallCredentials callCreds = googleGrpc.getCallCredentials(0);
-        checkArgument(callCreds.hasFromPlugin(), "only plugin credential supported");
-        return new FileBasedPluginCredential(callCreds.getFromPlugin());
-      }
-      logger.warning("No CallCredentials specified.");
-      return null;
-    }
-  }
-
-  @VisibleForTesting
-  static final class ChannelInfo {
-    @VisibleForTesting final String targetUri;
-    @VisibleForTesting final String channelType;
-    @VisibleForTesting final CallCredentials callCredentials;
-
-    private ChannelInfo(String targetUri, String channelType, CallCredentials callCredentials) {
-      this.targetUri = targetUri;
-      this.channelType = channelType;
-      this.callCredentials = callCredentials;
-    }
-  }
-
-  private SdsClient(
-      SdsSecretConfig sdsSecretConfig,
-      Node node,
-      Executor watcherExecutor,
-      ManagedChannel channel,
-      EventLoopGroup eventLoopGroup,
-      CallCredentials callCredentials) {
-    checkNotNull(sdsSecretConfig, "sdsSecretConfig");
-    checkNotNull(node, "node");
-    this.sdsSecretConfig = sdsSecretConfig;
-    this.clientNode = node;
-    this.watcherExecutor = watcherExecutor;
-    this.eventLoopGroup = eventLoopGroup;
-    checkNotNull(channel, "channel");
-    this.channel = channel;
-    this.callCredentials = callCredentials;
-  }
-
-  /**
-   * Starts resource discovery with SDS protocol. This method should be the first one to be called
-   * and should be called only once.
-   */
-  void start() {
-    if (requestObserver == null) {
-      secretDiscoveryServiceStub = SecretDiscoveryServiceGrpc.newStub(channel);
-      if (callCredentials != null) {
-        secretDiscoveryServiceStub =
-            secretDiscoveryServiceStub.withCallCredentials(callCredentials);
-      }
-      responseObserver = new ResponseObserver();
-      requestObserver = secretDiscoveryServiceStub.streamSecrets(responseObserver);
-      logger.log(Level.FINEST, "Stream created for {0}", sdsSecretConfig);
-    }
-  }
-
-  /** Stops resource discovery. No method in this class should be called after this point. */
-  void shutdown() {
-    if (requestObserver != null) {
-      requestObserver.onCompleted();
-      requestObserver = null;
-      channel.shutdownNow();
-      if (eventLoopGroup != null) {
-        eventLoopGroup = SharedResourceHolder.release(eventLoopGroupResource, eventLoopGroup);
-      }
-    }
-  }
-
-  /** Response observer for SdsClient. */
-  private final class ResponseObserver implements StreamObserver<DiscoveryResponse> {
-    ResponseObserver() {}
-
-    @Override
-    public void onNext(DiscoveryResponse discoveryResponse) {
-      logger.log(Level.FINEST, "response={0}", discoveryResponse);
-      processDiscoveryResponse(discoveryResponse);
-    }
-
-    @Override
-    public void onError(Throwable t) {
-      sendErrorToWatcher(t);
-    }
-
-    @Override
-    public void onCompleted() {
-      // TODO(sanjaypujare): add retry logic once client implementation is final
-      logger.warning("Stream unexpectedly completed.");
-    }
-  }
-
-  private void processDiscoveryResponse(final DiscoveryResponse response) {
-    watcherExecutor.execute(
-        new Runnable() {
-          @Override
-          public void run() {
-            try {
-              processSecretsFromDiscoveryResponse(response);
-            } catch (Throwable exceptionSeen) {
-              sendNack(exceptionSeen);
-              return;
-            }
-            lastResponse = response;
-            // send discovery request as ACK
-            sendDiscoveryRequestOnStream();
-          }
-        });
-  }
-
-  private void sendNack(Throwable exceptionSeen) {
-    String nonce = "";
-    String versionInfo = "";
-
-    if (lastResponse != null) {
-      nonce = lastResponse.getNonce();
-      versionInfo = lastResponse.getVersionInfo();
-    }
-    Status grpcStatus = Status.fromThrowable(exceptionSeen);
-    DiscoveryRequest.Builder builder =
-        DiscoveryRequest.newBuilder()
-            .setTypeUrl(SECRET_TYPE_URL)
-            .setResponseNonce(nonce)
-            .setVersionInfo(versionInfo)
-            .addResourceNames(sdsSecretConfig.getName())
-            .setErrorDetail(
-                com.google.rpc.Status.newBuilder()
-                    .setCode(grpcStatus.getCode().value())
-                    .setMessage(grpcStatus.getDescription() != null ? grpcStatus.getDescription()
-                        : "Secret not updated")
-                    .build())
-            .setNode(clientNode);
-
-    DiscoveryRequest req = builder.build();
-    logger.log(Level.FINEST, "Sending NACK req={0}", req);
-    requestObserver.onNext(req);
-  }
-
-  private void sendErrorToWatcher(final Throwable t) {
-    final SecretWatcher localCopy = watcher;
-    if (localCopy != null) {
-      watcherExecutor.execute(
-          new Runnable() {
-            @Override
-            public void run() {
-              try {
-                localCopy.onError(Status.fromThrowable(t));
-              } catch (Throwable throwable) {
-                logger.log(Level.SEVERE, "exception from onError", throwable);
-              }
-            }
-          });
-    }
-  }
-
-  private void processSecretsFromDiscoveryResponse(DiscoveryResponse response)
-      throws InvalidProtocolBufferException {
-    List<Any> resources = response.getResourcesList();
-    checkState(resources.size() == 1, "exactly one resource expected");
-    Any any = resources.get(0);
-    final String typeUrl = any.getTypeUrl();
-    checkState(SECRET_TYPE_URL.equals(typeUrl), "wrong value for typeUrl %s", typeUrl);
-    Secret secret = Secret.parseFrom(any.getValue());
-    processSecret(secret);
-  }
-
-  private void processSecret(Secret secret) {
-    checkState(
-        sdsSecretConfig.getName().equals(secret.getName()),
-        "expected secret name %s",
-        sdsSecretConfig.getName());
-    final SecretWatcher localCopy = watcher;
-    if (localCopy != null) {
-      localCopy.onSecretChanged(secret);
-    }
-  }
-
-  /** Registers a secret watcher for this client's SdsSecretConfig. */
-  void watchSecret(SecretWatcher secretWatcher) {
-    checkNotNull(secretWatcher, "secretWatcher");
-    checkState(watcher == null, "watcher already set");
-    watcher = secretWatcher;
-    if (lastResponse == null) {
-      sendDiscoveryRequestOnStream();
-    } else {
-      watcherExecutor.execute(
-          new Runnable() {
-            @Override
-            public void run() {
-              try {
-                processSecretsFromDiscoveryResponse(lastResponse);
-              } catch (Throwable throwable) {
-                logger.log(Level.SEVERE, "from watcherExecutor.execute", throwable);
-              }
-            }
-          });
-    }
-  }
-
-  /** Unregisters the given endpoints watcher. */
-  void cancelSecretWatch(SecretWatcher secretWatcher) {
-    checkNotNull(secretWatcher, "secretWatcher");
-    checkArgument(secretWatcher == watcher, "Incorrect secretWatcher to cancel");
-    watcher = null;
-  }
-
-  /** Secret watcher interface. */
-  interface SecretWatcher {
-    void onSecretChanged(Secret secretUpdate);
-
-    void onError(Status error);
-  }
-
-  private static final class EventLoopGroupResource implements Resource<EventLoopGroup> {
-    private final String name;
-
-    EventLoopGroupResource(String name) {
-      this.name = name;
-    }
-
-    @Override
-    public EventLoopGroup create() {
-      // Use Netty's DefaultThreadFactory in order to get the benefit of FastThreadLocal.
-      ThreadFactory threadFactory = new DefaultThreadFactory(name, /* daemon= */ true);
-      return new EpollEventLoopGroup(1, threadFactory);
-    }
-
-    @SuppressWarnings("FutureReturnValueIgnored")
-    @Override
-    public void close(EventLoopGroup instance) {
-      try {
-        instance.shutdownGracefully(0, 0, TimeUnit.SECONDS).sync();
-      } catch (InterruptedException e) {
-        logger.log(Level.SEVERE, "from EventLoopGroup.shutdownGracefully", e);
-        Thread.currentThread().interrupt(); // to not "swallow" the exception...
-      }
-    }
-  }
-
-  private void sendDiscoveryRequestOnStream() {
-    String nonce = "";
-    String versionInfo = "";
-    String requestType = "Sending initial req={0}";
-
-    if (lastResponse != null) {
-      nonce = lastResponse.getNonce();
-      versionInfo = lastResponse.getVersionInfo();
-      requestType = "Sending ACK req={0}";
-    }
-    DiscoveryRequest.Builder builder =
-        DiscoveryRequest.newBuilder()
-            .setTypeUrl(SECRET_TYPE_URL)
-            .setResponseNonce(nonce)
-            .setVersionInfo(versionInfo)
-            .addResourceNames(sdsSecretConfig.getName())
-            .setNode(clientNode);
-
-    DiscoveryRequest req = builder.build();
-    logger.log(Level.FINEST, requestType, req);
-    requestObserver.onNext(req);
-  }
-}
diff --git a/xds/src/main/java/io/grpc/xds/internal/sds/SdsClientSslContextProvider.java b/xds/src/main/java/io/grpc/xds/internal/sds/SdsClientSslContextProvider.java
deleted file mode 100644
index eef2faf2e23..00000000000
--- a/xds/src/main/java/io/grpc/xds/internal/sds/SdsClientSslContextProvider.java
+++ /dev/null
@@ -1,107 +0,0 @@
-/*
- * 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.sds;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-import io.envoyproxy.envoy.api.v2.core.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.CombinedCertificateValidationContext;
-import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.SdsSecretConfig;
-import io.grpc.netty.GrpcSslContexts;
-import io.grpc.xds.EnvoyServerProtoData.UpstreamTlsContext;
-import io.grpc.xds.internal.sds.trust.SdsTrustManagerFactory;
-import io.netty.handler.ssl.SslContextBuilder;
-import java.io.IOException;
-import java.security.cert.CertStoreException;
-import java.security.cert.CertificateException;
-import java.util.concurrent.Executor;
-
-/** A client SslContext provider that uses SDS to fetch secrets. */
-final class SdsClientSslContextProvider extends SdsSslContextProvider {
-
-  private SdsClientSslContextProvider(
-      Node node,
-      SdsSecretConfig certSdsConfig,
-      SdsSecretConfig validationContextSdsConfig,
-      CertificateValidationContext staticCertValidationContext,
-      Executor watcherExecutor,
-      Executor channelExecutor,
-      UpstreamTlsContext upstreamTlsContext) {
-    super(node,
-        certSdsConfig,
-        validationContextSdsConfig,
-        staticCertValidationContext,
-        watcherExecutor,
-        channelExecutor, upstreamTlsContext);
-  }
-
-  static SdsClientSslContextProvider getProvider(
-      UpstreamTlsContext upstreamTlsContext,
-      Node node,
-      Executor watcherExecutor,
-      Executor channelExecutor) {
-    checkNotNull(upstreamTlsContext, "upstreamTlsContext");
-    CommonTlsContext commonTlsContext = upstreamTlsContext.getCommonTlsContext();
-    SdsSecretConfig validationContextSdsConfig = null;
-    CertificateValidationContext staticCertValidationContext = null;
-    if (commonTlsContext.hasCombinedValidationContext()) {
-      CombinedCertificateValidationContext combinedValidationContext =
-          commonTlsContext.getCombinedValidationContext();
-      if (combinedValidationContext.hasValidationContextSdsSecretConfig()) {
-        validationContextSdsConfig =
-            combinedValidationContext.getValidationContextSdsSecretConfig();
-      }
-      if (combinedValidationContext.hasDefaultValidationContext()) {
-        staticCertValidationContext = combinedValidationContext.getDefaultValidationContext();
-      }
-    } else if (commonTlsContext.hasValidationContextSdsSecretConfig()) {
-      validationContextSdsConfig = commonTlsContext.getValidationContextSdsSecretConfig();
-    } else if (commonTlsContext.hasValidationContext()) {
-      staticCertValidationContext = commonTlsContext.getValidationContext();
-    }
-    SdsSecretConfig certSdsConfig = null;
-    if (commonTlsContext.getTlsCertificateSdsSecretConfigsCount() > 0) {
-      certSdsConfig = commonTlsContext.getTlsCertificateSdsSecretConfigs(0);
-    }
-    return new SdsClientSslContextProvider(
-        node,
-        certSdsConfig,
-        validationContextSdsConfig,
-        staticCertValidationContext,
-        watcherExecutor,
-        channelExecutor,
-        upstreamTlsContext);
-  }
-
-  @Override
-  protected final SslContextBuilder getSslContextBuilder(
-      CertificateValidationContext localCertValidationContext)
-      throws CertificateException, IOException, CertStoreException {
-    SslContextBuilder sslContextBuilder =
-        GrpcSslContexts.forClient()
-            .trustManager(new SdsTrustManagerFactory(localCertValidationContext));
-    if (tlsCertificate != null) {
-      sslContextBuilder.keyManager(
-          tlsCertificate.getCertificateChain().getInlineBytes().newInput(),
-          tlsCertificate.getPrivateKey().getInlineBytes().newInput(),
-          tlsCertificate.hasPassword() ? tlsCertificate.getPassword().getInlineString() : null);
-    }
-    return sslContextBuilder;
-  }
-}
diff --git a/xds/src/main/java/io/grpc/xds/internal/sds/SdsProtocolNegotiators.java b/xds/src/main/java/io/grpc/xds/internal/sds/SdsProtocolNegotiators.java
deleted file mode 100644
index b9174c1e03a..00000000000
--- a/xds/src/main/java/io/grpc/xds/internal/sds/SdsProtocolNegotiators.java
+++ /dev/null
@@ -1,457 +0,0 @@
-/*
- * 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.sds;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-import com.google.common.annotations.VisibleForTesting;
-import io.grpc.Attributes;
-import io.grpc.internal.GrpcUtil;
-import io.grpc.internal.ObjectPool;
-import io.grpc.netty.GrpcHttp2ConnectionHandler;
-import io.grpc.netty.InternalNettyChannelBuilder;
-import io.grpc.netty.InternalNettyChannelBuilder.ProtocolNegotiatorFactory;
-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.NettyChannelBuilder;
-import io.grpc.netty.ProtocolNegotiationEvent;
-import io.grpc.xds.EnvoyServerProtoData.DownstreamTlsContext;
-import io.grpc.xds.InternalXdsAttributes;
-import io.grpc.xds.XdsClientWrapperForServerSds;
-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.ArrayList;
-import java.util.List;
-import java.util.concurrent.Executor;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-import javax.annotation.Nullable;
-
-/**
- * Provides client and server side gRPC {@link ProtocolNegotiator}s that use SDS to provide the SSL
- * context.
- */
-@VisibleForTesting
-public final class SdsProtocolNegotiators {
-
-  // Prevent instantiation.
-  private SdsProtocolNegotiators() {
-  }
-
-  private static final Logger logger = Logger.getLogger(SdsProtocolNegotiators.class.getName());
-
-  public static final Attributes.Key<XdsClientWrapperForServerSds> SERVER_XDS_CLIENT
-      = Attributes.Key.create("serverXdsClient");
-  private static final AsciiString SCHEME = AsciiString.of("http");
-
-  /**
-   * Returns a {@link ProtocolNegotiatorFactory} to be used on {@link NettyChannelBuilder}.
-   *
-   * @param fallbackNegotiator protocol negotiator to use as fallback.
-   */
-  public static ProtocolNegotiatorFactory clientProtocolNegotiatorFactory(
-      @Nullable ProtocolNegotiator fallbackNegotiator) {
-    return new ClientSdsProtocolNegotiatorFactory(fallbackNegotiator);
-  }
-
-  /**
-   * Returns a {@link InternalProtocolNegotiator.ClientFactory} to be used on {@link
-   * NettyChannelBuilder}.
-   *
-   * @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);
-  }
-
-  /**
-   * Creates an SDS based {@link ProtocolNegotiator} for a {@link io.grpc.netty.NettyServerBuilder}.
-   * If xDS returns no DownstreamTlsContext, it will fall back to plaintext.
-   *
-   * @param fallbackProtocolNegotiator protocol negotiator to use as fallback.
-   */
-  public static ServerSdsProtocolNegotiator serverProtocolNegotiator(
-      @Nullable ProtocolNegotiator fallbackProtocolNegotiator) {
-    return new ServerSdsProtocolNegotiator(fallbackProtocolNegotiator);
-  }
-
-  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 ServerSdsProtocolNegotiator(
-          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 ClientSdsProtocolNegotiator(fallbackProtocolNegotiator.newNegotiator());
-    }
-
-    @Override
-    public int getDefaultPort() {
-      return GrpcUtil.DEFAULT_PORT_SSL;
-    }
-  }
-
-  private static final class ClientSdsProtocolNegotiatorFactory
-      implements InternalNettyChannelBuilder.ProtocolNegotiatorFactory {
-
-    private final ProtocolNegotiator fallbackProtocolNegotiator;
-
-    private ClientSdsProtocolNegotiatorFactory(ProtocolNegotiator fallbackNegotiator) {
-      this.fallbackProtocolNegotiator = fallbackNegotiator;
-    }
-
-    @Override
-    public InternalProtocolNegotiator.ProtocolNegotiator buildProtocolNegotiator() {
-      final ClientSdsProtocolNegotiator negotiator =
-          new ClientSdsProtocolNegotiator(fallbackProtocolNegotiator);
-      final class LocalSdsNegotiator 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 LocalSdsNegotiator();
-    }
-  }
-
-  @VisibleForTesting
-  static final class ClientSdsProtocolNegotiator implements ProtocolNegotiator {
-
-    @Nullable private final ProtocolNegotiator fallbackProtocolNegotiator;
-
-    ClientSdsProtocolNegotiator(@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(
-              InternalXdsAttributes.ATTR_SSL_CONTEXT_PROVIDER_SUPPLIER);
-      if (localSslContextProviderSupplier == null) {
-        checkNotNull(
-            fallbackProtocolNegotiator, "No TLS config and no fallbackProtocolNegotiator!");
-        return fallbackProtocolNegotiator.newHandler(grpcHandler);
-      }
-      return new ClientSdsHandler(grpcHandler, localSslContextProviderSupplier);
-    }
-
-    @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 ClientSdsHandler
-      extends InternalProtocolNegotiators.ProtocolNegotiationHandler {
-    private final GrpcHttp2ConnectionHandler grpcHandler;
-    private final SslContextProviderSupplier sslContextProviderSupplier;
-
-    ClientSdsHandler(
-        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);
-            }
-          });
-      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 updateSecret(SslContext sslContext) {
-              logger.log(
-                  Level.FINEST,
-                  "ClientSdsHandler.updateSecret authority={0}, ctx.name={1}",
-                  new Object[]{grpcHandler.getAuthority(), ctx.name()});
-              ChannelHandler handler =
-                  InternalProtocolNegotiators.tls(sslContext).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);
-            }
-          }
-      );
-    }
-
-    @Override
-    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause)
-        throws Exception {
-      logger.log(Level.SEVERE, "exceptionCaught", cause);
-      ctx.fireExceptionCaught(cause);
-    }
-  }
-
-  @VisibleForTesting
-  public static final class ServerSdsProtocolNegotiator implements ProtocolNegotiator {
-
-    @Nullable private final ProtocolNegotiator fallbackProtocolNegotiator;
-
-    /** Constructor. */
-    @VisibleForTesting
-    public ServerSdsProtocolNegotiator(@Nullable ProtocolNegotiator fallbackProtocolNegotiator) {
-      this.fallbackProtocolNegotiator = fallbackProtocolNegotiator;
-    }
-
-    @Override
-    public AsciiString scheme() {
-      return SCHEME;
-    }
-
-    @Override
-    public ChannelHandler newHandler(GrpcHttp2ConnectionHandler grpcHandler) {
-      XdsClientWrapperForServerSds xdsClientWrapperForServerSds =
-          grpcHandler.getEagAttributes().get(SERVER_XDS_CLIENT);
-      return new HandlerPickerHandler(grpcHandler, xdsClientWrapperForServerSds,
-          fallbackProtocolNegotiator);
-    }
-
-    @Override
-    public void close() {}
-  }
-
-  @VisibleForTesting
-  static final class HandlerPickerHandler
-      extends ChannelInboundHandlerAdapter {
-    private final GrpcHttp2ConnectionHandler grpcHandler;
-    private final XdsClientWrapperForServerSds xdsClientWrapperForServerSds;
-    @Nullable private final ProtocolNegotiator fallbackProtocolNegotiator;
-
-    HandlerPickerHandler(
-        GrpcHttp2ConnectionHandler grpcHandler,
-        @Nullable XdsClientWrapperForServerSds xdsClientWrapperForServerSds,
-        ProtocolNegotiator fallbackProtocolNegotiator) {
-      this.grpcHandler = checkNotNull(grpcHandler, "grpcHandler");
-      this.xdsClientWrapperForServerSds = xdsClientWrapperForServerSds;
-      this.fallbackProtocolNegotiator = fallbackProtocolNegotiator;
-    }
-
-    @Override
-    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
-      if (evt instanceof ProtocolNegotiationEvent) {
-        DownstreamTlsContext downstreamTlsContext =
-            xdsClientWrapperForServerSds == null
-                ? null
-                : xdsClientWrapperForServerSds.getDownstreamTlsContext(ctx.channel());
-        if (downstreamTlsContext == null) {
-          if (fallbackProtocolNegotiator == null) {
-            ctx.fireExceptionCaught(new CertStoreException("No certificate source found!"));
-            return;
-          }
-          logger.log(Level.INFO, "Using fallback for {0}", ctx.channel().localAddress());
-          ctx.pipeline()
-              .replace(
-                  this,
-                  null,
-                  fallbackProtocolNegotiator.newHandler(grpcHandler));
-          ProtocolNegotiationEvent pne = InternalProtocolNegotiationEvent.getDefault();
-          ctx.fireUserEventTriggered(pne);
-          return;
-        } else {
-          ctx.pipeline()
-              .replace(
-                  this,
-                  null,
-                  new ServerSdsHandler(
-                      grpcHandler, downstreamTlsContext, fallbackProtocolNegotiator));
-          ProtocolNegotiationEvent pne = InternalProtocolNegotiationEvent.getDefault();
-          ctx.fireUserEventTriggered(pne);
-          return;
-        }
-      } else {
-        super.userEventTriggered(ctx, evt);
-      }
-    }
-  }
-
-  @VisibleForTesting
-  static final class ServerSdsHandler
-          extends InternalProtocolNegotiators.ProtocolNegotiationHandler {
-    private final GrpcHttp2ConnectionHandler grpcHandler;
-    private final DownstreamTlsContext downstreamTlsContext;
-    @Nullable private final ProtocolNegotiator fallbackProtocolNegotiator;
-
-    ServerSdsHandler(
-            GrpcHttp2ConnectionHandler grpcHandler,
-            DownstreamTlsContext downstreamTlsContext,
-            ProtocolNegotiator fallbackProtocolNegotiator) {
-      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);
-            }
-          });
-      checkNotNull(grpcHandler, "grpcHandler");
-      this.grpcHandler = grpcHandler;
-      this.downstreamTlsContext = downstreamTlsContext;
-      this.fallbackProtocolNegotiator = fallbackProtocolNegotiator;
-    }
-
-    @Override
-    protected void handlerAdded0(final ChannelHandlerContext ctx) {
-      final BufferReadsHandler bufferReads = new BufferReadsHandler();
-      ctx.pipeline().addBefore(ctx.name(), null, bufferReads);
-
-      SslContextProvider sslContextProviderTemp = null;
-      try {
-        sslContextProviderTemp =
-            TlsContextManagerImpl.getInstance()
-                .findOrCreateServerSslContextProvider(downstreamTlsContext);
-      } catch (Exception e) {
-        if (fallbackProtocolNegotiator == null) {
-          ctx.fireExceptionCaught(new CertStoreException("No certificate source found!", e));
-          return;
-        }
-        logger.log(Level.INFO, "Using fallback for {0}", ctx.channel().localAddress());
-        // Delegate rest of handshake to fallback handler
-        ctx.pipeline().replace(this, null, fallbackProtocolNegotiator.newHandler(grpcHandler));
-        ctx.pipeline().remove(bufferReads);
-        return;
-      }
-      final SslContextProvider sslContextProvider = sslContextProviderTemp;
-      sslContextProvider.addCallback(
-          new SslContextProvider.Callback(ctx.executor()) {
-
-            @Override
-            public void updateSecret(SslContext sslContext) {
-              ChannelHandler handler =
-                  InternalProtocolNegotiators.serverTls(sslContext).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);
-              }
-              TlsContextManagerImpl.getInstance()
-                  .releaseServerSslContextProvider(sslContextProvider);
-            }
-
-            @Override
-            public void onException(Throwable throwable) {
-              ctx.fireExceptionCaught(throwable);
-            }
-          }
-      );
-    }
-  }
-}
diff --git a/xds/src/main/java/io/grpc/xds/internal/sds/SdsServerSslContextProvider.java b/xds/src/main/java/io/grpc/xds/internal/sds/SdsServerSslContextProvider.java
deleted file mode 100644
index 649309dc677..00000000000
--- a/xds/src/main/java/io/grpc/xds/internal/sds/SdsServerSslContextProvider.java
+++ /dev/null
@@ -1,96 +0,0 @@
-/*
- * 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.sds;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-import io.envoyproxy.envoy.api.v2.core.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.SdsSecretConfig;
-import io.grpc.netty.GrpcSslContexts;
-import io.grpc.xds.EnvoyServerProtoData.DownstreamTlsContext;
-import io.grpc.xds.internal.sds.trust.SdsTrustManagerFactory;
-import io.netty.handler.ssl.SslContextBuilder;
-import java.io.IOException;
-import java.security.cert.CertStoreException;
-import java.security.cert.CertificateException;
-import java.util.concurrent.Executor;
-
-/** A server SslContext provider that uses SDS to fetch secrets. */
-final class SdsServerSslContextProvider extends SdsSslContextProvider {
-
-  private SdsServerSslContextProvider(
-      Node node,
-      SdsSecretConfig certSdsConfig,
-      SdsSecretConfig validationContextSdsConfig,
-      Executor watcherExecutor,
-      Executor channelExecutor,
-      DownstreamTlsContext downstreamTlsContext) {
-    super(node,
-        certSdsConfig,
-        validationContextSdsConfig,
-        null,
-        watcherExecutor,
-        channelExecutor, downstreamTlsContext);
-  }
-
-  static SdsServerSslContextProvider getProvider(
-      DownstreamTlsContext downstreamTlsContext,
-      Node node,
-      Executor watcherExecutor,
-      Executor channelExecutor) {
-    checkNotNull(downstreamTlsContext, "downstreamTlsContext");
-    CommonTlsContext commonTlsContext = downstreamTlsContext.getCommonTlsContext();
-
-    SdsSecretConfig certSdsConfig = null;
-    if (commonTlsContext.getTlsCertificateSdsSecretConfigsCount() > 0) {
-      certSdsConfig = commonTlsContext.getTlsCertificateSdsSecretConfigs(0);
-    }
-
-    SdsSecretConfig validationContextSdsConfig = null;
-    if (commonTlsContext.hasValidationContextSdsSecretConfig()) {
-      validationContextSdsConfig = commonTlsContext.getValidationContextSdsSecretConfig();
-    }
-    return new SdsServerSslContextProvider(
-        node,
-        certSdsConfig,
-        validationContextSdsConfig,
-        watcherExecutor,
-        channelExecutor,
-        downstreamTlsContext);
-  }
-
-  @Override
-  protected final SslContextBuilder getSslContextBuilder(
-      CertificateValidationContext localCertValidationContext)
-      throws CertificateException, IOException, CertStoreException {
-    SslContextBuilder sslContextBuilder =
-        GrpcSslContexts.forServer(
-            tlsCertificate.getCertificateChain().getInlineBytes().newInput(),
-            tlsCertificate.getPrivateKey().getInlineBytes().newInput(),
-            tlsCertificate.hasPassword()
-                ? tlsCertificate.getPassword().getInlineString()
-                : null);
-    setClientAuthValues(
-        sslContextBuilder,
-        localCertValidationContext != null
-            ? new SdsTrustManagerFactory(localCertValidationContext)
-            : null);
-    return sslContextBuilder;
-  }
-}
diff --git a/xds/src/main/java/io/grpc/xds/internal/sds/SdsSslContextProvider.java b/xds/src/main/java/io/grpc/xds/internal/sds/SdsSslContextProvider.java
deleted file mode 100644
index b70c2f1e5cb..00000000000
--- a/xds/src/main/java/io/grpc/xds/internal/sds/SdsSslContextProvider.java
+++ /dev/null
@@ -1,129 +0,0 @@
-/*
- * 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.sds;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-import static com.google.common.base.Preconditions.checkState;
-
-import io.envoyproxy.envoy.api.v2.core.Node;
-import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.CertificateValidationContext;
-import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.SdsSecretConfig;
-import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.Secret;
-import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.TlsCertificate;
-import io.grpc.xds.EnvoyServerProtoData.BaseTlsContext;
-import java.util.concurrent.Executor;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-import javax.annotation.Nullable;
-
-/** Base class for  SdsClientSslContextProvider and SdsServerSslContextProvider. */
-abstract class SdsSslContextProvider extends DynamicSslContextProvider implements
-    SdsClient.SecretWatcher {
-
-  private static final Logger logger = Logger.getLogger(SdsSslContextProvider.class.getName());
-
-  @Nullable private final SdsClient certSdsClient;
-  @Nullable private final SdsClient validationContextSdsClient;
-  @Nullable private final SdsSecretConfig certSdsConfig;
-  @Nullable private final SdsSecretConfig validationContextSdsConfig;
-  @Nullable protected TlsCertificate tlsCertificate;
-  @Nullable private CertificateValidationContext certificateValidationContext;
-
-  protected SdsSslContextProvider(
-      Node node,
-      SdsSecretConfig certSdsConfig,
-      SdsSecretConfig validationContextSdsConfig,
-      CertificateValidationContext staticCertValidationContext,
-      Executor watcherExecutor,
-      Executor channelExecutor,
-      BaseTlsContext tlsContext) {
-    super(tlsContext, staticCertValidationContext);
-    this.certSdsConfig = certSdsConfig;
-    this.validationContextSdsConfig = validationContextSdsConfig;
-    if (certSdsConfig != null && certSdsConfig.isInitialized()) {
-      certSdsClient =
-          SdsClient.Factory.createSdsClient(certSdsConfig, node, watcherExecutor, channelExecutor);
-      certSdsClient.start();
-      certSdsClient.watchSecret(this);
-    } else {
-      certSdsClient = null;
-    }
-    if (validationContextSdsConfig != null && validationContextSdsConfig.isInitialized()) {
-      validationContextSdsClient =
-          SdsClient.Factory.createSdsClient(
-              validationContextSdsConfig, node, watcherExecutor, channelExecutor);
-      validationContextSdsClient.start();
-      validationContextSdsClient.watchSecret(this);
-    } else {
-      validationContextSdsClient = null;
-    }
-  }
-
-  @Override
-  public final synchronized void onSecretChanged(Secret secretUpdate) {
-    checkNotNull(secretUpdate);
-    if (secretUpdate.hasTlsCertificate()) {
-      checkState(
-          secretUpdate.getName().equals(certSdsConfig.getName()), "tlsCert names don't match");
-      logger.log(Level.FINEST, "onSecretChanged certSdsConfig.name={0}", certSdsConfig.getName());
-      tlsCertificate = secretUpdate.getTlsCertificate();
-      if (certificateValidationContext != null || validationContextSdsConfig == null) {
-        updateSslContext();
-      }
-    } else if (secretUpdate.hasValidationContext()) {
-      checkState(
-          secretUpdate.getName().equals(validationContextSdsConfig.getName()),
-          "validationContext names don't match");
-      logger.log(
-          Level.FINEST,
-          "onSecretChanged validationContextSdsConfig.name={0}",
-          validationContextSdsConfig.getName());
-      certificateValidationContext = secretUpdate.getValidationContext();
-      if (tlsCertificate != null || certSdsConfig == null) {
-        updateSslContext();
-      }
-    } else {
-      throw new UnsupportedOperationException(
-          "Unexpected secret type:" + secretUpdate.getTypeCase());
-    }
-  }
-
-  @Override
-  protected final CertificateValidationContext generateCertificateValidationContext() {
-    if (staticCertificateValidationContext == null) {
-      return certificateValidationContext;
-    }
-    if (certificateValidationContext == null) {
-      return staticCertificateValidationContext;
-    }
-    CertificateValidationContext.Builder localCertContextBuilder =
-        certificateValidationContext.toBuilder();
-    return localCertContextBuilder.mergeFrom(staticCertificateValidationContext).build();
-  }
-
-  @Override
-  public final void close() {
-    if (certSdsClient != null) {
-      certSdsClient.cancelSecretWatch(this);
-      certSdsClient.shutdown();
-    }
-    if (validationContextSdsClient != null) {
-      validationContextSdsClient.cancelSecretWatch(this);
-      validationContextSdsClient.shutdown();
-    }
-  }
-}
diff --git a/xds/src/main/java/io/grpc/xds/internal/sds/SecretVolumeClientSslContextProvider.java b/xds/src/main/java/io/grpc/xds/internal/sds/SecretVolumeClientSslContextProvider.java
deleted file mode 100644
index 8698c6cc099..00000000000
--- a/xds/src/main/java/io/grpc/xds/internal/sds/SecretVolumeClientSslContextProvider.java
+++ /dev/null
@@ -1,127 +0,0 @@
-/*
- * 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.sds;
-
-import static com.google.common.base.Preconditions.checkArgument;
-import static com.google.common.base.Preconditions.checkNotNull;
-import static io.grpc.xds.internal.sds.CommonTlsContextUtil.getCertificateValidationContext;
-import static io.grpc.xds.internal.sds.CommonTlsContextUtil.validateCertificateContext;
-import static io.grpc.xds.internal.sds.CommonTlsContextUtil.validateTlsCertificate;
-
-import com.google.common.annotations.VisibleForTesting;
-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.grpc.netty.GrpcSslContexts;
-import io.grpc.xds.EnvoyServerProtoData.UpstreamTlsContext;
-import io.grpc.xds.internal.sds.trust.SdsTrustManagerFactory;
-import io.netty.handler.ssl.SslContext;
-import io.netty.handler.ssl.SslContextBuilder;
-import java.io.File;
-import java.io.IOException;
-import java.security.cert.CertStoreException;
-import java.security.cert.CertificateException;
-import javax.annotation.Nullable;
-
-/** A client SslContext provider that uses file-based secrets (secret volume). */
-final class SecretVolumeClientSslContextProvider extends SslContextProvider {
-
-  @Nullable private final String privateKey;
-  @Nullable private final String privateKeyPassword;
-  @Nullable private final String certificateChain;
-  @Nullable private final CertificateValidationContext certContext;
-
-  private SecretVolumeClientSslContextProvider(
-      @Nullable String privateKey,
-      @Nullable String privateKeyPassword,
-      @Nullable String certificateChain,
-      @Nullable CertificateValidationContext certContext,
-      UpstreamTlsContext upstreamTlsContext) {
-    super(upstreamTlsContext);
-    this.privateKey = privateKey;
-    this.privateKeyPassword = privateKeyPassword;
-    this.certificateChain = certificateChain;
-    this.certContext = certContext;
-  }
-
-  static SecretVolumeClientSslContextProvider getProvider(UpstreamTlsContext upstreamTlsContext) {
-    checkNotNull(upstreamTlsContext, "upstreamTlsContext");
-    CommonTlsContext commonTlsContext = upstreamTlsContext.getCommonTlsContext();
-    checkArgument(
-        commonTlsContext.getTlsCertificateSdsSecretConfigsCount() == 0,
-        "unexpected TlsCertificateSdsSecretConfigs");
-    CertificateValidationContext certificateValidationContext =
-        getCertificateValidationContext(commonTlsContext);
-    // first validate
-    validateCertificateContext(certificateValidationContext, /* optional= */ false);
-    TlsCertificate tlsCertificate = null;
-    if (commonTlsContext.getTlsCertificatesCount() > 0) {
-      tlsCertificate = commonTlsContext.getTlsCertificates(0);
-    }
-    // tlsCertificate exists in case of mTLS, else null for a client
-    if (tlsCertificate != null) {
-      tlsCertificate = validateTlsCertificate(tlsCertificate, /* optional= */ true);
-    }
-    String privateKey = null;
-    String privateKeyPassword = null;
-    String certificateChain = null;
-    if (tlsCertificate != null) {
-      privateKey = tlsCertificate.getPrivateKey().getFilename();
-      if (tlsCertificate.hasPassword()) {
-        privateKeyPassword = tlsCertificate.getPassword().getInlineString();
-      }
-      certificateChain = tlsCertificate.getCertificateChain().getFilename();
-    }
-    return new SecretVolumeClientSslContextProvider(
-        privateKey,
-        privateKeyPassword,
-        certificateChain,
-        certificateValidationContext,
-        upstreamTlsContext);
-  }
-
-  @Override
-  public void addCallback(final Callback callback) {
-    checkNotNull(callback, "callback");
-    // as per the contract we will read the current secrets on disk
-    // this involves I/O which can potentially block the executor
-    performCallback(
-        new SslContextGetter() {
-          @Override
-          public SslContext get() throws CertificateException, IOException, CertStoreException {
-            return buildSslContextFromSecrets();
-          }
-        },
-        callback
-    );
-  }
-
-  @Override
-  public void close() {}
-
-  @VisibleForTesting
-  SslContext buildSslContextFromSecrets()
-      throws IOException, CertificateException, CertStoreException {
-    SslContextBuilder sslContextBuilder =
-        GrpcSslContexts.forClient().trustManager(new SdsTrustManagerFactory(certContext));
-    if (privateKey != null && certificateChain != null) {
-      sslContextBuilder.keyManager(
-          new File(certificateChain), new File(privateKey), privateKeyPassword);
-    }
-    return sslContextBuilder.build();
-  }
-}
diff --git a/xds/src/main/java/io/grpc/xds/internal/sds/SecretVolumeServerSslContextProvider.java b/xds/src/main/java/io/grpc/xds/internal/sds/SecretVolumeServerSslContextProvider.java
deleted file mode 100644
index f1bb93a6513..00000000000
--- a/xds/src/main/java/io/grpc/xds/internal/sds/SecretVolumeServerSslContextProvider.java
+++ /dev/null
@@ -1,120 +0,0 @@
-/*
- * 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.sds;
-
-import static com.google.common.base.Preconditions.checkArgument;
-import static com.google.common.base.Preconditions.checkNotNull;
-import static io.grpc.xds.internal.sds.CommonTlsContextUtil.getCertificateValidationContext;
-import static io.grpc.xds.internal.sds.CommonTlsContextUtil.validateCertificateContext;
-import static io.grpc.xds.internal.sds.CommonTlsContextUtil.validateTlsCertificate;
-
-import com.google.common.annotations.VisibleForTesting;
-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.grpc.netty.GrpcSslContexts;
-import io.grpc.xds.EnvoyServerProtoData.DownstreamTlsContext;
-import io.grpc.xds.internal.sds.trust.SdsTrustManagerFactory;
-import io.netty.handler.ssl.SslContext;
-import io.netty.handler.ssl.SslContextBuilder;
-import java.io.File;
-import java.io.IOException;
-import java.security.cert.CertStoreException;
-import java.security.cert.CertificateException;
-import javax.annotation.Nullable;
-
-/** A server SslContext provider that uses file-based secrets (secret volume). */
-final class SecretVolumeServerSslContextProvider extends SslContextProvider {
-
-  @Nullable private final String privateKey;
-  @Nullable private final String privateKeyPassword;
-  @Nullable private final String certificateChain;
-  @Nullable private final CertificateValidationContext certContext;
-
-  private SecretVolumeServerSslContextProvider(
-      @Nullable String privateKey,
-      @Nullable String privateKeyPassword,
-      @Nullable String certificateChain,
-      @Nullable CertificateValidationContext certContext,
-      DownstreamTlsContext downstreamTlsContext) {
-    super(downstreamTlsContext);
-    this.privateKey = privateKey;
-    this.privateKeyPassword = privateKeyPassword;
-    this.certificateChain = certificateChain;
-    this.certContext = certContext;
-  }
-
-  static SecretVolumeServerSslContextProvider getProvider(
-      DownstreamTlsContext downstreamTlsContext) {
-    checkNotNull(downstreamTlsContext, "downstreamTlsContext");
-    CommonTlsContext commonTlsContext = downstreamTlsContext.getCommonTlsContext();
-    checkArgument(
-        commonTlsContext.getTlsCertificateSdsSecretConfigsCount() == 0,
-        "unexpected TlsCertificateSdsSecretConfigs");
-    TlsCertificate tlsCertificate = null;
-    if (commonTlsContext.getTlsCertificatesCount() > 0) {
-      tlsCertificate = commonTlsContext.getTlsCertificates(0);
-    }
-    // first validate
-    validateTlsCertificate(tlsCertificate, /* optional= */ false);
-    CertificateValidationContext certificateValidationContext =
-        getCertificateValidationContext(commonTlsContext);
-    // certificateValidationContext exists in case of mTLS, else null for a server
-    if (certificateValidationContext != null) {
-      certificateValidationContext =
-          validateCertificateContext(certificateValidationContext, /* optional= */ true);
-    }
-    String privateKeyPassword =
-        tlsCertificate.hasPassword() ? tlsCertificate.getPassword().getInlineString() : null;
-    return new SecretVolumeServerSslContextProvider(
-        tlsCertificate.getPrivateKey().getFilename(),
-        privateKeyPassword,
-        tlsCertificate.getCertificateChain().getFilename(),
-        certificateValidationContext,
-        downstreamTlsContext);
-  }
-
-  @Override
-  public void addCallback(final Callback callback) {
-    checkNotNull(callback, "callback");
-    // as per the contract we will read the current secrets on disk
-    // this involves I/O which can potentially block the executor
-    performCallback(
-        new SslContextGetter() {
-          @Override
-          public SslContext get() throws CertificateException, IOException, CertStoreException {
-            return buildSslContextFromSecrets();
-          }
-        },
-        callback
-    );
-  }
-
-  @Override
-  public void close() {}
-
-  @VisibleForTesting
-  SslContext buildSslContextFromSecrets()
-      throws IOException, CertificateException, CertStoreException {
-    SslContextBuilder sslContextBuilder =
-        GrpcSslContexts.forServer(
-            new File(certificateChain), new File(privateKey), privateKeyPassword);
-    setClientAuthValues(
-        sslContextBuilder, certContext != null ? new SdsTrustManagerFactory(certContext) : null);
-    return sslContextBuilder.build();
-  }
-}
diff --git a/xds/src/main/java/io/grpc/xds/internal/sds/ServerSslContextProviderFactory.java b/xds/src/main/java/io/grpc/xds/internal/sds/ServerSslContextProviderFactory.java
deleted file mode 100644
index cd5bc852830..00000000000
--- a/xds/src/main/java/io/grpc/xds/internal/sds/ServerSslContextProviderFactory.java
+++ /dev/null
@@ -1,86 +0,0 @@
-/*
- * 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.sds;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-import com.google.common.util.concurrent.ThreadFactoryBuilder;
-import io.grpc.xds.Bootstrapper;
-import io.grpc.xds.EnvoyServerProtoData.DownstreamTlsContext;
-import io.grpc.xds.XdsInitializationException;
-import io.grpc.xds.internal.certprovider.CertProviderServerSslContextProvider;
-import io.grpc.xds.internal.sds.ReferenceCountingMap.ValueFactory;
-import java.util.concurrent.Executors;
-
-/** Factory to create server-side SslContextProvider from DownstreamTlsContext. */
-final class ServerSslContextProviderFactory
-    implements ValueFactory<DownstreamTlsContext, SslContextProvider> {
-
-  private final Bootstrapper bootstrapper;
-  private final CertProviderServerSslContextProvider.Factory
-      certProviderServerSslContextProviderFactory;
-
-  ServerSslContextProviderFactory(Bootstrapper bootstrapper) {
-    this(bootstrapper, CertProviderServerSslContextProvider.Factory.getInstance());
-  }
-
-  ServerSslContextProviderFactory(
-      Bootstrapper bootstrapper, CertProviderServerSslContextProvider.Factory factory) {
-    this.bootstrapper = bootstrapper;
-    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())) {
-      try {
-        Bootstrapper.BootstrapInfo bootstrapInfo = bootstrapper.bootstrap();
-        return certProviderServerSslContextProviderFactory.getProvider(
-                downstreamTlsContext,
-                bootstrapInfo.getNode().toEnvoyProtoNode(),
-                bootstrapInfo.getCertProviders());
-      } catch (XdsInitializationException e) {
-        throw new RuntimeException(e);
-      }
-    } else if (CommonTlsContextUtil.hasAllSecretsUsingFilename(
-        downstreamTlsContext.getCommonTlsContext())) {
-      return SecretVolumeServerSslContextProvider.getProvider(downstreamTlsContext);
-    } else if (CommonTlsContextUtil.hasAllSecretsUsingSds(
-        downstreamTlsContext.getCommonTlsContext())) {
-      try {
-        return SdsServerSslContextProvider.getProvider(
-            downstreamTlsContext,
-            bootstrapper.bootstrap().getNode().toEnvoyProtoNodeV2(),
-            Executors.newSingleThreadExecutor(new ThreadFactoryBuilder()
-                .setNameFormat("server-sds-sslcontext-provider-%d")
-                .setDaemon(true)
-                .build()),
-            /* channelExecutor= */ null);
-      } catch (XdsInitializationException e) {
-        throw new RuntimeException(e);
-      }
-    }
-    throw new UnsupportedOperationException("Unsupported configurations in DownstreamTlsContext!");
-  }
-}
diff --git a/xds/src/main/java/io/grpc/xds/internal/sds/ServerWrapperForXds.java b/xds/src/main/java/io/grpc/xds/internal/sds/ServerWrapperForXds.java
deleted file mode 100644
index cc75261f1ef..00000000000
--- a/xds/src/main/java/io/grpc/xds/internal/sds/ServerWrapperForXds.java
+++ /dev/null
@@ -1,170 +0,0 @@
-/*
- * 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.sds;
-
-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.util.concurrent.SettableFuture;
-import io.grpc.Server;
-import io.grpc.ServerServiceDefinition;
-import io.grpc.xds.EnvoyServerProtoData;
-import io.grpc.xds.XdsClientWrapperForServerSds;
-import io.grpc.xds.XdsServerBuilder;
-import java.io.IOException;
-import java.net.SocketAddress;
-import java.util.List;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.Future;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicBoolean;
-import javax.annotation.Nullable;
-
-/**
- * Wraps a {@link Server} delegate and {@link XdsClientWrapperForServerSds} and intercepts {@link
- * Server#shutdown()} and {@link Server#start()} to shut down and start the
- * {@link XdsClientWrapperForServerSds} object.
- */
-@VisibleForTesting
-public final class ServerWrapperForXds extends Server {
-  private final Server delegate;
-  private final XdsClientWrapperForServerSds xdsClientWrapperForServerSds;
-  private XdsServerBuilder.XdsServingStatusListener xdsServingStatusListener;
-  @Nullable XdsClientWrapperForServerSds.ServerWatcher serverWatcher;
-  private AtomicBoolean started = new AtomicBoolean();
-
-  /** Creates the wrapper object using the delegate passed. */
-  public ServerWrapperForXds(
-      Server delegate,
-      XdsClientWrapperForServerSds xdsClientWrapperForServerSds,
-      XdsServerBuilder.XdsServingStatusListener xdsServingStatusListener) {
-    this.delegate = checkNotNull(delegate, "delegate");
-    this.xdsClientWrapperForServerSds =
-        checkNotNull(xdsClientWrapperForServerSds, "xdsClientWrapperForServerSds");
-    this.xdsServingStatusListener =
-        checkNotNull(xdsServingStatusListener, "xdsServingStatusListener");
-  }
-
-  @Override
-  public Server start() throws IOException {
-    checkState(started.compareAndSet(false, true), "Already started");
-    Future<EnvoyServerProtoData.DownstreamTlsContext> future = addServerWatcher();
-    if (!xdsClientWrapperForServerSds.hasXdsClient()) {
-      xdsClientWrapperForServerSds.createXdsClientAndStart();
-    }
-    try {
-      future.get();
-    } catch (InterruptedException | ExecutionException ex) {
-      removeServerWatcher();
-      if (ex instanceof InterruptedException) {
-        Thread.currentThread().interrupt();
-      }
-      throw new RuntimeException(ex);
-    }
-    delegate.start();
-    xdsServingStatusListener.onServing();
-    return this;
-  }
-
-  private Future<EnvoyServerProtoData.DownstreamTlsContext> addServerWatcher() {
-    final SettableFuture<EnvoyServerProtoData.DownstreamTlsContext> settableFuture =
-        SettableFuture.create();
-    serverWatcher =
-        new XdsClientWrapperForServerSds.ServerWatcher() {
-          @Override
-          public void onError(Throwable throwable) {
-            xdsServingStatusListener.onNotServing(throwable);
-          }
-
-          @Override
-          public void onSuccess() {
-            settableFuture.set(null);
-          }
-        };
-    xdsClientWrapperForServerSds.addServerWatcher(serverWatcher);
-    return settableFuture;
-  }
-
-  private void removeServerWatcher() {
-    synchronized (xdsClientWrapperForServerSds) {
-      if (serverWatcher != null) {
-        xdsClientWrapperForServerSds.removeServerWatcher(serverWatcher);
-        serverWatcher = null;
-      }
-    }
-  }
-
-  @Override
-  public Server shutdown() {
-    delegate.shutdown();
-    xdsClientWrapperForServerSds.shutdown();
-    return this;
-  }
-
-  @Override
-  public Server shutdownNow() {
-    delegate.shutdownNow();
-    xdsClientWrapperForServerSds.shutdown();
-    return this;
-  }
-
-  @Override
-  public boolean isShutdown() {
-    return delegate.isShutdown();
-  }
-
-  @Override
-  public boolean isTerminated() {
-    return delegate.isTerminated();
-  }
-
-  @Override
-  public boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException {
-    return delegate.awaitTermination(timeout, unit);
-  }
-
-  @Override
-  public void awaitTermination() throws InterruptedException {
-    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();
-  }
-}
diff --git a/xds/src/main/java/io/grpc/xds/internal/sds/SslContextProviderSupplier.java b/xds/src/main/java/io/grpc/xds/internal/sds/SslContextProviderSupplier.java
deleted file mode 100644
index 715b81f35a9..00000000000
--- a/xds/src/main/java/io/grpc/xds/internal/sds/SslContextProviderSupplier.java
+++ /dev/null
@@ -1,85 +0,0 @@
-/*
- * 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.sds;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-import static com.google.common.base.Preconditions.checkState;
-
-import io.grpc.xds.EnvoyServerProtoData.UpstreamTlsContext;
-import io.netty.handler.ssl.SslContext;
-
-/**
- * Enables the CDS policy to initialize this object with the received {@link UpstreamTlsContext} &
- * communicate it to the consumer i.e. {@link SdsProtocolNegotiators.ClientSdsProtocolNegotiator}
- * to lazily evaluate the {@link SslContextProvider}. The supplier prevents credentials leakage in
- * cases where the user is not using xDS credentials but the CDS policy contains a non-default
- * {@link UpstreamTlsContext}.
- */
-public final class SslContextProviderSupplier implements Closeable {
-
-  private final UpstreamTlsContext upstreamTlsContext;
-  private final TlsContextManager tlsContextManager;
-  private SslContextProvider sslContextProvider;
-  private boolean shutdown;
-
-  public SslContextProviderSupplier(
-      UpstreamTlsContext upstreamTlsContext, TlsContextManager tlsContextManager) {
-    this.upstreamTlsContext = upstreamTlsContext;
-    this.tlsContextManager = tlsContextManager;
-  }
-
-  public UpstreamTlsContext getUpstreamTlsContext() {
-    return upstreamTlsContext;
-  }
-
-  /** Updates SslContext via the passed callback. */
-  public synchronized void updateSslContext(final SslContextProvider.Callback callback) {
-    checkNotNull(callback, "callback");
-    checkState(!shutdown, "Supplier is shutdown!");
-    if (sslContextProvider == null) {
-      sslContextProvider =
-          tlsContextManager.findOrCreateClientSslContextProvider(upstreamTlsContext);
-    }
-    // we want to increment the ref-count so call findOrCreate again...
-    final SslContextProvider toRelease =
-        tlsContextManager.findOrCreateClientSslContextProvider(upstreamTlsContext);
-    sslContextProvider.addCallback(
-        new SslContextProvider.Callback(callback.getExecutor()) {
-
-          @Override
-          public void updateSecret(SslContext sslContext) {
-            callback.updateSecret(sslContext);
-            tlsContextManager.releaseClientSslContextProvider(toRelease);
-          }
-
-          @Override
-          public void onException(Throwable throwable) {
-            callback.onException(throwable);
-            tlsContextManager.releaseClientSslContextProvider(toRelease);
-          }
-        });
-  }
-
-  /** Called by {@link io.grpc.xds.CdsLoadBalancer} when upstreamTlsContext changes. */
-  @Override
-  public synchronized void close() {
-    if (sslContextProvider != null) {
-      tlsContextManager.releaseClientSslContextProvider(sslContextProvider);
-    }
-    shutdown = true;
-  }
-}
diff --git a/xds/src/main/java/io/grpc/xds/internal/sds/TlsContextManagerImpl.java b/xds/src/main/java/io/grpc/xds/internal/sds/TlsContextManagerImpl.java
deleted file mode 100644
index ef5e4b3d5a7..00000000000
--- a/xds/src/main/java/io/grpc/xds/internal/sds/TlsContextManagerImpl.java
+++ /dev/null
@@ -1,138 +0,0 @@
-/*
- * 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.sds;
-
-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.Bootstrapper;
-import io.grpc.xds.BootstrapperImpl;
-import io.grpc.xds.EnvoyServerProtoData.DownstreamTlsContext;
-import io.grpc.xds.EnvoyServerProtoData.UpstreamTlsContext;
-import io.grpc.xds.internal.sds.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 {
-
-  public static final String GOOGLE_CLOUD_PRIVATE_SPIFFE = "google_cloud_private_spiffe";
-  private static TlsContextManagerImpl instance;
-
-  private static final boolean CERT_INSTANCE_OVERRIDE =
-      Boolean.parseBoolean(System.getenv("GRPC_XDS_CERT_INSTANCE_OVERRIDE"));
-
-  private final ReferenceCountingMap<UpstreamTlsContext, SslContextProvider> mapForClients;
-  private final ReferenceCountingMap<DownstreamTlsContext, SslContextProvider> mapForServers;
-  private final boolean hasCertInstanceOverride;
-
-  /** Create a TlsContextManagerImpl instance using the passed in {@link Bootstrapper}. */
-  @VisibleForTesting public TlsContextManagerImpl(Bootstrapper bootstrapper) {
-    this(
-        new ClientSslContextProviderFactory(bootstrapper),
-        new ServerSslContextProviderFactory(bootstrapper), CERT_INSTANCE_OVERRIDE);
-  }
-
-  @VisibleForTesting
-  TlsContextManagerImpl(
-      ValueFactory<UpstreamTlsContext, SslContextProvider> clientFactory,
-      ValueFactory<DownstreamTlsContext, SslContextProvider> serverFactory,
-      boolean certInstanceOverride) {
-    checkNotNull(clientFactory, "clientFactory");
-    checkNotNull(serverFactory, "serverFactory");
-    mapForClients = new ReferenceCountingMap<>(clientFactory);
-    mapForServers = new ReferenceCountingMap<>(serverFactory);
-    this.hasCertInstanceOverride = certInstanceOverride;
-  }
-
-  /** Gets the TlsContextManagerImpl singleton. */
-  public static synchronized TlsContextManagerImpl getInstance() {
-    if (instance == null) {
-      instance = new TlsContextManagerImpl(new BootstrapperImpl());
-    }
-    return instance;
-  }
-
-  @Override
-  public SslContextProvider findOrCreateServerSslContextProvider(
-      DownstreamTlsContext downstreamTlsContext) {
-    checkNotNull(downstreamTlsContext, "downstreamTlsContext");
-    CommonTlsContext.Builder builder = downstreamTlsContext.getCommonTlsContext().toBuilder();
-    builder = performCertInstanceOverride(builder);
-    downstreamTlsContext =
-        new DownstreamTlsContext(
-            builder.build(), downstreamTlsContext.isRequireClientCertificate());
-    return mapForServers.get(downstreamTlsContext);
-  }
-
-  @Override
-  public SslContextProvider findOrCreateClientSslContextProvider(
-      UpstreamTlsContext upstreamTlsContext) {
-    checkNotNull(upstreamTlsContext, "upstreamTlsContext");
-    CommonTlsContext.Builder builder = upstreamTlsContext.getCommonTlsContext().toBuilder();
-    builder = performCertInstanceOverride(builder);
-    upstreamTlsContext = new UpstreamTlsContext(builder.build());
-    return mapForClients.get(upstreamTlsContext);
-  }
-
-  @VisibleForTesting
-  CommonTlsContext.Builder performCertInstanceOverride(CommonTlsContext.Builder builder) {
-    if (hasCertInstanceOverride) {
-      if (builder.getTlsCertificateSdsSecretConfigsCount() > 0) {
-        builder.setTlsCertificateCertificateProviderInstance(
-            CommonTlsContext.CertificateProviderInstance.newBuilder()
-                .setInstanceName(GOOGLE_CLOUD_PRIVATE_SPIFFE));
-      }
-      if (builder.hasCombinedValidationContext()) {
-        CommonTlsContext.CombinedCertificateValidationContext.Builder ccvcBuilder =
-                builder.getCombinedValidationContextBuilder();
-        if (ccvcBuilder.hasValidationContextSdsSecretConfig()) {
-          ccvcBuilder =
-              ccvcBuilder.setValidationContextCertificateProviderInstance(
-                  CommonTlsContext.CertificateProviderInstance.newBuilder()
-                      .setInstanceName(GOOGLE_CLOUD_PRIVATE_SPIFFE));
-          builder.setCombinedValidationContext(ccvcBuilder);
-        }
-      } else if (builder.hasValidationContextSdsSecretConfig()) {
-        builder.setValidationContextCertificateProviderInstance(
-            CommonTlsContext.CertificateProviderInstance.newBuilder()
-                .setInstanceName(GOOGLE_CLOUD_PRIVATE_SPIFFE));
-      }
-    }
-    return builder;
-  }
-
-  @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/sds/XdsChannelBuilder.java b/xds/src/main/java/io/grpc/xds/internal/sds/XdsChannelBuilder.java
deleted file mode 100644
index ab0384c42e9..00000000000
--- a/xds/src/main/java/io/grpc/xds/internal/sds/XdsChannelBuilder.java
+++ /dev/null
@@ -1,87 +0,0 @@
-/*
- * 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.sds;
-
-import io.grpc.ForwardingChannelBuilder;
-import io.grpc.ManagedChannel;
-import io.grpc.ManagedChannelBuilder;
-import io.grpc.netty.InternalNettyChannelBuilder;
-import io.grpc.netty.InternalProtocolNegotiator;
-import io.grpc.netty.NettyChannelBuilder;
-import java.net.SocketAddress;
-import javax.annotation.CheckReturnValue;
-
-/**
- * A version of {@link ManagedChannelBuilder} to create xDS managed channels that will use SDS to
- * set up SSL with peers. Note, this is not ready to use yet.
- */
-public final class XdsChannelBuilder extends ForwardingChannelBuilder<XdsChannelBuilder> {
-
-  private final NettyChannelBuilder delegate;
-  private InternalProtocolNegotiator.ProtocolNegotiator fallbackProtocolNegotiator;
-
-  private XdsChannelBuilder(NettyChannelBuilder delegate) {
-    this.delegate = delegate;
-  }
-
-  /**
-   * Creates a new builder with the given server address. See {@link
-   * NettyChannelBuilder#forAddress(SocketAddress)} for more info.
-   */
-  @CheckReturnValue
-  public static XdsChannelBuilder forAddress(SocketAddress serverAddress) {
-    return new XdsChannelBuilder(NettyChannelBuilder.forAddress(serverAddress));
-  }
-
-  /**
-   * Creates a new builder with the given host and port. See {@link
-   * NettyChannelBuilder#forAddress(String, int)} for more info.
-   */
-  @CheckReturnValue
-  public static XdsChannelBuilder forAddress(String host, int port) {
-    return new XdsChannelBuilder(NettyChannelBuilder.forAddress(host, port));
-  }
-
-  /**
-   * Creates a new builder with the given target string. See {@link
-   * NettyChannelBuilder#forTarget(String)} for more info.
-   */
-  @CheckReturnValue
-  public static XdsChannelBuilder forTarget(String target) {
-    return new XdsChannelBuilder(NettyChannelBuilder.forTarget(target));
-  }
-
-  /** Set the fallback protocolNegotiator. Pass null to unset a previously set value. */
-  public XdsChannelBuilder fallbackProtocolNegotiator(
-          InternalProtocolNegotiator.ProtocolNegotiator fallbackProtocolNegotiator) {
-    this.fallbackProtocolNegotiator = fallbackProtocolNegotiator;
-    return this;
-  }
-
-  @Override
-  protected ManagedChannelBuilder<?> delegate() {
-    return delegate;
-  }
-
-  @Override
-  public ManagedChannel build() {
-    InternalNettyChannelBuilder.setProtocolNegotiatorFactory(
-        delegate,
-        SdsProtocolNegotiators.clientProtocolNegotiatorFactory(fallbackProtocolNegotiator));
-    return delegate.build();
-  }
-}
diff --git a/xds/src/main/java/io/grpc/xds/internal/sds/trust/CertificateUtils.java b/xds/src/main/java/io/grpc/xds/internal/sds/trust/CertificateUtils.java
deleted file mode 100644
index e4ddb99a2b1..00000000000
--- a/xds/src/main/java/io/grpc/xds/internal/sds/trust/CertificateUtils.java
+++ /dev/null
@@ -1,145 +0,0 @@
-/*
- * 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.sds.trust;
-
-import io.netty.buffer.ByteBuf;
-import io.netty.buffer.Unpooled;
-import io.netty.handler.codec.base64.Base64;
-import io.netty.util.CharsetUtil;
-import java.io.BufferedInputStream;
-import java.io.ByteArrayOutputStream;
-import java.io.File;
-import java.io.FileInputStream;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.OutputStream;
-import java.security.KeyException;
-import java.security.KeyFactory;
-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.PKCS8EncodedKeySpec;
-import java.util.Collection;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-
-/**
- * Contains certificate utility method(s).
- */
-public final class CertificateUtils {
-  private static final Logger logger = Logger.getLogger(CertificateUtils.class.getName());
-
-  private static CertificateFactory factory;
-  private static final Pattern KEY_PATTERN = Pattern.compile(
-          "-+BEGIN\\s+.*PRIVATE\\s+KEY[^-]*-+(?:\\s|\\r|\\n)+" + // Header
-                  "([a-z0-9+/=\\r\\n]+)" +                             // Base64 text
-                  "-+END\\s+.*PRIVATE\\s+KEY[^-]*-+",                  // Footer
-          Pattern.CASE_INSENSITIVE);
-
-  private static synchronized void initInstance() throws CertificateException {
-    if (factory == null) {
-      factory = CertificateFactory.getInstance("X.509");
-    }
-  }
-
-  /**
-   * 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 synchronized X509Certificate[] toX509Certificates(InputStream inputStream)
-      throws CertificateException, IOException {
-    initInstance();
-    Collection<? extends Certificate> certs = factory.generateCertificates(inputStream);
-    return certs.toArray(new X509Certificate[0]);
-
-  }
-
-  /** See {@link CertificateFactory#generateCertificate(InputStream)}. */
-  public static synchronized X509Certificate toX509Certificate(InputStream inputStream)
-          throws CertificateException, IOException {
-    initInstance();
-    Certificate cert = factory.generateCertificate(inputStream);
-    return (X509Certificate) cert;
-  }
-
-  /** Generates a {@link PrivateKey} from the {@link InputStream}. */
-  public static PrivateKey getPrivateKey(InputStream inputStream)
-          throws Exception {
-    ByteBuf encodedKeyBuf = readPrivateKey(inputStream);
-    byte[] encodedKey = new byte[encodedKeyBuf.readableBytes()];
-    encodedKeyBuf.readBytes(encodedKey).release();
-    PKCS8EncodedKeySpec spec = new PKCS8EncodedKeySpec(encodedKey);
-    return KeyFactory.getInstance("RSA").generatePrivate(spec);
-  }
-
-  private static ByteBuf readPrivateKey(InputStream in) throws KeyException {
-    String content;
-    try {
-      content = readContent(in);
-    } catch (IOException e) {
-      throw new KeyException("failed to read key input stream", e);
-    }
-    Matcher m = KEY_PATTERN.matcher(content);
-    if (!m.find()) {
-      throw new KeyException("could not find a PKCS #8 private key in input stream");
-    }
-    ByteBuf base64 = Unpooled.copiedBuffer(m.group(1), CharsetUtil.US_ASCII);
-    ByteBuf der = Base64.decode(base64);
-    base64.release();
-    return der;
-  }
-
-  private static String readContent(InputStream in) throws IOException {
-    ByteArrayOutputStream out = new ByteArrayOutputStream();
-    try {
-      byte[] buf = new byte[8192];
-      for (; ; ) {
-        int ret = in.read(buf);
-        if (ret < 0) {
-          break;
-        }
-        out.write(buf, 0, ret);
-      }
-      return out.toString(CharsetUtil.US_ASCII.name());
-    } finally {
-      safeClose(out);
-    }
-  }
-
-  private static void safeClose(OutputStream out) {
-    try {
-      out.close();
-    } catch (IOException e) {
-      logger.log(Level.WARNING, "Failed to close a stream.", e);
-    }
-  }
-
-  private CertificateUtils() {}
-}
diff --git a/xds/src/main/java/io/grpc/xds/internal/sds/trust/SdsTrustManagerFactory.java b/xds/src/main/java/io/grpc/xds/internal/sds/trust/SdsTrustManagerFactory.java
deleted file mode 100644
index 479569f1596..00000000000
--- a/xds/src/main/java/io/grpc/xds/internal/sds/trust/SdsTrustManagerFactory.java
+++ /dev/null
@@ -1,153 +0,0 @@
-/*
- * 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.sds.trust;
-
-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.Strings;
-import io.envoyproxy.envoy.config.core.v3.DataSource.SpecifierCase;
-import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.CertificateValidationContext;
-import io.grpc.xds.internal.sds.TlsContextManagerImpl;
-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.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 by providers of {@link TlsContextManagerImpl} to provide a
- * {@link SdsX509TrustManager} for trust and SAN checks.
- */
-public final class SdsTrustManagerFactory extends SimpleTrustManagerFactory {
-
-  private static final Logger logger = Logger.getLogger(SdsTrustManagerFactory.class.getName());
-  private SdsX509TrustManager sdsX509TrustManager;
-
-  /** Constructor constructs from a {@link CertificateValidationContext}. */
-  public SdsTrustManagerFactory(CertificateValidationContext certificateValidationContext)
-      throws CertificateException, IOException, CertStoreException {
-    this(
-        getTrustedCaFromCertContext(certificateValidationContext),
-        certificateValidationContext,
-        false);
-  }
-
-  public SdsTrustManagerFactory(
-          X509Certificate[] certs, CertificateValidationContext staticCertificateValidationContext)
-          throws CertStoreException {
-    this(certs, staticCertificateValidationContext, true);
-  }
-
-  private SdsTrustManagerFactory(
-      X509Certificate[] certs,
-      CertificateValidationContext certificateValidationContext,
-      boolean validationContextIsStatic)
-      throws CertStoreException {
-    if (validationContextIsStatic) {
-      checkArgument(
-          certificateValidationContext == null || !certificateValidationContext.hasTrustedCa(),
-          "only static certificateValidationContext expected");
-    }
-    sdsX509TrustManager = createSdsX509TrustManager(certs, certificateValidationContext);
-  }
-
-  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 SdsX509TrustManager createSdsX509TrustManager(
-      X509Certificate[] certs, CertificateValidationContext certContext) 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, "createSdsX509TrustManager", 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 new SdsX509TrustManager(certContext, 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[] {sdsX509TrustManager};
-  }
-}
diff --git a/xds/src/main/java/io/grpc/xds/internal/sds/trust/SdsX509TrustManager.java b/xds/src/main/java/io/grpc/xds/internal/sds/trust/SdsX509TrustManager.java
deleted file mode 100644
index 1e16676d0a8..00000000000
--- a/xds/src/main/java/io/grpc/xds/internal/sds/trust/SdsX509TrustManager.java
+++ /dev/null
@@ -1,260 +0,0 @@
-/*
- * 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.sds.trust;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Strings;
-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 java.net.Socket;
-import java.security.cert.CertificateException;
-import java.security.cert.CertificateParsingException;
-import java.security.cert.X509Certificate;
-import java.util.Collection;
-import java.util.List;
-import javax.annotation.Nullable;
-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 SdsX509TrustManager 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 CertificateValidationContext certContext;
-
-  SdsX509TrustManager(@Nullable CertificateValidationContext certContext,
-      X509ExtendedTrustManager delegate) {
-    checkNotNull(delegate, "delegate");
-    this.certContext = certContext;
-    this.delegate = delegate;
-  }
-
-  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().startsWith(sanToVerifyPrefix.toLowerCase())
-        : altNameFromCert.startsWith(sanToVerifyPrefix);
-  }
-
-  private static boolean verifyDnsNameSuffix(
-          String altNameFromCert, String sanToVerifySuffix, boolean ignoreCase) {
-    if (Strings.isNullOrEmpty(sanToVerifySuffix)) {
-      return false;
-    }
-    return ignoreCase
-            ? altNameFromCert.toLowerCase().endsWith(sanToVerifySuffix.toLowerCase())
-            : altNameFromCert.endsWith(sanToVerifySuffix);
-  }
-
-  private static boolean verifyDnsNameContains(
-          String altNameFromCert, String sanToVerifySubstring, boolean ignoreCase) {
-    if (Strings.isNullOrEmpty(sanToVerifySubstring)) {
-      return false;
-    }
-    return ignoreCase
-            ? altNameFromCert.toLowerCase().contains(sanToVerifySubstring.toLowerCase())
-            : altNameFromCert.contains(sanToVerifySubstring);
-  }
-
-  private static boolean verifyDnsNameExact(
-      String altNameFromCert, String sanToVerifyExact, boolean ignoreCase) {
-    if (Strings.isNullOrEmpty(sanToVerifyExact)) {
-      return false;
-    }
-    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");
-    }
-    String altNameFromCert = (String) entry.get(1);
-    switch (altNameType) {
-      case ALT_DNS_NAME:
-      case ALT_URI_NAME:
-      case ALT_IPA_NAME:
-        return verifyDnsNameInSanList(altNameFromCert, verifySanList);
-      default:
-        throw new CertificateParsingException("Unsupported altNameType: " + altNameType);
-    }
-  }
-
-  // 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) throws CertificateException {
-    if (certContext == null) {
-      return;
-    }
-    List<StringMatcher> verifyList = certContext.getMatchSubjectAltNamesList();
-    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
-  public void checkClientTrusted(X509Certificate[] chain, String authType, Socket socket)
-      throws CertificateException {
-    delegate.checkClientTrusted(chain, authType, socket);
-    verifySubjectAltNameInChain(chain);
-  }
-
-  @Override
-  public void checkClientTrusted(X509Certificate[] chain, String authType, SSLEngine sslEngine)
-      throws CertificateException {
-    delegate.checkClientTrusted(chain, authType, sslEngine);
-    verifySubjectAltNameInChain(chain);
-  }
-
-  @Override
-  public void checkClientTrusted(X509Certificate[] chain, String authType)
-      throws CertificateException {
-    delegate.checkClientTrusted(chain, authType);
-    verifySubjectAltNameInChain(chain);
-  }
-
-  @Override
-  public void checkServerTrusted(X509Certificate[] chain, String authType, Socket socket)
-      throws CertificateException {
-    if (socket instanceof SSLSocket) {
-      SSLSocket sslSocket = (SSLSocket) socket;
-      SSLParameters sslParams = sslSocket.getSSLParameters();
-      if (sslParams != null) {
-        sslParams.setEndpointIdentificationAlgorithm(null);
-        sslSocket.setSSLParameters(sslParams);
-      }
-    }
-    delegate.checkServerTrusted(chain, authType, socket);
-    verifySubjectAltNameInChain(chain);
-  }
-
-  @Override
-  public void checkServerTrusted(X509Certificate[] chain, String authType, SSLEngine sslEngine)
-      throws CertificateException {
-    SSLParameters sslParams = sslEngine.getSSLParameters();
-    if (sslParams != null) {
-      sslParams.setEndpointIdentificationAlgorithm(null);
-      sslEngine.setSSLParameters(sslParams);
-    }
-    delegate.checkServerTrusted(chain, authType, sslEngine);
-    verifySubjectAltNameInChain(chain);
-  }
-
-  @Override
-  public void checkServerTrusted(X509Certificate[] chain, String authType)
-      throws CertificateException {
-    delegate.checkServerTrusted(chain, authType);
-    verifySubjectAltNameInChain(chain);
-  }
-
-  @Override
-  public X509Certificate[] getAcceptedIssuers() {
-    return delegate.getAcceptedIssuers();
-  }
-}
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/sds/Closeable.java b/xds/src/main/java/io/grpc/xds/internal/security/Closeable.java
similarity index 92%
rename from xds/src/main/java/io/grpc/xds/internal/sds/Closeable.java
rename to xds/src/main/java/io/grpc/xds/internal/security/Closeable.java
index c3695cecaf3..c78714abfbf 100644
--- a/xds/src/main/java/io/grpc/xds/internal/sds/Closeable.java
+++ b/xds/src/main/java/io/grpc/xds/internal/security/Closeable.java
@@ -14,10 +14,10 @@
  * limitations under the License.
  */
 
-package io.grpc.xds.internal.sds;
+package io.grpc.xds.internal.security;
 
 public interface Closeable extends java.io.Closeable {
 
   @Override
-  public void close();
+  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..e7b27cd644a
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/internal/security/DynamicSslContextProvider.java
@@ -0,0 +1,156 @@
+/*
+ * 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 DynamicSslContextProvider(
+      BaseTlsContext tlsContext, CertificateValidationContext staticCertValidationContext) {
+    super(tlsContext);
+    this.staticCertificateValidationContext = staticCertValidationContext;
+  }
+
+  @Nullable
+  public AbstractMap.SimpleImmutableEntry<SslContext, X509TrustManager>
+      getSslContextAndTrustManager() {
+    return sslContextAndTrustManager;
+  }
+
+  protected abstract CertificateValidationContext generateCertificateValidationContext();
+
+  /** 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/sds/ReferenceCountingMap.java b/xds/src/main/java/io/grpc/xds/internal/security/ReferenceCountingMap.java
similarity index 97%
rename from xds/src/main/java/io/grpc/xds/internal/sds/ReferenceCountingMap.java
rename to xds/src/main/java/io/grpc/xds/internal/security/ReferenceCountingMap.java
index 6a3a03a2870..08b8f6a325b 100644
--- a/xds/src/main/java/io/grpc/xds/internal/sds/ReferenceCountingMap.java
+++ b/xds/src/main/java/io/grpc/xds/internal/security/ReferenceCountingMap.java
@@ -14,15 +14,15 @@
  * limitations under the License.
  */
 
-package io.grpc.xds.internal.sds;
+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.CheckReturnValue;
 import javax.annotation.concurrent.ThreadSafe;
 
 /**
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..a93299de11c
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/internal/security/SecurityProtocolNegotiators.java
@@ -0,0 +1,414 @@
+/*
+ * 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);
+
+      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;
+    }
+
+    @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/sds/SslContextProvider.java b/xds/src/main/java/io/grpc/xds/internal/security/SslContextProvider.java
similarity index 83%
rename from xds/src/main/java/io/grpc/xds/internal/sds/SslContextProvider.java
rename to xds/src/main/java/io/grpc/xds/internal/security/SslContextProvider.java
index 6b661715e48..a5d14f72dc5 100644
--- a/xds/src/main/java/io/grpc/xds/internal/sds/SslContextProvider.java
+++ b/xds/src/main/java/io/grpc/xds/internal/security/SslContextProvider.java
@@ -14,24 +14,27 @@
  * limitations under the License.
  */
 
-package io.grpc.xds.internal.sds;
+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.sds.trust.SdsTrustManagerFactory;
+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
@@ -39,6 +42,7 @@
  * 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;
@@ -55,7 +59,8 @@ protected Callback(Executor executor) {
     }
 
     /** Informs callee of new/updated SslContext. */
-    @VisibleForTesting public abstract void updateSecret(SslContext 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);
@@ -70,11 +75,11 @@ protected CommonTlsContext getCommonTlsContext() {
   }
 
   protected void setClientAuthValues(
-      SslContextBuilder sslContextBuilder, SdsTrustManagerFactory sdsTrustManagerFactory)
+      SslContextBuilder sslContextBuilder, XdsTrustManagerFactory xdsTrustManagerFactory)
       throws CertificateException, IOException, CertStoreException {
     DownstreamTlsContext downstreamTlsContext = getDownstreamTlsContext();
-    if (sdsTrustManagerFactory != null) {
-      sslContextBuilder.trustManager(sdsTrustManagerFactory);
+    if (xdsTrustManagerFactory != null) {
+      sslContextBuilder.trustManager(xdsTrustManagerFactory);
       sslContextBuilder.clientAuth(
           downstreamTlsContext.isRequireClientCertificate()
               ? ClientAuth.REQUIRE
@@ -117,8 +122,9 @@ protected final void performCallback(
           @Override
           public void run() {
             try {
-              SslContext sslContext = sslContextGetter.get();
-              callback.updateSecret(sslContext);
+              AbstractMap.SimpleImmutableEntry<SslContext, X509TrustManager> sslContextAndTm =
+                  sslContextGetter.get();
+              callback.updateSslContextAndExtendedX509TrustManager(sslContextAndTm);
             } catch (Throwable e) {
               callback.onException(e);
             }
@@ -128,6 +134,6 @@ public void run() {
 
   /** Allows implementations to compute or get SslContext. */
   protected interface SslContextGetter {
-    SslContext get() throws Exception;
+    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..94fc423c202
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/internal/security/SslContextProviderSupplier.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.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(autoSniSanValidationDoesNotApply);
+        }
+      }
+      // we want to increment the ref-count so call findOrCreate again...
+      final SslContextProvider toRelease = getSslContextProvider(autoSniSanValidationDoesNotApply);
+      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(boolean autoSniSanValidationDoesNotApply) {
+    if (tlsContext instanceof UpstreamTlsContext) {
+      UpstreamTlsContext upstreamTlsContext = (UpstreamTlsContext) tlsContext;
+      if (autoSniSanValidationDoesNotApply && upstreamTlsContext.getAutoSniSanValidation()) {
+        upstreamTlsContext = new UpstreamTlsContext(
+            upstreamTlsContext.getCommonTlsContext(),
+            upstreamTlsContext.getSni(),
+            upstreamTlsContext.getAutoHostSni(),
+            false);
+      }
+      return tlsContextManager.findOrCreateClientSslContextProvider(upstreamTlsContext);
+    }
+    return 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..8984efc9435
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/internal/security/certprovider/CertProviderClientSslContextProvider.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.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 {
+    UpstreamTlsContext upstreamTlsContext = (UpstreamTlsContext) tlsContext;
+    XdsTrustManagerFactory trustManagerFactory;
+    if (savedSpiffeTrustMap != null) {
+      trustManagerFactory = new XdsTrustManagerFactory(
+              savedSpiffeTrustMap,
+              certificateValidationContext,
+              upstreamTlsContext.getAutoSniSanValidation());
+    } else if (savedTrustedRoots != null) {
+      trustManagerFactory = new XdsTrustManagerFactory(
+              savedTrustedRoots.toArray(new X509Certificate[0]),
+              certificateValidationContext,
+              upstreamTlsContext.getAutoSniSanValidation());
+    } else {
+      // Should be impossible because of the check in CertProviderClientSslContextProviderFactory
+      throw new IllegalStateException("There must be trusted roots or a SPIFFE trust map");
+    }
+
+    SslContextBuilder sslContextBuilder =
+        GrpcSslContexts.forClient().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/certprovider/CertificateProvider.java b/xds/src/main/java/io/grpc/xds/internal/security/certprovider/CertificateProvider.java
similarity index 85%
rename from xds/src/main/java/io/grpc/xds/internal/certprovider/CertificateProvider.java
rename to xds/src/main/java/io/grpc/xds/internal/security/certprovider/CertificateProvider.java
index 04ed997fa58..009bb7bf566 100644
--- a/xds/src/main/java/io/grpc/xds/internal/certprovider/CertificateProvider.java
+++ b/xds/src/main/java/io/grpc/xds/internal/security/certprovider/CertificateProvider.java
@@ -14,18 +14,19 @@
  * limitations under the License.
  */
 
-package io.grpc.xds.internal.certprovider;
+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.sds.Closeable;
+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;
 
 /**
@@ -45,6 +46,8 @@ public interface Watcher {
 
     void updateTrustedRoots(List<X509Certificate> trustedRoots);
 
+    void updateSpiffeTrustMap(Map<String, List<X509Certificate>> spiffeTrustMap);
+
     void onError(Status errorStatus);
   }
 
@@ -53,6 +56,7 @@ 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<>();
@@ -65,6 +69,9 @@ synchronized void addWatcher(Watcher watcher) {
       if (trustedRoots != null) {
         sendLastTrustedRootsUpdate(watcher);
       }
+      if (spiffeTrustMap != null) {
+        sendLastSpiffeTrustMapUpdate(watcher);
+      }
     }
 
     synchronized void removeWatcher(Watcher watcher) {
@@ -83,6 +90,10 @@ 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");
@@ -103,6 +114,14 @@ public synchronized void updateTrustedRoots(List<X509Certificate> trustedRoots)
       }
     }
 
+    @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) {
@@ -147,7 +166,7 @@ protected CertificateProvider(DistributorWatcher watcher, boolean notifyCertUpda
   @Override
   public abstract void close();
 
-  /** Starts the cert refresh and watcher update cycle. */
+  /** Starts the async cert refresh and watcher update cycle. */
   public abstract void start();
 
   private final DistributorWatcher watcher;
diff --git a/xds/src/main/java/io/grpc/xds/internal/certprovider/CertificateProviderProvider.java b/xds/src/main/java/io/grpc/xds/internal/security/certprovider/CertificateProviderProvider.java
similarity index 93%
rename from xds/src/main/java/io/grpc/xds/internal/certprovider/CertificateProviderProvider.java
rename to xds/src/main/java/io/grpc/xds/internal/security/certprovider/CertificateProviderProvider.java
index a426542eea0..e2e26ead502 100644
--- a/xds/src/main/java/io/grpc/xds/internal/certprovider/CertificateProviderProvider.java
+++ b/xds/src/main/java/io/grpc/xds/internal/security/certprovider/CertificateProviderProvider.java
@@ -14,10 +14,10 @@
  * limitations under the License.
  */
 
-package io.grpc.xds.internal.certprovider;
+package io.grpc.xds.internal.security.certprovider;
 
 import io.grpc.Internal;
-import io.grpc.xds.internal.certprovider.CertificateProvider.Watcher;
+import io.grpc.xds.internal.security.certprovider.CertificateProvider.Watcher;
 
 /**
  * Provider of {@link CertificateProvider}s. Implemented by the implementer of the plugin. We may
diff --git a/xds/src/main/java/io/grpc/xds/internal/certprovider/CertificateProviderRegistry.java b/xds/src/main/java/io/grpc/xds/internal/security/certprovider/CertificateProviderRegistry.java
similarity index 93%
rename from xds/src/main/java/io/grpc/xds/internal/certprovider/CertificateProviderRegistry.java
rename to xds/src/main/java/io/grpc/xds/internal/security/certprovider/CertificateProviderRegistry.java
index ac5ca9711fd..f8ced7bb2cc 100644
--- a/xds/src/main/java/io/grpc/xds/internal/certprovider/CertificateProviderRegistry.java
+++ b/xds/src/main/java/io/grpc/xds/internal/security/certprovider/CertificateProviderRegistry.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.grpc.xds.internal.certprovider;
+package io.grpc.xds.internal.security.certprovider;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
@@ -40,8 +40,6 @@ public static synchronized CertificateProviderRegistry getInstance() {
       instance = new CertificateProviderRegistry();
       // TODO(sanjaypujare): replace with Java's SPI mechanism and META-INF resource
       instance.register(new FileWatcherCertificateProviderProvider());
-      instance.register(new DynamicReloadingCertificateProviderProvider());
-      instance.register(new MeshCaCertificateProviderProvider());
     }
     return instance;
   }
@@ -61,7 +59,7 @@ public synchronized void register(CertificateProviderProvider certificateProvide
    * 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}.
+   *                                    {@link #register}.
    */
   public synchronized void deregister(CertificateProviderProvider certificateProviderProvider) {
     checkNotNull(certificateProviderProvider, "certificateProviderProvider");
diff --git a/xds/src/main/java/io/grpc/xds/internal/certprovider/CertificateProviderStore.java b/xds/src/main/java/io/grpc/xds/internal/security/certprovider/CertificateProviderStore.java
similarity index 97%
rename from xds/src/main/java/io/grpc/xds/internal/certprovider/CertificateProviderStore.java
rename to xds/src/main/java/io/grpc/xds/internal/security/certprovider/CertificateProviderStore.java
index 43143ebb3ae..0fe342a36c0 100644
--- a/xds/src/main/java/io/grpc/xds/internal/certprovider/CertificateProviderStore.java
+++ b/xds/src/main/java/io/grpc/xds/internal/security/certprovider/CertificateProviderStore.java
@@ -14,12 +14,11 @@
  * limitations under the License.
  */
 
-package io.grpc.xds.internal.certprovider;
+package io.grpc.xds.internal.security.certprovider;
 
 import com.google.common.annotations.VisibleForTesting;
-import io.grpc.xds.internal.certprovider.CertificateProvider.Watcher;
-import io.grpc.xds.internal.sds.ReferenceCountingMap;
-
+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;
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..9cb9a867118
--- /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/certprovider/FileWatcherCertificateProviderProvider.java b/xds/src/main/java/io/grpc/xds/internal/security/certprovider/FileWatcherCertificateProviderProvider.java
similarity index 78%
rename from xds/src/main/java/io/grpc/xds/internal/certprovider/FileWatcherCertificateProviderProvider.java
rename to xds/src/main/java/io/grpc/xds/internal/security/certprovider/FileWatcherCertificateProviderProvider.java
index bfef3677b96..e4871dc4c84 100644
--- a/xds/src/main/java/io/grpc/xds/internal/certprovider/FileWatcherCertificateProviderProvider.java
+++ b/xds/src/main/java/io/grpc/xds/internal/security/certprovider/FileWatcherCertificateProviderProvider.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.grpc.xds.internal.certprovider;
+package io.grpc.xds.internal.security.certprovider;
 
 import static com.google.common.base.Preconditions.checkArgument;
 import static com.google.common.base.Preconditions.checkNotNull;
@@ -23,6 +23,7 @@
 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;
@@ -33,11 +34,16 @@
 /**
  * Provider of {@link FileWatcherCertificateProvider}s.
  */
-final class FileWatcherCertificateProviderProvider implements CertificateProviderProvider {
+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;
@@ -82,6 +88,7 @@ public CertificateProvider createCertificateProvider(
         configObj.certFile,
         configObj.keyFile,
         configObj.rootFile,
+        configObj.spiffeTrustMapFile,
         configObj.refrehInterval,
         scheduledExecutorServiceFactory.create(),
         timeProvider);
@@ -98,12 +105,26 @@ private static Config validateAndTranslateConfig(Object config) {
     Config configObj = new Config();
     configObj.certFile = checkForNullAndGet(map, CERT_FILE_KEY);
     configObj.keyFile = checkForNullAndGet(map, KEY_FILE_KEY);
-    configObj.rootFile = checkForNullAndGet(map, ROOT_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);
       }
@@ -138,6 +159,7 @@ 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..41a3980c123
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/internal/security/trust/CertificateUtils.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.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 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..01f25dda6c7
--- /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 (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/internal/sts/StsCredentials.java b/xds/src/main/java/io/grpc/xds/internal/sts/StsCredentials.java
deleted file mode 100644
index 9d85ffcecce..00000000000
--- a/xds/src/main/java/io/grpc/xds/internal/sts/StsCredentials.java
+++ /dev/null
@@ -1,185 +0,0 @@
-/*
- * 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.sts;
-
-import com.google.api.client.http.GenericUrl;
-import com.google.api.client.http.HttpContent;
-import com.google.api.client.http.HttpRequest;
-import com.google.api.client.http.HttpRequestFactory;
-import com.google.api.client.http.HttpResponse;
-import com.google.api.client.http.HttpStatusCodes;
-import com.google.api.client.http.HttpTransport;
-import com.google.api.client.http.javanet.NetHttpTransport;
-import com.google.api.client.http.json.JsonHttpContent;
-import com.google.api.client.json.JsonObjectParser;
-import com.google.api.client.json.jackson2.JacksonFactory;
-import com.google.api.client.util.GenericData;
-import com.google.auth.http.HttpTransportFactory;
-import com.google.auth.oauth2.AccessToken;
-import com.google.auth.oauth2.GoogleCredentials;
-import com.google.common.annotations.VisibleForTesting;
-import com.google.common.io.Files;
-
-import java.io.File;
-import java.io.IOException;
-import java.math.BigDecimal;
-import java.nio.charset.StandardCharsets;
-import java.util.Date;
-import java.util.HashMap;
-import java.util.Map;
-
-// TODO(sanjaypujare): replace with the official implementation from google-auth once ready
-/** Implementation of OAuth2 Token Exchange as per https://tools.ietf.org/html/rfc8693. */
-public final class StsCredentials extends GoogleCredentials {
-  private static final long serialVersionUID = 6647041424685484932L;
-
-  @VisibleForTesting static final HttpTransportFactory defaultHttpTransportFactory =
-      new DefaultHttpTransportFactory();
-  private static final String CLOUD_PLATFORM_SCOPE =
-      "https://www.googleapis.com/auth/cloud-platform";
-  @VisibleForTesting final String sourceCredentialsFileLocation;
-  @VisibleForTesting final String identityTokenEndpoint;
-  @VisibleForTesting final String audience;
-  @VisibleForTesting transient HttpTransportFactory transportFactory;
-
-  private StsCredentials(
-      String identityTokenEndpoint,
-      String audience,
-      String sourceCredentialsFileLocation,
-      HttpTransportFactory transportFactory) {
-    this.identityTokenEndpoint = identityTokenEndpoint;
-    this.audience = audience;
-    this.sourceCredentialsFileLocation = sourceCredentialsFileLocation;
-    this.transportFactory = transportFactory;
-  }
-
-  @SuppressWarnings("JdkObsolete") // We can't use java.time
-  @Override
-  public AccessToken refreshAccessToken() throws IOException {
-    AccessToken tok = getSourceAccessTokenFromFileLocation();
-
-    HttpTransport httpTransport = this.transportFactory.create();
-    JsonObjectParser parser = new JsonObjectParser(JacksonFactory.getDefaultInstance());
-
-    HttpRequestFactory requestFactory = httpTransport.createRequestFactory();
-    GenericUrl url = new GenericUrl(identityTokenEndpoint);
-
-    Map<String, String> params = new HashMap<>();
-    params.put("grant_type", "urn:ietf:params:oauth:grant-type:token-exchange");
-    params.put("subject_token_type", "urn:ietf:params:oauth:token-type:jwt");
-    params.put("requested_token_type", "urn:ietf:params:oauth:token-type:access_token");
-    params.put("subject_token", tok.getTokenValue());
-    params.put("scope", CLOUD_PLATFORM_SCOPE);
-    params.put("audience", audience);
-    HttpContent content = new JsonHttpContent(parser.getJsonFactory(), params);
-    HttpRequest request = requestFactory.buildPostRequest(url, content);
-    request.setParser(parser);
-
-    HttpResponse response = null;
-    try {
-      response = request.execute();
-    } catch (IOException e) {
-      throw new IOException("Error requesting access token", e);
-    }
-
-    if (response.getStatusCode() != HttpStatusCodes.STATUS_CODE_OK) {
-      throw new IOException("Error getting access token: " + getStatusString(response));
-    }
-
-    GenericData responseData = null;
-    try {
-      responseData = response.parseAs(GenericData.class);
-    } finally {
-      response.disconnect();
-    }
-
-    String access_token = (String) responseData.get("access_token");
-    Date expiryTime = null;  // just in case expired_in value is not present
-    if (responseData.containsKey("expires_in")) {
-      expiryTime = new Date(System.currentTimeMillis()
-        + ((BigDecimal) responseData.get("expires_in")).longValue() * 1000L);
-    }
-    return new AccessToken(access_token, expiryTime);
-  }
-
-  private AccessToken getSourceAccessTokenFromFileLocation() throws IOException {
-    return new AccessToken(
-        Files.asCharSource(new File(sourceCredentialsFileLocation), StandardCharsets.UTF_8).read(),
-        null);
-  }
-
-  private static String getStatusString(HttpResponse response) {
-    return response.getStatusCode() + " : " + response.getStatusMessage();
-  }
-
-  @Override
-  public Builder toBuilder() {
-    throw new UnsupportedOperationException("toBuilder not supported");
-  }
-
-  /** Factory for creating StsCredentials. */
-  public abstract static class Factory {
-    private static final Factory DEFAULT_INSTANCE =
-        new Factory() {
-
-          @Override
-          public StsCredentials create(
-              String identityTokenEndpoint, String audience, String sourceCredentialsFileLocation) {
-            return create(
-                identityTokenEndpoint,
-                audience,
-                sourceCredentialsFileLocation,
-                getFromServiceLoader(HttpTransportFactory.class, defaultHttpTransportFactory));
-          }
-        };
-
-    public static Factory getInstance() {
-      return DEFAULT_INSTANCE;
-    }
-
-    /**
-     * Creates an StsCredentials.
-     *
-     * @param identityTokenEndpoint  URL of the token exchange service to use.
-     * @param audience Audience to use in the STS request.
-     * @param sourceCredentialsFileLocation file-system location that contains the
-     *                                      source creds e.g. JWT contents.
-     */
-    public abstract StsCredentials create(
-            String identityTokenEndpoint, String audience, String sourceCredentialsFileLocation);
-
-    @VisibleForTesting
-    static StsCredentials create(
-            String identityTokenEndpoint,
-            String audience,
-            String sourceCredentialsFileLocation,
-            HttpTransportFactory transportFactory) {
-      return new StsCredentials(
-              identityTokenEndpoint, audience, sourceCredentialsFileLocation, transportFactory);
-    }
-  }
-
-  private static class DefaultHttpTransportFactory implements HttpTransportFactory {
-
-    private static final HttpTransport netHttpTransport = new NetHttpTransport();
-
-    @Override
-    public HttpTransport create() {
-      return netHttpTransport;
-    }
-  }
-}
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..b37b9bc42e3
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/orca/OrcaOobUtil.java
@@ -0,0 +1,632 @@
+/*
+ * 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.ConnectivityState;
+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.PickResult;
+import io.grpc.LoadBalancer.PickSubchannelArgs;
+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.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 void updateBalancingState(ConnectivityState newState, SubchannelPicker newPicker) {
+      delegate.updateBalancingState(newState, new OrcaOobPicker(newPicker));
+    }
+
+    @VisibleForTesting
+    static final class OrcaOobPicker extends SubchannelPicker {
+      final SubchannelPicker delegate;
+
+      OrcaOobPicker(SubchannelPicker delegate) {
+        this.delegate = delegate;
+      }
+
+      @Override
+      public PickResult pickSubchannel(PickSubchannelArgs args) {
+        PickResult result = delegate.pickSubchannel(args);
+        Subchannel subchannel = result.getSubchannel();
+        if (subchannel instanceof SubchannelImpl) {
+          return result.copyWithSubchannel(((SubchannelImpl) subchannel).delegate());
+        }
+        return result;
+      }
+    }
+
+    @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/OrcaPerRequestUtil.java b/xds/src/main/java/io/grpc/xds/orca/OrcaPerRequestUtil.java
similarity index 87%
rename from xds/src/main/java/io/grpc/xds/OrcaPerRequestUtil.java
rename to xds/src/main/java/io/grpc/xds/orca/OrcaPerRequestUtil.java
index c193f5e35e5..814015ba93e 100644
--- a/xds/src/main/java/io/grpc/xds/OrcaPerRequestUtil.java
+++ b/xds/src/main/java/io/grpc/xds/orca/OrcaPerRequestUtil.java
@@ -14,19 +14,22 @@
  * limitations under the License.
  */
 
-package io.grpc.xds;
+package io.grpc.xds.orca;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
-import com.github.udpa.udpa.data.orca.v1.OrcaLoadReport;
+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.util.ForwardingClientStreamTracer;
+import io.grpc.services.InternalCallMetricRecorder;
+import io.grpc.services.MetricReport;
 import java.util.ArrayList;
 import java.util.List;
 
@@ -34,7 +37,8 @@
  * 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).
  */
-abstract class OrcaPerRequestUtil {
+@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() {
@@ -67,7 +71,7 @@ public static OrcaPerRequestUtil getInstance() {
   }
 
   /**
-   * Creates a new {@link ClientStreamTracer.Factory} with provided {@link
+   * Creates a new {@link io.grpc.ClientStreamTracer.Factory} with provided {@link
    * OrcaPerRequestReportListener} installed to receive callback when a per-request ORCA report is
    * received.
    *
@@ -93,7 +97,7 @@ public abstract ClientStreamTracer.Factory newOrcaClientStreamTracerFactory(
       OrcaPerRequestReportListener listener);
 
   /**
-   * Creates a new {@link ClientStreamTracer.Factory} with provided {@link
+   * Creates a new {@link io.grpc.ClientStreamTracer.Factory} with provided {@link
    * OrcaPerRequestReportListener} installed to receive callback when a per-request ORCA report is
    * received.
    *
@@ -173,14 +177,14 @@ public abstract ClientStreamTracer.Factory newOrcaClientStreamTracerFactory(
   public interface OrcaPerRequestReportListener {
 
     /**
-     * Invoked when an per-request ORCA report is received.
+     * 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 ORCA format.
+     * @param report load report in the format of grpc {@link MetricReport}.
      */
-    void onLoadReport(OrcaLoadReport report);
+    void onLoadReport(MetricReport report);
   }
 
   /**
@@ -189,12 +193,13 @@ public interface OrcaPerRequestReportListener {
    * per-request ORCA reports and push to registered listeners for calls they trace.
    */
   @VisibleForTesting
-  static final class OrcaReportingTracerFactory extends ClientStreamTracer.Factory {
+  static final class OrcaReportingTracerFactory extends
+      ClientStreamTracer.Factory {
 
     @VisibleForTesting
     static final Metadata.Key<OrcaLoadReport> ORCA_ENDPOINT_LOAD_METRICS_KEY =
         Metadata.Key.of(
-            "x-endpoint-load-metrics-bin",
+            "endpoint-load-metrics-bin",
             ProtoUtils.metadataMarshaller(OrcaLoadReport.getDefaultInstance()));
 
     private static final CallOptions.Key<OrcaReportBroker> ORCA_REPORT_BROKER_KEY =
@@ -247,6 +252,13 @@ public void inboundTrailers(Metadata trailers) {
     }
   }
 
+  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.
@@ -260,8 +272,9 @@ void addListener(OrcaPerRequestReportListener listener) {
     }
 
     void onReport(OrcaLoadReport report) {
+      MetricReport metricReport = fromOrcaLoadReport(report);
       for (OrcaPerRequestReportListener listener : listeners) {
-        listener.onLoadReport(report);
+        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
index 74fa88cfe38..9cc15cd5449 100644
--- a/xds/src/main/java/io/grpc/xds/package-info.java
+++ b/xds/src/main/java/io/grpc/xds/package-info.java
@@ -15,7 +15,7 @@
  */
 
 /**
- * Library for gPRC proxyless service mesh using Envoy xDS protocol.
+ * 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
diff --git a/xds/src/main/resources/META-INF/services/io.grpc.LoadBalancerProvider b/xds/src/main/resources/META-INF/services/io.grpc.LoadBalancerProvider
index 6929006c103..04a2d9cf7a8 100644
--- a/xds/src/main/resources/META-INF/services/io.grpc.LoadBalancerProvider
+++ b/xds/src/main/resources/META-INF/services/io.grpc.LoadBalancerProvider
@@ -2,5 +2,8 @@ io.grpc.xds.CdsLoadBalancerProvider
 io.grpc.xds.PriorityLoadBalancerProvider
 io.grpc.xds.WeightedTargetLoadBalancerProvider
 io.grpc.xds.ClusterManagerLoadBalancerProvider
-io.grpc.xds.ClusterResolverLoadBalancerProvider
 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
index c1f2c40e7ee..269cdd38801 100644
--- a/xds/src/main/resources/META-INF/services/io.grpc.NameResolverProvider
+++ b/xds/src/main/resources/META-INF/services/io.grpc.NameResolverProvider
@@ -1,2 +1 @@
 io.grpc.xds.XdsNameResolverProvider
-io.grpc.xds.GoogleCloudToProdNameResolverProvider
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/BootstrapperImplTest.java b/xds/src/test/java/io/grpc/xds/BootstrapperImplTest.java
deleted file mode 100644
index 5744931ee3f..00000000000
--- a/xds/src/test/java/io/grpc/xds/BootstrapperImplTest.java
+++ /dev/null
@@ -1,700 +0,0 @@
-/*
- * 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 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.Bootstrapper.BootstrapInfo;
-import io.grpc.xds.Bootstrapper.ServerInfo;
-import io.grpc.xds.EnvoyProtoData.Node;
-import java.io.IOException;
-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.rules.ExpectedException;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-
-/** Unit tests for {@link Bootstrapper}. */
-@RunWith(JUnit4.class)
-public class BootstrapperImplTest {
-
-  private static final String BOOTSTRAP_FILE_PATH = "/fake/fs/path/bootstrap.json";
-  private static final String SERVER_URI = "trafficdirector.googleapis.com:443";
-  @SuppressWarnings("deprecation") // https://github.com/grpc/grpc-java/issues/7467
-  @Rule
-  public final ExpectedException thrown = ExpectedException.none();
-
-  private final BootstrapperImpl bootstrapper = new BootstrapperImpl();
-  private String originalBootstrapPathFromEnvVar;
-  private String originalBootstrapPathFromSysProp;
-  private String originalBootstrapConfigFromEnvVar;
-  private String originalBootstrapConfigFromSysProp;
-
-  @Before
-  public void setUp() {
-    saveEnvironment();
-    BootstrapperImpl.bootstrapPathFromEnvVar = BOOTSTRAP_FILE_PATH;
-  }
-
-  private void saveEnvironment() {
-    originalBootstrapPathFromEnvVar = BootstrapperImpl.bootstrapPathFromEnvVar;
-    originalBootstrapPathFromSysProp = BootstrapperImpl.bootstrapPathFromSysProp;
-    originalBootstrapConfigFromEnvVar = BootstrapperImpl.bootstrapConfigFromEnvVar;
-    originalBootstrapConfigFromSysProp = BootstrapperImpl.bootstrapConfigFromSysProp;
-  }
-
-  @After
-  public void restoreEnvironment() {
-    BootstrapperImpl.bootstrapPathFromEnvVar = originalBootstrapPathFromEnvVar;
-    BootstrapperImpl.bootstrapPathFromSysProp = originalBootstrapPathFromSysProp;
-    BootstrapperImpl.bootstrapConfigFromEnvVar = originalBootstrapConfigFromEnvVar;
-    BootstrapperImpl.bootstrapConfigFromSysProp = originalBootstrapConfigFromSysProp;
-  }
-
-  @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.getServers()).hasSize(1);
-    ServerInfo serverInfo = Iterables.getOnlyElement(info.getServers());
-    assertThat(serverInfo.getTarget()).isEqualTo(SERVER_URI);
-    assertThat(serverInfo.getChannelCredentials()).isInstanceOf(InsecureChannelCredentials.class);
-    assertThat(info.getNode()).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.getServers()).hasSize(2);
-    List<ServerInfo> serverInfoList = info.getServers();
-    assertThat(serverInfoList.get(0).getTarget())
-        .isEqualTo("trafficdirector-foo.googleapis.com:443");
-    assertThat(serverInfoList.get(0).getChannelCredentials())
-        .isInstanceOf(TlsChannelCredentials.class);
-    assertThat(serverInfoList.get(1).getTarget())
-        .isEqualTo("trafficdirector-bar.googleapis.com:443");
-    assertThat(serverInfoList.get(1).getChannelCredentials())
-        .isInstanceOf(InsecureChannelCredentials.class);
-    assertThat(info.getNode()).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.getServers()).hasSize(1);
-    ServerInfo serverInfo = Iterables.getOnlyElement(info.getServers());
-    assertThat(serverInfo.getTarget()).isEqualTo(SERVER_URI);
-    assertThat(serverInfo.getChannelCredentials()).isInstanceOf(InsecureChannelCredentials.class);
-    assertThat(info.getNode()).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() throws XdsInitializationException {
-    String rawData = "{\n"
-        + "  \"xds_servers\": [\n"
-        + "    {\n"
-        + "      \"server_uri\": \"" + SERVER_URI + "\"\n"
-        + "    }\n"
-        + "  ]\n"
-        + "}";
-
-    bootstrapper.setFileReader(createFileReader(BOOTSTRAP_FILE_PATH, rawData));
-    thrown.expect(XdsInitializationException.class);
-    thrown.expectMessage("Invalid bootstrap: server " + SERVER_URI + " 'channel_creds' required");
-    bootstrapper.bootstrap();
-  }
-
-  @Test
-  public void parseBootstrap_unsupportedServerChannelCreds() throws XdsInitializationException {
-    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));
-    thrown.expect(XdsInitializationException.class);
-    thrown.expectMessage("Server " + SERVER_URI + ": no supported channel credentials found");
-    bootstrapper.bootstrap();
-  }
-
-  @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.getServers()).hasSize(1);
-    ServerInfo serverInfo = Iterables.getOnlyElement(info.getServers());
-    assertThat(serverInfo.getTarget()).isEqualTo(SERVER_URI);
-    assertThat(serverInfo.getChannelCredentials()).isInstanceOf(InsecureChannelCredentials.class);
-    assertThat(info.getNode()).isEqualTo(getNodeBuilder().build());
-  }
-
-  @Test
-  public void parseBootstrap_noXdsServers() 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"
-        + "}";
-
-    bootstrapper.setFileReader(createFileReader(BOOTSTRAP_FILE_PATH, rawData));
-    thrown.expect(XdsInitializationException.class);
-    thrown.expectMessage("Invalid bootstrap: 'xds_servers' does not exist.");
-    bootstrapper.bootstrap();
-  }
-
-  @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));
-    thrown.expectMessage("Invalid bootstrap: missing 'server_uri'");
-    bootstrapper.bootstrap();
-  }
-
-  @Test
-  public void parseBootstrap_certProviderInstances() throws XdsInitializationException {
-    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"
-            + "      \"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.getServers()).isEmpty();
-    assertThat(info.getNode()).isEqualTo(getNodeBuilder().build());
-    Map<String, Bootstrapper.CertificateProviderInfo> certProviders = info.getCertProviders();
-    assertThat(certProviders).isNotNull();
-    Bootstrapper.CertificateProviderInfo gcpId = certProviders.get("gcp_id");
-    Bootstrapper.CertificateProviderInfo fileProvider = certProviders.get("file_provider");
-    assertThat(gcpId.getPluginName()).isEqualTo("meshca");
-    assertThat(gcpId.getConfig()).isInstanceOf(Map.class);
-    assertThat(fileProvider.getPluginName()).isEqualTo("file_watcher");
-    assertThat(fileProvider.getConfig()).isInstanceOf(Map.class);
-    Map<String, ?> meshCaConfig = (Map<String, ?>)gcpId.getConfig();
-    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"
-            + "  \"grpc_server_resource_name_id\": \"grpc/serverx\"\n"
-            + "}";
-
-    bootstrapper.setFileReader(createFileReader(BOOTSTRAP_FILE_PATH, rawData));
-    BootstrapInfo info = bootstrapper.bootstrap();
-    assertThat(info.getGrpcServerResourceId()).isEqualTo("grpc/serverx");
-  }
-
-  @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.getServers());
-    assertThat(serverInfo.getTarget()).isEqualTo(SERVER_URI);
-    assertThat(serverInfo.getChannelCredentials()).isInstanceOf(InsecureChannelCredentials.class);
-    assertThat(serverInfo.isUseProtocolV3()).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.getServers());
-    assertThat(serverInfo.getTarget()).isEqualTo(SERVER_URI);
-    assertThat(serverInfo.getChannelCredentials()).isInstanceOf(InsecureChannelCredentials.class);
-    assertThat(serverInfo.isUseProtocolV3()).isTrue();
-  }
-
-  @Test
-  public void notFound() {
-    BootstrapperImpl.bootstrapPathFromEnvVar = null;
-    BootstrapperImpl.bootstrapPathFromSysProp = null;
-    BootstrapperImpl.bootstrapConfigFromEnvVar = null;
-    BootstrapperImpl.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";
-    BootstrapperImpl.bootstrapPathFromEnvVar = null;
-    BootstrapperImpl.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"
-        + "}";
-
-    BootstrapperImpl.bootstrapPathFromEnvVar = null;
-    BootstrapperImpl.bootstrapPathFromSysProp = null;
-    BootstrapperImpl.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"
-        + "}";
-    
-    BootstrapperImpl.bootstrapPathFromEnvVar = null;
-    BootstrapperImpl.bootstrapPathFromSysProp = null;
-    BootstrapperImpl.bootstrapConfigFromEnvVar = null;
-    BootstrapperImpl.bootstrapConfigFromSysProp = rawData;
-    bootstrapper.setFileReader(mock(BootstrapperImpl.FileReader.class));
-    bootstrapper.bootstrap();
-  }
-
-  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(BootstrapperImpl.CLIENT_FEATURE_DISABLE_OVERPROVISIONING);
-  }
-}
diff --git a/xds/src/test/java/io/grpc/xds/CdsLoadBalancer2Test.java b/xds/src/test/java/io/grpc/xds/CdsLoadBalancer2Test.java
index b95117acbff..ff4813fe6a8 100644
--- a/xds/src/test/java/io/grpc/xds/CdsLoadBalancer2Test.java
+++ b/xds/src/test/java/io/grpc/xds/CdsLoadBalancer2Test.java
@@ -17,8 +17,12 @@
 package io.grpc.xds;
 
 import static com.google.common.truth.Truth.assertThat;
-import static io.grpc.xds.XdsLbPolicies.CLUSTER_RESOLVER_POLICY_NAME;
-import static io.grpc.xds.XdsLbPolicies.WEIGHTED_TARGET_POLICY_NAME;
+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;
@@ -26,446 +30,637 @@
 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.EquivalentAddressGroup;
 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.NameResolverRegistry;
 import io.grpc.Status;
 import io.grpc.Status.Code;
 import io.grpc.SynchronizationContext;
-import io.grpc.internal.ObjectPool;
+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.ClusterResolverLoadBalancerProvider.ClusterResolverConfig;
-import io.grpc.xds.ClusterResolverLoadBalancerProvider.ClusterResolverConfig.DiscoveryMechanism;
-import io.grpc.xds.EnvoyServerProtoData.UpstreamTlsContext;
-import io.grpc.xds.internal.sds.CommonTlsContextTestsUtil;
+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.HashMap;
 import java.util.List;
 import java.util.Map;
-import javax.annotation.Nullable;
+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.MockitoAnnotations;
+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 CLUSTER = "cluster-foo.googleapis.com";  // cluster of entry point
-
+  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 LRS_SERVER_NAME = "lrs.googleapis.com";
-  private final UpstreamTlsContext upstreamTlsContext =
-      CommonTlsContextTestsUtil.buildUpstreamTlsContextFromFilenames(
-          CommonTlsContextTestsUtil.CLIENT_KEY_FILE,
-          CommonTlsContextTestsUtil.CLIENT_PEM_FILE,
-          CommonTlsContextTestsUtil.CA_PEM_FILE);
-
-  private final SynchronizationContext syncContext = new SynchronizationContext(
-      new Thread.UncaughtExceptionHandler() {
-        @Override
-        public void uncaughtException(Thread t, Throwable e) {
-          throw new AssertionError(e);
-        }
-      });
+  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 FakeXdsClient xdsClient = new FakeXdsClient();
-  private final ObjectPool<XdsClient> xdsClientPool = new ObjectPool<XdsClient>() {
-    @Override
-    public XdsClient getObject() {
-      xdsClientRefs++;
-      return xdsClient;
-    }
-
-    @Override
-    public XdsClient returnObject(Object object) {
-      xdsClientRefs--;
-      return null;
-    }
-  };
+  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 int xdsClientRefs;
-  private CdsLoadBalancer2  loadBalancer;
+  private CdsLoadBalancer2 loadBalancer;
+  private XdsConfig lastXdsConfig;
 
   @Before
-  public void setUp() {
-    MockitoAnnotations.initMocks(this);
-
-    when(helper.getSynchronizationContext()).thenReturn(syncContext);
-    lbRegistry.register(new FakeLoadBalancerProvider(CLUSTER_RESOLVER_POLICY_NAME));
-    lbRegistry.register(new FakeLoadBalancerProvider(WEIGHTED_TARGET_POLICY_NAME));
+  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"));
-    loadBalancer = new CdsLoadBalancer2(helper, lbRegistry);
-    loadBalancer.handleResolvedAddresses(
-        ResolvedAddresses.newBuilder()
-            .setAddresses(Collections.<EquivalentAddressGroup>emptyList())
-            .setAttributes(
-                // Other attributes not used by cluster_resolver LB are omitted.
-                Attributes.newBuilder()
-                    .set(InternalXdsAttributes.XDS_CLIENT_POOL, xdsClientPool)
-                    .build())
-            .setLoadBalancingPolicyConfig(new CdsConfig(CLUSTER))
-            .build());
-    assertThat(Iterables.getOnlyElement(xdsClient.watchers.keySet())).isEqualTo(CLUSTER);
+    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() {
-    loadBalancer.shutdown();
-    assertThat(xdsClient.watchers).isEmpty();
-    assertThat(xdsClientRefs).isEqualTo(0);
+    if (loadBalancer != null) {
+      shutdownLoadBalancer();
+    }
+    assertThat(childBalancers).isEmpty();
+
+    if (xdsDepManager != null) {
+      xdsDepManager.shutdown();
+    }
+    xdsClient.shutdown();
   }
 
-  @Test
-  public void discoverTopLevelEdsCluster() {
-    xdsClient.deliverEdsCluster(CLUSTER, EDS_SERVICE_NAME, LRS_SERVER_NAME, 100L,
-        upstreamTlsContext);
-    assertThat(childBalancers).hasSize(1);
-    FakeLoadBalancer childBalancer = Iterables.getOnlyElement(childBalancers);
-    assertThat(childBalancer.name).isEqualTo(CLUSTER_RESOLVER_POLICY_NAME);
-    ClusterResolverConfig childLbConfig = (ClusterResolverConfig) childBalancer.config;
-    assertThat(childLbConfig.discoveryMechanisms).hasSize(1);
-    DiscoveryMechanism instance = Iterables.getOnlyElement(childLbConfig.discoveryMechanisms);
-    assertDiscoveryMechanism(instance, CLUSTER, DiscoveryMechanism.Type.EDS, EDS_SERVICE_NAME,
-        LRS_SERVER_NAME, 100L, upstreamTlsContext);
-    assertThat(childLbConfig.localityPickingPolicy.getProvider().getPolicyName())
-        .isEqualTo(WEIGHTED_TARGET_POLICY_NAME);
-    assertThat(childLbConfig.endpointPickingPolicy.getProvider().getPolicyName())
-        .isEqualTo("round_robin");
+  private void shutdownLoadBalancer() {
+    LoadBalancer lb = this.loadBalancer;
+    this.loadBalancer = null; // Must avoid calling acceptResolvedAddresses after shutdown
+    lb.shutdown();
   }
 
   @Test
-  public void discoverTopLevelLogicalDnsCluster() {
-    xdsClient.deliverLogicalDnsCluster(CLUSTER, LRS_SERVER_NAME, 100L, upstreamTlsContext);
+  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(CLUSTER_RESOLVER_POLICY_NAME);
-    ClusterResolverConfig childLbConfig = (ClusterResolverConfig) childBalancer.config;
-    assertThat(childLbConfig.discoveryMechanisms).hasSize(1);
-    DiscoveryMechanism instance = Iterables.getOnlyElement(childLbConfig.discoveryMechanisms);
-    assertDiscoveryMechanism(instance, CLUSTER, DiscoveryMechanism.Type.LOGICAL_DNS, null,
-        LRS_SERVER_NAME, 100L, upstreamTlsContext);
-    assertThat(childLbConfig.localityPickingPolicy.getProvider().getPolicyName())
-        .isEqualTo(WEIGHTED_TARGET_POLICY_NAME);
-    assertThat(childLbConfig.endpointPickingPolicy.getProvider().getPolicyName())
-        .isEqualTo("round_robin");
+    assertThat(childBalancer.name).isEqualTo(PRIORITY_POLICY_NAME);
   }
 
   @Test
   public void nonAggregateCluster_resourceNotExist_returnErrorPicker() {
-    xdsClient.deliverResourceNotExist(CLUSTER);
+    startXdsDepManager();
     verify(helper).updateBalancingState(
         eq(ConnectivityState.TRANSIENT_FAILURE), pickerCaptor.capture());
-    Status unavailable = Status.UNAVAILABLE.withDescription("Cluster " + CLUSTER + " unusable");
-    assertPicker(pickerCaptor.getValue(), unavailable, null);
+    String expectedDescription = "Error retrieving CDS resource " + CLUSTER
+        + " nodeID: " + NODE_ID
+        + ": NOT_FOUND: Timed out waiting for resource " + CLUSTER + " from xDS server";
+    Status unavailable = Status.UNAVAILABLE.withDescription(expectedDescription);
+    assertPickerStatus(pickerCaptor.getValue(), unavailable);
     assertThat(childBalancers).isEmpty();
   }
 
   @Test
   public void nonAggregateCluster_resourceUpdate() {
-    xdsClient.deliverEdsCluster(CLUSTER, null, null, 100L, upstreamTlsContext);
+    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);
-    ClusterResolverConfig childLbConfig = (ClusterResolverConfig) childBalancer.config;
-    DiscoveryMechanism instance = Iterables.getOnlyElement(childLbConfig.discoveryMechanisms);
-    assertDiscoveryMechanism(instance, CLUSTER, DiscoveryMechanism.Type.EDS, null, null, 100L,
-        upstreamTlsContext);
-
-    xdsClient.deliverEdsCluster(CLUSTER, EDS_SERVICE_NAME, LRS_SERVER_NAME, 200L, null);
-    childLbConfig = (ClusterResolverConfig) childBalancer.config;
-    instance = Iterables.getOnlyElement(childLbConfig.discoveryMechanisms);
-    assertDiscoveryMechanism(instance, CLUSTER, DiscoveryMechanism.Type.EDS, EDS_SERVICE_NAME,
-        LRS_SERVER_NAME, 200L, null);
+    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() {
-    xdsClient.deliverLogicalDnsCluster(CLUSTER, null, 100L, upstreamTlsContext);
+    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);
-    ClusterResolverConfig childLbConfig = (ClusterResolverConfig) childBalancer.config;
-    DiscoveryMechanism instance = Iterables.getOnlyElement(childLbConfig.discoveryMechanisms);
-    assertDiscoveryMechanism(instance, CLUSTER, DiscoveryMechanism.Type.LOGICAL_DNS, null, null,
-        100L, upstreamTlsContext);
+    ClusterImplConfig childLbConfig = (ClusterImplConfig) childBalancer.config;
+    assertThat(childLbConfig.cluster).isEqualTo(CLUSTER);
+
+    controlPlaneService.setXdsConfig(ADS_TYPE_URL_CDS, ImmutableMap.of());
 
-    xdsClient.deliverResourceNotExist(CLUSTER);
     assertThat(childBalancer.shutdown).isTrue();
-    Status unavailable = Status.UNAVAILABLE.withDescription("Cluster " + CLUSTER + " unusable");
+    String expectedDescription = "Error retrieving CDS resource " + CLUSTER
+        + " nodeID: " + NODE_ID
+        + ": NOT_FOUND: Resource " + CLUSTER + " does not exist";
+    Status unavailable = Status.UNAVAILABLE.withDescription(expectedDescription);
     verify(helper).updateBalancingState(
         eq(ConnectivityState.TRANSIENT_FAILURE), pickerCaptor.capture());
-    assertPicker(pickerCaptor.getValue(), unavailable, null);
+    assertPickerStatus(pickerCaptor.getValue(), unavailable);
     assertThat(childBalancer.shutdown).isTrue();
     assertThat(childBalancers).isEmpty();
   }
 
   @Test
-  public void discoveryAggregateCluster() {
+  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";
-    // CLUSTER (aggr.) -> [cluster1 (aggr.), cluster2 (logical DNS)]
-    xdsClient.deliverAggregateCluster(CLUSTER, Arrays.asList(cluster1, cluster2));
-    assertThat(xdsClient.watchers.keySet()).containsExactly(CLUSTER, cluster1, cluster2);
-    assertThat(childBalancers).isEmpty();
     String cluster3 = "cluster-03.googleapis.com";
     String cluster4 = "cluster-04.googleapis.com";
-    // cluster1 (aggr.) -> [cluster3 (EDS), cluster4 (EDS)]
-    xdsClient.deliverAggregateCluster(cluster1, Arrays.asList(cluster3, cluster4));
-    assertThat(xdsClient.watchers.keySet()).containsExactly(
-        CLUSTER, cluster1, cluster2, cluster3, cluster4);
-    assertThat(childBalancers).isEmpty();
-    xdsClient.deliverEdsCluster(cluster3, EDS_SERVICE_NAME, LRS_SERVER_NAME, 200L,
-        upstreamTlsContext);
-    assertThat(childBalancers).isEmpty();
-    xdsClient.deliverLogicalDnsCluster(cluster2, null, 100L, null);
-    assertThat(childBalancers).isEmpty();
-    xdsClient.deliverEdsCluster(cluster4, null, LRS_SERVER_NAME, 300L,
-        null);
-    assertThat(childBalancers).hasSize(1);  // all non-aggregate clusters discovered
+    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(CLUSTER_RESOLVER_POLICY_NAME);
-    ClusterResolverConfig childLbConfig = (ClusterResolverConfig) childBalancer.config;
-    assertThat(childLbConfig.discoveryMechanisms).hasSize(3);
-    // Clusters on higher level has higher priority: [cluster2, cluster3, cluster4]
-    assertDiscoveryMechanism(childLbConfig.discoveryMechanisms.get(0), cluster2,
-        DiscoveryMechanism.Type.LOGICAL_DNS, null, null, 100L, null);
-    assertDiscoveryMechanism(childLbConfig.discoveryMechanisms.get(1), cluster3,
-        DiscoveryMechanism.Type.EDS, EDS_SERVICE_NAME, LRS_SERVER_NAME, 200L, upstreamTlsContext);
-    assertDiscoveryMechanism(childLbConfig.discoveryMechanisms.get(2), cluster4,
-        DiscoveryMechanism.Type.EDS, null, LRS_SERVER_NAME, 300L, null);
-    assertThat(childLbConfig.localityPickingPolicy.getProvider().getPolicyName())
-        .isEqualTo(WEIGHTED_TARGET_POLICY_NAME);
-    assertThat(childLbConfig.endpointPickingPolicy.getProvider().getPolicyName())
-        .isEqualTo("round_robin");
+    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
-  public void aggregateCluster_noNonAggregateClusterExits_returnErrorPicker() {
-    String cluster1 = "cluster-01.googleapis.com";
-    // CLUSTER (aggr.) -> [cluster1 (EDS)]
-    xdsClient.deliverAggregateCluster(CLUSTER, Collections.singletonList(cluster1));
-    assertThat(xdsClient.watchers.keySet()).containsExactly(CLUSTER, cluster1);
-    xdsClient.deliverResourceNotExist(cluster1);
-    verify(helper).updateBalancingState(
-        eq(ConnectivityState.TRANSIENT_FAILURE), pickerCaptor.capture());
-    Status unavailable = Status.UNAVAILABLE.withDescription("Cluster " + CLUSTER + " unusable");
-    assertPicker(pickerCaptor.getValue(), unavailable, null);
-    assertThat(childBalancers).isEmpty();
-  }
+  // 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);
 
-  @Test
-  public void aggregateCluster_descendantClustersRevoked() {
     String cluster1 = "cluster-01.googleapis.com";
     String cluster2 = "cluster-02.googleapis.com";
-    // CLUSTER (aggr.) -> [cluster1 (EDS), cluster2 (logical DNS)]
-    xdsClient.deliverAggregateCluster(CLUSTER, Arrays.asList(cluster1, cluster2));
-    assertThat(xdsClient.watchers.keySet()).containsExactly(CLUSTER, cluster1, cluster2);
-    xdsClient.deliverLogicalDnsCluster(cluster2, LRS_SERVER_NAME, 100L, null);
-    xdsClient.deliverEdsCluster(cluster1, EDS_SERVICE_NAME, LRS_SERVER_NAME, 200L,
-        upstreamTlsContext);
-    FakeLoadBalancer childBalancer = Iterables.getOnlyElement(childBalancers);
-    ClusterResolverConfig childLbConfig = (ClusterResolverConfig) childBalancer.config;
-    assertThat(childLbConfig.discoveryMechanisms).hasSize(2);
-    assertDiscoveryMechanism(childLbConfig.discoveryMechanisms.get(0), cluster1,
-        DiscoveryMechanism.Type.EDS, EDS_SERVICE_NAME, LRS_SERVER_NAME, 200L, upstreamTlsContext);
-    assertDiscoveryMechanism(childLbConfig.discoveryMechanisms.get(1), cluster2,
-        DiscoveryMechanism.Type.LOGICAL_DNS, null, LRS_SERVER_NAME, 100L, null);
-
-    // Revoke cluster1, should still be able to proceed with cluster2.
-    xdsClient.deliverResourceNotExist(cluster1);
-    assertThat(xdsClient.watchers.keySet()).containsExactly(CLUSTER, cluster1, cluster2);
-    childLbConfig = (ClusterResolverConfig) childBalancer.config;
-    assertThat(childLbConfig.discoveryMechanisms).hasSize(1);
-    assertDiscoveryMechanism(Iterables.getOnlyElement(childLbConfig.discoveryMechanisms), cluster2,
-        DiscoveryMechanism.Type.LOGICAL_DNS, null, LRS_SERVER_NAME, 100L, null);
-    verify(helper, never()).updateBalancingState(
-        eq(ConnectivityState.TRANSIENT_FAILURE), any(SubchannelPicker.class));
-
-    // All revoked.
-    xdsClient.deliverResourceNotExist(cluster2);
-    verify(helper).updateBalancingState(
-        eq(ConnectivityState.TRANSIENT_FAILURE), pickerCaptor.capture());
-    Status unavailable = Status.UNAVAILABLE.withDescription("Cluster " + CLUSTER + " unusable");
-    assertPicker(pickerCaptor.getValue(), unavailable, null);
-    assertThat(childBalancer.shutdown).isTrue();
-    assertThat(childBalancers).isEmpty();
+    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_rootClusterRevoked() {
-    String cluster1 = "cluster-01.googleapis.com";
-    String cluster2 = "cluster-02.googleapis.com";
-    // CLUSTER (aggr.) -> [cluster1 (EDS), cluster2 (logical DNS)]
-    xdsClient.deliverAggregateCluster(CLUSTER, Arrays.asList(cluster1, cluster2));
-    assertThat(xdsClient.watchers.keySet()).containsExactly(CLUSTER, cluster1, cluster2);
-    xdsClient.deliverLogicalDnsCluster(cluster2, LRS_SERVER_NAME, 100L, null);
-    xdsClient.deliverEdsCluster(cluster1, EDS_SERVICE_NAME, LRS_SERVER_NAME, 200L,
-        upstreamTlsContext);
-    FakeLoadBalancer childBalancer = Iterables.getOnlyElement(childBalancers);
-    ClusterResolverConfig childLbConfig = (ClusterResolverConfig) childBalancer.config;
-    assertThat(childLbConfig.discoveryMechanisms).hasSize(2);
-    assertDiscoveryMechanism(childLbConfig.discoveryMechanisms.get(0), cluster1,
-        DiscoveryMechanism.Type.EDS, EDS_SERVICE_NAME, LRS_SERVER_NAME, 200L, upstreamTlsContext);
-    assertDiscoveryMechanism(childLbConfig.discoveryMechanisms.get(1), cluster2,
-        DiscoveryMechanism.Type.LOGICAL_DNS, null, LRS_SERVER_NAME, 100L, null);
-
-    xdsClient.deliverResourceNotExist(CLUSTER);
-    assertThat(xdsClient.watchers.keySet())
-        .containsExactly(CLUSTER);  // subscription to all descendant clusters cancelled
-    verify(helper).updateBalancingState(
-        eq(ConnectivityState.TRANSIENT_FAILURE), pickerCaptor.capture());
-    Status unavailable = Status.UNAVAILABLE.withDescription("Cluster " + CLUSTER + " unusable");
-    assertPicker(pickerCaptor.getValue(), unavailable, null);
-    assertThat(childBalancer.shutdown).isTrue();
+  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_intermediateClusterChanges() {
-    String cluster1 = "cluster-01.googleapis.com";
-    // CLUSTER (aggr.) -> [cluster1]
-    xdsClient.deliverAggregateCluster(CLUSTER, Collections.singletonList(cluster1));
-    assertThat(xdsClient.watchers.keySet()).containsExactly(CLUSTER, cluster1);
+  public void aggregateCluster_noNonAggregateClusterExits_returnErrorPicker() {
+    lbRegistry.register(new PriorityLoadBalancerProvider());
+    CdsLoadBalancerProvider cdsLoadBalancerProvider = new CdsLoadBalancerProvider(lbRegistry);
+    lbRegistry.register(cdsLoadBalancerProvider);
+    loadBalancer = (CdsLoadBalancer2) cdsLoadBalancerProvider.newLoadBalancer(helper);
 
-    // CLUSTER (aggr.) -> [cluster2 (aggr.)]
-    String cluster2 = "cluster-02.googleapis.com";
-    xdsClient.deliverAggregateCluster(CLUSTER, Collections.singletonList(cluster2));
-    assertThat(xdsClient.watchers.keySet()).containsExactly(CLUSTER, cluster2);
+    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();
 
-    // cluster2 (aggr.) -> [cluster3 (EDS)]
-    String cluster3 = "cluster-03.googleapis.com";
-    xdsClient.deliverAggregateCluster(cluster2, Collections.singletonList(cluster3));
-    assertThat(xdsClient.watchers.keySet()).containsExactly(CLUSTER, cluster2, cluster3);
-    xdsClient.deliverEdsCluster(cluster3, EDS_SERVICE_NAME, LRS_SERVER_NAME, 100L,
-        upstreamTlsContext);
-    FakeLoadBalancer childBalancer = Iterables.getOnlyElement(childBalancers);
-    ClusterResolverConfig childLbConfig = (ClusterResolverConfig) childBalancer.config;
-    assertThat(childLbConfig.discoveryMechanisms).hasSize(1);
-    DiscoveryMechanism instance = Iterables.getOnlyElement(childLbConfig.discoveryMechanisms);
-    assertDiscoveryMechanism(instance, cluster3, DiscoveryMechanism.Type.EDS, EDS_SERVICE_NAME,
-        LRS_SERVER_NAME, 100L, upstreamTlsContext);
-
-    // cluster2 revoked
-    xdsClient.deliverResourceNotExist(cluster2);
-    assertThat(xdsClient.watchers.keySet())
-        .containsExactly(CLUSTER, cluster2);  // cancelled subscription to cluster3
     verify(helper).updateBalancingState(
         eq(ConnectivityState.TRANSIENT_FAILURE), pickerCaptor.capture());
-    Status unavailable = Status.UNAVAILABLE.withDescription("Cluster " + CLUSTER + " unusable");
-    assertPicker(pickerCaptor.getValue(), unavailable, null);
-    assertThat(childBalancer.shutdown).isTrue();
+    String expectedDescription = "Error retrieving CDS resource " + cluster1
+        + " nodeID: " + NODE_ID
+        + ": NOT_FOUND: Timed out waiting for resource " + cluster1 + " from xDS server";
+    Status status = Status.UNAVAILABLE.withDescription(expectedDescription);
+    assertPickerStatus(pickerCaptor.getValue(), status);
     assertThat(childBalancers).isEmpty();
   }
 
   @Test
-  public void aggregateCluster_discoveryErrorBeforeChildLbCreated_returnErrorPicker() {
-    String cluster1 = "cluster-01.googleapis.com";
-    // CLUSTER (aggr.) -> [cluster1]
-    xdsClient.deliverAggregateCluster(CLUSTER, Collections.singletonList(cluster1));
-    assertThat(xdsClient.watchers.keySet()).containsExactly(CLUSTER, cluster1);
-    Status error = Status.RESOURCE_EXHAUSTED.withDescription("OOM");
-    xdsClient.deliverError(error);
+  public void handleNameResolutionErrorFromUpstream_beforeChildLbCreated_failingPicker() {
+    Status status = Status.UNAVAILABLE.withDescription("unreachable");
+    loadBalancer.handleNameResolutionError(status);
     verify(helper).updateBalancingState(
         eq(ConnectivityState.TRANSIENT_FAILURE), pickerCaptor.capture());
-    assertPicker(pickerCaptor.getValue(), error, null);
-    assertThat(childBalancers).isEmpty();
+    assertPickerStatus(pickerCaptor.getValue(), status);
   }
 
   @Test
-  public void aggregateCluster_discoveryErrorAfterChildLbCreated_propagateToChildLb() {
-    String cluster1 = "cluster-01.googleapis.com";
-    // CLUSTER (aggr.) -> [cluster1 (logical DNS)]
-    xdsClient.deliverAggregateCluster(CLUSTER, Collections.singletonList(cluster1));
-    xdsClient.deliverLogicalDnsCluster(cluster1, LRS_SERVER_NAME, 200L, null);
-    FakeLoadBalancer childLb = Iterables.getOnlyElement(childBalancers);
-    ClusterResolverConfig childLbConfig = (ClusterResolverConfig) childLb.config;
-    assertThat(childLbConfig.discoveryMechanisms).hasSize(1);
-
-    Status error = Status.RESOURCE_EXHAUSTED.withDescription("OOM");
-    xdsClient.deliverError(error);
-    assertThat(childLb.upstreamError).isEqualTo(error);
-    assertThat(childLb.shutdown).isFalse();  // child LB may choose to keep working
+  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 handleNameResolutionErrorFromUpstream_beforeChildLbCreated_returnErrorPicker() {
-    Status upstreamError = Status.UNAVAILABLE.withDescription("unreachable");
-    loadBalancer.handleNameResolutionError(upstreamError);
+  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());
-    assertPicker(pickerCaptor.getValue(), upstreamError, null);
+    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 handleNameResolutionErrorFromUpstream_afterChildLbCreated_fallThrough() {
-    xdsClient.deliverEdsCluster(CLUSTER, EDS_SERVICE_NAME, LRS_SERVER_NAME, 100L,
-        upstreamTlsContext);
-    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, never()).updateBalancingState(
-        any(ConnectivityState.class), any(SubchannelPicker.class));
+  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 static void assertPicker(SubchannelPicker picker, Status expectedStatus,
-      @Nullable Subchannel expectedSubchannel)  {
+  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());
-    if (actualStatus.isOk()) {
-      assertThat(result.getSubchannel()).isSameInstanceAs(expectedSubchannel);
-    }
-  }
-
-  private static void assertDiscoveryMechanism(DiscoveryMechanism instance, String name,
-      DiscoveryMechanism.Type type, @Nullable String edsServiceName,
-      @Nullable String lrsServerName, @Nullable Long maxConcurrentRequests,
-      @Nullable UpstreamTlsContext tlsContext) {
-    assertThat(instance.cluster).isEqualTo(name);
-    assertThat(instance.type).isEqualTo(type);
-    assertThat(instance.edsServiceName).isEqualTo(edsServiceName);
-    assertThat(instance.lrsServerName).isEqualTo(lrsServerName);
-    assertThat(instance.maxConcurrentRequests).isEqualTo(maxConcurrentRequests);
-    assertThat(instance.tlsContext).isEqualTo(tlsContext);
   }
 
   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, helper);
+      FakeLoadBalancer balancer = new FakeLoadBalancer(policyName);
       childBalancers.add(balancer);
       return balancer;
     }
@@ -484,23 +679,31 @@ public int getPriority() {
     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 final Helper helper;
     private Object config;
     private Status upstreamError;
     private boolean shutdown;
 
-    FakeLoadBalancer(String name, Helper helper) {
+    FakeLoadBalancer(String name) {
       this.name = name;
-      this.helper = helper;
     }
 
     @Override
-    public void handleResolvedAddresses(ResolvedAddresses resolvedAddresses) {
+    public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
       config = resolvedAddresses.getLoadBalancingPolicyConfig();
+      return Status.OK;
     }
 
     @Override
@@ -513,72 +716,5 @@ 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);
-    }
-  }
-
-  private static final class FakeXdsClient extends XdsClient {
-    private final Map<String, CdsResourceWatcher> watchers = new HashMap<>();
-
-    @Override
-    void watchCdsResource(String resourceName, CdsResourceWatcher watcher) {
-      assertThat(watchers).doesNotContainKey(resourceName);
-      watchers.put(resourceName, watcher);
-    }
-
-    @Override
-    void cancelCdsResourceWatch(String resourceName, CdsResourceWatcher watcher) {
-      assertThat(watchers).containsKey(resourceName);
-      watchers.remove(resourceName);
-    }
-
-    private void deliverEdsCluster(String clusterName, @Nullable String edsServiceName,
-        @Nullable String lrsServerName, @Nullable Long maxConcurrentRequests,
-        @Nullable UpstreamTlsContext tlsContext) {
-      if (watchers.containsKey(clusterName)) {
-        CdsUpdate update = CdsUpdate.forEds(
-            clusterName, edsServiceName, lrsServerName, maxConcurrentRequests, tlsContext)
-            .lbPolicy("round_robin").build();
-        watchers.get(clusterName).onChanged(update);
-      }
-    }
-
-    private void deliverLogicalDnsCluster(String clusterName, @Nullable String lrsServerName,
-        @Nullable Long maxConcurrentRequests, @Nullable UpstreamTlsContext tlsContext) {
-      if (watchers.containsKey(clusterName)) {
-        CdsUpdate update = CdsUpdate.forLogicalDns(
-            clusterName, lrsServerName, maxConcurrentRequests, tlsContext)
-            .lbPolicy("round_robin").build();
-        watchers.get(clusterName).onChanged(update);
-      }
-    }
-
-    private void deliverAggregateCluster(String clusterName, List<String> clusters) {
-      if (watchers.containsKey(clusterName)) {
-        CdsUpdate update = CdsUpdate.forAggregate(clusterName, clusters)
-            .lbPolicy("round_robin").build();
-        watchers.get(clusterName).onChanged(update);
-      }
-    }
-
-    private void deliverResourceNotExist(String clusterName)  {
-      if (watchers.containsKey(clusterName)) {
-        watchers.get(clusterName).onResourceDoesNotExist(clusterName);
-      }
-    }
-
-    private void deliverError(Status error) {
-      for (CdsResourceWatcher watcher : watchers.values()) {
-        watcher.onError(error);
-      }
-    }
   }
 }
diff --git a/xds/src/test/java/io/grpc/xds/ClientXdsClientDataTest.java b/xds/src/test/java/io/grpc/xds/ClientXdsClientDataTest.java
deleted file mode 100644
index 7cffacdf5db..00000000000
--- a/xds/src/test/java/io/grpc/xds/ClientXdsClientDataTest.java
+++ /dev/null
@@ -1,616 +0,0 @@
-/*
- * 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.UInt32Value;
-import com.google.protobuf.util.Durations;
-import com.google.re2j.Pattern;
-import io.envoyproxy.envoy.config.core.v3.Address;
-import io.envoyproxy.envoy.config.core.v3.Locality;
-import io.envoyproxy.envoy.config.core.v3.RuntimeFractionalPercent;
-import io.envoyproxy.envoy.config.core.v3.SocketAddress;
-import io.envoyproxy.envoy.config.endpoint.v3.Endpoint;
-import io.envoyproxy.envoy.config.route.v3.DirectResponseAction;
-import io.envoyproxy.envoy.config.route.v3.FilterAction;
-import io.envoyproxy.envoy.config.route.v3.RedirectAction;
-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.WeightedCluster;
-import io.envoyproxy.envoy.extensions.filters.http.fault.v3.FaultAbort.HeaderAbort;
-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.v3.FractionalPercent;
-import io.envoyproxy.envoy.type.v3.FractionalPercent.DenominatorType;
-import io.envoyproxy.envoy.type.v3.Int64Range;
-import io.grpc.Status.Code;
-import io.grpc.xds.ClientXdsClient.StructOrError;
-import io.grpc.xds.Endpoints.LbEndpoint;
-import io.grpc.xds.Endpoints.LocalityLbEndpoints;
-import io.grpc.xds.HttpFault.FaultAbort;
-import io.grpc.xds.Matchers.FractionMatcher;
-import io.grpc.xds.Matchers.HeaderMatcher;
-import io.grpc.xds.Matchers.PathMatcher;
-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 java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
-import java.util.concurrent.TimeUnit;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-
-@RunWith(JUnit4.class)
-public class ClientXdsClientDataTest {
-
-  @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 = ClientXdsClient.parseRoute(proto);
-    assertThat(struct.getErrorDetail()).isNull();
-    assertThat(struct.getStruct())
-        .isEqualTo(
-            Route.create(
-                RouteMatch.create(PathMatcher.fromPath("/service/method", false),
-                    Collections.<HeaderMatcher>emptyList(), null),
-                RouteAction.forCluster("cluster-foo", Collections.<HashPolicy>emptyList(), null),
-                null));
-  }
-
-  @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 = ClientXdsClient.parseRoute(redirectRoute);
-    assertThat(res.getStruct()).isNull();
-    assertThat(res.getErrorDetail()).isEqualTo("Unsupported 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 = ClientXdsClient.parseRoute(directResponseRoute);
-    assertThat(res.getStruct()).isNull();
-    assertThat(res.getErrorDetail()).isEqualTo("Unsupported 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 = ClientXdsClient.parseRoute(filterRoute);
-    assertThat(res.getStruct()).isNull();
-    assertThat(res.getErrorDetail()).isEqualTo("Unsupported 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(ClientXdsClient.parseRoute(proto)).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(ClientXdsClient.parseRoute(proto)).isNull();
-  }
-
-  @Test
-  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 = ClientXdsClient.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 = ClientXdsClient.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 = ClientXdsClient.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 = ClientXdsClient.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 = ClientXdsClient.parsePathMatcher(proto);
-    assertThat(struct.getErrorDetail()).isNull();
-    assertThat(struct.getStruct()).isEqualTo(PathMatcher.fromRegEx(Pattern.compile(".")));
-  }
-
-  @Test
-  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 = ClientXdsClient.parseHeaderMatcher(proto);
-    assertThat(struct1.getErrorDetail()).isNull();
-    assertThat(struct1.getStruct()).isEqualTo(
-        HeaderMatcher.forExactValue(":method", "PUT", false));
-  }
-
-  @Test
-  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 = ClientXdsClient.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 = ClientXdsClient.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 = ClientXdsClient.parseHeaderMatcher(proto);
-    assertThat(struct5.getErrorDetail()).isNull();
-    assertThat(struct5.getStruct()).isEqualTo(
-        HeaderMatcher.forPresent("user-agent", true, false));
-  }
-
-  @Test
-  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 = ClientXdsClient.parseHeaderMatcher(proto);
-    assertThat(struct6.getErrorDetail()).isNull();
-    assertThat(struct6.getStruct()).isEqualTo(
-        HeaderMatcher.forPrefix("authority", "service-foo", false));
-  }
-
-  @Test
-  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 = ClientXdsClient.parseHeaderMatcher(proto);
-    assertThat(struct7.getErrorDetail()).isNull();
-    assertThat(struct7.getStruct()).isEqualTo(
-        HeaderMatcher.forSuffix("authority", "googleapis.com", false));
-  }
-
-  @Test
-  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 = ClientXdsClient.parseHeaderMatcher(proto);
-    assertThat(struct.getErrorDetail()).isNotNull();
-    assertThat(struct.getStruct()).isNull();
-  }
-
-  @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 = ClientXdsClient.parseRouteAction(proto);
-    assertThat(struct.getErrorDetail()).isNull();
-    assertThat(struct.getStruct().cluster()).isEqualTo("cluster-foo");
-    assertThat(struct.getStruct().weightedClusters()).isNull();
-  }
-
-  @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 = ClientXdsClient.parseRouteAction(proto);
-    assertThat(struct.getErrorDetail()).isNull();
-    assertThat(struct.getStruct().cluster()).isNull();
-    assertThat(struct.getStruct().weightedClusters()).containsExactly(
-        ClusterWeight.create("cluster-foo", 30, null),
-        ClusterWeight.create("cluster-bar", 70, null));
-  }
-
-  @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 = ClientXdsClient.parseRouteAction(proto);
-    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 = ClientXdsClient.parseRouteAction(proto);
-    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 = ClientXdsClient.parseRouteAction(proto);
-    assertThat(struct.getStruct().timeoutNano()).isNull();
-  }
-
-  @Test
-  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(ClientXdsClient.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 = ClientXdsClient.parseRouteAction(proto);
-    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 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 = ClientXdsClient.parseClusterWeight(proto).getStruct();
-    assertThat(clusterWeight.name()).isEqualTo("cluster-foo");
-    assertThat(clusterWeight.weight()).isEqualTo(30);
-  }
-
-  // TODO(zdapeng): add tests for parseClusterWeight with HttpFault.
-
-  // TODO(zdapeng): add tests for parseHttpFault.
-
-  @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();
-    FaultAbort faultAbort = ClientXdsClient.parseFaultAbort(proto).getStruct();
-    assertThat(faultAbort.headerAbort()).isTrue();
-    assertThat(faultAbort.percent().numerator()).isEqualTo(20);
-    assertThat(faultAbort.percent().denominatorType())
-        .isEqualTo(HttpFault.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();
-    FaultAbort res = ClientXdsClient.parseFaultAbort(proto).getStruct();
-    assertThat(res.percent().numerator()).isEqualTo(100);
-    assertThat(res.percent().denominatorType())
-        .isEqualTo(HttpFault.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();
-    FaultAbort faultAbort = ClientXdsClient.parseFaultAbort(proto).getStruct();
-    assertThat(faultAbort.percent().numerator()).isEqualTo(600);
-    assertThat(faultAbort.percent().denominatorType())
-        .isEqualTo(HttpFault.FractionalPercent.DenominatorType.MILLION);
-    assertThat(faultAbort.status().getCode()).isEqualTo(Code.DEADLINE_EXCEEDED);
-  }
-
-  @Test
-  public void parseLocalityLbEndpoints_withHealthyEndpoints() {
-    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 = ClientXdsClient.parseLocalityLbEndpoints(proto);
-    assertThat(struct.getErrorDetail()).isNull();
-    assertThat(struct.getStruct()).isEqualTo(
-        LocalityLbEndpoints.create(
-            Collections.singletonList(LbEndpoint.create("172.14.14.5", 8888, 20, true)), 100, 1));
-  }
-
-  @Test
-  public void parseLocalityLbEndpoints_treatUnknownHealthAsHealthy() {
-    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 = ClientXdsClient.parseLocalityLbEndpoints(proto);
-    assertThat(struct.getErrorDetail()).isNull();
-    assertThat(struct.getStruct()).isEqualTo(
-        LocalityLbEndpoints.create(
-            Collections.singletonList(LbEndpoint.create("172.14.14.5", 8888, 20, true)), 100, 1));
-  }
-
-  @Test
-  public void parseLocalityLbEndpoints_withUnHealthyEndpoints() {
-    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 = ClientXdsClient.parseLocalityLbEndpoints(proto);
-    assertThat(struct.getErrorDetail()).isNull();
-    assertThat(struct.getStruct()).isEqualTo(
-        LocalityLbEndpoints.create(
-            Collections.singletonList(LbEndpoint.create("172.14.14.5", 8888, 20, false)), 100, 1));
-  }
-
-  @Test
-  public void parseLocalityLbEndpoints_ignorZeroWeightLocality() {
-    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(ClientXdsClient.parseLocalityLbEndpoints(proto)).isNull();
-  }
-
-  @Test
-  public void parseLocalityLbEndpoints_invalidPriority() {
-    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 = ClientXdsClient.parseLocalityLbEndpoints(proto);
-    assertThat(struct.getErrorDetail()).isEqualTo("negative priority");
-  }
-}
diff --git a/xds/src/test/java/io/grpc/xds/ClientXdsClientTestBase.java b/xds/src/test/java/io/grpc/xds/ClientXdsClientTestBase.java
deleted file mode 100644
index 72a2f1870c6..00000000000
--- a/xds/src/test/java/io/grpc/xds/ClientXdsClientTestBase.java
+++ /dev/null
@@ -1,1598 +0,0 @@
-/*
- * 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.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.ImmutableList;
-import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.Iterables;
-import com.google.protobuf.Any;
-import com.google.protobuf.Message;
-import com.google.protobuf.StringValue;
-import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.SdsSecretConfig;
-import io.grpc.BindableService;
-import io.grpc.ManagedChannel;
-import io.grpc.Status;
-import io.grpc.Status.Code;
-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.testing.GrpcCleanupRule;
-import io.grpc.xds.AbstractXdsClient.ResourceType;
-import io.grpc.xds.Endpoints.DropOverload;
-import io.grpc.xds.Endpoints.LbEndpoint;
-import io.grpc.xds.Endpoints.LocalityLbEndpoints;
-import io.grpc.xds.EnvoyProtoData.Node;
-import io.grpc.xds.HttpFault.FractionalPercent.DenominatorType;
-import io.grpc.xds.LoadStatsManager2.ClusterDropStats;
-import io.grpc.xds.XdsClient.CdsResourceWatcher;
-import io.grpc.xds.XdsClient.CdsUpdate;
-import io.grpc.xds.XdsClient.CdsUpdate.ClusterType;
-import io.grpc.xds.XdsClient.CdsUpdate.HashFunction;
-import io.grpc.xds.XdsClient.EdsResourceWatcher;
-import io.grpc.xds.XdsClient.EdsUpdate;
-import io.grpc.xds.XdsClient.LdsResourceWatcher;
-import io.grpc.xds.XdsClient.LdsUpdate;
-import io.grpc.xds.XdsClient.RdsResourceWatcher;
-import io.grpc.xds.XdsClient.RdsUpdate;
-import io.grpc.xds.XdsClient.ResourceWatcher;
-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.Queue;
-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.MockitoAnnotations;
-
-/**
- * Tests for {@link ClientXdsClient}.
- */
-@RunWith(JUnit4.class)
-public abstract class ClientXdsClientTestBase {
-  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 Node NODE = Node.newBuilder().build();
-  private static final FakeClock.TaskFilter RPC_RETRY_TASK_FILTER =
-      new FakeClock.TaskFilter() {
-        @Override
-        public boolean shouldAccept(Runnable command) {
-          return command.toString().contains(AbstractXdsClient.RpcRetryTask.class.getSimpleName());
-        }
-      };
-
-  private static final FakeClock.TaskFilter LDS_RESOURCE_FETCH_TIMEOUT_TASK_FILTER =
-      new TaskFilter() {
-        @Override
-        public boolean shouldAccept(Runnable command) {
-          return command.toString().contains(ResourceType.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(ResourceType.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(ResourceType.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(ResourceType.EDS.toString());
-        }
-      };
-
-  @Rule
-  public final GrpcCleanupRule cleanupRule = new GrpcCleanupRule();
-
-  private final FakeClock fakeClock = new FakeClock();
-  protected final Queue<DiscoveryRpcCall> resourceDiscoveryCalls = new ArrayDeque<>();
-  protected final Queue<LrsRpcCall> loadReportCalls = new ArrayDeque<>();
-  protected final AtomicBoolean adsEnded = new AtomicBoolean(true);
-  protected final AtomicBoolean lrsEnded = new AtomicBoolean(true);
-  private final MessageFactory mf = createMessageFactory();
-
-  @Captor
-  private ArgumentCaptor<LdsUpdate> ldsUpdateCaptor;
-  @Captor
-  private ArgumentCaptor<RdsUpdate> rdsUpdateCaptor;
-  @Captor
-  private ArgumentCaptor<CdsUpdate> cdsUpdateCaptor;
-  @Captor
-  private ArgumentCaptor<EdsUpdate> edsUpdateCaptor;
-  @Captor
-  private ArgumentCaptor<Status> errorCaptor;
-  @Mock
-  private BackoffPolicy.Provider backoffPolicyProvider;
-  @Mock
-  private BackoffPolicy backoffPolicy1;
-  @Mock
-  private BackoffPolicy backoffPolicy2;
-  @Mock
-  private LdsResourceWatcher ldsResourceWatcher;
-  @Mock
-  private RdsResourceWatcher rdsResourceWatcher;
-  @Mock
-  private CdsResourceWatcher cdsResourceWatcher;
-  @Mock
-  private EdsResourceWatcher edsResourceWatcher;
-
-  private ManagedChannel channel;
-  private ClientXdsClient xdsClient;
-  private boolean originalEnableFaultInjection;
-
-  @Before
-  public void setUp() throws IOException {
-    originalEnableFaultInjection = ClientXdsClient.enableFaultInjection;
-    ClientXdsClient.enableFaultInjection = true;
-    MockitoAnnotations.initMocks(this);
-    when(backoffPolicyProvider.get()).thenReturn(backoffPolicy1, backoffPolicy2);
-    when(backoffPolicy1.nextBackoffNanos()).thenReturn(10L, 100L);
-    when(backoffPolicy2.nextBackoffNanos()).thenReturn(20L, 200L);
-
-    final String serverName = InProcessServerBuilder.generateName();
-    cleanupRule.register(
-        InProcessServerBuilder
-            .forName(serverName)
-            .addService(createAdsService())
-            .addService(createLrsService())
-            .directExecutor()
-            .build()
-            .start());
-    channel =
-        cleanupRule.register(InProcessChannelBuilder.forName(serverName).directExecutor().build());
-
-    xdsClient =
-        new ClientXdsClient(
-            channel,
-            useProtocolV3(),
-            EnvoyProtoData.Node.newBuilder().build(),
-            fakeClock.getScheduledExecutorService(),
-            backoffPolicyProvider,
-            fakeClock.getStopwatchSupplier());
-
-    assertThat(resourceDiscoveryCalls).isEmpty();
-    assertThat(loadReportCalls).isEmpty();
-  }
-
-  @After
-  public void tearDown() {
-    ClientXdsClient.enableFaultInjection = originalEnableFaultInjection;
-    xdsClient.shutdown();
-    channel.shutdown();  // channel not owned by XdsClient
-    assertThat(adsEnded.get()).isTrue();
-    assertThat(lrsEnded.get()).isTrue();
-    assertThat(fakeClock.getPendingTasks()).isEmpty();
-  }
-
-  protected abstract boolean useProtocolV3();
-
-  protected abstract BindableService createAdsService();
-
-  protected abstract BindableService createLrsService();
-
-  protected abstract MessageFactory createMessageFactory();
-
-  @Test
-  public void ldsResourceNotFound() {
-    DiscoveryRpcCall call =
-        startResourceWatcher(ResourceType.LDS, LDS_RESOURCE, ldsResourceWatcher);
-    List<Any> listeners = ImmutableList.of(
-        Any.pack(mf.buildListener("bar.googleapis.com",
-            mf.buildRouteConfiguration("route-bar.googleapis.com",
-                mf.buildOpaqueVirtualHosts(1)))));
-    call.sendResponse("0", listeners, ResourceType.LDS, "0000");
-
-    // Client sends an ACK LDS request.
-    call.verifyRequest(NODE, "0", Collections.singletonList(LDS_RESOURCE), ResourceType.LDS,
-        "0000");
-
-    verifyNoInteractions(ldsResourceWatcher);
-    fakeClock.forwardTime(ClientXdsClient.INITIAL_RESOURCE_FETCH_TIMEOUT_SEC, TimeUnit.SECONDS);
-    verify(ldsResourceWatcher).onResourceDoesNotExist(LDS_RESOURCE);
-    assertThat(fakeClock.getPendingTasks(LDS_RESOURCE_FETCH_TIMEOUT_TASK_FILTER)).isEmpty();
-  }
-
-  @Test
-  public void ldsResourceFound_containsVirtualHosts() {
-    DiscoveryRpcCall call =
-        startResourceWatcher(ResourceType.LDS, LDS_RESOURCE, ldsResourceWatcher);
-    List<Any> listeners = ImmutableList.of(
-        Any.pack(mf.buildListener(LDS_RESOURCE,
-            mf.buildRouteConfiguration("do not care", mf.buildOpaqueVirtualHosts(2)))));
-    call.sendResponse("0", listeners, ResourceType.LDS, "0000");
-
-    // Client sends an ACK LDS request.
-    call.verifyRequest(NODE, "0", Collections.singletonList(LDS_RESOURCE), ResourceType.LDS,
-        "0000");
-    verify(ldsResourceWatcher).onChanged(ldsUpdateCaptor.capture());
-    assertThat(ldsUpdateCaptor.getValue().virtualHosts).hasSize(2);
-    assertThat(fakeClock.getPendingTasks(LDS_RESOURCE_FETCH_TIMEOUT_TASK_FILTER)).isEmpty();
-  }
-
-  @Test
-  public void ldsResourceFound_containsRdsName() {
-    DiscoveryRpcCall call =
-        startResourceWatcher(ResourceType.LDS, LDS_RESOURCE, ldsResourceWatcher);
-    List<Any> listeners = ImmutableList.of(
-        Any.pack(mf.buildListenerForRds(LDS_RESOURCE, RDS_RESOURCE)));
-    call.sendResponse("0", listeners, ResourceType.LDS, "0000");
-
-    // Client sends an ACK LDS request.
-    call.verifyRequest(NODE, "0", Collections.singletonList(LDS_RESOURCE), ResourceType.LDS,
-        "0000");
-    verify(ldsResourceWatcher).onChanged(ldsUpdateCaptor.capture());
-    assertThat(ldsUpdateCaptor.getValue().rdsName).isEqualTo(RDS_RESOURCE);
-    assertThat(fakeClock.getPendingTasks(LDS_RESOURCE_FETCH_TIMEOUT_TASK_FILTER)).isEmpty();
-  }
-
-  @Test
-  public void cachedLdsResource_data() {
-    DiscoveryRpcCall call =
-        startResourceWatcher(ResourceType.LDS, LDS_RESOURCE, ldsResourceWatcher);
-    List<Any> listeners = ImmutableList.of(
-        Any.pack(mf.buildListenerForRds(LDS_RESOURCE, RDS_RESOURCE)));
-    call.sendResponse("0", listeners, ResourceType.LDS, "0000");
-
-    // Client sends an ACK LDS request.
-    call.verifyRequest(NODE, "0", Collections.singletonList(LDS_RESOURCE), ResourceType.LDS,
-        "0000");
-    LdsResourceWatcher watcher = mock(LdsResourceWatcher.class);
-    xdsClient.watchLdsResource(LDS_RESOURCE, watcher);
-    verify(watcher).onChanged(ldsUpdateCaptor.capture());
-    assertThat(ldsUpdateCaptor.getValue().rdsName).isEqualTo(RDS_RESOURCE);
-    call.verifyNoMoreRequest();
-  }
-
-  @Test
-  public void cachedLdsResource_absent() {
-    DiscoveryRpcCall call =
-        startResourceWatcher(ResourceType.LDS, LDS_RESOURCE, ldsResourceWatcher);
-    fakeClock.forwardTime(ClientXdsClient.INITIAL_RESOURCE_FETCH_TIMEOUT_SEC, TimeUnit.SECONDS);
-    verify(ldsResourceWatcher).onResourceDoesNotExist(LDS_RESOURCE);
-    LdsResourceWatcher watcher = mock(LdsResourceWatcher.class);
-    xdsClient.watchLdsResource(LDS_RESOURCE, watcher);
-    verify(watcher).onResourceDoesNotExist(LDS_RESOURCE);
-    call.verifyNoMoreRequest();
-  }
-
-  @Test
-  public void ldsResourceUpdated() {
-    DiscoveryRpcCall call =
-        startResourceWatcher(ResourceType.LDS, LDS_RESOURCE, ldsResourceWatcher);
-    List<Any> listeners = ImmutableList.of(
-        Any.pack(mf.buildListener(LDS_RESOURCE,
-            mf.buildRouteConfiguration("do not care", mf.buildOpaqueVirtualHosts(2)))));
-    call.sendResponse("0", listeners, ResourceType.LDS, "0000");
-
-    // Client sends an ACK LDS request.
-    call.verifyRequest(NODE, "0", Collections.singletonList(LDS_RESOURCE), ResourceType.LDS,
-        "0000");
-    verify(ldsResourceWatcher).onChanged(ldsUpdateCaptor.capture());
-    assertThat(ldsUpdateCaptor.getValue().virtualHosts).hasSize(2);
-
-    listeners = ImmutableList.of(
-        Any.pack(mf.buildListenerForRds(LDS_RESOURCE, RDS_RESOURCE)));
-    call.sendResponse("1", listeners, ResourceType.LDS, "0001");
-
-    // Client sends an ACK LDS request.
-    call.verifyRequest(NODE, "1", Collections.singletonList(LDS_RESOURCE), ResourceType.LDS,
-        "0001");
-    verify(ldsResourceWatcher, times(2)).onChanged(ldsUpdateCaptor.capture());
-    assertThat(ldsUpdateCaptor.getValue().rdsName).isEqualTo(RDS_RESOURCE);
-  }
-
-  @Test
-  public void ldsResourceUpdate_withFaultInjection() {
-    Assume.assumeTrue(useProtocolV3());
-    DiscoveryRpcCall call =
-        startResourceWatcher(ResourceType.LDS, LDS_RESOURCE, ldsResourceWatcher);
-    List<Any> listeners = ImmutableList.of(
-        Any.pack(mf.buildListener(
-            LDS_RESOURCE,
-            mf.buildRouteConfiguration(
-                "do not care",
-                ImmutableList.of(
-                    mf.buildVirtualHost(
-                        mf.buildOpaqueRoutes(1),
-                        ImmutableMap.of(
-                            "irrelevant",
-                            Any.pack(StringValue.of("irrelevant")),
-                            "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),
-                mf.buildHttpFilter("envoy.fault", null)
-            ))));
-    call.sendResponse("0", listeners, ResourceType.LDS, "0000");
-
-    // Client sends an ACK LDS request.
-    call.verifyRequest(NODE, "0", Collections.singletonList(LDS_RESOURCE), ResourceType.LDS,
-        "0000");
-    verify(ldsResourceWatcher).onChanged(ldsUpdateCaptor.capture());
-    LdsUpdate ldsUpdate = ldsUpdateCaptor.getValue();
-    assertThat(ldsUpdate.virtualHosts).hasSize(2);
-    assertThat(ldsUpdate.hasFaultInjection).isTrue();
-    assertThat(ldsUpdate.httpFault).isNull();
-    HttpFault httpFault = ldsUpdate.virtualHosts.get(0).httpFault();
-    assertThat(httpFault.faultDelay().delayNanos()).isEqualTo(300);
-    assertThat(httpFault.faultDelay().percent().numerator()).isEqualTo(1000);
-    assertThat(httpFault.faultDelay().percent().denominatorType())
-        .isEqualTo(DenominatorType.MILLION);
-    assertThat(httpFault.faultAbort()).isNull();
-    assertThat(httpFault.upstreamCluster()).isEqualTo("cluster1");
-    assertThat(httpFault.maxActiveFaults()).isEqualTo(100);
-    httpFault = ldsUpdate.virtualHosts.get(1).httpFault();
-    assertThat(httpFault.faultDelay()).isNull();
-    assertThat(httpFault.faultAbort().status().getCode()).isEqualTo(Status.Code.UNAVAILABLE);
-    assertThat(httpFault.faultAbort().percent().numerator()).isEqualTo(2000);
-    assertThat(httpFault.faultAbort().percent().denominatorType())
-        .isEqualTo(DenominatorType.MILLION);
-    assertThat(httpFault.upstreamCluster()).isEqualTo("cluster2");
-    assertThat(httpFault.maxActiveFaults()).isEqualTo(101);
-  }
-
-  @Test
-  public void ldsResourceDeleted() {
-    DiscoveryRpcCall call =
-        startResourceWatcher(ResourceType.LDS, LDS_RESOURCE, ldsResourceWatcher);
-    List<Any> listeners = ImmutableList.of(
-        Any.pack(mf.buildListener(LDS_RESOURCE,
-            mf.buildRouteConfiguration("do not care", mf.buildOpaqueVirtualHosts(2)))));
-    call.sendResponse("0", listeners, ResourceType.LDS, "0000");
-
-    // Client sends an ACK LDS request.
-    call.verifyRequest(NODE, "0", Collections.singletonList(LDS_RESOURCE), ResourceType.LDS,
-        "0000");
-    verify(ldsResourceWatcher).onChanged(ldsUpdateCaptor.capture());
-    assertThat(ldsUpdateCaptor.getValue().virtualHosts).hasSize(2);
-
-    call.sendResponse("1", Collections.<Any>emptyList(), ResourceType.LDS, "0001");
-
-    // Client sends an ACK LDS request.
-    call.verifyRequest(NODE, "1", Collections.singletonList(LDS_RESOURCE), ResourceType.LDS,
-        "0001");
-    verify(ldsResourceWatcher).onResourceDoesNotExist(LDS_RESOURCE);
-  }
-
-  @Test
-  public void multipleLdsWatchers() {
-    String ldsResource = "bar.googleapis.com";
-    LdsResourceWatcher watcher1 = mock(LdsResourceWatcher.class);
-    LdsResourceWatcher watcher2 = mock(LdsResourceWatcher.class);
-    xdsClient.watchLdsResource(LDS_RESOURCE, ldsResourceWatcher);
-    xdsClient.watchLdsResource(ldsResource, watcher1);
-    xdsClient.watchLdsResource(ldsResource, watcher2);
-    DiscoveryRpcCall call = resourceDiscoveryCalls.poll();
-    call.verifyRequest(NODE, "", Arrays.asList(LDS_RESOURCE, ldsResource), ResourceType.LDS, "");
-
-    fakeClock.forwardTime(ClientXdsClient.INITIAL_RESOURCE_FETCH_TIMEOUT_SEC, TimeUnit.SECONDS);
-    verify(ldsResourceWatcher).onResourceDoesNotExist(LDS_RESOURCE);
-    verify(watcher1).onResourceDoesNotExist(ldsResource);
-    verify(watcher2).onResourceDoesNotExist(ldsResource);
-
-    List<Any> listeners = ImmutableList.of(
-        Any.pack(mf.buildListener(LDS_RESOURCE,
-            mf.buildRouteConfiguration("do not care", mf.buildOpaqueVirtualHosts(2)))),
-        Any.pack(mf.buildListener(ldsResource,
-            mf.buildRouteConfiguration("do not care", mf.buildOpaqueVirtualHosts(4)))));
-    call.sendResponse("0", listeners, ResourceType.LDS, "0000");
-    verify(ldsResourceWatcher).onChanged(ldsUpdateCaptor.capture());
-    assertThat(ldsUpdateCaptor.getValue().virtualHosts).hasSize(2);
-    verify(watcher1).onChanged(ldsUpdateCaptor.capture());
-    assertThat(ldsUpdateCaptor.getValue().virtualHosts).hasSize(4);
-    verify(watcher2).onChanged(ldsUpdateCaptor.capture());
-    assertThat(ldsUpdateCaptor.getValue().virtualHosts).hasSize(4);
-  }
-
-  @Test
-  public void rdsResourceNotFound() {
-    DiscoveryRpcCall call =
-        startResourceWatcher(ResourceType.RDS, RDS_RESOURCE, rdsResourceWatcher);
-    List<Any> routeConfigs = ImmutableList.of(
-        Any.pack(mf.buildRouteConfiguration("route-bar.googleapis.com",
-            mf.buildOpaqueVirtualHosts(2))));
-    call.sendResponse("0", routeConfigs, ResourceType.RDS, "0000");
-
-    // Client sends an ACK RDS request.
-    call.verifyRequest(NODE, "0", Collections.singletonList(RDS_RESOURCE), ResourceType.RDS,
-        "0000");
-
-    verifyNoInteractions(rdsResourceWatcher);
-    fakeClock.forwardTime(ClientXdsClient.INITIAL_RESOURCE_FETCH_TIMEOUT_SEC, TimeUnit.SECONDS);
-    verify(rdsResourceWatcher).onResourceDoesNotExist(RDS_RESOURCE);
-    assertThat(fakeClock.getPendingTasks(RDS_RESOURCE_FETCH_TIMEOUT_TASK_FILTER)).isEmpty();
-  }
-
-  @Test
-  public void rdsResourceFound() {
-    DiscoveryRpcCall call =
-        startResourceWatcher(ResourceType.RDS, RDS_RESOURCE, rdsResourceWatcher);
-    List<Any> routeConfigs = ImmutableList.of(
-        Any.pack(mf.buildRouteConfiguration(RDS_RESOURCE, mf.buildOpaqueVirtualHosts(2))));
-    call.sendResponse("0", routeConfigs, ResourceType.RDS, "0000");
-
-    // Client sends an ACK RDS request.
-    call.verifyRequest(NODE, "0", Collections.singletonList(RDS_RESOURCE), ResourceType.RDS,
-        "0000");
-    verify(rdsResourceWatcher).onChanged(rdsUpdateCaptor.capture());
-    assertThat(rdsUpdateCaptor.getValue().virtualHosts).hasSize(2);
-    assertThat(fakeClock.getPendingTasks(RDS_RESOURCE_FETCH_TIMEOUT_TASK_FILTER)).isEmpty();
-  }
-
-  @Test
-  public void cachedRdsResource_data() {
-    DiscoveryRpcCall call =
-        startResourceWatcher(ResourceType.RDS, RDS_RESOURCE, rdsResourceWatcher);
-    List<Any> routeConfigs = ImmutableList.of(
-        Any.pack(mf.buildRouteConfiguration(RDS_RESOURCE, mf.buildOpaqueVirtualHosts(2))));
-    call.sendResponse("0", routeConfigs, ResourceType.RDS, "0000");
-
-    // Client sends an ACK RDS request.
-    call.verifyRequest(NODE, "0", Collections.singletonList(RDS_RESOURCE), ResourceType.RDS,
-        "0000");
-
-    RdsResourceWatcher watcher = mock(RdsResourceWatcher.class);
-    xdsClient.watchRdsResource(RDS_RESOURCE, watcher);
-    verify(watcher).onChanged(rdsUpdateCaptor.capture());
-    assertThat(rdsUpdateCaptor.getValue().virtualHosts).hasSize(2);
-    call.verifyNoMoreRequest();
-  }
-
-  @Test
-  public void cachedRdsResource_absent() {
-    DiscoveryRpcCall call =
-        startResourceWatcher(ResourceType.RDS, RDS_RESOURCE, rdsResourceWatcher);
-    fakeClock.forwardTime(ClientXdsClient.INITIAL_RESOURCE_FETCH_TIMEOUT_SEC, TimeUnit.SECONDS);
-    verify(rdsResourceWatcher).onResourceDoesNotExist(RDS_RESOURCE);
-    RdsResourceWatcher watcher = mock(RdsResourceWatcher.class);
-    xdsClient.watchRdsResource(RDS_RESOURCE, watcher);
-    verify(watcher).onResourceDoesNotExist(RDS_RESOURCE);
-    call.verifyNoMoreRequest();
-  }
-
-  @Test
-  public void rdsResourceUpdated() {
-    DiscoveryRpcCall call =
-        startResourceWatcher(ResourceType.RDS, RDS_RESOURCE, rdsResourceWatcher);
-    List<Any> routeConfigs = ImmutableList.of(
-        Any.pack(mf.buildRouteConfiguration(RDS_RESOURCE, mf.buildOpaqueVirtualHosts(2))));
-    call.sendResponse("0", routeConfigs, ResourceType.RDS, "0000");
-
-    // Client sends an ACK RDS request.
-    call.verifyRequest(NODE, "0", Collections.singletonList(RDS_RESOURCE), ResourceType.RDS,
-        "0000");
-    verify(rdsResourceWatcher).onChanged(rdsUpdateCaptor.capture());
-    assertThat(rdsUpdateCaptor.getValue().virtualHosts).hasSize(2);
-
-    routeConfigs = ImmutableList.of(
-        Any.pack(mf.buildRouteConfiguration(RDS_RESOURCE, mf.buildOpaqueVirtualHosts(4))));
-    call.sendResponse("1", routeConfigs, ResourceType.RDS, "0001");
-
-    // Client sends an ACK RDS request.
-    call.verifyRequest(NODE, "1", Collections.singletonList(RDS_RESOURCE), ResourceType.RDS,
-        "0001");
-    verify(rdsResourceWatcher, times(2)).onChanged(rdsUpdateCaptor.capture());
-    assertThat(rdsUpdateCaptor.getValue().virtualHosts).hasSize(4);
-  }
-
-  @Test
-  public void rdsResourceDeletedByLds() {
-    xdsClient.watchLdsResource(LDS_RESOURCE, ldsResourceWatcher);
-    xdsClient.watchRdsResource(RDS_RESOURCE, rdsResourceWatcher);
-    DiscoveryRpcCall call = resourceDiscoveryCalls.poll();
-    List<Any> listeners = ImmutableList.of(
-        Any.pack(mf.buildListenerForRds(LDS_RESOURCE, RDS_RESOURCE)));
-    call.sendResponse("0", listeners, ResourceType.LDS, "0000");
-    verify(ldsResourceWatcher).onChanged(ldsUpdateCaptor.capture());
-    assertThat(ldsUpdateCaptor.getValue().rdsName).isEqualTo(RDS_RESOURCE);
-
-    List<Any> routeConfigs = ImmutableList.of(
-        Any.pack(mf.buildRouteConfiguration(RDS_RESOURCE, mf.buildOpaqueVirtualHosts(2))));
-    call.sendResponse("0", routeConfigs, ResourceType.RDS, "0000");
-    verify(rdsResourceWatcher).onChanged(rdsUpdateCaptor.capture());
-    assertThat(rdsUpdateCaptor.getValue().virtualHosts).hasSize(2);
-
-    listeners = ImmutableList.of(
-        Any.pack(mf.buildListener(LDS_RESOURCE,
-            mf.buildRouteConfiguration("do not care", mf.buildOpaqueVirtualHosts(5)))));
-    call.sendResponse("1", listeners, ResourceType.LDS, "0001");
-    verify(ldsResourceWatcher, times(2)).onChanged(ldsUpdateCaptor.capture());
-    assertThat(ldsUpdateCaptor.getValue().virtualHosts).hasSize(5);
-    verify(rdsResourceWatcher).onResourceDoesNotExist(RDS_RESOURCE);
-  }
-
-  @Test
-  public void multipleRdsWatchers() {
-    String rdsResource = "route-bar.googleapis.com";
-    RdsResourceWatcher watcher1 = mock(RdsResourceWatcher.class);
-    RdsResourceWatcher watcher2 = mock(RdsResourceWatcher.class);
-    xdsClient.watchRdsResource(RDS_RESOURCE, rdsResourceWatcher);
-    xdsClient.watchRdsResource(rdsResource, watcher1);
-    xdsClient.watchRdsResource(rdsResource, watcher2);
-    DiscoveryRpcCall call = resourceDiscoveryCalls.poll();
-    call.verifyRequest(NODE, "", Arrays.asList(RDS_RESOURCE, rdsResource), ResourceType.RDS, "");
-
-    fakeClock.forwardTime(ClientXdsClient.INITIAL_RESOURCE_FETCH_TIMEOUT_SEC, TimeUnit.SECONDS);
-    verify(rdsResourceWatcher).onResourceDoesNotExist(RDS_RESOURCE);
-    verify(watcher1).onResourceDoesNotExist(rdsResource);
-    verify(watcher2).onResourceDoesNotExist(rdsResource);
-
-    List<Any> routeConfigs = ImmutableList.of(
-        Any.pack(mf.buildRouteConfiguration(RDS_RESOURCE, mf.buildOpaqueVirtualHosts(2))));
-    call.sendResponse("0", routeConfigs, ResourceType.RDS, "0000");
-
-    verify(rdsResourceWatcher).onChanged(rdsUpdateCaptor.capture());
-    assertThat(rdsUpdateCaptor.getValue().virtualHosts).hasSize(2);
-    verifyNoMoreInteractions(watcher1, watcher2);
-
-    routeConfigs = ImmutableList.of(Any.pack(
-        mf.buildRouteConfiguration(rdsResource, mf.buildOpaqueVirtualHosts(4))));
-    call.sendResponse("2", routeConfigs, ResourceType.RDS, "0002");
-
-    verify(watcher1).onChanged(rdsUpdateCaptor.capture());
-    assertThat(rdsUpdateCaptor.getValue().virtualHosts).hasSize(4);
-    verify(watcher2).onChanged(rdsUpdateCaptor.capture());
-    assertThat(rdsUpdateCaptor.getValue().virtualHosts).hasSize(4);
-    verifyNoMoreInteractions(rdsResourceWatcher);
-  }
-
-  @Test
-  public void cdsResourceNotFound() {
-    DiscoveryRpcCall call =
-        startResourceWatcher(ResourceType.CDS, CDS_RESOURCE, cdsResourceWatcher);
-
-    List<Any> clusters = ImmutableList.of(
-        Any.pack(mf.buildEdsCluster("cluster-bar.googleapis.com", null, "round_robin", null,
-            false, null, null)),
-        Any.pack(mf.buildEdsCluster("cluster-baz.googleapis.com", null, "round_robin", null,
-            false, null, null)));
-    call.sendResponse("0", clusters, ResourceType.CDS, "0000");
-
-    // Client sent an ACK CDS request.
-    call.verifyRequest(NODE, "0", Collections.singletonList(CDS_RESOURCE), ResourceType.CDS,
-        "0000");
-    verifyNoInteractions(cdsResourceWatcher);
-
-    fakeClock.forwardTime(ClientXdsClient.INITIAL_RESOURCE_FETCH_TIMEOUT_SEC, TimeUnit.SECONDS);
-    verify(cdsResourceWatcher).onResourceDoesNotExist(CDS_RESOURCE);
-    assertThat(fakeClock.getPendingTasks(CDS_RESOURCE_FETCH_TIMEOUT_TASK_FILTER)).isEmpty();
-  }
-
-  @Test
-  public void cdsResourceFound() {
-    DiscoveryRpcCall call =
-        startResourceWatcher(ResourceType.CDS, CDS_RESOURCE, cdsResourceWatcher);
-    List<Any> clusters = ImmutableList.of(
-        Any.pack(mf.buildEdsCluster(CDS_RESOURCE, null, "round_robin", null, false, null, null)));
-    call.sendResponse("0", clusters, ResourceType.CDS, "0000");
-
-    // Client sent an ACK CDS request.
-    call.verifyRequest(NODE, "0", Collections.singletonList(CDS_RESOURCE), ResourceType.CDS,
-        "0000");
-    verify(cdsResourceWatcher).onChanged(cdsUpdateCaptor.capture());
-    CdsUpdate cdsUpdate = cdsUpdateCaptor.getValue();
-    assertThat(cdsUpdate.clusterName()).isEqualTo(CDS_RESOURCE);
-    assertThat(cdsUpdate.clusterType()).isEqualTo(ClusterType.EDS);
-    assertThat(cdsUpdate.edsServiceName()).isNull();
-    assertThat(cdsUpdate.lbPolicy()).isEqualTo("round_robin");
-    assertThat(cdsUpdate.lrsServerName()).isNull();
-    assertThat(cdsUpdate.maxConcurrentRequests()).isNull();
-    assertThat(cdsUpdate.upstreamTlsContext()).isNull();
-    assertThat(fakeClock.getPendingTasks(CDS_RESOURCE_FETCH_TIMEOUT_TASK_FILTER)).isEmpty();
-  }
-
-  @Test
-  public void cdsResourceFound_ringHashLbPolicy() {
-    DiscoveryRpcCall call =
-        startResourceWatcher(ResourceType.CDS, CDS_RESOURCE, cdsResourceWatcher);
-    Message ringHashConfig = mf.buildRingHashLbConfig("xx_hash", 10L, 100L);
-    List<Any> clusters = ImmutableList.of(
-        Any.pack(mf.buildEdsCluster(CDS_RESOURCE, null, "ring_hash", ringHashConfig, false, null,
-            null)));
-    call.sendResponse("0", clusters, ResourceType.CDS, "0000");
-
-    // Client sent an ACK CDS request.
-    call.verifyRequest(NODE, "0", Collections.singletonList(CDS_RESOURCE), ResourceType.CDS,
-        "0000");
-    verify(cdsResourceWatcher).onChanged(cdsUpdateCaptor.capture());
-    CdsUpdate cdsUpdate = cdsUpdateCaptor.getValue();
-    assertThat(cdsUpdate.clusterName()).isEqualTo(CDS_RESOURCE);
-    assertThat(cdsUpdate.clusterType()).isEqualTo(ClusterType.EDS);
-    assertThat(cdsUpdate.edsServiceName()).isNull();
-    assertThat(cdsUpdate.lbPolicy()).isEqualTo("ring_hash");
-    assertThat(cdsUpdate.hashFunction()).isEqualTo(HashFunction.XX_HASH);
-    assertThat(cdsUpdate.minRingSize()).isEqualTo(10L);
-    assertThat(cdsUpdate.maxRingSize()).isEqualTo(100L);
-    assertThat(cdsUpdate.lrsServerName()).isNull();
-    assertThat(cdsUpdate.maxConcurrentRequests()).isNull();
-    assertThat(cdsUpdate.upstreamTlsContext()).isNull();
-    assertThat(fakeClock.getPendingTasks(CDS_RESOURCE_FETCH_TIMEOUT_TASK_FILTER)).isEmpty();
-  }
-
-  @Test
-  public void cdsResponseWithAggregateCluster() {
-    DiscoveryRpcCall call =
-        startResourceWatcher(ResourceType.CDS, CDS_RESOURCE, cdsResourceWatcher);
-    List<String> candidates = Arrays.asList(
-        "cluster1.googleapis.com", "cluster2.googleapis.com", "cluster3.googleapis.com");
-    List<Any> clusters = ImmutableList.of(
-        Any.pack(mf.buildAggregateCluster(CDS_RESOURCE, "round_robin", null, candidates)));
-    call.sendResponse("0", clusters, ResourceType.CDS, "0000");
-
-    // Client sent an ACK CDS request.
-    call.verifyRequest(NODE, "0", Collections.singletonList(CDS_RESOURCE), ResourceType.CDS,
-        "0000");
-    verify(cdsResourceWatcher).onChanged(cdsUpdateCaptor.capture());
-    CdsUpdate cdsUpdate = cdsUpdateCaptor.getValue();
-    assertThat(cdsUpdate.clusterName()).isEqualTo(CDS_RESOURCE);
-    assertThat(cdsUpdate.clusterType()).isEqualTo(ClusterType.AGGREGATE);
-    assertThat(cdsUpdate.lbPolicy()).isEqualTo("round_robin");
-    assertThat(cdsUpdate.prioritizedClusterNames()).containsExactlyElementsIn(candidates).inOrder();
-  }
-
-  @Test
-  public void cdsResponseWithCircuitBreakers() {
-    DiscoveryRpcCall call =
-        startResourceWatcher(ResourceType.CDS, CDS_RESOURCE, cdsResourceWatcher);
-    List<Any> clusters = ImmutableList.of(
-        Any.pack(mf.buildEdsCluster(CDS_RESOURCE, null, "round_robin", null, false, null,
-            mf.buildCircuitBreakers(50, 200))));
-    call.sendResponse("0", clusters, ResourceType.CDS, "0000");
-
-    // Client sent an ACK CDS request.
-    call.verifyRequest(NODE, "0", Collections.singletonList(CDS_RESOURCE), ResourceType.CDS,
-        "0000");
-    verify(cdsResourceWatcher).onChanged(cdsUpdateCaptor.capture());
-    CdsUpdate cdsUpdate = cdsUpdateCaptor.getValue();
-    assertThat(cdsUpdate.clusterName()).isEqualTo(CDS_RESOURCE);
-    assertThat(cdsUpdate.clusterType()).isEqualTo(ClusterType.EDS);
-    assertThat(cdsUpdate.edsServiceName()).isNull();
-    assertThat(cdsUpdate.lbPolicy()).isEqualTo("round_robin");
-    assertThat(cdsUpdate.lrsServerName()).isNull();
-    assertThat(cdsUpdate.maxConcurrentRequests()).isEqualTo(200L);
-    assertThat(cdsUpdate.upstreamTlsContext()).isNull();
-  }
-
-  /**
-   * CDS response containing UpstreamTlsContext for a cluster.
-   */
-  @Test
-  public void cdsResponseWithUpstreamTlsContext() {
-    DiscoveryRpcCall call =
-        startResourceWatcher(ResourceType.CDS, CDS_RESOURCE, cdsResourceWatcher);
-
-    // Management server sends back CDS response with UpstreamTlsContext.
-    List<Any> clusters = ImmutableList.of(
-        Any.pack(mf.buildLogicalDnsCluster("cluster-bar.googleapis.com", "round_robin", null,
-            false, null, null)),
-        Any.pack(mf.buildEdsCluster(CDS_RESOURCE, "eds-cluster-foo.googleapis.com", "round_robin",
-            null, true,
-            mf.buildUpstreamTlsContext("secret1", "unix:/var/uds2"), null)),
-        Any.pack(mf.buildEdsCluster("cluster-baz.googleapis.com", null, "round_robin", null, false,
-            null, null)));
-    call.sendResponse("0", clusters, ResourceType.CDS, "0000");
-
-    // Client sent an ACK CDS request.
-    call.verifyRequest(NODE, "0", Collections.singletonList(CDS_RESOURCE), ResourceType.CDS,
-        "0000");
-    verify(cdsResourceWatcher, times(1)).onChanged(cdsUpdateCaptor.capture());
-    CdsUpdate cdsUpdate = cdsUpdateCaptor.getValue();
-    SdsSecretConfig validationContextSdsSecretConfig =
-        cdsUpdate.upstreamTlsContext().getCommonTlsContext().getValidationContextSdsSecretConfig();
-    assertThat(validationContextSdsSecretConfig.getName()).isEqualTo("secret1");
-    assertThat(
-        Iterables.getOnlyElement(
-            validationContextSdsSecretConfig
-                .getSdsConfig()
-                .getApiConfigSource()
-                .getGrpcServicesList())
-            .getGoogleGrpc()
-            .getTargetUri())
-        .isEqualTo("unix:/var/uds2");
-  }
-
-  @Test
-  public void cachedCdsResource_data() {
-    DiscoveryRpcCall call =
-        startResourceWatcher(ResourceType.CDS, CDS_RESOURCE, cdsResourceWatcher);
-    List<Any> clusters = ImmutableList.of(
-        Any.pack(mf.buildEdsCluster(CDS_RESOURCE, null, "round_robin", null, false, null, null)));
-    call.sendResponse("0", clusters, ResourceType.CDS, "0000");
-
-    // Client sends an ACK CDS request.
-    call.verifyRequest(NODE, "0", Collections.singletonList(CDS_RESOURCE), ResourceType.CDS,
-        "0000");
-
-    CdsResourceWatcher watcher = mock(CdsResourceWatcher.class);
-    xdsClient.watchCdsResource(CDS_RESOURCE, watcher);
-    verify(watcher).onChanged(cdsUpdateCaptor.capture());
-    CdsUpdate cdsUpdate = cdsUpdateCaptor.getValue();
-    assertThat(cdsUpdate.clusterName()).isEqualTo(CDS_RESOURCE);
-    assertThat(cdsUpdate.clusterType()).isEqualTo(ClusterType.EDS);
-    assertThat(cdsUpdate.edsServiceName()).isNull();
-    assertThat(cdsUpdate.lbPolicy()).isEqualTo("round_robin");
-    assertThat(cdsUpdate.lrsServerName()).isNull();
-    assertThat(cdsUpdate.maxConcurrentRequests()).isNull();
-    assertThat(cdsUpdate.upstreamTlsContext()).isNull();
-    call.verifyNoMoreRequest();
-  }
-
-  @Test
-  public void cachedCdsResource_absent() {
-    DiscoveryRpcCall call =
-        startResourceWatcher(ResourceType.CDS, CDS_RESOURCE, cdsResourceWatcher);
-    fakeClock.forwardTime(ClientXdsClient.INITIAL_RESOURCE_FETCH_TIMEOUT_SEC, TimeUnit.SECONDS);
-    verify(cdsResourceWatcher).onResourceDoesNotExist(CDS_RESOURCE);
-    CdsResourceWatcher watcher = mock(CdsResourceWatcher.class);
-    xdsClient.watchCdsResource(CDS_RESOURCE, watcher);
-    verify(watcher).onResourceDoesNotExist(CDS_RESOURCE);
-    call.verifyNoMoreRequest();
-  }
-
-  @Test
-  public void cdsResourceUpdated() {
-    DiscoveryRpcCall call =
-        startResourceWatcher(ResourceType.CDS, CDS_RESOURCE, cdsResourceWatcher);
-    List<Any> clusters = ImmutableList.of(
-        Any.pack(mf.buildLogicalDnsCluster(CDS_RESOURCE, "round_robin", null, false, null, null)));
-    call.sendResponse("0", clusters, ResourceType.CDS, "0000");
-
-    // Client sends an ACK CDS request.
-    call.verifyRequest(NODE, "0", Collections.singletonList(CDS_RESOURCE), ResourceType.CDS,
-        "0000");
-    verify(cdsResourceWatcher).onChanged(cdsUpdateCaptor.capture());
-    CdsUpdate cdsUpdate = cdsUpdateCaptor.getValue();
-    assertThat(cdsUpdate.clusterName()).isEqualTo(CDS_RESOURCE);
-    assertThat(cdsUpdate.clusterType()).isEqualTo(ClusterType.LOGICAL_DNS);
-    assertThat(cdsUpdate.lbPolicy()).isEqualTo("round_robin");
-    assertThat(cdsUpdate.lrsServerName()).isNull();
-    assertThat(cdsUpdate.maxConcurrentRequests()).isNull();
-    assertThat(cdsUpdate.upstreamTlsContext()).isNull();
-
-    String edsService = "eds-service-bar.googleapis.com";
-    clusters = ImmutableList.of(
-        Any.pack(mf.buildEdsCluster(CDS_RESOURCE, edsService, "round_robin", null, true, null,
-            null)));
-    call.sendResponse("1", clusters, ResourceType.CDS, "0001");
-
-    // Client sends an ACK CDS request.
-    call.verifyRequest(NODE, "1", Collections.singletonList(CDS_RESOURCE), ResourceType.CDS,
-        "0001");
-    verify(cdsResourceWatcher, times(2)).onChanged(cdsUpdateCaptor.capture());
-    cdsUpdate = cdsUpdateCaptor.getValue();
-    assertThat(cdsUpdate.clusterName()).isEqualTo(CDS_RESOURCE);
-    assertThat(cdsUpdate.clusterType()).isEqualTo(ClusterType.EDS);
-    assertThat(cdsUpdate.edsServiceName()).isEqualTo(edsService);
-    assertThat(cdsUpdate.lbPolicy()).isEqualTo("round_robin");
-    assertThat(cdsUpdate.lrsServerName()).isEqualTo("");
-    assertThat(cdsUpdate.maxConcurrentRequests()).isNull();
-    assertThat(cdsUpdate.upstreamTlsContext()).isNull();
-  }
-
-  @Test
-  public void cdsResourceDeleted() {
-    DiscoveryRpcCall call =
-        startResourceWatcher(ResourceType.CDS, CDS_RESOURCE, cdsResourceWatcher);
-    List<Any> clusters = ImmutableList.of(
-        Any.pack(mf.buildEdsCluster(CDS_RESOURCE, null, "round_robin", null, false, null, null)));
-    call.sendResponse("0", clusters, ResourceType.CDS, "0000");
-
-    // Client sends an ACK CDS request.
-    call.verifyRequest(NODE, "0", Collections.singletonList(CDS_RESOURCE), ResourceType.CDS,
-        "0000");
-    verify(cdsResourceWatcher).onChanged(cdsUpdateCaptor.capture());
-    CdsUpdate cdsUpdate = cdsUpdateCaptor.getValue();
-    assertThat(cdsUpdate.clusterName()).isEqualTo(CDS_RESOURCE);
-    assertThat(cdsUpdate.clusterType()).isEqualTo(ClusterType.EDS);
-    assertThat(cdsUpdate.edsServiceName()).isNull();
-    assertThat(cdsUpdate.lbPolicy()).isEqualTo("round_robin");
-    assertThat(cdsUpdate.lrsServerName()).isNull();
-    assertThat(cdsUpdate.maxConcurrentRequests()).isNull();
-    assertThat(cdsUpdate.upstreamTlsContext()).isNull();
-
-    call.sendResponse("1", Collections.<Any>emptyList(), ResourceType.CDS, "0001");
-
-    // Client sends an ACK CDS request.
-    call.verifyRequest(NODE, "1", Collections.singletonList(CDS_RESOURCE), ResourceType.CDS,
-        "0001");
-    verify(cdsResourceWatcher).onResourceDoesNotExist(CDS_RESOURCE);
-  }
-
-  @Test
-  public void multipleCdsWatchers() {
-    String cdsResource = "cluster-bar.googleapis.com";
-    CdsResourceWatcher watcher1 = mock(CdsResourceWatcher.class);
-    CdsResourceWatcher watcher2 = mock(CdsResourceWatcher.class);
-    xdsClient.watchCdsResource(CDS_RESOURCE, cdsResourceWatcher);
-    xdsClient.watchCdsResource(cdsResource, watcher1);
-    xdsClient.watchCdsResource(cdsResource, watcher2);
-    DiscoveryRpcCall call = resourceDiscoveryCalls.poll();
-    call.verifyRequest(NODE, "", Arrays.asList(CDS_RESOURCE, cdsResource), ResourceType.CDS, "");
-
-    fakeClock.forwardTime(ClientXdsClient.INITIAL_RESOURCE_FETCH_TIMEOUT_SEC, TimeUnit.SECONDS);
-    verify(cdsResourceWatcher).onResourceDoesNotExist(CDS_RESOURCE);
-    verify(watcher1).onResourceDoesNotExist(cdsResource);
-    verify(watcher2).onResourceDoesNotExist(cdsResource);
-
-    String edsService = "eds-service-bar.googleapis.com";
-    List<Any> clusters = ImmutableList.of(
-        Any.pack(mf.buildLogicalDnsCluster(CDS_RESOURCE, "round_robin", null, false, null, null)),
-        Any.pack(mf.buildEdsCluster(cdsResource, edsService, "round_robin", null, true, null,
-            null)));
-    call.sendResponse("0", clusters, ResourceType.CDS, "0000");
-    verify(cdsResourceWatcher).onChanged(cdsUpdateCaptor.capture());
-    CdsUpdate cdsUpdate = cdsUpdateCaptor.getValue();
-    assertThat(cdsUpdate.clusterName()).isEqualTo(CDS_RESOURCE);
-    assertThat(cdsUpdate.clusterType()).isEqualTo(ClusterType.LOGICAL_DNS);
-    assertThat(cdsUpdate.lbPolicy()).isEqualTo("round_robin");
-    assertThat(cdsUpdate.lrsServerName()).isNull();
-    assertThat(cdsUpdate.maxConcurrentRequests()).isNull();
-    assertThat(cdsUpdate.upstreamTlsContext()).isNull();
-    verify(watcher1).onChanged(cdsUpdateCaptor.capture());
-    cdsUpdate = cdsUpdateCaptor.getValue();
-    assertThat(cdsUpdate.clusterName()).isEqualTo(cdsResource);
-    assertThat(cdsUpdate.clusterType()).isEqualTo(ClusterType.EDS);
-    assertThat(cdsUpdate.edsServiceName()).isEqualTo(edsService);
-    assertThat(cdsUpdate.lbPolicy()).isEqualTo("round_robin");
-    assertThat(cdsUpdate.lrsServerName()).isEqualTo("");
-    assertThat(cdsUpdate.maxConcurrentRequests()).isNull();
-    assertThat(cdsUpdate.upstreamTlsContext()).isNull();
-    verify(watcher2).onChanged(cdsUpdateCaptor.capture());
-    cdsUpdate = cdsUpdateCaptor.getValue();
-    assertThat(cdsUpdate.clusterName()).isEqualTo(cdsResource);
-    assertThat(cdsUpdate.clusterType()).isEqualTo(ClusterType.EDS);
-    assertThat(cdsUpdate.edsServiceName()).isEqualTo(edsService);
-    assertThat(cdsUpdate.lbPolicy()).isEqualTo("round_robin");
-    assertThat(cdsUpdate.lrsServerName()).isEqualTo("");
-    assertThat(cdsUpdate.maxConcurrentRequests()).isNull();
-    assertThat(cdsUpdate.upstreamTlsContext()).isNull();
-  }
-
-  @Test
-  public void edsResourceNotFound() {
-    DiscoveryRpcCall call =
-        startResourceWatcher(ResourceType.EDS, EDS_RESOURCE, edsResourceWatcher);
-    List<Any> clusterLoadAssignments =
-        ImmutableList.of(
-            Any.pack(
-                mf.buildClusterLoadAssignment("cluster-bar.googleapis.com",
-                    ImmutableList.of(
-                        mf.buildLocalityLbEndpoints("region1", "zone1", "subzone1",
-                            ImmutableList.of(
-                                mf.buildLbEndpoint("192.168.0.1", 8080, "healthy", 2)),
-                            1, 0)),
-                    ImmutableList.<Message>of())));
-    call.sendResponse("0", clusterLoadAssignments, ResourceType.EDS, "0000");
-
-    // Client sent an ACK EDS request.
-    call.verifyRequest(NODE, "0", Collections.singletonList(EDS_RESOURCE), ResourceType.EDS,
-        "0000");
-    verifyNoInteractions(edsResourceWatcher);
-
-    fakeClock.forwardTime(ClientXdsClient.INITIAL_RESOURCE_FETCH_TIMEOUT_SEC, TimeUnit.SECONDS);
-    verify(edsResourceWatcher).onResourceDoesNotExist(EDS_RESOURCE);
-    assertThat(fakeClock.getPendingTasks(EDS_RESOURCE_FETCH_TIMEOUT_TASK_FILTER)).isEmpty();
-  }
-
-  @Test
-  public void edsResourceFound() {
-    DiscoveryRpcCall call =
-        startResourceWatcher(ResourceType.EDS, EDS_RESOURCE, edsResourceWatcher);
-    List<Any> clusterLoadAssignments =
-        ImmutableList.of(
-            Any.pack(
-                mf.buildClusterLoadAssignment(EDS_RESOURCE,
-                    ImmutableList.of(
-                        mf.buildLocalityLbEndpoints("region1", "zone1", "subzone1",
-                            ImmutableList.of(
-                                mf.buildLbEndpoint("192.168.0.1", 8080, "healthy", 2)),
-                            1, 0),
-                        mf.buildLocalityLbEndpoints("region3", "zone3", "subzone3",
-                            ImmutableList.<Message>of(),
-                            2, 1), /* locality with 0 endpoint */
-                        mf.buildLocalityLbEndpoints("region4", "zone4", "subzone4",
-                            ImmutableList.of(
-                                mf.buildLbEndpoint("192.168.142.5", 80, "unknown", 5)),
-                            0, 2) /* locality with 0 weight */),
-                    ImmutableList.of(
-                        mf.buildDropOverload("lb", 200),
-                        mf.buildDropOverload("throttle", 1000)))));
-    call.sendResponse("0", clusterLoadAssignments, ResourceType.EDS, "0000");
-
-    // Client sent an ACK EDS request.
-    call.verifyRequest(NODE, "0", Collections.singletonList(EDS_RESOURCE), ResourceType.EDS,
-        "0000");
-    verify(edsResourceWatcher).onChanged(edsUpdateCaptor.capture());
-    EdsUpdate edsUpdate = edsUpdateCaptor.getValue();
-    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)), 1, 0),
-            Locality.create("region3", "zone3", "subzone3"),
-            LocalityLbEndpoints.create(ImmutableList.<LbEndpoint>of(), 2, 1));
-  }
-
-  @Test
-  public void cachedEdsResource_data() {
-    DiscoveryRpcCall call =
-        startResourceWatcher(ResourceType.EDS, EDS_RESOURCE, edsResourceWatcher);
-    List<Any> clusterLoadAssignments =
-        ImmutableList.of(
-            Any.pack(
-                mf.buildClusterLoadAssignment(EDS_RESOURCE,
-                    ImmutableList.of(
-                        mf.buildLocalityLbEndpoints("region1", "zone1", "subzone1",
-                            ImmutableList.of(
-                                mf.buildLbEndpoint("192.168.0.1", 8080, "healthy", 2)),
-                            1, 0),
-                        mf.buildLocalityLbEndpoints("region3", "zone3", "subzone3",
-                            ImmutableList.<Message>of(),
-                            2, 1), /* locality with 0 endpoint */
-                        mf.buildLocalityLbEndpoints("region4", "zone4", "subzone4",
-                            ImmutableList.of(
-                                mf.buildLbEndpoint("192.168.142.5", 80, "unknown", 5)),
-                            0, 2) /* locality with 0 weight */),
-                    ImmutableList.of(
-                        mf.buildDropOverload("lb", 200),
-                        mf.buildDropOverload("throttle", 1000)))));
-    call.sendResponse("0", clusterLoadAssignments, ResourceType.EDS, "0000");
-
-    // Client sent an ACK EDS request.
-    call.verifyRequest(NODE, "0", Collections.singletonList(EDS_RESOURCE), ResourceType.EDS,
-        "0000");
-
-    EdsResourceWatcher watcher = mock(EdsResourceWatcher.class);
-    xdsClient.watchEdsResource(EDS_RESOURCE, watcher);
-    verify(watcher).onChanged(edsUpdateCaptor.capture());
-    EdsUpdate edsUpdate = edsUpdateCaptor.getValue();
-    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)), 1, 0),
-            Locality.create("region3", "zone3", "subzone3"),
-            LocalityLbEndpoints.create(ImmutableList.<LbEndpoint>of(), 2, 1));
-    call.verifyNoMoreRequest();
-  }
-
-  @Test
-  public void cachedEdsResource_absent() {
-    DiscoveryRpcCall call =
-        startResourceWatcher(ResourceType.EDS, EDS_RESOURCE, edsResourceWatcher);
-    fakeClock.forwardTime(ClientXdsClient.INITIAL_RESOURCE_FETCH_TIMEOUT_SEC, TimeUnit.SECONDS);
-    verify(edsResourceWatcher).onResourceDoesNotExist(EDS_RESOURCE);
-    EdsResourceWatcher watcher = mock(EdsResourceWatcher.class);
-    xdsClient.watchEdsResource(EDS_RESOURCE, watcher);
-    verify(watcher).onResourceDoesNotExist(EDS_RESOURCE);
-    call.verifyNoMoreRequest();
-  }
-
-  @Test
-  public void edsResourceUpdated() {
-    DiscoveryRpcCall call =
-        startResourceWatcher(ResourceType.EDS, EDS_RESOURCE, edsResourceWatcher);
-    List<Any> clusterLoadAssignments =
-        ImmutableList.of(
-            Any.pack(
-                mf.buildClusterLoadAssignment(EDS_RESOURCE,
-                    ImmutableList.of(
-                        mf.buildLocalityLbEndpoints("region1", "zone1", "subzone1",
-                            ImmutableList.of(
-                                mf.buildLbEndpoint("192.168.0.1", 8080, "healthy", 2)),
-                            1, 0),
-                        mf.buildLocalityLbEndpoints("region3", "zone3", "subzone3",
-                            ImmutableList.<Message>of(),
-                            2, 1), /* locality with 0 endpoint */
-                        mf.buildLocalityLbEndpoints("region4", "zone4", "subzone4",
-                            ImmutableList.of(
-                                mf.buildLbEndpoint("192.168.142.5", 80, "unknown", 5)),
-                            0, 2) /* locality with 0 weight */),
-                    ImmutableList.of(
-                        mf.buildDropOverload("lb", 200),
-                        mf.buildDropOverload("throttle", 1000)))));
-    call.sendResponse("0", clusterLoadAssignments, ResourceType.EDS, "0000");
-
-    // Client sent an ACK EDS request.
-    call.verifyRequest(NODE, "0", Collections.singletonList(EDS_RESOURCE), ResourceType.EDS,
-        "0000");
-    verify(edsResourceWatcher).onChanged(edsUpdateCaptor.capture());
-    EdsUpdate edsUpdate = edsUpdateCaptor.getValue();
-    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)), 1, 0),
-            Locality.create("region3", "zone3", "subzone3"),
-            LocalityLbEndpoints.create(ImmutableList.<LbEndpoint>of(), 2, 1));
-
-    clusterLoadAssignments =
-        ImmutableList.of(
-            Any.pack(
-                mf.buildClusterLoadAssignment(EDS_RESOURCE,
-                    ImmutableList.of(
-                        mf.buildLocalityLbEndpoints("region2", "zone2", "subzone2",
-                            ImmutableList.of(
-                                mf.buildLbEndpoint("172.44.2.2", 8000, "unknown", 3)),
-                            2, 0)),
-                    ImmutableList.<Message>of())));
-    call.sendResponse("1", clusterLoadAssignments, ResourceType.EDS, "0001");
-
-    verify(edsResourceWatcher, times(2)).onChanged(edsUpdateCaptor.capture());
-    edsUpdate = edsUpdateCaptor.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)), 2, 0));
-  }
-
-  @Test
-  public void edsResourceDeletedByCds() {
-    String resource = "backend-service.googleapis.com";
-    CdsResourceWatcher cdsWatcher = mock(CdsResourceWatcher.class);
-    EdsResourceWatcher edsWatcher = mock(EdsResourceWatcher.class);
-    xdsClient.watchCdsResource(resource, cdsWatcher);
-    xdsClient.watchEdsResource(resource, edsWatcher);
-    xdsClient.watchCdsResource(CDS_RESOURCE, cdsResourceWatcher);
-    xdsClient.watchEdsResource(EDS_RESOURCE, edsResourceWatcher);
-    DiscoveryRpcCall call = resourceDiscoveryCalls.poll();
-    List<Any> clusters = ImmutableList.of(
-        Any.pack(mf.buildEdsCluster(resource, null, "round_robin", null, true, null, null)),
-        Any.pack(mf.buildEdsCluster(CDS_RESOURCE, EDS_RESOURCE, "round_robin", null, false, null,
-            null)));
-    call.sendResponse("0", clusters, ResourceType.CDS, "0000");
-    verify(cdsWatcher).onChanged(cdsUpdateCaptor.capture());
-    CdsUpdate cdsUpdate = cdsUpdateCaptor.getValue();
-    assertThat(cdsUpdate.edsServiceName()).isEqualTo(null);
-    assertThat(cdsUpdate.lrsServerName()).isEqualTo("");
-    verify(cdsResourceWatcher).onChanged(cdsUpdateCaptor.capture());
-    cdsUpdate = cdsUpdateCaptor.getValue();
-    assertThat(cdsUpdate.edsServiceName()).isEqualTo(EDS_RESOURCE);
-    assertThat(cdsUpdate.lrsServerName()).isNull();
-
-    List<Any> clusterLoadAssignments =
-        ImmutableList.of(
-            Any.pack(
-                mf.buildClusterLoadAssignment(EDS_RESOURCE,
-                    ImmutableList.of(
-                        mf.buildLocalityLbEndpoints("region1", "zone1", "subzone1",
-                            ImmutableList.of(
-                                mf.buildLbEndpoint("192.168.0.1", 8080, "healthy", 2)),
-                            1, 0)),
-                    ImmutableList.of(
-                        mf.buildDropOverload("lb", 200),
-                        mf.buildDropOverload("throttle", 1000)))),
-            Any.pack(
-                mf.buildClusterLoadAssignment(resource,
-                    ImmutableList.of(
-                        mf.buildLocalityLbEndpoints("region2", "zone2", "subzone2",
-                            ImmutableList.of(
-                                mf.buildLbEndpoint("192.168.0.2", 9090, "healthy", 3)),
-                            1, 0)),
-                    ImmutableList.of(
-                        mf.buildDropOverload("lb", 100)))));
-    call.sendResponse("0", clusterLoadAssignments, ResourceType.EDS, "0000");
-    verify(edsWatcher).onChanged(edsUpdateCaptor.capture());
-    assertThat(edsUpdateCaptor.getValue().clusterName).isEqualTo(resource);
-    verify(edsResourceWatcher).onChanged(edsUpdateCaptor.capture());
-    assertThat(edsUpdateCaptor.getValue().clusterName).isEqualTo(EDS_RESOURCE);
-
-    clusters = ImmutableList.of(
-        Any.pack(mf.buildEdsCluster(resource, null, "round_robin", null, true, null,
-            null)),  // no change
-        Any.pack(mf.buildEdsCluster(CDS_RESOURCE, null, "round_robin", null, false, null, null)));
-    call.sendResponse("1", clusters, ResourceType.CDS, "0001");
-    verify(cdsResourceWatcher, times(2)).onChanged(cdsUpdateCaptor.capture());
-    assertThat(cdsUpdateCaptor.getValue().edsServiceName()).isNull();
-    verify(edsResourceWatcher).onResourceDoesNotExist(EDS_RESOURCE);
-    verifyNoMoreInteractions(cdsWatcher, edsWatcher);
-  }
-
-  @Test
-  public void multipleEdsWatchers() {
-    String edsResource = "cluster-load-assignment-bar.googleapis.com";
-    EdsResourceWatcher watcher1 = mock(EdsResourceWatcher.class);
-    EdsResourceWatcher watcher2 = mock(EdsResourceWatcher.class);
-    xdsClient.watchEdsResource(EDS_RESOURCE, edsResourceWatcher);
-    xdsClient.watchEdsResource(edsResource, watcher1);
-    xdsClient.watchEdsResource(edsResource, watcher2);
-    DiscoveryRpcCall call = resourceDiscoveryCalls.poll();
-    call.verifyRequest(NODE, "", Arrays.asList(EDS_RESOURCE, edsResource), ResourceType.EDS, "");
-
-    fakeClock.forwardTime(ClientXdsClient.INITIAL_RESOURCE_FETCH_TIMEOUT_SEC, TimeUnit.SECONDS);
-    verify(edsResourceWatcher).onResourceDoesNotExist(EDS_RESOURCE);
-    verify(watcher1).onResourceDoesNotExist(edsResource);
-    verify(watcher2).onResourceDoesNotExist(edsResource);
-
-    List<Any> clusterLoadAssignments =
-        ImmutableList.of(
-            Any.pack(
-                mf.buildClusterLoadAssignment(EDS_RESOURCE,
-                    ImmutableList.of(
-                        mf.buildLocalityLbEndpoints("region1", "zone1", "subzone1",
-                            ImmutableList.of(
-                                mf.buildLbEndpoint("192.168.0.1", 8080, "healthy", 2)),
-                            1, 0),
-                        mf.buildLocalityLbEndpoints("region3", "zone3", "subzone3",
-                            ImmutableList.<Message>of(),
-                            2, 1), /* locality with 0 endpoint */
-                        mf.buildLocalityLbEndpoints("region4", "zone4", "subzone4",
-                            ImmutableList.of(
-                                mf.buildLbEndpoint("192.168.142.5", 80, "unknown", 5)),
-                            0, 2) /* locality with 0 weight */),
-                    ImmutableList.of(
-                        mf.buildDropOverload("lb", 200),
-                        mf.buildDropOverload("throttle", 1000)))));
-    call.sendResponse("0", clusterLoadAssignments, ResourceType.EDS, "0000");
-    verify(edsResourceWatcher).onChanged(edsUpdateCaptor.capture());
-    EdsUpdate edsUpdate = edsUpdateCaptor.getValue();
-    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)), 1, 0),
-            Locality.create("region3", "zone3", "subzone3"),
-            LocalityLbEndpoints.create(ImmutableList.<LbEndpoint>of(), 2, 1));
-    verifyNoMoreInteractions(watcher1, watcher2);
-
-    clusterLoadAssignments =
-        ImmutableList.of(
-            Any.pack(
-                mf.buildClusterLoadAssignment(edsResource,
-                    ImmutableList.of(
-                        mf.buildLocalityLbEndpoints("region2", "zone2", "subzone2",
-                            ImmutableList.of(
-                                mf.buildLbEndpoint("172.44.2.2", 8000, "healthy", 3)),
-                            2, 0)),
-                    ImmutableList.<Message>of())));
-    call.sendResponse("1", clusterLoadAssignments, ResourceType.EDS, "0001");
-
-    verify(watcher1).onChanged(edsUpdateCaptor.capture());
-    edsUpdate = edsUpdateCaptor.getValue();
-    assertThat(edsUpdate.clusterName).isEqualTo(edsResource);
-    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)), 2, 0));
-    verify(watcher2).onChanged(edsUpdateCaptor.capture());
-    edsUpdate = edsUpdateCaptor.getValue();
-    assertThat(edsUpdate.clusterName).isEqualTo(edsResource);
-    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)), 2, 0));
-    verifyNoMoreInteractions(edsResourceWatcher);
-  }
-
-  @Test
-  public void streamClosedAndRetryWithBackoff() {
-    InOrder inOrder = Mockito.inOrder(backoffPolicyProvider, backoffPolicy1, backoffPolicy2);
-    xdsClient.watchLdsResource(LDS_RESOURCE, ldsResourceWatcher);
-    xdsClient.watchRdsResource(RDS_RESOURCE, rdsResourceWatcher);
-    xdsClient.watchCdsResource(CDS_RESOURCE, cdsResourceWatcher);
-    xdsClient.watchEdsResource(EDS_RESOURCE, edsResourceWatcher);
-    DiscoveryRpcCall call = resourceDiscoveryCalls.poll();
-    call.verifyRequest(NODE, "", Collections.singletonList(LDS_RESOURCE), ResourceType.LDS, "");
-    call.verifyRequest(NODE, "", Collections.singletonList(RDS_RESOURCE), ResourceType.RDS, "");
-    call.verifyRequest(NODE, "", Collections.singletonList(CDS_RESOURCE), ResourceType.CDS, "");
-    call.verifyRequest(NODE, "", Collections.singletonList(EDS_RESOURCE), ResourceType.EDS, "");
-
-    // Management server closes the RPC stream with an error.
-    call.sendError(Status.UNKNOWN.asException());
-    verify(ldsResourceWatcher).onError(errorCaptor.capture());
-    assertThat(errorCaptor.getValue().getCode()).isEqualTo(Code.UNKNOWN);
-    verify(rdsResourceWatcher).onError(errorCaptor.capture());
-    assertThat(errorCaptor.getValue().getCode()).isEqualTo(Code.UNKNOWN);
-    verify(cdsResourceWatcher).onError(errorCaptor.capture());
-    assertThat(errorCaptor.getValue().getCode()).isEqualTo(Code.UNKNOWN);
-    verify(edsResourceWatcher).onError(errorCaptor.capture());
-    assertThat(errorCaptor.getValue().getCode()).isEqualTo(Code.UNKNOWN);
-
-    // 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();
-    call.verifyRequest(NODE, "", Collections.singletonList(LDS_RESOURCE), ResourceType.LDS, "");
-    call.verifyRequest(NODE, "", Collections.singletonList(RDS_RESOURCE), ResourceType.RDS, "");
-    call.verifyRequest(NODE, "", Collections.singletonList(CDS_RESOURCE), ResourceType.CDS, "");
-    call.verifyRequest(NODE, "", Collections.singletonList(EDS_RESOURCE), ResourceType.EDS, "");
-
-    // Management server becomes unreachable.
-    call.sendError(Status.UNAVAILABLE.asException());
-    verify(ldsResourceWatcher, times(2)).onError(errorCaptor.capture());
-    assertThat(errorCaptor.getValue().getCode()).isEqualTo(Code.UNAVAILABLE);
-    verify(rdsResourceWatcher, times(2)).onError(errorCaptor.capture());
-    assertThat(errorCaptor.getValue().getCode()).isEqualTo(Code.UNAVAILABLE);
-    verify(cdsResourceWatcher, times(2)).onError(errorCaptor.capture());
-    assertThat(errorCaptor.getValue().getCode()).isEqualTo(Code.UNAVAILABLE);
-    verify(edsResourceWatcher, times(2)).onError(errorCaptor.capture());
-    assertThat(errorCaptor.getValue().getCode()).isEqualTo(Code.UNAVAILABLE);
-
-    // 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(NODE, "", Collections.singletonList(LDS_RESOURCE), ResourceType.LDS, "");
-    call.verifyRequest(NODE, "", Collections.singletonList(RDS_RESOURCE), ResourceType.RDS, "");
-    call.verifyRequest(NODE, "", Collections.singletonList(CDS_RESOURCE), ResourceType.CDS, "");
-    call.verifyRequest(NODE, "", Collections.singletonList(EDS_RESOURCE), ResourceType.EDS, "");
-
-    List<Any> listeners = ImmutableList.of(
-        Any.pack(mf.buildListener(LDS_RESOURCE,
-            mf.buildRouteConfiguration("do not care", mf.buildOpaqueVirtualHosts(2)))));
-    call.sendResponse("63", listeners, ResourceType.LDS, "3242");
-    call.verifyRequest(NODE, "63", Collections.singletonList(LDS_RESOURCE), ResourceType.LDS,
-        "3242");
-
-    List<Any> routeConfigs = ImmutableList.of(
-        Any.pack(mf.buildRouteConfiguration(RDS_RESOURCE, mf.buildOpaqueVirtualHosts(2))));
-    call.sendResponse("5", routeConfigs, ResourceType.RDS, "6764");
-    call.verifyRequest(NODE, "5", Collections.singletonList(RDS_RESOURCE), ResourceType.RDS,
-        "6764");
-
-    call.sendError(Status.DEADLINE_EXCEEDED.asException());
-    verify(ldsResourceWatcher, times(3)).onError(errorCaptor.capture());
-    assertThat(errorCaptor.getValue().getCode()).isEqualTo(Code.DEADLINE_EXCEEDED);
-    verify(rdsResourceWatcher, times(3)).onError(errorCaptor.capture());
-    assertThat(errorCaptor.getValue().getCode()).isEqualTo(Code.DEADLINE_EXCEEDED);
-    verify(cdsResourceWatcher, times(3)).onError(errorCaptor.capture());
-    assertThat(errorCaptor.getValue().getCode()).isEqualTo(Code.DEADLINE_EXCEEDED);
-    verify(edsResourceWatcher, times(3)).onError(errorCaptor.capture());
-    assertThat(errorCaptor.getValue().getCode()).isEqualTo(Code.DEADLINE_EXCEEDED);
-
-    // Reset backoff sequence and retry immediately.
-    inOrder.verify(backoffPolicyProvider).get();
-    fakeClock.runDueTasks();
-    call = resourceDiscoveryCalls.poll();
-    call.verifyRequest(NODE, "63", Collections.singletonList(LDS_RESOURCE), ResourceType.LDS, "");
-    call.verifyRequest(NODE, "5", Collections.singletonList(RDS_RESOURCE), ResourceType.RDS, "");
-    call.verifyRequest(NODE, "", Collections.singletonList(CDS_RESOURCE), ResourceType.CDS, "");
-    call.verifyRequest(NODE, "", Collections.singletonList(EDS_RESOURCE), ResourceType.EDS, "");
-
-    // Management server becomes unreachable again.
-    call.sendError(Status.UNAVAILABLE.asException());
-    verify(ldsResourceWatcher, times(4)).onError(errorCaptor.capture());
-    assertThat(errorCaptor.getValue().getCode()).isEqualTo(Code.UNAVAILABLE);
-    verify(rdsResourceWatcher, times(4)).onError(errorCaptor.capture());
-    assertThat(errorCaptor.getValue().getCode()).isEqualTo(Code.UNAVAILABLE);
-    verify(cdsResourceWatcher, times(4)).onError(errorCaptor.capture());
-    assertThat(errorCaptor.getValue().getCode()).isEqualTo(Code.UNAVAILABLE);
-    verify(edsResourceWatcher, times(4)).onError(errorCaptor.capture());
-    assertThat(errorCaptor.getValue().getCode()).isEqualTo(Code.UNAVAILABLE);
-
-    // Retry after backoff.
-    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();
-    call.verifyRequest(NODE, "63", Collections.singletonList(LDS_RESOURCE), ResourceType.LDS, "");
-    call.verifyRequest(NODE, "5", Collections.singletonList(RDS_RESOURCE), ResourceType.RDS, "");
-    call.verifyRequest(NODE, "", Collections.singletonList(CDS_RESOURCE), ResourceType.CDS, "");
-    call.verifyRequest(NODE, "", Collections.singletonList(EDS_RESOURCE), ResourceType.EDS, "");
-
-    inOrder.verifyNoMoreInteractions();
-  }
-
-  @Test
-  public void streamClosedAndRetryRaceWithAddRemoveWatchers() {
-    xdsClient.watchLdsResource(LDS_RESOURCE, ldsResourceWatcher);
-    xdsClient.watchRdsResource(RDS_RESOURCE, rdsResourceWatcher);
-    DiscoveryRpcCall call = resourceDiscoveryCalls.poll();
-    call.sendError(Status.UNAVAILABLE.asException());
-    verify(ldsResourceWatcher).onError(errorCaptor.capture());
-    assertThat(errorCaptor.getValue().getCode()).isEqualTo(Code.UNAVAILABLE);
-    verify(rdsResourceWatcher).onError(errorCaptor.capture());
-    assertThat(errorCaptor.getValue().getCode()).isEqualTo(Code.UNAVAILABLE);
-    ScheduledTask retryTask =
-        Iterables.getOnlyElement(fakeClock.getPendingTasks(RPC_RETRY_TASK_FILTER));
-    assertThat(retryTask.getDelay(TimeUnit.NANOSECONDS)).isEqualTo(10L);
-
-    xdsClient.cancelLdsResourceWatch(LDS_RESOURCE, ldsResourceWatcher);
-    xdsClient.cancelRdsResourceWatch(RDS_RESOURCE, rdsResourceWatcher);
-    xdsClient.watchCdsResource(CDS_RESOURCE, cdsResourceWatcher);
-    xdsClient.watchEdsResource(EDS_RESOURCE, edsResourceWatcher);
-    fakeClock.forwardNanos(10L);
-    call = resourceDiscoveryCalls.poll();
-    call.verifyRequest(NODE, "", Collections.singletonList(CDS_RESOURCE), ResourceType.CDS, "");
-    call.verifyRequest(NODE, "", Collections.singletonList(EDS_RESOURCE), ResourceType.EDS, "");
-    call.verifyNoMoreRequest();
-
-    List<Any> listeners = ImmutableList.of(
-        Any.pack(mf.buildListener(LDS_RESOURCE,
-            mf.buildRouteConfiguration("do not care", mf.buildOpaqueVirtualHosts(2)))));
-    call.sendResponse("0", listeners, ResourceType.LDS, "0000");
-    List<Any> routeConfigs = ImmutableList.of(
-        Any.pack(mf.buildRouteConfiguration(RDS_RESOURCE, mf.buildOpaqueVirtualHosts(2))));
-    call.sendResponse("0", routeConfigs, ResourceType.RDS, "0000");
-
-    verifyNoMoreInteractions(ldsResourceWatcher, rdsResourceWatcher);
-  }
-
-  @Test
-  public void streamClosedAndRetryRestartsResourceInitialFetchTimerForUnresolvedResources() {
-    xdsClient.watchLdsResource(LDS_RESOURCE, ldsResourceWatcher);
-    xdsClient.watchRdsResource(RDS_RESOURCE, rdsResourceWatcher);
-    xdsClient.watchCdsResource(CDS_RESOURCE, cdsResourceWatcher);
-    xdsClient.watchEdsResource(EDS_RESOURCE, edsResourceWatcher);
-    DiscoveryRpcCall call = resourceDiscoveryCalls.poll();
-    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));
-    List<Any> listeners = ImmutableList.of(
-        Any.pack(mf.buildListener(LDS_RESOURCE, mf.buildRouteConfiguration("do not care",
-            mf.buildOpaqueVirtualHosts(2)))));
-    call.sendResponse("0", listeners, ResourceType.LDS, "0000");
-    assertThat(ldsResourceTimeout.isCancelled()).isTrue();
-
-    List<Any> routeConfigs = ImmutableList.of(
-        Any.pack(mf.buildRouteConfiguration(RDS_RESOURCE, mf.buildOpaqueVirtualHosts(2))));
-    call.sendResponse("0", routeConfigs, ResourceType.RDS, "0000");
-    assertThat(rdsResourceTimeout.isCancelled()).isTrue();
-
-    call.sendError(Status.UNAVAILABLE.asException());
-    assertThat(cdsResourceTimeout.isCancelled()).isTrue();
-    assertThat(edsResourceTimeout.isCancelled()).isTrue();
-
-    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() {
-    String clusterName = "cluster-foo.googleapis.com";
-    ClusterDropStats dropStats = xdsClient.addClusterDropStats(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
-  }
-
-  private DiscoveryRpcCall startResourceWatcher(
-      ResourceType type, String name, ResourceWatcher watcher) {
-    FakeClock.TaskFilter timeoutTaskFilter;
-    switch (type) {
-      case LDS:
-        timeoutTaskFilter = LDS_RESOURCE_FETCH_TIMEOUT_TASK_FILTER;
-        xdsClient.watchLdsResource(name, (LdsResourceWatcher) watcher);
-        break;
-      case RDS:
-        timeoutTaskFilter = RDS_RESOURCE_FETCH_TIMEOUT_TASK_FILTER;
-        xdsClient.watchRdsResource(name, (RdsResourceWatcher) watcher);
-        break;
-      case CDS:
-        timeoutTaskFilter = CDS_RESOURCE_FETCH_TIMEOUT_TASK_FILTER;
-        xdsClient.watchCdsResource(name, (CdsResourceWatcher) watcher);
-        break;
-      case EDS:
-        timeoutTaskFilter = EDS_RESOURCE_FETCH_TIMEOUT_TASK_FILTER;
-        xdsClient.watchEdsResource(name, (EdsResourceWatcher) watcher);
-        break;
-      case UNKNOWN:
-      default:
-        throw new AssertionError("should never be here");
-    }
-    DiscoveryRpcCall call = resourceDiscoveryCalls.poll();
-    call.verifyRequest(NODE, "", Collections.singletonList(name), type, "");
-    ScheduledTask timeoutTask =
-        Iterables.getOnlyElement(fakeClock.getPendingTasks(timeoutTaskFilter));
-    assertThat(timeoutTask.getDelay(TimeUnit.SECONDS))
-        .isEqualTo(ClientXdsClient.INITIAL_RESOURCE_FETCH_TIMEOUT_SEC);
-    return call;
-  }
-
-  protected abstract static class DiscoveryRpcCall {
-
-    protected abstract void verifyRequest(Node node, String versionInfo, List<String> resources,
-        ResourceType type, String nonce);
-
-    protected abstract void verifyNoMoreRequest();
-
-    protected abstract void sendResponse(String versionInfo, List<Any> resources,
-        ResourceType type, String nonce);
-
-    protected abstract void sendError(Throwable t);
-
-    protected abstract void sendCompleted();
-  }
-
-  protected abstract static class LrsRpcCall {
-
-    /**
-     * Verifies a LRS request has been sent with ClusterStats of the given list of clusters.
-     */
-    protected abstract void verifyNextReportClusters(List<String[]> clusters);
-
-    protected abstract void sendResponse(List<String> clusters, long loadReportIntervalNano);
-  }
-
-  protected abstract static class MessageFactory {
-
-    protected final Message buildListener(String name, Message routeConfiguration) {
-      return buildListener(name, routeConfiguration, Collections.<Message>emptyList());
-    }
-
-    @SuppressWarnings("unchecked")
-    protected abstract Message buildListener(
-        String name, Message routeConfiguration, List<? extends Message> httpFilters);
-
-    protected abstract Message buildListenerForRds(String name, String rdsResourceName);
-
-    protected abstract Message buildHttpFilter(String name, @Nullable Any typedConfig);
-
-    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 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 buildEdsCluster(String clusterName, @Nullable String edsServiceName,
-        String lbPolicy, @Nullable Message ringHashLbConfig, boolean enableLrs,
-        @Nullable Message upstreamTlsContext, @Nullable Message circuitBreakers);
-
-    protected abstract Message buildLogicalDnsCluster(String clusterName, String lbPolicy,
-        @Nullable Message ringHashLbConfig, boolean enableLrs,
-        @Nullable Message upstreamTlsContext, @Nullable Message circuitBreakers);
-
-    protected abstract Message buildAggregateCluster(String clusterName, String lbPolicy,
-        @Nullable Message ringHashLbConfig, List<String> clusters);
-
-    protected abstract Message buildRingHashLbConfig(String hashFunction, long minRingSize,
-        long maxRingSize);
-
-    protected abstract Message buildUpstreamTlsContext(String secretName, String targetUri);
-
-    protected abstract Message buildCircuitBreakers(int highPriorityMaxRequests,
-        int defaultPriorityMaxRequests);
-
-    protected abstract Message buildClusterLoadAssignment(String cluster,
-        List<Message> localityLbEndpoints, List<Message> dropOverloads);
-
-    protected abstract Message buildLocalityLbEndpoints(String region, String zone, String subZone,
-        List<Message> lbEndpointList, int loadBalancingWeight, int priority);
-
-    protected abstract Message buildLbEndpoint(String address, int port, String healthStatus,
-        int lbWeight);
-
-    protected abstract Message buildDropOverload(String category, int dropPerMillion);
-  }
-}
diff --git a/xds/src/test/java/io/grpc/xds/ClientXdsClientV2Test.java b/xds/src/test/java/io/grpc/xds/ClientXdsClientV2Test.java
deleted file mode 100644
index b99eaa504b2..00000000000
--- a/xds/src/test/java/io/grpc/xds/ClientXdsClientV2Test.java
+++ /dev/null
@@ -1,618 +0,0 @@
-/*
- * 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.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.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 io.envoyproxy.envoy.api.v2.Cluster;
-import io.envoyproxy.envoy.api.v2.Cluster.CustomClusterType;
-import io.envoyproxy.envoy.api.v2.Cluster.DiscoveryType;
-import io.envoyproxy.envoy.api.v2.Cluster.EdsClusterConfig;
-import io.envoyproxy.envoy.api.v2.Cluster.LbPolicy;
-import io.envoyproxy.envoy.api.v2.Cluster.RingHashLbConfig;
-import io.envoyproxy.envoy.api.v2.Cluster.RingHashLbConfig.HashFunction;
-import io.envoyproxy.envoy.api.v2.ClusterLoadAssignment;
-import io.envoyproxy.envoy.api.v2.ClusterLoadAssignment.Policy;
-import io.envoyproxy.envoy.api.v2.ClusterLoadAssignment.Policy.DropOverload;
-import io.envoyproxy.envoy.api.v2.DiscoveryRequest;
-import io.envoyproxy.envoy.api.v2.DiscoveryResponse;
-import io.envoyproxy.envoy.api.v2.Listener;
-import io.envoyproxy.envoy.api.v2.RouteConfiguration;
-import io.envoyproxy.envoy.api.v2.auth.CommonTlsContext;
-import io.envoyproxy.envoy.api.v2.auth.SdsSecretConfig;
-import io.envoyproxy.envoy.api.v2.auth.UpstreamTlsContext;
-import io.envoyproxy.envoy.api.v2.cluster.CircuitBreakers;
-import io.envoyproxy.envoy.api.v2.cluster.CircuitBreakers.Thresholds;
-import io.envoyproxy.envoy.api.v2.core.Address;
-import io.envoyproxy.envoy.api.v2.core.AggregatedConfigSource;
-import io.envoyproxy.envoy.api.v2.core.ApiConfigSource;
-import io.envoyproxy.envoy.api.v2.core.ConfigSource;
-import io.envoyproxy.envoy.api.v2.core.GrpcService;
-import io.envoyproxy.envoy.api.v2.core.GrpcService.GoogleGrpc;
-import io.envoyproxy.envoy.api.v2.core.HealthStatus;
-import io.envoyproxy.envoy.api.v2.core.Locality;
-import io.envoyproxy.envoy.api.v2.core.Node;
-import io.envoyproxy.envoy.api.v2.core.RoutingPriority;
-import io.envoyproxy.envoy.api.v2.core.SelfConfigSource;
-import io.envoyproxy.envoy.api.v2.core.SocketAddress;
-import io.envoyproxy.envoy.api.v2.core.TransportSocket;
-import io.envoyproxy.envoy.api.v2.endpoint.ClusterStats;
-import io.envoyproxy.envoy.api.v2.endpoint.Endpoint;
-import io.envoyproxy.envoy.api.v2.endpoint.LbEndpoint;
-import io.envoyproxy.envoy.api.v2.endpoint.LocalityLbEndpoints;
-import io.envoyproxy.envoy.api.v2.listener.FilterChain;
-import io.envoyproxy.envoy.api.v2.route.Route;
-import io.envoyproxy.envoy.api.v2.route.RouteAction;
-import io.envoyproxy.envoy.api.v2.route.RouteMatch;
-import io.envoyproxy.envoy.api.v2.route.VirtualHost;
-import io.envoyproxy.envoy.config.cluster.aggregate.v2alpha.ClusterConfig;
-import io.envoyproxy.envoy.config.filter.network.http_connection_manager.v2.HttpConnectionManager;
-import io.envoyproxy.envoy.config.filter.network.http_connection_manager.v2.HttpFilter;
-import io.envoyproxy.envoy.config.filter.network.http_connection_manager.v2.Rds;
-import io.envoyproxy.envoy.config.listener.v2.ApiListener;
-import io.envoyproxy.envoy.service.discovery.v2.AggregatedDiscoveryServiceGrpc.AggregatedDiscoveryServiceImplBase;
-import io.envoyproxy.envoy.service.load_stats.v2.LoadReportingServiceGrpc.LoadReportingServiceImplBase;
-import io.envoyproxy.envoy.service.load_stats.v2.LoadStatsRequest;
-import io.envoyproxy.envoy.service.load_stats.v2.LoadStatsResponse;
-import io.envoyproxy.envoy.type.FractionalPercent;
-import io.envoyproxy.envoy.type.FractionalPercent.DenominatorType;
-import io.grpc.BindableService;
-import io.grpc.Context;
-import io.grpc.Context.CancellationListener;
-import io.grpc.Status;
-import io.grpc.stub.StreamObserver;
-import io.grpc.xds.AbstractXdsClient.ResourceType;
-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 javax.annotation.Nullable;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-import org.mockito.ArgumentMatcher;
-import org.mockito.InOrder;
-
-/**
- * Tests for {@link ClientXdsClient} with protocol version v2.
- */
-@RunWith(JUnit4.class)
-public class ClientXdsClientV2Test extends ClientXdsClientTestBase {
-
-  @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);
-        DiscoveryRpcCall call = new DiscoveryRpcCallV2(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 LrsRpcCallV2(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 MessageFactoryV2();
-  }
-
-  @Override
-  protected boolean useProtocolV3() {
-    return false;
-  }
-
-  private static class DiscoveryRpcCallV2 extends DiscoveryRpcCall {
-    StreamObserver<DiscoveryRequest> requestObserver;
-    StreamObserver<DiscoveryResponse> responseObserver;
-
-    private DiscoveryRpcCallV2(StreamObserver<DiscoveryRequest> requestObserver,
-        StreamObserver<DiscoveryResponse> responseObserver) {
-      this.requestObserver = requestObserver;
-      this.responseObserver = responseObserver;
-    }
-
-    @Override
-    protected void verifyRequest(EnvoyProtoData.Node node, String versionInfo,
-        List<String> resources, ResourceType type, String nonce) {
-      verify(requestObserver).onNext(argThat(new DiscoveryRequestMatcher(
-          node.toEnvoyProtoNodeV2(), versionInfo, resources, type.typeUrlV2(), nonce)));
-    }
-
-    @Override
-    protected void verifyNoMoreRequest() {
-      verifyNoMoreInteractions(requestObserver);
-    }
-
-    @Override
-    protected void sendResponse(String versionInfo, List<Any> resources, ResourceType type,
-        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();
-    }
-  }
-
-  private static class LrsRpcCallV2 extends LrsRpcCall {
-    private final StreamObserver<LoadStatsRequest> requestObserver;
-    private final StreamObserver<LoadStatsResponse> responseObserver;
-    private final InOrder inOrder;
-
-    private LrsRpcCallV2(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 MessageFactoryV2 extends MessageFactory {
-
-    @SuppressWarnings("unchecked")
-    @Override
-    protected Message buildListener(
-        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 buildListenerForRds(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())))
-                      .build())))
-          .build();
-    }
-
-    @Override
-    protected Message buildHttpFilter(String name, @Nullable Any typedConfig) {
-      throw new UnsupportedOperationException();
-    }
-
-    @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) {
-      throw new UnsupportedOperationException();
-    }
-
-    @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 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 buildEdsCluster(String clusterName, @Nullable String edsServiceName,
-        String lbPolicy, @Nullable Message ringHashLbConfig, boolean enableLrs,
-        @Nullable Message upstreamTlsContext, @Nullable Message circuitBreakers) {
-      Cluster.Builder builder = initClusterBuilder(clusterName, lbPolicy, ringHashLbConfig,
-          enableLrs, upstreamTlsContext, circuitBreakers);
-      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 lbPolicy,
-        @Nullable Message ringHashLbConfig, boolean enableLrs,
-        @Nullable Message upstreamTlsContext, @Nullable Message circuitBreakers) {
-      Cluster.Builder builder = initClusterBuilder(clusterName, lbPolicy, ringHashLbConfig,
-          enableLrs, upstreamTlsContext, circuitBreakers);
-      builder.setType(DiscoveryType.LOGICAL_DNS);
-      return builder.build();
-    }
-
-    @Override
-    protected Message buildAggregateCluster(String clusterName, String lbPolicy,
-        @Nullable Message ringHashLbConfig, List<String> clusters) {
-      ClusterConfig clusterConfig = ClusterConfig.newBuilder().addAllClusters(clusters).build();
-      CustomClusterType type =
-          CustomClusterType.newBuilder()
-              .setName(ClientXdsClient.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")) {
-        builder.setLbPolicy(LbPolicy.RING_HASH);
-        builder.setRingHashLbConfig((RingHashLbConfig) ringHashLbConfig);
-      } else {
-        throw new AssertionError("Invalid LB policy");
-      }
-      return builder.build();
-    }
-
-    private Cluster.Builder initClusterBuilder(String clusterName, String lbPolicy,
-        @Nullable Message ringHashLbConfig, boolean enableLrs,
-        @Nullable Message upstreamTlsContext, @Nullable Message circuitBreakers) {
-      Cluster.Builder builder = Cluster.newBuilder();
-      builder.setName(clusterName);
-      if (lbPolicy.equals("round_robin")) {
-        builder.setLbPolicy(LbPolicy.ROUND_ROBIN);
-      } else if (lbPolicy.equals("ring_hash")) {
-        builder.setLbPolicy(LbPolicy.RING_HASH);
-        builder.setRingHashLbConfig((RingHashLbConfig) ringHashLbConfig);
-      } else {
-        throw new AssertionError("Invalid LB policy");
-      }
-      if (enableLrs) {
-        builder.setLrsServer(
-            ConfigSource.newBuilder()
-                .setSelf(SelfConfigSource.getDefaultInstance()));
-      }
-      if (upstreamTlsContext != null) {
-        builder.setTransportSocket(
-            TransportSocket.newBuilder()
-                .setName("envoy.transport_sockets.tls")
-                .setTypedConfig(Any.pack(upstreamTlsContext)));
-      }
-      if (circuitBreakers != null) {
-        builder.setCircuitBreakers((CircuitBreakers) circuitBreakers);
-      }
-      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 buildUpstreamTlsContext(String secretName, String targetUri) {
-      GrpcService grpcService =
-          GrpcService.newBuilder()
-              .setGoogleGrpc(GoogleGrpc.newBuilder().setTargetUri(targetUri))
-              .build();
-      ConfigSource sdsConfig =
-          ConfigSource.newBuilder()
-              .setApiConfigSource(ApiConfigSource.newBuilder().addGrpcServices(grpcService))
-              .build();
-      SdsSecretConfig validationContextSdsSecretConfig =
-          SdsSecretConfig.newBuilder()
-              .setName(secretName)
-              .setSdsConfig(sdsConfig)
-              .build();
-      return UpstreamTlsContext.newBuilder()
-          .setCommonTlsContext(
-              CommonTlsContext.newBuilder()
-                  .setValidationContextSdsSecretConfig(validationContextSdsSecretConfig))
-          .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 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) {
-      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))))
-          .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();
-    }
-  }
-
-  /**
-   * 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;
-
-    private DiscoveryRequestMatcher(Node node, String versionInfo, List<String> resources,
-        String typeUrl, String responseNonce) {
-      this.node = node;
-      this.versionInfo = versionInfo;
-      this.resources = new HashSet<>(resources);
-      this.typeUrl = typeUrl;
-      this.responseNonce = responseNonce;
-    }
-
-    @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;
-      }
-      return node.equals(argument.getNode());
-    }
-  }
-
-  /**
-   * 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);
-    }
-  }
-}
diff --git a/xds/src/test/java/io/grpc/xds/ClientXdsClientV3Test.java b/xds/src/test/java/io/grpc/xds/ClientXdsClientV3Test.java
deleted file mode 100644
index 66cf8be5fb8..00000000000
--- a/xds/src/test/java/io/grpc/xds/ClientXdsClientV3Test.java
+++ /dev/null
@@ -1,658 +0,0 @@
-/*
- * 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.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.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 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.RingHashLbConfig;
-import io.envoyproxy.envoy.config.cluster.v3.Cluster.RingHashLbConfig.HashFunction;
-import io.envoyproxy.envoy.config.core.v3.Address;
-import io.envoyproxy.envoy.config.core.v3.AggregatedConfigSource;
-import io.envoyproxy.envoy.config.core.v3.ApiConfigSource;
-import io.envoyproxy.envoy.config.core.v3.ConfigSource;
-import io.envoyproxy.envoy.config.core.v3.GrpcService;
-import io.envoyproxy.envoy.config.core.v3.GrpcService.GoogleGrpc;
-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.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.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.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.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.CommonTlsContext;
-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.AggregatedDiscoveryServiceGrpc.AggregatedDiscoveryServiceImplBase;
-import io.envoyproxy.envoy.service.discovery.v3.DiscoveryRequest;
-import io.envoyproxy.envoy.service.discovery.v3.DiscoveryResponse;
-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.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.StreamObserver;
-import io.grpc.xds.AbstractXdsClient.ResourceType;
-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 javax.annotation.Nullable;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-import org.mockito.ArgumentMatcher;
-import org.mockito.InOrder;
-
-/**
- * Tests for {@link ClientXdsClient} with protocol version v3.
- */
-@RunWith(JUnit4.class)
-public class ClientXdsClientV3Test extends ClientXdsClientTestBase {
-
-  @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);
-        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 useProtocolV3() {
-    return true;
-  }
-
-  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(EnvoyProtoData.Node node, String versionInfo,
-        List<String> resources, ResourceType type, String nonce) {
-      verify(requestObserver).onNext(argThat(new DiscoveryRequestMatcher(
-          node.toEnvoyProtoNode(), versionInfo, resources, type.typeUrl(), nonce)));
-    }
-
-    @Override
-    protected void verifyNoMoreRequest() {
-      verifyNoMoreInteractions(requestObserver);
-    }
-
-    @Override
-    protected void sendResponse(String versionInfo, List<Any> resources, ResourceType type,
-        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();
-    }
-  }
-
-  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 {
-
-    @SuppressWarnings("unchecked")
-    @Override
-    protected Message buildListener(
-        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 buildListenerForRds(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())))
-                      .build())))
-          .build();
-    }
-
-    @Override
-    protected Message buildHttpFilter(String name, @Nullable Any typedConfig) {
-      HttpFilter.Builder builder = HttpFilter.newBuilder().setName(name);
-      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 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 buildEdsCluster(String clusterName, @Nullable String edsServiceName,
-        String lbPolicy, @Nullable Message ringHashLbConfig, boolean enableLrs,
-        @Nullable Message upstreamTlsContext, @Nullable Message circuitBreakers) {
-      Cluster.Builder builder = initClusterBuilder(clusterName, lbPolicy, ringHashLbConfig,
-          enableLrs, upstreamTlsContext, circuitBreakers);
-      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 lbPolicy,
-        @Nullable Message ringHashLbConfig, boolean enableLrs,
-        @Nullable Message upstreamTlsContext, @Nullable Message circuitBreakers) {
-      Cluster.Builder builder = initClusterBuilder(clusterName, lbPolicy, ringHashLbConfig,
-          enableLrs, upstreamTlsContext, circuitBreakers);
-      builder.setType(DiscoveryType.LOGICAL_DNS);
-      return builder.build();
-    }
-
-    @Override
-    protected Message buildAggregateCluster(String clusterName, String lbPolicy,
-        @Nullable Message ringHashLbConfig, List<String> clusters) {
-      ClusterConfig clusterConfig = ClusterConfig.newBuilder().addAllClusters(clusters).build();
-      CustomClusterType type =
-          CustomClusterType.newBuilder()
-              .setName(ClientXdsClient.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")) {
-        builder.setLbPolicy(LbPolicy.RING_HASH);
-        builder.setRingHashLbConfig((RingHashLbConfig) ringHashLbConfig);
-      } else {
-        throw new AssertionError("Invalid LB policy");
-      }
-      return builder.build();
-    }
-
-    private Cluster.Builder initClusterBuilder(String clusterName, String lbPolicy,
-        @Nullable Message ringHashLbConfig, boolean enableLrs,
-        @Nullable Message upstreamTlsContext, @Nullable Message circuitBreakers) {
-      Cluster.Builder builder = Cluster.newBuilder();
-      builder.setName(clusterName);
-      if (lbPolicy.equals("round_robin")) {
-        builder.setLbPolicy(LbPolicy.ROUND_ROBIN);
-      } else if (lbPolicy.equals("ring_hash")) {
-        builder.setLbPolicy(LbPolicy.RING_HASH);
-        builder.setRingHashLbConfig((RingHashLbConfig) ringHashLbConfig);
-      } else {
-        throw new AssertionError("Invalid LB policy");
-      }
-      if (enableLrs) {
-        builder.setLrsServer(
-            ConfigSource.newBuilder()
-                .setSelf(SelfConfigSource.getDefaultInstance()));
-      }
-      if (upstreamTlsContext != null) {
-        builder.setTransportSocket(
-            TransportSocket.newBuilder()
-                .setName("envoy.transport_sockets.tls")
-                .setTypedConfig(Any.pack(upstreamTlsContext)));
-      }
-      if (circuitBreakers != null) {
-        builder.setCircuitBreakers((CircuitBreakers) circuitBreakers);
-      }
-      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 buildUpstreamTlsContext(String secretName, String targetUri) {
-      GrpcService grpcService =
-          GrpcService.newBuilder()
-              .setGoogleGrpc(GoogleGrpc.newBuilder().setTargetUri(targetUri))
-              .build();
-      ConfigSource sdsConfig =
-          ConfigSource.newBuilder()
-              .setApiConfigSource(ApiConfigSource.newBuilder().addGrpcServices(grpcService))
-              .build();
-      SdsSecretConfig validationContextSdsSecretConfig =
-          SdsSecretConfig.newBuilder()
-              .setName(secretName)
-              .setSdsConfig(sdsConfig)
-              .build();
-      return UpstreamTlsContext.newBuilder()
-          .setCommonTlsContext(
-              CommonTlsContext.newBuilder()
-                  .setValidationContextSdsSecretConfig(validationContextSdsSecretConfig))
-          .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 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) {
-      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))))
-          .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();
-    }
-  }
-
-  /**
-   * 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;
-
-    private DiscoveryRequestMatcher(Node node, String versionInfo, List<String> resources,
-        String typeUrl, String responseNonce) {
-      this.node = node;
-      this.versionInfo = versionInfo;
-      this.resources = new HashSet<>(resources);
-      this.typeUrl = typeUrl;
-      this.responseNonce = responseNonce;
-    }
-
-    @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;
-      }
-      return node.equals(argument.getNode());
-    }
-  }
-
-  /**
-   * 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);
-    }
-  }
-}
diff --git a/xds/src/test/java/io/grpc/xds/ClusterImplLoadBalancerTest.java b/xds/src/test/java/io/grpc/xds/ClusterImplLoadBalancerTest.java
index 6d3cf01b7c0..9277675385a 100644
--- a/xds/src/test/java/io/grpc/xds/ClusterImplLoadBalancerTest.java
+++ b/xds/src/test/java/io/grpc/xds/ClusterImplLoadBalancerTest.java
@@ -16,77 +16,113 @@
 
 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.ObjectPool;
-import io.grpc.internal.ServiceConfigUtil.PolicySelection;
+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.LoadStatsManager2.ClusterDropStats;
-import io.grpc.xds.LoadStatsManager2.ClusterLocalityStats;
-import io.grpc.xds.Stats.ClusterStats;
-import io.grpc.xds.Stats.UpstreamLocalityStats;
 import io.grpc.xds.WeightedTargetLoadBalancerProvider.WeightedPolicySelection;
 import io.grpc.xds.WeightedTargetLoadBalancerProvider.WeightedTargetConfig;
 import io.grpc.xds.XdsNameResolverProvider.CallCounterProvider;
-import io.grpc.xds.internal.sds.CommonTlsContextTestsUtil;
-import io.grpc.xds.internal.sds.SslContextProvider;
-import io.grpc.xds.internal.sds.SslContextProviderSupplier;
-import io.grpc.xds.internal.sds.TlsContextManager;
+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.MockitoAnnotations;
+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 String LRS_SERVER_NAME = "";
+  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
@@ -97,33 +133,23 @@ public void uncaughtException(Thread t, Throwable e) {
   private final FakeClock fakeClock = new FakeClock();
   private final Locality locality =
       Locality.create("test-region", "test-zone", "test-subzone");
-  private final PolicySelection roundRobin =
-      new PolicySelection(new FakeLoadBalancerProvider("round_robin"), null);
+  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 ObjectPool<XdsClient> xdsClientPool = new ObjectPool<XdsClient>() {
-    @Override
-    public XdsClient getObject() {
-      xdsClientRefs++;
-      return xdsClient;
-    }
-
-    @Override
-    public XdsClient returnObject(Object object) {
-      xdsClientRefs--;
-      return null;
-    }
-  };
   private final CallCounterProvider callCounterProvider = new CallCounterProvider() {
     @Override
     public AtomicLong getOrCreate(String cluster, @Nullable String edsServiceName) {
       return new AtomicLong();
     }
   };
-  private final Helper helper = new FakeLbHelper();
+  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;
@@ -133,13 +159,14 @@ public AtomicLong getOrCreate(String cluster, @Nullable String edsServiceName) {
 
   @Before
   public void setUp() {
-    MockitoAnnotations.initMocks(this);
-    loadBalancer = new ClusterImplLoadBalancer(helper, mockRandom, tlsContextManager);
+    loadBalancer = new ClusterImplLoadBalancer(helper, mockRandom);
   }
 
   @After
   public void tearDown() {
-    loadBalancer.shutdown();
+    if (loadBalancer != null) {
+      loadBalancer.shutdown();
+    }
     assertThat(xdsClientRefs).isEqualTo(0);
     assertThat(downstreamBalancers).isEmpty();
   }
@@ -149,23 +176,65 @@ 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_NAME,
+    ClusterImplConfig config = new ClusterImplConfig(CLUSTER, EDS_SERVICE_NAME, LRS_SERVER_INFO,
         null, Collections.<DropOverload>emptyList(),
-        new PolicySelection(weightedTargetProvider, weightedTargetConfig), null);
+        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(InternalXdsAttributes.XDS_CLIENT_POOL))
-        .isSameInstanceAs(xdsClientPool);
+    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(mock(PickSubchannelArgs.class));
+    PickResult result = currentPicker.pickSubchannel(pickSubchannelArgs);
     assertThat(result.getStatus().isOk()).isFalse();
     assertThat(result.getStatus().getCode()).isEqualTo(Code.UNIMPLEMENTED);
     assertThat(result.getStatus().getDescription()).isEqualTo("not found");
@@ -176,9 +245,11 @@ public void nameResolutionError_afterChildPolicyInstantiated_propagateToDownstre
     FakeLoadBalancerProvider weightedTargetProvider =
         new FakeLoadBalancerProvider(XdsLbPolicies.WEIGHTED_TARGET_POLICY_NAME);
     Object weightedTargetConfig = new Object();
-    ClusterImplConfig config = new ClusterImplConfig(CLUSTER, EDS_SERVICE_NAME, LRS_SERVER_NAME,
+    ClusterImplConfig config = new ClusterImplConfig(CLUSTER, EDS_SERVICE_NAME, LRS_SERVER_INFO,
         null, Collections.<DropOverload>emptyList(),
-        new PolicySelection(weightedTargetProvider, weightedTargetConfig), null);
+        GracefulSwitchLoadBalancer.createLoadBalancingPolicyConfig(
+            weightedTargetProvider, weightedTargetConfig),
+        null, Collections.emptyMap(), null);
     EquivalentAddressGroup endpoint = makeAddress("endpoint-addr", locality);
     deliverAddressesAndConfig(Collections.singletonList(endpoint), config);
     FakeLoadBalancer childBalancer = Iterables.getOnlyElement(downstreamBalancers);
@@ -190,22 +261,81 @@ public void nameResolutionError_afterChildPolicyInstantiated_propagateToDownstre
         .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_NAME,
+    ClusterImplConfig config = new ClusterImplConfig(CLUSTER, EDS_SERVICE_NAME, LRS_SERVER_INFO,
         null, Collections.<DropOverload>emptyList(),
-        new PolicySelection(weightedTargetProvider, weightedTargetConfig), null);
+        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.helper.createSubchannel(
-        CreateSubchannelArgs.newBuilder().setAddresses(leafBalancer.addresses).build());
-    leafBalancer.deliverSubchannelState(subchannel, ConnectivityState.READY);
+    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(mock(PickSubchannelArgs.class));
+    PickResult result = currentPicker.pickSubchannel(pickSubchannelArgs);
     assertThat(result.getStatus().isOk()).isTrue();
     ClientStreamTracer streamTracer1 = result.getStreamTracerFactory().newClientStreamTracer(
         ClientStreamTracer.StreamInfo.newBuilder().build(), new Metadata());  // first RPC call
@@ -213,7 +343,21 @@ public void recordLoadStats() {
         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));
@@ -224,9 +368,27 @@ public void recordLoadStats() {
     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
+    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.
@@ -236,19 +398,229 @@ public void recordLoadStats() {
     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_NAME,
+    ClusterImplConfig config = new ClusterImplConfig(CLUSTER, EDS_SERVICE_NAME, LRS_SERVER_INFO,
         null, Collections.singletonList(DropOverload.create("throttle", 500_000)),
-        new PolicySelection(weightedTargetProvider, weightedTargetConfig), null);
+        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);
@@ -257,11 +629,14 @@ public void dropRpcsWithRespectToLbConfigDropCategories() {
     assertThat(leafBalancer.name).isEqualTo("round_robin");
     assertThat(Iterables.getOnlyElement(leafBalancer.addresses).getAddresses())
         .isEqualTo(endpoint.getAddresses());
-    Subchannel subchannel = leafBalancer.helper.createSubchannel(
-        CreateSubchannelArgs.newBuilder().setAddresses(leafBalancer.addresses).build());
-    leafBalancer.deliverSubchannelState(subchannel, ConnectivityState.READY);
+    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(mock(PickSubchannelArgs.class));
+    PickResult result = currentPicker.pickSubchannel(pickSubchannelArgs);
     assertThat(result.getStatus().isOk()).isFalse();
     assertThat(result.getStatus().getCode()).isEqualTo(Code.UNAVAILABLE);
     assertThat(result.getStatus().getDescription()).isEqualTo("Dropped: throttle");
@@ -275,19 +650,21 @@ public void dropRpcsWithRespectToLbConfigDropCategories() {
     assertThat(clusterStats.totalDroppedRequests()).isEqualTo(1L);
 
     //  Config update updates drop policies.
-    config = new ClusterImplConfig(CLUSTER, EDS_SERVICE_NAME, LRS_SERVER_NAME, null,
+    config = new ClusterImplConfig(CLUSTER, EDS_SERVICE_NAME, LRS_SERVER_INFO, null,
         Collections.singletonList(DropOverload.create("lb", 1_000_000)),
-        new PolicySelection(weightedTargetProvider, weightedTargetConfig), null);
-    loadBalancer.handleResolvedAddresses(
+        GracefulSwitchLoadBalancer.createLoadBalancingPolicyConfig(
+            weightedTargetProvider, weightedTargetConfig),
+        null, Collections.emptyMap(), null);
+    loadBalancer.acceptResolvedAddresses(
         ResolvedAddresses.newBuilder()
             .setAddresses(Collections.singletonList(endpoint))
             .setAttributes(
                 Attributes.newBuilder()
-                    .set(InternalXdsAttributes.XDS_CLIENT_POOL, xdsClientPool)
+                    .set(io.grpc.xds.XdsAttributes.XDS_CLIENT, xdsClient)
                     .build())
             .setLoadBalancingPolicyConfig(config)
             .build());
-    result = currentPicker.pickSubchannel(mock(PickSubchannelArgs.class));
+    result = currentPicker.pickSubchannel(pickSubchannelArgs);
     assertThat(result.getStatus().isOk()).isFalse();
     assertThat(result.getStatus().getCode()).isEqualTo(Code.UNAVAILABLE);
     assertThat(result.getStatus().getDescription()).isEqualTo("Dropped: lb");
@@ -300,21 +677,21 @@ public void dropRpcsWithRespectToLbConfigDropCategories() {
         .isEqualTo(1L);
     assertThat(clusterStats.totalDroppedRequests()).isEqualTo(1L);
 
-    result = currentPicker.pickSubchannel(mock(PickSubchannelArgs.class));
+    result = currentPicker.pickSubchannel(pickSubchannelArgs);
     assertThat(result.getStatus().isOk()).isTrue();
   }
 
   @Test
-  public void maxConcurrentRequests_appliedByLbConfig_enableCircuitBreaking() {
+  public void maxConcurrentRequests_appliedByLbConfig_disableCircuitBreaking() {
     boolean originalEnableCircuitBreaking = ClusterImplLoadBalancer.enableCircuitBreaking;
-    ClusterImplLoadBalancer.enableCircuitBreaking = true;
-    subtest_maxConcurrentRequests_appliedByLbConfig(true);
+    ClusterImplLoadBalancer.enableCircuitBreaking = false;
+    subtest_maxConcurrentRequests_appliedByLbConfig(false);
     ClusterImplLoadBalancer.enableCircuitBreaking = originalEnableCircuitBreaking;
   }
 
   @Test
-  public void maxConcurrentRequests_appliedByLbConfig_circuitBreakingDisabledByDefault() {
-    subtest_maxConcurrentRequests_appliedByLbConfig(false);
+  public void maxConcurrentRequests_appliedByLbConfig_circuitBreakingEnabledByDefault() {
+    subtest_maxConcurrentRequests_appliedByLbConfig(true);
   }
 
   private void subtest_maxConcurrentRequests_appliedByLbConfig(boolean enableCircuitBreaking) {
@@ -322,9 +699,11 @@ private void subtest_maxConcurrentRequests_appliedByLbConfig(boolean enableCircu
     LoadBalancerProvider weightedTargetProvider = new WeightedTargetLoadBalancerProvider();
     WeightedTargetConfig weightedTargetConfig =
         buildWeightedTargetConfig(ImmutableMap.of(locality, 10));
-    ClusterImplConfig config = new ClusterImplConfig(CLUSTER, EDS_SERVICE_NAME, LRS_SERVER_NAME,
+    ClusterImplConfig config = new ClusterImplConfig(CLUSTER, EDS_SERVICE_NAME, LRS_SERVER_INFO,
         maxConcurrentRequests, Collections.<DropOverload>emptyList(),
-        new PolicySelection(weightedTargetProvider, weightedTargetConfig), null);
+        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
@@ -332,30 +711,33 @@ private void subtest_maxConcurrentRequests_appliedByLbConfig(boolean enableCircu
     assertThat(leafBalancer.name).isEqualTo("round_robin");
     assertThat(Iterables.getOnlyElement(leafBalancer.addresses).getAddresses())
         .isEqualTo(endpoint.getAddresses());
-    Subchannel subchannel = leafBalancer.helper.createSubchannel(
-        CreateSubchannelArgs.newBuilder().setAddresses(leafBalancer.addresses).build());
-    leafBalancer.deliverSubchannelState(subchannel, ConnectivityState.READY);
+    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(mock(PickSubchannelArgs.class));
+      PickResult result = currentPicker.pickSubchannel(pickSubchannelArgs);
       assertThat(result.getStatus().isOk()).isTrue();
       ClientStreamTracer.Factory streamTracerFactory = result.getStreamTracerFactory();
-      streamTracerFactory.newClientStreamTracer(ClientStreamTracer.StreamInfo.newBuilder().build(),
-          new Metadata());
+      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(mock(PickSubchannelArgs.class));
+    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 exceeded");
+          .isEqualTo("Cluster max concurrent requests limit of 100 exceeded");
       assertThat(clusterStats.totalDroppedRequests()).isEqualTo(1L);
     } else {
       assertThat(result.getStatus().isOk()).isTrue();
@@ -364,12 +746,14 @@ private void subtest_maxConcurrentRequests_appliedByLbConfig(boolean enableCircu
 
     // Config update increments circuit breakers max_concurrent_requests threshold.
     maxConcurrentRequests = 101L;
-    config = new ClusterImplConfig(CLUSTER, EDS_SERVICE_NAME, LRS_SERVER_NAME,
+    config = new ClusterImplConfig(CLUSTER, EDS_SERVICE_NAME, LRS_SERVER_INFO,
         maxConcurrentRequests, Collections.<DropOverload>emptyList(),
-        new PolicySelection(weightedTargetProvider, weightedTargetConfig), null);
+        GracefulSwitchLoadBalancer.createLoadBalancingPolicyConfig(
+            weightedTargetProvider, weightedTargetConfig),
+        null, Collections.emptyMap(), null);
     deliverAddressesAndConfig(Collections.singletonList(endpoint), config);
 
-    result = currentPicker.pickSubchannel(mock(PickSubchannelArgs.class));
+    result = currentPicker.pickSubchannel(pickSubchannelArgs);
     assertThat(result.getStatus().isOk()).isTrue();
     result.getStreamTracerFactory().newClientStreamTracer(
         ClientStreamTracer.StreamInfo.newBuilder().build(), new Metadata());  // 101th request
@@ -377,14 +761,14 @@ private void subtest_maxConcurrentRequests_appliedByLbConfig(boolean enableCircu
     assertThat(clusterStats.clusterServiceName()).isEqualTo(EDS_SERVICE_NAME);
     assertThat(clusterStats.totalDroppedRequests()).isEqualTo(0L);
 
-    result = currentPicker.pickSubchannel(mock(PickSubchannelArgs.class));  // 102th request
+    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 exceeded");
+          .isEqualTo("Cluster max concurrent requests limit of 101 exceeded");
       assertThat(clusterStats.totalDroppedRequests()).isEqualTo(1L);
     } else {
       assertThat(result.getStatus().isOk()).isTrue();
@@ -393,16 +777,16 @@ private void subtest_maxConcurrentRequests_appliedByLbConfig(boolean enableCircu
   }
 
   @Test
-  public void maxConcurrentRequests_appliedWithDefaultValue_enableCircuitBreaking() {
+  public void maxConcurrentRequests_appliedWithDefaultValue_disableCircuitBreaking() {
     boolean originalEnableCircuitBreaking = ClusterImplLoadBalancer.enableCircuitBreaking;
-    ClusterImplLoadBalancer.enableCircuitBreaking = true;
-    subtest_maxConcurrentRequests_appliedWithDefaultValue(true);
+    ClusterImplLoadBalancer.enableCircuitBreaking = false;
+    subtest_maxConcurrentRequests_appliedWithDefaultValue(false);
     ClusterImplLoadBalancer.enableCircuitBreaking = originalEnableCircuitBreaking;
   }
 
   @Test
-  public void maxConcurrentRequests_appliedWithDefaultValue_circuitBreakingDisabledByDefault() {
-    subtest_maxConcurrentRequests_appliedWithDefaultValue(false);
+  public void maxConcurrentRequests_appliedWithDefaultValue_circuitBreakingEnabledByDefault() {
+    subtest_maxConcurrentRequests_appliedWithDefaultValue(true);
   }
 
   private void subtest_maxConcurrentRequests_appliedWithDefaultValue(
@@ -410,9 +794,11 @@ private void subtest_maxConcurrentRequests_appliedWithDefaultValue(
     LoadBalancerProvider weightedTargetProvider = new WeightedTargetLoadBalancerProvider();
     WeightedTargetConfig weightedTargetConfig =
         buildWeightedTargetConfig(ImmutableMap.of(locality, 10));
-    ClusterImplConfig config = new ClusterImplConfig(CLUSTER, EDS_SERVICE_NAME, LRS_SERVER_NAME,
+    ClusterImplConfig config = new ClusterImplConfig(CLUSTER, EDS_SERVICE_NAME, LRS_SERVER_INFO,
         null, Collections.<DropOverload>emptyList(),
-        new PolicySelection(weightedTargetProvider, weightedTargetConfig), null);
+        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
@@ -420,30 +806,33 @@ private void subtest_maxConcurrentRequests_appliedWithDefaultValue(
     assertThat(leafBalancer.name).isEqualTo("round_robin");
     assertThat(Iterables.getOnlyElement(leafBalancer.addresses).getAddresses())
         .isEqualTo(endpoint.getAddresses());
-    Subchannel subchannel = leafBalancer.helper.createSubchannel(
-        CreateSubchannelArgs.newBuilder().setAddresses(leafBalancer.addresses).build());
-    leafBalancer.deliverSubchannelState(subchannel, ConnectivityState.READY);
+    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(mock(PickSubchannelArgs.class));
+      PickResult result = currentPicker.pickSubchannel(pickSubchannelArgs);
       assertThat(result.getStatus().isOk()).isTrue();
       ClientStreamTracer.Factory streamTracerFactory = result.getStreamTracerFactory();
-      streamTracerFactory.newClientStreamTracer(ClientStreamTracer.StreamInfo.newBuilder().build(),
-          new Metadata());
+      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(mock(PickSubchannelArgs.class));
+    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 exceeded");
+          .isEqualTo("Cluster max concurrent requests limit of 1024 exceeded");
       assertThat(clusterStats.totalDroppedRequests()).isEqualTo(1L);
     } else {
       assertThat(result.getStatus().isOk()).isTrue();
@@ -456,9 +845,11 @@ public void endpointAddressesAttachedWithClusterName() {
     LoadBalancerProvider weightedTargetProvider = new WeightedTargetLoadBalancerProvider();
     WeightedTargetConfig weightedTargetConfig =
         buildWeightedTargetConfig(ImmutableMap.of(locality, 10));
-    ClusterImplConfig config = new ClusterImplConfig(CLUSTER, EDS_SERVICE_NAME, LRS_SERVER_NAME,
+    ClusterImplConfig config = new ClusterImplConfig(CLUSTER, EDS_SERVICE_NAME, LRS_SERVER_INFO,
         null, Collections.<DropOverload>emptyList(),
-        new PolicySelection(weightedTargetProvider, weightedTargetConfig), null);
+        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);
@@ -466,6 +857,7 @@ public void endpointAddressesAttachedWithClusterName() {
     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()
@@ -473,36 +865,131 @@ public void endpointAddressesAttachedWithClusterName() {
             .build();
     Subchannel subchannel = leafBalancer.helper.createSubchannel(args);
     for (EquivalentAddressGroup eag : subchannel.getAllAddresses()) {
-      assertThat(eag.getAttributes().get(InternalXdsAttributes.ATTR_CLUSTER_NAME))
+      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 endpointAddressesAttachedWithTlsConfig_enableSecurity() {
-    boolean originalEnableSecurity = ClusterImplLoadBalancer.enableSecurity;
-    ClusterImplLoadBalancer.enableSecurity = true;
-    subtest_endpointAddressesAttachedWithTlsConfig(true);
-    ClusterImplLoadBalancer.enableSecurity = originalEnableSecurity;
+  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 endpointAddressesAttachedWithTlsConfig_securityDisabledByDefault() {
-    subtest_endpointAddressesAttachedWithTlsConfig(false);
+  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();
   }
 
-  private void subtest_endpointAddressesAttachedWithTlsConfig(boolean enableSecurity) {
+  @Test
+  public void endpointAddressesAttachedWithTlsConfig_securityEnabledByDefault() {
     UpstreamTlsContext upstreamTlsContext =
-        CommonTlsContextTestsUtil.buildUpstreamTlsContextFromFilenames(
-            CommonTlsContextTestsUtil.CLIENT_KEY_FILE,
-            CommonTlsContextTestsUtil.CLIENT_PEM_FILE,
-            CommonTlsContextTestsUtil.CA_PEM_FILE);
+        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_NAME,
+    ClusterImplConfig config = new ClusterImplConfig(CLUSTER, EDS_SERVICE_NAME, LRS_SERVER_INFO,
         null, Collections.<DropOverload>emptyList(),
-        new PolicySelection(weightedTargetProvider, weightedTargetConfig), upstreamTlsContext);
+        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);
@@ -518,58 +1005,60 @@ private void subtest_endpointAddressesAttachedWithTlsConfig(boolean enableSecuri
     Subchannel subchannel = leafBalancer.helper.createSubchannel(args);
     for (EquivalentAddressGroup eag : subchannel.getAllAddresses()) {
       SslContextProviderSupplier supplier =
-          eag.getAttributes().get(InternalXdsAttributes.ATTR_SSL_CONTEXT_PROVIDER_SUPPLIER);
-      if (enableSecurity) {
-        assertThat(supplier.getUpstreamTlsContext()).isEqualTo(upstreamTlsContext);
-      } else {
-        assertThat(supplier).isNull();
-      }
+          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_NAME,
+    config = new ClusterImplConfig(CLUSTER, EDS_SERVICE_NAME, LRS_SERVER_INFO,
         null, Collections.<DropOverload>emptyList(),
-        new PolicySelection(weightedTargetProvider, weightedTargetConfig), null);
+        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(InternalXdsAttributes.ATTR_SSL_CONTEXT_PROVIDER_SUPPLIER))
+      assertThat(
+            eag.getAttributes().get(SecurityProtocolNegotiators.ATTR_SSL_CONTEXT_PROVIDER_SUPPLIER))
           .isNull();
     }
 
     // Config with a new UpstreamTlsContext.
-    upstreamTlsContext =
-        CommonTlsContextTestsUtil.buildUpstreamTlsContextFromFilenames(
-            CommonTlsContextTestsUtil.BAD_CLIENT_KEY_FILE,
-            CommonTlsContextTestsUtil.BAD_CLIENT_PEM_FILE,
-            CommonTlsContextTestsUtil.CA_PEM_FILE);
-    config = new ClusterImplConfig(CLUSTER, EDS_SERVICE_NAME, LRS_SERVER_NAME,
+    upstreamTlsContext = CommonTlsContextTestsUtil.buildUpstreamTlsContext(
+        "google_cloud_private_spiffe1", true);
+    config = new ClusterImplConfig(CLUSTER, EDS_SERVICE_NAME, LRS_SERVER_INFO,
         null, Collections.<DropOverload>emptyList(),
-        new PolicySelection(weightedTargetProvider, weightedTargetConfig), upstreamTlsContext);
+        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(InternalXdsAttributes.ATTR_SSL_CONTEXT_PROVIDER_SUPPLIER);
-      if (enableSecurity) {
-        assertThat(supplier.getUpstreamTlsContext()).isEqualTo(upstreamTlsContext);
-      } else {
-        assertThat(supplier).isNull();
-      }
+          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.handleResolvedAddresses(
+    loadBalancer.acceptResolvedAddresses(
         ResolvedAddresses.newBuilder()
             .setAddresses(addresses)
             .setAttributes(
                 Attributes.newBuilder()
-                    .set(InternalXdsAttributes.XDS_CLIENT_POOL, xdsClientPool)
-                    .set(InternalXdsAttributes.CALL_COUNTER_PROVIDER, callCounterProvider)
+                    .set(io.grpc.xds.XdsAttributes.XDS_CLIENT, xdsClient)
+                    .set(io.grpc.xds.XdsAttributes.CALL_COUNTER_PROVIDER, callCounterProvider)
                     .build())
             .setLoadBalancingPolicyConfig(config)
             .build());
@@ -590,6 +1079,11 @@ private WeightedTargetConfig buildWeightedTargetConfig(Map<Locality, Integer> lo
    * 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;
 
@@ -620,8 +1114,15 @@ public String toString() {
       }
     }
 
+    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.newBuilder().set(InternalXdsAttributes.ATTR_LOCALITY, locality).build());
+        attributes.build());
     return AddressFilter.setPathFilter(eag, Collections.singletonList(locality.toString()));
   }
 
@@ -669,10 +1170,11 @@ private final class FakeLoadBalancer extends LoadBalancer {
     }
 
     @Override
-    public void handleResolvedAddresses(ResolvedAddresses resolvedAddresses) {
+    public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
       addresses = resolvedAddresses.getAddresses();
       config = resolvedAddresses.getLoadBalancingPolicyConfig();
       attributes = resolvedAddresses.getAttributes();
+      return Status.OK;
     }
 
     @Override
@@ -686,18 +1188,38 @@ public void shutdown() {
     }
 
     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 PickResult.withSubchannel(subchannel);
+          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;
@@ -712,7 +1234,9 @@ public void updateBalancingState(
 
     @Override
     public Subchannel createSubchannel(CreateSubchannelArgs args) {
-      return new FakeSubchannel(args.getAddresses(), args.getAttributes());
+      FakeSubchannel subchannel = new FakeSubchannel(args.getAddresses(), args.getAttributes());
+      subchannels.add(subchannel);
+      return subchannel;
     }
 
     @Override
@@ -724,23 +1248,38 @@ public ManagedChannel createOobChannel(EquivalentAddressGroup eag, String author
     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
@@ -752,18 +1291,69 @@ public List<EquivalentAddressGroup> getAllAddresses() {
     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
-    ClusterDropStats addClusterDropStats(String clusterName, @Nullable String edsServiceName) {
+    public ClusterDropStats addClusterDropStats(
+        ServerInfo lrsServerInfo, String clusterName, @Nullable String edsServiceName) {
       return loadStatsManager.getClusterDropStats(clusterName, edsServiceName);
     }
 
     @Override
-    ClusterLocalityStats addClusterLocalityStats(String clusterName,
-        @Nullable String edsServiceName, Locality locality) {
-      return loadStatsManager.getClusterLocalityStats(clusterName, edsServiceName, locality);
+    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;
     }
   }
 
diff --git a/xds/src/test/java/io/grpc/xds/ClusterManagerLoadBalancerProviderTest.java b/xds/src/test/java/io/grpc/xds/ClusterManagerLoadBalancerProviderTest.java
index dfef96e5454..40943658520 100644
--- a/xds/src/test/java/io/grpc/xds/ClusterManagerLoadBalancerProviderTest.java
+++ b/xds/src/test/java/io/grpc/xds/ClusterManagerLoadBalancerProviderTest.java
@@ -23,8 +23,10 @@
 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.internal.ServiceConfigUtil.PolicySelection;
+import io.grpc.util.GracefulSwitchLoadBalancer;
 import io.grpc.xds.ClusterManagerLoadBalancerProvider.ClusterManagerConfig;
 import java.io.IOException;
 import java.util.Map;
@@ -36,11 +38,12 @@
 @RunWith(JUnit4.class)
 public class ClusterManagerLoadBalancerProviderTest {
 
+  private final LoadBalancerRegistry lbRegistry = new LoadBalancerRegistry();
+  private final ClusterManagerLoadBalancerProvider provider =
+      new ClusterManagerLoadBalancerProvider(lbRegistry);
+
   @Test
-  public void parseClusterManagerLoadBalancingPolicyConfig() throws IOException {
-    LoadBalancerRegistry lbRegistry = new LoadBalancerRegistry();
-    ClusterManagerLoadBalancerProvider provider =
-        new ClusterManagerLoadBalancerProvider(lbRegistry);
+  public void parseLoadBalancingConfig_valid() throws IOException {
     final Object fooConfig = new Object();
     LoadBalancerProvider lbProviderFoo = new LoadBalancerProvider() {
       @Override
@@ -130,10 +133,23 @@ public ConfigOrError parseLoadBalancingPolicyConfig(
     assertThat(config.childPolicies)
         .containsExactly(
             "child1",
-            new PolicySelection(
-                lbProviderFoo, fooConfig),
+            GracefulSwitchLoadBalancer.createLoadBalancingPolicyConfig(lbProviderFoo, fooConfig),
             "child2",
-            new PolicySelection(lbProviderBar, barConfig));
+            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
diff --git a/xds/src/test/java/io/grpc/xds/ClusterManagerLoadBalancerTest.java b/xds/src/test/java/io/grpc/xds/ClusterManagerLoadBalancerTest.java
index 7fb9ddf0e04..8856efd685f 100644
--- a/xds/src/test/java/io/grpc/xds/ClusterManagerLoadBalancerTest.java
+++ b/xds/src/test/java/io/grpc/xds/ClusterManagerLoadBalancerTest.java
@@ -17,14 +17,18 @@
 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;
@@ -33,6 +37,7 @@
 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;
@@ -47,10 +52,11 @@
 import io.grpc.SynchronizationContext;
 import io.grpc.internal.FakeClock;
 import io.grpc.internal.PickSubchannelArgsImpl;
-import io.grpc.internal.ServiceConfigUtil.PolicySelection;
 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;
@@ -59,17 +65,20 @@
 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.MockitoAnnotations;
+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() {
@@ -87,17 +96,17 @@ public void uncaughtException(Thread t, Throwable e) {
 
   private final Map<String, Object> lbConfigInventory = new HashMap<>();
   private final List<FakeLoadBalancer> childBalancers = new ArrayList<>();
-  private LoadBalancer clusterManagerLoadBalancer;
+  private ClusterManagerLoadBalancer clusterManagerLoadBalancer;
 
   @Before
   public void setUp() {
-    MockitoAnnotations.initMocks(this);
     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
@@ -109,7 +118,7 @@ public void tearDown() {
   }
 
   @Test
-  public void handleResolvedAddressesUpdatesChannelPicker() {
+  public void acceptResolvedAddressesUpdatesChannelPicker() {
     deliverResolvedAddresses(ImmutableMap.of("childA", "policy_a", "childB", "policy_b"));
 
     verify(helper, atLeastOnce()).updateBalancingState(
@@ -118,10 +127,14 @@ public void handleResolvedAddressesUpdatesChannelPicker() {
     assertThat(pickSubchannel(picker, "childA")).isEqualTo(PickResult.withNoResult());
     assertThat(pickSubchannel(picker, "childB")).isEqualTo(PickResult.withNoResult());
     assertThat(childBalancers).hasSize(2);
-    FakeLoadBalancer childBalancer1 = childBalancers.get(0);
-    FakeLoadBalancer childBalancer2 = childBalancers.get(1);
-    assertThat(childBalancer1.name).isEqualTo("policy_a");
-    assertThat(childBalancer2.name).isEqualTo("policy_b");
+    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"));
 
@@ -135,15 +148,15 @@ public void handleResolvedAddressesUpdatesChannelPicker() {
     assertThat(pickSubchannel(picker, "childC")).isEqualTo(PickResult.withNoResult());
     Status status = pickSubchannel(picker, "childB").getStatus();
     assertThat(status.getCode()).isEqualTo(Code.UNAVAILABLE);
-    assertThat(status.getDescription()).isEqualTo("Unable to find cluster childB");
+    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 = childBalancers.get(2);
-    assertThat(childBalancer3.name).isEqualTo("policy_c");
+    FakeLoadBalancer childBalancer3 = getChildBalancerByName("policy_c");
     assertThat(childBalancer3.config).isEqualTo(lbConfigInventory.get("childC"));
 
     // delayed policy_b deletion
@@ -157,8 +170,8 @@ public void updateBalancingStateFromChildBalancers() {
     deliverResolvedAddresses(ImmutableMap.of("childA", "policy_a", "childB", "policy_b"));
 
     assertThat(childBalancers).hasSize(2);
-    FakeLoadBalancer childBalancer1 = childBalancers.get(0);
-    FakeLoadBalancer childBalancer2 = childBalancers.get(1);
+    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);
@@ -175,23 +188,47 @@ public void updateBalancingStateFromChildBalancers() {
         .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 = childBalancers.get(0);  // policy_a (deactivated)
+    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
+    // 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(
@@ -207,8 +244,8 @@ public void handleNameResolutionError_beforeChildLbsInstantiated_returnErrorPick
   public void handleNameResolutionError_afterChildLbsInstantiated_propagateToChildLbs() {
     deliverResolvedAddresses(ImmutableMap.of("childA", "policy_a", "childB", "policy_b"));
     assertThat(childBalancers).hasSize(2);
-    FakeLoadBalancer childBalancer1 = childBalancers.get(0);
-    FakeLoadBalancer childBalancer2 = childBalancers.get(1);
+    FakeLoadBalancer childBalancer1 = getChildBalancerByName("policy_a");
+    FakeLoadBalancer childBalancer2 = getChildBalancerByName("policy_b");
     clusterManagerLoadBalancer.handleNameResolutionError(
         Status.UNAVAILABLE.withDescription("resolver error"));
     assertThat(childBalancer1.upstreamError.getCode()).isEqualTo(Code.UNAVAILABLE);
@@ -221,8 +258,8 @@ public void handleNameResolutionError_afterChildLbsInstantiated_propagateToChild
   public void handleNameResolutionError_notPropagateToDeactivatedChildLbs() {
     deliverResolvedAddresses(ImmutableMap.of("childA", "policy_a", "childB", "policy_b"));
     deliverResolvedAddresses(ImmutableMap.of("childB", "policy_b"));
-    FakeLoadBalancer childBalancer1 = childBalancers.get(0);  // policy_a (deactivated)
-    FakeLoadBalancer childBalancer2 = childBalancers.get(1);  // 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();
@@ -230,24 +267,49 @@ public void handleNameResolutionError_notPropagateToDeactivatedChildLbs() {
     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) {
-    clusterManagerLoadBalancer.handleResolvedAddresses(
+    deliverResolvedAddresses(childPolicies, false);
+  }
+
+  private void deliverResolvedAddresses(final Map<String, String> childPolicies, boolean failing) {
+    clusterManagerLoadBalancer.acceptResolvedAddresses(
         ResolvedAddresses.newBuilder()
             .setAddresses(Collections.<EquivalentAddressGroup>emptyList())
-            .setLoadBalancingPolicyConfig(buildConfig(childPolicies))
+            .setLoadBalancingPolicyConfig(buildConfig(childPolicies, failing))
             .build());
   }
 
-  private ClusterManagerConfig buildConfig(Map<String, String> childPolicies) {
-    Map<String, PolicySelection> childPolicySelections = new LinkedHashMap<>();
+  // 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);
-      PolicySelection policy =
-          new PolicySelection(new FakeLoadBalancerProvider(childPolicyName), childConfig);
-      childPolicySelections.put(name, policy);
+      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(childPolicySelections);
+    return new ClusterManagerConfig(childConfigs);
   }
 
   private static PickResult pickSubchannel(SubchannelPicker picker, String clusterName) {
@@ -261,20 +323,23 @@ private static PickResult pickSubchannel(SubchannelPicker picker, String cluster
                 .build(),
             new Metadata(),
             CallOptions.DEFAULT.withOption(
-                XdsNameResolver.CLUSTER_SELECTION_KEY, clusterName));
+                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) {
+    FakeLoadBalancerProvider(String policyName, boolean failing) {
       this.policyName = policyName;
+      this.failing = failing;
     }
 
     @Override
     public LoadBalancer newLoadBalancer(Helper helper) {
-      FakeLoadBalancer balancer = new FakeLoadBalancer(policyName, helper);
+      FakeLoadBalancer balancer = new FakeLoadBalancer(policyName, helper, failing);
       childBalancers.add(balancer);
       return balancer;
     }
@@ -298,18 +363,26 @@ public String getPolicyName() {
   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) {
+    FakeLoadBalancer(String name, Helper helper, boolean failing) {
       this.name = name;
       this.helper = helper;
+      this.failing = failing;
     }
 
     @Override
-    public void handleResolvedAddresses(ResolvedAddresses resolvedAddresses) {
+    public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
       config = resolvedAddresses.getLoadBalancingPolicyConfig();
+
+      if (failing) {
+        helper.updateBalancingState(
+            TRANSIENT_FAILURE, new FixedResultPicker(PickResult.withError(Status.INTERNAL)));
+      }
+      return Status.OK;
     }
 
     @Override
diff --git a/xds/src/test/java/io/grpc/xds/ClusterResolverLoadBalancerProviderTest.java b/xds/src/test/java/io/grpc/xds/ClusterResolverLoadBalancerProviderTest.java
deleted file mode 100644
index a201ecfaa4b..00000000000
--- a/xds/src/test/java/io/grpc/xds/ClusterResolverLoadBalancerProviderTest.java
+++ /dev/null
@@ -1,79 +0,0 @@
-/*
- * 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.ChannelLogger;
-import io.grpc.LoadBalancer;
-import io.grpc.LoadBalancer.Helper;
-import io.grpc.LoadBalancerProvider;
-import io.grpc.LoadBalancerRegistry;
-import io.grpc.NameResolver;
-import io.grpc.NameResolver.ServiceConfigParser;
-import io.grpc.NameResolverRegistry;
-import io.grpc.SynchronizationContext;
-import io.grpc.internal.FakeClock;
-import io.grpc.internal.GrpcUtil;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-
-/** Tests for {@link ClusterResolverLoadBalancerProvider}. */
-@RunWith(JUnit4.class)
-public class ClusterResolverLoadBalancerProviderTest {
-
-  @Test
-  public void provided() {
-    LoadBalancerProvider provider =
-        LoadBalancerRegistry.getDefaultRegistry().getProvider(
-            XdsLbPolicies.CLUSTER_RESOLVER_POLICY_NAME);
-    assertThat(provider).isInstanceOf(ClusterResolverLoadBalancerProvider.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);
-          }
-        });
-    FakeClock fakeClock = new FakeClock();
-    NameResolverRegistry nsRegistry = new NameResolverRegistry();
-    NameResolver.Args args = NameResolver.Args.newBuilder()
-        .setDefaultPort(8080)
-        .setProxyDetector(GrpcUtil.NOOP_PROXY_DETECTOR)
-        .setSynchronizationContext(syncContext)
-        .setServiceConfigParser(mock(ServiceConfigParser.class))
-        .setChannelLogger(mock(ChannelLogger.class))
-        .build();
-    when(helper.getNameResolverRegistry()).thenReturn(nsRegistry);
-    when(helper.getNameResolverArgs()).thenReturn(args);
-    when(helper.getSynchronizationContext()).thenReturn(syncContext);
-    when(helper.getScheduledExecutorService()).thenReturn(fakeClock.getScheduledExecutorService());
-    when(helper.getAuthority()).thenReturn("api.google.com");
-    LoadBalancerProvider provider = new ClusterResolverLoadBalancerProvider();
-    LoadBalancer loadBalancer = provider.newLoadBalancer(helper);
-    assertThat(loadBalancer).isInstanceOf(ClusterResolverLoadBalancer.class);
-  }
-}
diff --git a/xds/src/test/java/io/grpc/xds/ClusterResolverLoadBalancerTest.java b/xds/src/test/java/io/grpc/xds/ClusterResolverLoadBalancerTest.java
index 3c2c226cd4f..a508da34f88 100644
--- a/xds/src/test/java/io/grpc/xds/ClusterResolverLoadBalancerTest.java
+++ b/xds/src/test/java/io/grpc/xds/ClusterResolverLoadBalancerTest.java
@@ -20,20 +20,47 @@
 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.reset;
 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.InternalEquivalentAddressGroup;
 import io.grpc.LoadBalancer;
 import io.grpc.LoadBalancer.Helper;
 import io.grpc.LoadBalancer.PickResult;
@@ -48,71 +75,91 @@
 import io.grpc.NameResolverProvider;
 import io.grpc.NameResolverRegistry;
 import io.grpc.Status;
-import io.grpc.Status.Code;
+import io.grpc.StatusOr;
 import io.grpc.SynchronizationContext;
-import io.grpc.internal.BackoffPolicy;
+import io.grpc.inprocess.InProcessChannelBuilder;
+import io.grpc.inprocess.InProcessServerBuilder;
 import io.grpc.internal.FakeClock;
-import io.grpc.internal.FakeClock.ScheduledTask;
 import io.grpc.internal.GrpcUtil;
-import io.grpc.internal.ObjectPool;
-import io.grpc.internal.ServiceConfigUtil.PolicySelection;
+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.ClusterResolverLoadBalancerProvider.ClusterResolverConfig;
-import io.grpc.xds.ClusterResolverLoadBalancerProvider.ClusterResolverConfig.DiscoveryMechanism;
 import io.grpc.xds.Endpoints.DropOverload;
-import io.grpc.xds.Endpoints.LbEndpoint;
-import io.grpc.xds.Endpoints.LocalityLbEndpoints;
 import io.grpc.xds.EnvoyServerProtoData.UpstreamTlsContext;
 import io.grpc.xds.PriorityLoadBalancerProvider.PriorityLbConfig;
 import io.grpc.xds.PriorityLoadBalancerProvider.PriorityLbConfig.PriorityChildConfig;
-import io.grpc.xds.WeightedTargetLoadBalancerProvider.WeightedPolicySelection;
-import io.grpc.xds.WeightedTargetLoadBalancerProvider.WeightedTargetConfig;
-import io.grpc.xds.internal.sds.CommonTlsContextTestsUtil;
-import java.net.SocketAddress;
+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.net.URISyntaxException;
 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.Objects;
 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.InOrder;
 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 ClusterResolverLoadBalancer}. */
 @RunWith(JUnit4.class)
 public class ClusterResolverLoadBalancerTest {
-  private static final String AUTHORITY = "api.google.com";
-  private static final String CLUSTER1 = "cluster-foo.googleapis.com";
-  private static final String CLUSTER2 = "cluster-bar.googleapis.com";
-  private static final String CLUSTER_DNS = "cluster-dns.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 String LRS_SERVER_NAME = "lrs.googleapis.com";
-  private final Locality locality1 =
-      Locality.create("test-region-1", "test-zone-1", "test-subzone-1");
-  private final Locality locality2 =
-      Locality.create("test-region-2", "test-zone-2", "test-subzone-2");
-  private final Locality locality3 =
-      Locality.create("test-region-3", "test-zone-3", "test-subzone-3");
-  private final UpstreamTlsContext tlsContext =
-      CommonTlsContextTestsUtil.buildUpstreamTlsContextFromFilenames(
-          CommonTlsContextTestsUtil.CLIENT_KEY_FILE,
-          CommonTlsContextTestsUtil.CLIENT_PEM_FILE,
-          CommonTlsContextTestsUtil.CA_PEM_FILE);
+  @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() {
@@ -124,318 +171,742 @@ public void uncaughtException(Thread t, Throwable e) {
   private final FakeClock fakeClock = new FakeClock();
   private final LoadBalancerRegistry lbRegistry = new LoadBalancerRegistry();
   private final NameResolverRegistry nsRegistry = new NameResolverRegistry();
-  private final PolicySelection roundRobin =
-      new PolicySelection(new FakeLoadBalancerProvider("round_robin"), null);
-  private final PolicySelection weightedTarget =
-      new PolicySelection(new FakeLoadBalancerProvider(WEIGHTED_TARGET_POLICY_NAME), null);
   private final List<FakeLoadBalancer> childBalancers = new ArrayList<>();
   private final List<FakeNameResolver> resolvers = new ArrayList<>();
-  private final FakeXdsClient xdsClient = new FakeXdsClient();
-  private final ObjectPool<XdsClient> xdsClientPool = new ObjectPool<XdsClient>() {
-    @Override
-    public XdsClient getObject() {
-      xdsClientRefs++;
-      return xdsClient;
-    }
-
-    @Override
-    public XdsClient returnObject(Object object) {
-      xdsClientRefs--;
-      return null;
-    }
-  };
-
+  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;
-  @Mock
-  private BackoffPolicy.Provider backoffPolicyProvider;
-  @Mock
-  private BackoffPolicy backoffPolicy1;
-  @Mock
-  private BackoffPolicy backoffPolicy2;
   @Captor
   private ArgumentCaptor<SubchannelPicker> pickerCaptor;
-  private int xdsClientRefs;
-  private ClusterResolverLoadBalancer loadBalancer;
-
+  private CdsLoadBalancer2 loadBalancer;
+  private boolean originalIsEnabledXdsHttpConnect;
 
   @Before
-  public void setUp() throws URISyntaxException {
-    MockitoAnnotations.initMocks(this);
-
+  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
-    URI targetUri = new URI(AUTHORITY);
+    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();
-    nsRegistry.register(new FakeNameResolverProvider(targetUri));
-    when(helper.getNameResolverRegistry()).thenReturn(nsRegistry);
-    when(helper.getNameResolverArgs()).thenReturn(args);
-    when(helper.getSynchronizationContext()).thenReturn(syncContext);
-    when(helper.getScheduledExecutorService()).thenReturn(fakeClock.getScheduledExecutorService());
-    when(helper.getAuthority()).thenReturn(AUTHORITY);
-    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(5L), TimeUnit.SECONDS.toNanos(50L));
-    loadBalancer = new ClusterResolverLoadBalancer(helper, lbRegistry, backoffPolicyProvider);
+
+    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() {
+  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(xdsClient.watchers).isEmpty();
-    assertThat(xdsClientRefs).isEqualTo(0);
     assertThat(fakeClock.getPendingTasks()).isEmpty();
   }
 
   @Test
-  public void onlyEdsClusters_receivedEndpoints() {
-    deliverConfigWithEdsClusters();  // CLUSTER1 and CLUSTER2
-    // CLUSTER1 has priority 1 (priority3), which has locality 2, which has endpoint3.
-    // CLUSTER2 has priority 1 (priority1) and 2 (priority2); priority1 has locality1,
-    // which has endpoint1 and endpoint2; priority2 has locality3, which has endpoint4.
-    EquivalentAddressGroup endpoint1 = makeAddress("endpoint-addr-1");
-    EquivalentAddressGroup endpoint2 = makeAddress("endpoint-addr-2");
-    EquivalentAddressGroup endpoint3 = makeAddress("endpoint-addr-3");
-    EquivalentAddressGroup endpoint4 = makeAddress("endpoint-addr-4");
-    LocalityLbEndpoints localityLbEndpoints1 =
-        buildLocalityLbEndpoints(1, 70, ImmutableMap.of(endpoint1, true, endpoint2, true));
-    LocalityLbEndpoints localityLbEndpoints2 =
-        buildLocalityLbEndpoints(1, 10, Collections.singletonMap(endpoint3, true));
-    LocalityLbEndpoints localityLbEndpoints3 =
-        buildLocalityLbEndpoints(2, 20, Collections.singletonMap(endpoint4, true));
-    String priority1 = CLUSTER2 + "[priority1]";
-    String priority2 = CLUSTER2 + "[priority2]";
-    String priority3 = CLUSTER1 + "[priority1]";
-
-    // First deliver CLUSTER2's endpoints, two priorities with each has one locality.
-    xdsClient.deliverClusterLoadAssignment(
-        EDS_SERVICE_NAME2,
-        ImmutableMap.of(locality1, localityLbEndpoints1, locality3, localityLbEndpoints3));
+  public void edsClustersWithRingHashEndpointLbPolicy_oppositePickFirstWeightedShuffling()
+      throws Exception {
+    boolean original = CdsLoadBalancer2.pickFirstWeightedShuffling;
+    CdsLoadBalancer2.pickFirstWeightedShuffling = !CdsLoadBalancer2.pickFirstWeightedShuffling;
+    try {
+      edsClustersWithRingHashEndpointLbPolicy();
+    } finally {
+      CdsLoadBalancer2.pickFirstWeightedShuffling = original;
+    }
+  }
+
+  @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(InternalEquivalentAddressGroup.ATTR_BACKEND_SERVICE))
+        .isEqualTo(CLUSTER);
+    assertThat(addr1.getAttributes().get(io.grpc.xds.XdsAttributes.ATTR_SERVER_WEIGHT))
+        .isEqualTo(CdsLoadBalancer2.pickFirstWeightedShuffling ? 0x0AAAAAAA /* 1/12 */ : 10);
+    assertThat(addr2.getAddresses())
+        .isEqualTo(Arrays.asList(newInetSocketAddress("127.0.0.2", 8080)));
+    assertThat(addr2.getAttributes().get(InternalEquivalentAddressGroup.ATTR_BACKEND_SERVICE))
+        .isEqualTo(CLUSTER);
+    assertThat(addr2.getAttributes().get(io.grpc.xds.XdsAttributes.ATTR_SERVER_WEIGHT))
+        .isEqualTo(CdsLoadBalancer2.pickFirstWeightedShuffling ? 0x0AAAAAAA /* 1/12 */ : 10);
+    assertThat(addr3.getAddresses())
+        .isEqualTo(Arrays.asList(newInetSocketAddress("127.0.1.1", 8080)));
+    assertThat(addr3.getAttributes().get(InternalEquivalentAddressGroup.ATTR_BACKEND_SERVICE))
+        .isEqualTo(CLUSTER);
+    assertThat(addr3.getAttributes().get(io.grpc.xds.XdsAttributes.ATTR_SERVER_WEIGHT))
+        .isEqualTo(CdsLoadBalancer2.pickFirstWeightedShuffling ? 0x6AAAAAAA /* 5/6 */ : 50 * 60);
     assertThat(childBalancer.name).isEqualTo(PRIORITY_POLICY_NAME);
     PriorityLbConfig priorityLbConfig = (PriorityLbConfig) childBalancer.config;
-    assertThat(priorityLbConfig.priorities).containsExactly(priority1, priority2).inOrder();
-    PriorityChildConfig priorityChildConfig = priorityLbConfig.childConfigs.get(priority1);
+    assertThat(priorityLbConfig.priorities).containsExactly(CLUSTER + "[child1]");
+    PriorityChildConfig priorityChildConfig =
+        Iterables.getOnlyElement(priorityLbConfig.childConfigs.values());
     assertThat(priorityChildConfig.ignoreReresolution).isTrue();
-    assertThat(priorityChildConfig.policySelection.getProvider().getPolicyName())
+    assertThat(GracefulSwitchLoadBalancerAccessor.getChildProvider(priorityChildConfig.childConfig)
+          .getPolicyName())
         .isEqualTo(CLUSTER_IMPL_POLICY_NAME);
-    ClusterImplConfig clusterImplConfig =
-        (ClusterImplConfig) priorityChildConfig.policySelection.getConfig();
-    assertClusterImplConfig(clusterImplConfig, CLUSTER2, EDS_SERVICE_NAME2, LRS_SERVER_NAME, 200L,
-        tlsContext, Collections.<DropOverload>emptyList(), WEIGHTED_TARGET_POLICY_NAME);
-    WeightedTargetConfig weightedTargetConfig =
-        (WeightedTargetConfig) clusterImplConfig.childPolicy.getConfig();
-    assertThat(weightedTargetConfig.targets.keySet()).containsExactly(locality1.toString());
-    WeightedPolicySelection target = weightedTargetConfig.targets.get(locality1.toString());
-    assertThat(target.weight).isEqualTo(70);
-    assertThat(target.policySelection.getProvider().getPolicyName()).isEqualTo("round_robin");
-
-    priorityChildConfig = priorityLbConfig.childConfigs.get(priority2);
-    assertThat(priorityChildConfig.ignoreReresolution).isTrue();
-    assertThat(priorityChildConfig.policySelection.getProvider().getPolicyName())
+    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) priorityChildConfig.policySelection.getConfig();
-    assertClusterImplConfig(clusterImplConfig, CLUSTER2, EDS_SERVICE_NAME2, LRS_SERVER_NAME, 200L,
-        tlsContext, Collections.<DropOverload>emptyList(), WEIGHTED_TARGET_POLICY_NAME);
-    weightedTargetConfig = (WeightedTargetConfig) clusterImplConfig.childPolicy.getConfig();
-    assertThat(weightedTargetConfig.targets.keySet()).containsExactly(locality3.toString());
-    target = weightedTargetConfig.targets.get(locality3.toString());
-    assertThat(target.weight).isEqualTo(20);
-    assertThat(target.policySelection.getProvider().getPolicyName()).isEqualTo("round_robin");
-    List<EquivalentAddressGroup> priorityAddrs1 =
-        AddressFilter.filter(childBalancer.addresses, priority1);
-    assertThat(priorityAddrs1).hasSize(2);
-    assertAddressesEqual(Arrays.asList(endpoint1, endpoint2), priorityAddrs1);
-    List<EquivalentAddressGroup> priorityAddrs2 =
-        AddressFilter.filter(childBalancer.addresses, priority2);
-    assertThat(priorityAddrs2).hasSize(1);
-    assertAddressesEqual(Collections.singletonList(endpoint4), priorityAddrs2);
-
-    // Then deliver CLUSTER1's endpoints, one priority with one locality.
-    xdsClient.deliverClusterLoadAssignment(
-        EDS_SERVICE_NAME1, Collections.singletonMap(locality2, localityLbEndpoints2));
-
-    priorityLbConfig = (PriorityLbConfig) childBalancer.config;
+    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(priority3, priority1, priority2).inOrder();
+        .containsExactly(priority1, priority2).inOrder();
 
-    priorityChildConfig = priorityLbConfig.childConfigs.get(priority3);
-    assertThat(priorityChildConfig.ignoreReresolution).isTrue();
-    assertThat(priorityChildConfig.policySelection.getProvider().getPolicyName())
+    PriorityChildConfig priorityChildConfig1 = priorityLbConfig.childConfigs.get(priority1);
+    assertThat(priorityChildConfig1.ignoreReresolution).isTrue();
+    assertThat(GracefulSwitchLoadBalancerAccessor.getChildProvider(priorityChildConfig1.childConfig)
+        .getPolicyName())
         .isEqualTo(CLUSTER_IMPL_POLICY_NAME);
-    clusterImplConfig = (ClusterImplConfig) priorityChildConfig.policySelection.getConfig();
-    assertClusterImplConfig(clusterImplConfig, CLUSTER1, EDS_SERVICE_NAME1, LRS_SERVER_NAME, 100L,
-        tlsContext, Collections.<DropOverload>emptyList(), WEIGHTED_TARGET_POLICY_NAME);
-    weightedTargetConfig = (WeightedTargetConfig) clusterImplConfig.childPolicy.getConfig();
-    assertThat(weightedTargetConfig.targets.keySet()).containsExactly(locality2.toString());
-    target = weightedTargetConfig.targets.get(locality2.toString());
-    assertThat(target.weight).isEqualTo(10);
-    assertThat(target.policySelection.getProvider().getPolicyName()).isEqualTo("round_robin");
-    List<EquivalentAddressGroup> priorityAddrs3 =
-        AddressFilter.filter(childBalancer.addresses, priority3);
-    assertThat(priorityAddrs3).hasSize(1);
-    assertAddressesEqual(Collections.singletonList(endpoint3), priorityAddrs3);
+    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() {
-    deliverConfigWithEdsClusters();  // CLUSTER1 and CLUSTER2
-    reset(helper);
-    xdsClient.deliverResourceNotFound(EDS_SERVICE_NAME1);
-    verify(helper).updateBalancingState(eq(ConnectivityState.CONNECTING), pickerCaptor.capture());
-    PickResult result = pickerCaptor.getValue().pickSubchannel(mock(PickSubchannelArgs.class));
-    assertThat(result.getStatus().isOk()).isTrue();
-    assertThat(result.getSubchannel()).isNull();  // buffer picker expected
-
-    xdsClient.deliverResourceNotFound(EDS_SERVICE_NAME2);
+    controlPlaneService.setXdsConfig(ADS_TYPE_URL_CDS, ImmutableMap.of());
+    startXdsDepManager();
+
     verify(helper).updateBalancingState(
         eq(ConnectivityState.TRANSIENT_FAILURE), pickerCaptor.capture());
-    Status expectedError = Status.UNAVAILABLE.withDescription("No usable endpoint");
+    String expectedDescription = "Error retrieving CDS resource " + CLUSTER + " nodeID: node-id: "
+        + "NOT_FOUND: Timed out waiting for resource " + CLUSTER + " from xDS server";
+    Status expectedError = Status.UNAVAILABLE.withDescription(expectedDescription);
     assertPicker(pickerCaptor.getValue(), expectedError, null);
   }
 
   @Test
-  public void onlyEdsClusters_allResourcesRevoked_shutDownChildLbPolicy() {
-    deliverConfigWithEdsClusters();  // CLUSTER1 and CLUSTER2
-    reset(helper);
-    EquivalentAddressGroup endpoint1 = makeAddress("endpoint-addr-1");
-    EquivalentAddressGroup endpoint2 = makeAddress("endpoint-addr-2");
-    LocalityLbEndpoints localityLbEndpoints1 =
-        buildLocalityLbEndpoints(1, 10, Collections.singletonMap(endpoint1, true));
-    LocalityLbEndpoints localityLbEndpoints2 =
-        buildLocalityLbEndpoints(2, 20, Collections.singletonMap(endpoint2, true));
-    xdsClient.deliverClusterLoadAssignment(
-        EDS_SERVICE_NAME1, Collections.singletonMap(locality1, localityLbEndpoints1));
-    xdsClient.deliverClusterLoadAssignment(
-        EDS_SERVICE_NAME2, Collections.singletonMap(locality2, localityLbEndpoints2));
+  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 + " nodeID: node-id: "
+        + "NOT_FOUND: Timed out waiting for resource " + CLUSTER + " from xDS server";
+    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(2);
-    assertAddressesEqual(Arrays.asList(endpoint1, endpoint2), childBalancer.addresses);
+    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 + " nodeID: node-id: "
+        + "NOT_FOUND: Resource " + CLUSTER + " does not exist";
+    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());
 
-    xdsClient.deliverResourceNotFound(EDS_SERVICE_NAME2);
-    xdsClient.deliverResourceNotFound(EDS_SERVICE_NAME1);
+    startXdsDepManager();
+    assertThat(childBalancers).hasSize(0);  // Graceful switch handles it, so no child policies yet
     verify(helper).updateBalancingState(
         eq(ConnectivityState.TRANSIENT_FAILURE), pickerCaptor.capture());
-    Status expectedError = Status.UNAVAILABLE.withDescription("No usable endpoint");
+    String expectedDescription = "Error retrieving EDS resource " + EDS_SERVICE_NAME
+        + " nodeID: node-id: "
+        + "NOT_FOUND: Timed out waiting for resource " + EDS_SERVICE_NAME + " from xDS server";
+    Status expectedError = Status.UNAVAILABLE.withDescription(expectedDescription);
     assertPicker(pickerCaptor.getValue(), expectedError, null);
   }
 
-  private void deliverConfigWithEdsClusters() {
-    DiscoveryMechanism instance1 =
-        DiscoveryMechanism.forEds(CLUSTER1, EDS_SERVICE_NAME1, LRS_SERVER_NAME, 100L, tlsContext);
-    DiscoveryMechanism instance2 =
-        DiscoveryMechanism.forEds(CLUSTER2, EDS_SERVICE_NAME2, LRS_SERVER_NAME, 200L, tlsContext);
-    ClusterResolverConfig config =
-        new ClusterResolverConfig(Arrays.asList(instance1, instance2), weightedTarget, roundRobin);
-    deliverLbConfig(config);
-    assertThat(xdsClient.watchers.keySet()).containsExactly(EDS_SERVICE_NAME1, EDS_SERVICE_NAME2);
+  @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() {
-    deliverConfigWithSingleEdsCluster();  // CLUSTER1
-    EquivalentAddressGroup endpoint1 = makeAddress("endpoint-addr-1");
-    EquivalentAddressGroup endpoint2 = makeAddress("endpoint-addr-2");
-    LocalityLbEndpoints localityLbEndpoints =
-        buildLocalityLbEndpoints(1, 10, ImmutableMap.of(endpoint1, false, endpoint2, true));
-    xdsClient.deliverClusterLoadAssignment(
-        EDS_SERVICE_NAME1, Collections.singletonMap(locality1, localityLbEndpoints));
+    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);
-    assertThat(childBalancer.addresses).hasSize(1);
-    assertAddressesEqual(Collections.singletonList(endpoint2), childBalancer.addresses);
+    assertAddressesEqual(
+        Arrays.asList(new EquivalentAddressGroup(newInetSocketAddress("127.0.0.2", 8000))),
+        childBalancer.addresses);
   }
 
   @Test
   public void handleEdsResource_ignoreLocalitiesWithNoHealthyEndpoints() {
-    deliverConfigWithSingleEdsCluster();  // CLUSTER1
-    EquivalentAddressGroup endpoint1 = makeAddress("endpoint-addr-1");
-    EquivalentAddressGroup endpoint2 = makeAddress("endpoint-addr-2");
-    LocalityLbEndpoints localityLbEndpoints1 =
-        buildLocalityLbEndpoints(1, 10, Collections.singletonMap(endpoint1, false));
-    LocalityLbEndpoints localityLbEndpoints2 =
-        buildLocalityLbEndpoints(1, 10, Collections.singletonMap(endpoint2, true));
-    String priority = CLUSTER1 + "[priority1]";
-    xdsClient.deliverClusterLoadAssignment(
-        EDS_SERVICE_NAME1,
-        ImmutableMap.of(locality1, localityLbEndpoints1, locality2, localityLbEndpoints2));
+    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);
-    PriorityLbConfig priorityLbConfig = (PriorityLbConfig) childBalancer.config;
-    PriorityChildConfig priorityChildConfig = priorityLbConfig.childConfigs.get(priority);
-    ClusterImplConfig clusterImplConfig =
-        (ClusterImplConfig) priorityChildConfig.policySelection.getConfig();
-    WeightedTargetConfig weightedTargetConfig =
-        (WeightedTargetConfig) clusterImplConfig.childPolicy.getConfig();
-    assertThat(weightedTargetConfig.targets.keySet()).containsExactly(locality2.toString());
+    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() {
-    deliverConfigWithSingleEdsCluster();   // CLUSTER1
-    EquivalentAddressGroup endpoint1 = makeAddress("endpoint-addr-1");
-    EquivalentAddressGroup endpoint2 = makeAddress("endpoint-addr-2");
-    LocalityLbEndpoints localityLbEndpoints1 =
-        buildLocalityLbEndpoints(1, 10, Collections.singletonMap(endpoint1, false));
-    LocalityLbEndpoints localityLbEndpoints2 =
-        buildLocalityLbEndpoints(2, 10, Collections.singletonMap(endpoint2, true));
-    String priority2 = CLUSTER1 + "[priority2]";
-    xdsClient.deliverClusterLoadAssignment(
-        EDS_SERVICE_NAME1,
-        ImmutableMap.of(locality1, localityLbEndpoints1, locality2, localityLbEndpoints2));
+    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);
-    PriorityLbConfig config = (PriorityLbConfig) childBalancer.config;
-    assertThat(config.priorities).containsExactly(priority2);
+    assertThat(((PriorityLbConfig) childBalancer.config).priorities).containsExactly(priority2);
   }
 
   @Test
   public void handleEdsResource_noHealthyEndpoint() {
-    deliverConfigWithSingleEdsCluster();   // CLUSTER1
-    EquivalentAddressGroup endpoint = makeAddress("endpoint-addr-1");
-    LocalityLbEndpoints localityLbEndpoints =
-        buildLocalityLbEndpoints(1, 10, Collections.singletonMap(endpoint, false));
-    xdsClient.deliverClusterLoadAssignment(EDS_SERVICE_NAME1,
-        Collections.singletonMap(locality1, localityLbEndpoints));  // single endpoint, unhealthy
+    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).isEmpty();
+    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.UNAVAILABLE.withDescription("No usable endpoint"), null);
-  }
-
-  private void deliverConfigWithSingleEdsCluster() {
-    DiscoveryMechanism instance =
-        DiscoveryMechanism.forEds(CLUSTER1, EDS_SERVICE_NAME1, LRS_SERVER_NAME, 100L, null);
-    ClusterResolverConfig config =
-        new ClusterResolverConfig(Collections.singletonList(instance), weightedTarget, roundRobin);
-    deliverLbConfig(config);
-    assertThat(xdsClient.watchers.keySet()).containsExactly(EDS_SERVICE_NAME1);
-    assertThat(childBalancers).isEmpty();
+    Status expectedStatus = Status.UNAVAILABLE
+        .withDescription("No usable endpoint from cluster: " + CLUSTER);
+    assertPicker(pickerCaptor.getValue(), expectedStatus, null);
   }
 
   @Test
   public void onlyLogicalDnsCluster_endpointsResolved() {
-    deliverConfigWithSingleLogicalDnsCluster();
-    EquivalentAddressGroup endpoint1 = makeAddress("endpoint-addr-1");
-    EquivalentAddressGroup endpoint2 = makeAddress("endpoint-addr-2");
-    FakeNameResolver resolver = Iterables.getOnlyElement(resolvers);
-    resolver.deliverEndpointAddresses(Arrays.asList(endpoint1, endpoint2));
+    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);
@@ -443,291 +914,152 @@ public void onlyLogicalDnsCluster_endpointsResolved() {
     String priority = Iterables.getOnlyElement(priorityLbConfig.priorities);
     PriorityChildConfig priorityChildConfig = priorityLbConfig.childConfigs.get(priority);
     assertThat(priorityChildConfig.ignoreReresolution).isFalse();
-    assertThat(priorityChildConfig.policySelection.getProvider().getPolicyName())
+    assertThat(GracefulSwitchLoadBalancerAccessor.getChildProvider(priorityChildConfig.childConfig)
+        .getPolicyName())
         .isEqualTo(CLUSTER_IMPL_POLICY_NAME);
-    ClusterImplConfig clusterImplConfig =
-        (ClusterImplConfig) priorityChildConfig.policySelection.getConfig();
-    assertClusterImplConfig(clusterImplConfig, CLUSTER_DNS, null, LRS_SERVER_NAME, 100L, null,
-        Collections.<DropOverload>emptyList(), "pick_first");
-    assertAddressesEqual(Arrays.asList(endpoint1, endpoint2), childBalancer.addresses);
+    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(InternalEquivalentAddressGroup.ATTR_BACKEND_SERVICE)).isEqualTo(CLUSTER);
+    assertThat(childBalancer.addresses.get(0).getAttributes()
+        .get(XdsInternalAttributes.ATTR_ADDRESS_NAME)).isEqualTo(DNS_HOST_NAME + ":9000");
   }
 
   @Test
   public void onlyLogicalDnsCluster_handleRefreshNameResolution() {
-    deliverConfigWithSingleLogicalDnsCluster();
-    EquivalentAddressGroup endpoint1 = makeAddress("endpoint-addr-1");
-    EquivalentAddressGroup endpoint2 = makeAddress("endpoint-addr-2");
-    FakeNameResolver resolver = Iterables.getOnlyElement(resolvers);
-    resolver.deliverEndpointAddresses(Arrays.asList(endpoint1, endpoint2));
-    assertThat(resolver.refreshCount).isEqualTo(0);
-    FakeLoadBalancer childBalancer = Iterables.getOnlyElement(childBalancers);
-    childBalancer.helper.refreshNameResolution();
-    assertThat(resolver.refreshCount).isEqualTo(1);
-  }
+    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);
 
-  @Test
-  public void onlyLogicalDnsCluster_resolutionError_backoffAndRefresh() {
-    InOrder inOrder = Mockito.inOrder(helper, backoffPolicyProvider,
-        backoffPolicy1, backoffPolicy2);
-    deliverConfigWithSingleLogicalDnsCluster();
-    FakeNameResolver resolver = Iterables.getOnlyElement(resolvers);
-    Status error = Status.UNAVAILABLE.withDescription("cannot reach DNS server");
-    resolver.deliverError(error);
-    inOrder.verify(helper).updateBalancingState(
-        eq(ConnectivityState.TRANSIENT_FAILURE), pickerCaptor.capture());
-    assertPicker(pickerCaptor.getValue(), error, null);
+    verify(helper, never()).updateBalancingState(eq(ConnectivityState.TRANSIENT_FAILURE), any());
     assertThat(resolver.refreshCount).isEqualTo(0);
-    inOrder.verify(backoffPolicyProvider).get();
-    inOrder.verify(backoffPolicy1).nextBackoffNanos();
-    assertThat(fakeClock.getPendingTasks()).hasSize(1);
-    assertThat(Iterables.getOnlyElement(fakeClock.getPendingTasks()).getDelay(TimeUnit.SECONDS))
-        .isEqualTo(1L);
-    fakeClock.forwardTime(1L, TimeUnit.SECONDS);
-    assertThat(resolver.refreshCount).isEqualTo(1);
-
-    error = Status.UNKNOWN.withDescription("I am lost");
-    resolver.deliverError(error);
-    inOrder.verify(helper).updateBalancingState(
-        eq(ConnectivityState.TRANSIENT_FAILURE), pickerCaptor.capture());
-    inOrder.verify(backoffPolicy1).nextBackoffNanos();
-    assertPicker(pickerCaptor.getValue(), error, null);
-    assertThat(fakeClock.getPendingTasks()).hasSize(1);
-    assertThat(Iterables.getOnlyElement(fakeClock.getPendingTasks()).getDelay(TimeUnit.SECONDS))
-        .isEqualTo(10L);
-    fakeClock.forwardTime(10L, TimeUnit.SECONDS);
-    assertThat(resolver.refreshCount).isEqualTo(2);
-
-    // Succeed.
-    EquivalentAddressGroup endpoint1 = makeAddress("endpoint-addr-1");
-    EquivalentAddressGroup endpoint2 = makeAddress("endpoint-addr-2");
-    resolver.deliverEndpointAddresses(Arrays.asList(endpoint1, endpoint2));
-    assertThat(childBalancers).hasSize(1);
-    assertAddressesEqual(Arrays.asList(endpoint1, endpoint2),
-        Iterables.getOnlyElement(childBalancers).addresses);
-
-    assertThat(fakeClock.getPendingTasks()).isEmpty();
-    inOrder.verifyNoMoreInteractions();
-  }
-
-  @Test
-  public void onlyLogicalDnsCluster_refreshNameResolutionRaceWithResolutionError() {
-    InOrder inOrder = Mockito.inOrder(backoffPolicyProvider, backoffPolicy1, backoffPolicy2);
-    deliverConfigWithSingleLogicalDnsCluster();
-    EquivalentAddressGroup endpoint = makeAddress("endpoint-addr");
-    FakeNameResolver resolver = Iterables.getOnlyElement(resolvers);
-    resolver.deliverEndpointAddresses(Collections.singletonList(endpoint));
     FakeLoadBalancer childBalancer = Iterables.getOnlyElement(childBalancers);
-    assertAddressesEqual(Collections.singletonList(endpoint), childBalancer.addresses);
-    assertThat(resolver.refreshCount).isEqualTo(0);
-
     childBalancer.helper.refreshNameResolution();
     assertThat(resolver.refreshCount).isEqualTo(1);
-    resolver.deliverError(Status.UNAVAILABLE.withDescription("I am lost"));
-    inOrder.verify(backoffPolicyProvider).get();
-    inOrder.verify(backoffPolicy1).nextBackoffNanos();
-    assertThat(fakeClock.getPendingTasks()).hasSize(1);
-    ScheduledTask task = Iterables.getOnlyElement(fakeClock.getPendingTasks());
-    assertThat(task.getDelay(TimeUnit.SECONDS)).isEqualTo(1L);
-
-    fakeClock.forwardTime( 100L, TimeUnit.MILLISECONDS);
-    childBalancer.helper.refreshNameResolution();
-    assertThat(resolver.refreshCount).isEqualTo(2);
-    assertThat(task.isCancelled()).isTrue();
-    assertThat(fakeClock.getPendingTasks()).isEmpty();
-    resolver.deliverError(Status.UNAVAILABLE.withDescription("I am still lost"));
-    inOrder.verify(backoffPolicyProvider).get();  // active refresh resets backoff sequence
-    inOrder.verify(backoffPolicy2).nextBackoffNanos();
-    task = Iterables.getOnlyElement(fakeClock.getPendingTasks());
-    assertThat(task.getDelay(TimeUnit.SECONDS)).isEqualTo(5L);
-
-    fakeClock.forwardTime(5L, TimeUnit.SECONDS);
-    assertThat(resolver.refreshCount).isEqualTo(3);
-    inOrder.verifyNoMoreInteractions();
-  }
-
-  private void deliverConfigWithSingleLogicalDnsCluster() {
-    DiscoveryMechanism instance =
-        DiscoveryMechanism.forLogicalDns(CLUSTER_DNS, LRS_SERVER_NAME, 100L, null);
-    ClusterResolverConfig config =
-        new ClusterResolverConfig(Collections.singletonList(instance), weightedTarget, roundRobin);
-    deliverLbConfig(config);
-    assertThat(resolvers).hasSize(1);
-    assertThat(childBalancers).isEmpty();
   }
 
   @Test
-  public void edsClustersAndLogicalDnsCluster_receivedEndpoints() {
-    deliverConfigWithEdsAndLogicalDnsClusters();  // CLUSTER1 and CLUSTER_DNS
-    EquivalentAddressGroup endpoint1 = makeAddress("endpoint-addr-1");  // DNS endpoint
-    EquivalentAddressGroup endpoint2 = makeAddress("endpoint-addr-2");  // DNS endpoint
-    EquivalentAddressGroup endpoint3 = makeAddress("endpoint-addr-3");  // EDS endpoint
-    FakeNameResolver resolver = Iterables.getOnlyElement(resolvers);
-    resolver.deliverEndpointAddresses(Arrays.asList(endpoint1, endpoint2));
-    LocalityLbEndpoints localityLbEndpoints =
-        buildLocalityLbEndpoints(1, 10, Collections.singletonMap(endpoint3, true));
-    xdsClient.deliverClusterLoadAssignment(
-        EDS_SERVICE_NAME1, Collections.singletonMap(locality1, localityLbEndpoints));
+  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(((PriorityLbConfig) childBalancer.config).priorities)
-        .containsExactly(CLUSTER1 + "[priority1]", CLUSTER_DNS + "[priority0]").inOrder();
-    assertAddressesEqual(Arrays.asList(endpoint3, endpoint1, endpoint2),
-        childBalancer.addresses);  // ordered by cluster then addresses
-    assertAddressesEqual(AddressFilter.filter(AddressFilter.filter(
-        childBalancer.addresses, CLUSTER1 + "[priority1]"), locality1.toString()),
-        Collections.singletonList(endpoint3));
-    assertAddressesEqual(AddressFilter.filter(AddressFilter.filter(
-        childBalancer.addresses, CLUSTER_DNS + "[priority0]"),
-        Locality.create("", "", "").toString()),
-        Arrays.asList(endpoint1, endpoint2));
+    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 noEdsResourceExists_useDnsResolutionResults() {
-    deliverConfigWithEdsAndLogicalDnsClusters();
-    reset(helper);
-    xdsClient.deliverResourceNotFound(EDS_SERVICE_NAME1);
-    verify(helper).updateBalancingState(eq(ConnectivityState.CONNECTING), pickerCaptor.capture());
-    PickResult result = pickerCaptor.getValue().pickSubchannel(mock(PickSubchannelArgs.class));
-    assertThat(result.getStatus().isOk()).isTrue();
-    assertThat(result.getSubchannel()).isNull();  // buffer picker expected, waiting for DNS
-
-    FakeNameResolver resolver = Iterables.getOnlyElement(resolvers);
-    EquivalentAddressGroup endpoint1 = makeAddress("endpoint-addr-1");
-    EquivalentAddressGroup endpoint2 = makeAddress("endpoint-addr-2");
-    resolver.deliverEndpointAddresses(Arrays.asList(endpoint1, endpoint2));
-    assertThat(childBalancers).hasSize(1);
-    FakeLoadBalancer childBalancer = Iterables.getOnlyElement(childBalancers);
-    String priority = Iterables.getOnlyElement(
-        ((PriorityLbConfig) childBalancer.config).priorities);
-    assertThat(priority).isEqualTo(CLUSTER_DNS + "[priority0]");
-    assertAddressesEqual(Arrays.asList(endpoint1, endpoint2), childBalancer.addresses);
-  }
+  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();
 
-  @Test
-  public void edsResourceRevoked_dnsResolutionError_shutDownChildLbPolicyAndReturnErrorPicker() {
-    deliverConfigWithEdsAndLogicalDnsClusters();
-    reset(helper);
-    EquivalentAddressGroup endpoint = makeAddress("endpoint-addr-1");
-    LocalityLbEndpoints localityLbEndpoints =
-        buildLocalityLbEndpoints(1, 10, Collections.singletonMap(endpoint, true));
-    xdsClient.deliverClusterLoadAssignment(
-        EDS_SERVICE_NAME1, Collections.singletonMap(locality1, localityLbEndpoints));
-    FakeNameResolver resolver = Iterables.getOnlyElement(resolvers);
-    resolver.deliverError(Status.UNKNOWN.withDescription("I am lost"));
+    verify(helper, never()).updateBalancingState(eq(ConnectivityState.TRANSIENT_FAILURE), any());
     assertThat(childBalancers).hasSize(1);
     FakeLoadBalancer childBalancer = Iterables.getOnlyElement(childBalancers);
-    assertThat(((PriorityLbConfig) childBalancer.config).priorities)
-        .containsExactly(CLUSTER1 + "[priority1]");
-    assertAddressesEqual(Collections.singletonList(endpoint), childBalancer.addresses);
-    assertThat(childBalancer.shutdown).isFalse();
-    xdsClient.deliverResourceNotFound(EDS_SERVICE_NAME1);
-    assertThat(childBalancer.shutdown).isTrue();
-    verify(helper).updateBalancingState(
-        eq(ConnectivityState.TRANSIENT_FAILURE), pickerCaptor.capture());
-    assertPicker(pickerCaptor.getValue(),
-        Status.UNAVAILABLE.withDescription("No usable endpoint"), null);
+    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");
   }
 
-  @Test
-  public void resolutionErrorAfterChildLbCreated_propagateErrorIfAllClustersEncounterError() {
-    deliverConfigWithEdsAndLogicalDnsClusters();
-    reset(helper);
-    EquivalentAddressGroup endpoint = makeAddress("endpoint-addr-1");
-    LocalityLbEndpoints localityLbEndpoints =
-        buildLocalityLbEndpoints(1, 10, Collections.singletonMap(endpoint, true));
-    xdsClient.deliverClusterLoadAssignment(
-        EDS_SERVICE_NAME1, Collections.singletonMap(locality1, localityLbEndpoints));
-    FakeLoadBalancer childBalancer = Iterables.getOnlyElement(childBalancers);  // child LB created
-    FakeNameResolver resolver = Iterables.getOnlyElement(resolvers);
-    resolver.deliverError(Status.UNKNOWN.withDescription("I am lost"));
-    assertThat(childBalancer.upstreamError).isNull();  // should not propagate error to child LB
-    xdsClient.deliverError(Status.RESOURCE_EXHAUSTED.withDescription("out of memory"));
-    assertThat(childBalancer.upstreamError).isNotNull();  // last cluster's (DNS) error propagated
-    assertThat(childBalancer.upstreamError.getCode()).isEqualTo(Code.UNKNOWN);
-    assertThat(childBalancer.upstreamError.getDescription()).isEqualTo("I am lost");
-    assertThat(childBalancer.shutdown).isFalse();
-    verify(helper, never()).updateBalancingState(
-        eq(ConnectivityState.TRANSIENT_FAILURE), any(SubchannelPicker.class));
+  private void startXdsDepManager() {
+    startXdsDepManager(new CdsConfig(CLUSTER));
   }
 
-  @Test
-  public void resolutionErrorBeforeChildLbCreated_returnErrorPickerIfAllClustersEncounterError() {
-    deliverConfigWithEdsAndLogicalDnsClusters();
-    reset(helper);
-    xdsClient.deliverError(Status.UNIMPLEMENTED.withDescription("not found"));
-    assertThat(childBalancers).isEmpty();
-    verify(helper, never()).updateBalancingState(
-        eq(ConnectivityState.TRANSIENT_FAILURE), any(SubchannelPicker.class));  // wait for DNS
-    FakeNameResolver resolver = Iterables.getOnlyElement(resolvers);
-    Status dnsError = Status.UNKNOWN.withDescription("I am lost");
-    resolver.deliverError(dnsError);
-    verify(helper).updateBalancingState(
-        eq(ConnectivityState.TRANSIENT_FAILURE), pickerCaptor.capture());
-    assertPicker(pickerCaptor.getValue(), dnsError, null);
+  private void startXdsDepManager(final CdsConfig cdsConfig) {
+    startXdsDepManager(cdsConfig, true);
   }
 
-  @Test
-  public void handleNameResolutionErrorFromUpstream_beforeChildLbCreated_returnErrorPicker() {
-    deliverConfigWithEdsAndLogicalDnsClusters();
-    reset(helper);
-    Status upstreamError = Status.UNAVAILABLE.withDescription("unreachable");
-    loadBalancer.handleNameResolutionError(upstreamError);
-    verify(helper).updateBalancingState(
-        eq(ConnectivityState.TRANSIENT_FAILURE), pickerCaptor.capture());
-    assertPicker(pickerCaptor.getValue(), upstreamError, null);
+  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);
+    }
   }
 
-  @Test
-  public void handleNameResolutionErrorFromUpstream_afterChildLbCreated_fallThrough() {
-    deliverConfigWithEdsAndLogicalDnsClusters();
-    reset(helper);
-    EquivalentAddressGroup endpoint1 = makeAddress("endpoint-addr-1");
-    EquivalentAddressGroup endpoint2 = makeAddress("endpoint-addr-2");
-    LocalityLbEndpoints localityLbEndpoints =
-        buildLocalityLbEndpoints(1, 10, Collections.singletonMap(endpoint1, true));
-    xdsClient.deliverClusterLoadAssignment(
-        EDS_SERVICE_NAME1, Collections.singletonMap(locality1, localityLbEndpoints));
-    FakeNameResolver resolver = Iterables.getOnlyElement(resolvers);
-    resolver.deliverEndpointAddresses(Collections.singletonList(endpoint2));
-    assertThat(childBalancers).hasSize(1);
-    FakeLoadBalancer childBalancer = Iterables.getOnlyElement(childBalancers);
-    assertThat(((PriorityLbConfig) childBalancer.config).priorities)
-        .containsExactly(CLUSTER1 + "[priority1]", CLUSTER_DNS + "[priority0]");
-    assertAddressesEqual(Arrays.asList(endpoint1, endpoint2), childBalancer.addresses);
-
-    loadBalancer.handleNameResolutionError(Status.UNAVAILABLE.withDescription("unreachable"));
-    assertThat(childBalancer.upstreamError.getCode()).isEqualTo(Code.UNAVAILABLE);
-    assertThat(childBalancer.upstreamError.getDescription()).isEqualTo("unreachable");
-    verify(helper, never()).updateBalancingState(
-        any(ConnectivityState.class), any(SubchannelPicker.class));
-  }
-
-  private void deliverConfigWithEdsAndLogicalDnsClusters() {
-    DiscoveryMechanism instance1 =
-        DiscoveryMechanism.forEds(CLUSTER1, EDS_SERVICE_NAME1, LRS_SERVER_NAME, 100L, null);
-    DiscoveryMechanism instance2 =
-        DiscoveryMechanism.forLogicalDns(CLUSTER_DNS, LRS_SERVER_NAME, 200L, null);
-    ClusterResolverConfig config =
-        new ClusterResolverConfig(Arrays.asList(instance1, instance2), weightedTarget, roundRobin);
-    deliverLbConfig(config);
-    assertThat(xdsClient.watchers.keySet()).containsExactly(EDS_SERVICE_NAME1);
+  private FakeNameResolver assertResolverCreated(String uriPath) {
     assertThat(resolvers).hasSize(1);
-    assertThat(childBalancers).isEmpty();
-  }
-
-  private void deliverLbConfig(ClusterResolverConfig config) {
-    loadBalancer.handleResolvedAddresses(
-        ResolvedAddresses.newBuilder()
-            .setAddresses(Collections.<EquivalentAddressGroup>emptyList())
-            .setAttributes(
-                // Other attributes not used by cluster_resolver LB are omitted.
-                Attributes.newBuilder()
-                    .set(InternalXdsAttributes.XDS_CLIENT_POOL, xdsClientPool)
-                    .build())
-            .setLoadBalancingPolicyConfig(config)
-            .build());
+    FakeNameResolver resolver = Iterables.getOnlyElement(resolvers);
+    assertThat(resolver.targetUri.getPath()).isEqualTo(uriPath);
+    return resolver;
   }
 
   private static void assertPicker(SubchannelPicker picker, Status expectedStatus,
@@ -742,133 +1074,65 @@ private static void assertPicker(SubchannelPicker picker, Status expectedStatus,
   }
 
   private static void assertClusterImplConfig(ClusterImplConfig config, String cluster,
-      @Nullable String edsServiceName, String lrsServerName, Long maxConcurrentRequests,
+      @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.lrsServerName).isEqualTo(lrsServerName);
+    assertThat(config.lrsServerInfo).isEqualTo(lrsServerInfo);
     assertThat(config.maxConcurrentRequests).isEqualTo(maxConcurrentRequests);
     assertThat(config.tlsContext).isEqualTo(tlsContext);
     assertThat(config.dropCategories).isEqualTo(dropCategories);
-    assertThat(config.childPolicy.getProvider().getPolicyName()).isEqualTo(childPolicy);
+    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) {
-    assertThat(actual.size()).isEqualTo(expected.size());
-    for (int i = 0; i < actual.size(); i++) {
-      assertThat(actual.get(i).getAddresses()).isEqualTo(expected.get(i).getAddresses());
-    }
+    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);
   }
 
-  private static LocalityLbEndpoints buildLocalityLbEndpoints(
-      int priority, int localityWeight, Map<EquivalentAddressGroup, Boolean> managedEndpoints) {
-    List<LbEndpoint> endpoints = new ArrayList<>();
-    for (EquivalentAddressGroup addr : managedEndpoints.keySet()) {
-      boolean status = managedEndpoints.get(addr);
-      endpoints.add(LbEndpoint.create(addr, 100 /* unused */, status));
-    }
-    return LocalityLbEndpoints.create(endpoints, localityWeight, priority);
+  @SuppressWarnings("AddressSelection")
+  private static InetSocketAddress newInetSocketAddress(String ip, int port) {
+    return new InetSocketAddress(ip, port);
   }
 
-  private static EquivalentAddressGroup makeAddress(final String name) {
-    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;
-      }
-    }
-
-    return new EquivalentAddressGroup(new FakeSocketAddress(name));
+  private static EquivalentAddressGroup newInetSocketAddressEag(String ip, int port) {
+    return new EquivalentAddressGroup(newInetSocketAddress(ip, port));
   }
 
-  private static final class FakeXdsClient extends XdsClient {
-    private final Map<String, EdsResourceWatcher> watchers = new HashMap<>();
-
-    @Override
-    void watchEdsResource(String resourceName, EdsResourceWatcher watcher) {
-      assertThat(watchers).doesNotContainKey(resourceName);
-      watchers.put(resourceName, watcher);
-    }
-
-    @Override
-    void cancelEdsResourceWatch(String resourceName, EdsResourceWatcher watcher) {
-      assertThat(watchers).containsKey(resourceName);
-      watchers.remove(resourceName);
-    }
-
-    void deliverClusterLoadAssignment(
-        String resource, Map<Locality, LocalityLbEndpoints> localityLbEndpointsMap) {
-      deliverClusterLoadAssignment(
-          resource, Collections.<DropOverload>emptyList(), localityLbEndpointsMap);
-    }
-
-    void deliverClusterLoadAssignment(String resource, List<DropOverload> dropOverloads,
-        Map<Locality, LocalityLbEndpoints> localityLbEndpointsMap) {
-      if (watchers.containsKey(resource)) {
-        watchers.get(resource).onChanged(
-            new EdsUpdate(resource, localityLbEndpointsMap, dropOverloads));
-      }
-    }
-
-    void deliverResourceNotFound(String resource) {
-      if (watchers.containsKey(resource)) {
-        watchers.get(resource).onResourceDoesNotExist(resource);
-      }
-    }
+  private static LbEndpoint.Builder newSocketLbEndpoint(String ip, int port) {
+    return LbEndpoint.newBuilder()
+        .setEndpoint(Endpoint.newBuilder()
+          .setAddress(newAddress(ip, port)))
+        .setHealthStatus(HealthStatus.HEALTHY);
+  }
 
-    void deliverError(Status error) {
-      for (EdsResourceWatcher watcher : watchers.values()) {
-        watcher.onError(error);
-      }
-    }
+  private static Address.Builder newAddress(String ip, int port) {
+    return Address.newBuilder()
+        .setSocketAddress(SocketAddress.newBuilder()
+            .setAddress(ip)
+            .setPortValue(port));
   }
 
   private class FakeNameResolverProvider extends NameResolverProvider {
-    private final URI expectedUri;
-
-    FakeNameResolverProvider(URI expectedUri) {
-      this.expectedUri = expectedUri;
-    }
-
     @Override
     public NameResolver newNameResolver(URI targetUri, NameResolver.Args args) {
-      if (expectedUri.equals(targetUri)) {
-        FakeNameResolver resolver = new FakeNameResolver(targetUri);
-        resolvers.add(resolver);
-        return resolver;
-      }
-      return null;
+      assertThat(targetUri.getScheme()).isEqualTo("dns");
+      FakeNameResolver resolver = new FakeNameResolver(targetUri);
+      resolvers.add(resolver);
+      return resolver;
     }
 
     @Override
     public String getDefaultScheme() {
-      return "fake";
+      return "dns";
     }
 
     @Override
@@ -882,18 +1146,19 @@ protected int priority() {
     }
   }
 
+
   private class FakeNameResolver extends NameResolver {
-    private final URI uri;
-    private Listener2 listener;
+    private final URI targetUri;
+    protected Listener2 listener;
     private int refreshCount;
 
-    FakeNameResolver(URI uri) {
-      this.uri = uri;
+    private FakeNameResolver(URI targetUri) {
+      this.targetUri = targetUri;
     }
 
     @Override
     public String getServiceAuthority() {
-      return uri.getAuthority();
+      throw new UnsupportedOperationException("should not be called");
     }
 
     @Override
@@ -911,13 +1176,17 @@ public void shutdown() {
       resolvers.remove(this);
     }
 
-    private void deliverEndpointAddresses(List<EquivalentAddressGroup> addresses) {
-      listener.onResult(ResolutionResult.newBuilder().setAddresses(addresses).build());
-
+    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);
+      });
     }
 
-    private void deliverError(Status error) {
-      listener.onError(error);
+    protected void deliverError(Status error) {
+      syncContext.execute(() -> listener.onResult2(ResolutionResult.newBuilder()
+                      .setAddressesOrError(StatusOr.fromStatus(error)).build()));
     }
   }
 
@@ -956,7 +1225,6 @@ private final class FakeLoadBalancer extends LoadBalancer {
     private final Helper helper;
     private List<EquivalentAddressGroup> addresses;
     private Object config;
-    private Status upstreamError;
     private boolean shutdown;
 
     FakeLoadBalancer(String name, Helper helper) {
@@ -965,14 +1233,14 @@ private final class FakeLoadBalancer extends LoadBalancer {
     }
 
     @Override
-    public void handleResolvedAddresses(ResolvedAddresses resolvedAddresses) {
+    public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
       addresses = resolvedAddresses.getAddresses();
       config = resolvedAddresses.getLoadBalancingPolicyConfig();
+      return Status.OK;
     }
 
     @Override
     public void handleNameResolutionError(Status error) {
-      upstreamError = error;
     }
 
     @Override
@@ -980,15 +1248,5 @@ 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/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/CommonBootstrapperTestUtils.java b/xds/src/test/java/io/grpc/xds/CommonBootstrapperTestUtils.java
deleted file mode 100644
index 15a63d6c23f..00000000000
--- a/xds/src/test/java/io/grpc/xds/CommonBootstrapperTestUtils.java
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
- * 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.collect.ImmutableList;
-import com.google.common.collect.ImmutableMap;
-import io.grpc.internal.JsonParser;
-import java.io.IOException;
-import java.util.Map;
-
-public class CommonBootstrapperTestUtils {
-  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 =
-          new Bootstrapper.CertificateProviderInfo(
-              "testca", (Map<String, ?>) JsonParser.parse(MESHCA_CONFIG));
-      Bootstrapper.CertificateProviderInfo fileProvider =
-          new Bootstrapper.CertificateProviderInfo(
-              "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 =
-          new Bootstrapper.BootstrapInfo(
-              ImmutableList.<Bootstrapper.ServerInfo>of(),
-              EnvoyProtoData.Node.newBuilder().build(),
-              certProviders,
-              "grpc/server");
-      return bootstrapInfo;
-    } catch (IOException e) {
-      throw new AssertionError(e);
-    }
-  }
-}
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/EnvoyProtoDataTest.java b/xds/src/test/java/io/grpc/xds/EnvoyProtoDataTest.java
deleted file mode 100644
index 65e801c97dd..00000000000
--- a/xds/src/test/java/io/grpc/xds/EnvoyProtoDataTest.java
+++ /dev/null
@@ -1,125 +0,0 @@
-/*
- * 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.collect.ImmutableMap;
-import com.google.protobuf.Struct;
-import com.google.protobuf.Value;
-import io.grpc.xds.EnvoyProtoData.Address;
-import io.grpc.xds.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);
-
-    @SuppressWarnings("deprecation") // Deprecated v2 API setBuildVersion().
-    io.envoyproxy.envoy.api.v2.core.Node nodeProtoV2 =
-        io.envoyproxy.envoy.api.v2.core.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.api.v2.core.Locality.newBuilder()
-                    .setRegion("region")
-                    .setZone("zone")
-                    .setSubZone("subzone"))
-            .addListeningAddresses(
-                io.envoyproxy.envoy.api.v2.core.Address.newBuilder()
-                    .setSocketAddress(
-                        io.envoyproxy.envoy.api.v2.core.SocketAddress.newBuilder()
-                            .setAddress("www.foo.com")
-                            .setPortValue(8080)))
-            .addListeningAddresses(
-                io.envoyproxy.envoy.api.v2.core.Address.newBuilder()
-                    .setSocketAddress(
-                        io.envoyproxy.envoy.api.v2.core.SocketAddress.newBuilder()
-                            .setAddress("www.bar.com")
-                            .setPortValue(8088)))
-            .setBuildVersion("v1")
-            .setUserAgentName("agent")
-            .setUserAgentVersion("1.1")
-            .addClientFeatures("feature-1")
-            .addClientFeatures("feature-2")
-            .build();
-    assertThat(node.toEnvoyProtoNodeV2()).isEqualTo(nodeProtoV2);
-  }
-}
diff --git a/xds/src/test/java/io/grpc/xds/EnvoyServerProtoDataTest.java b/xds/src/test/java/io/grpc/xds/EnvoyServerProtoDataTest.java
deleted file mode 100644
index 0ee203c09c6..00000000000
--- a/xds/src/test/java/io/grpc/xds/EnvoyServerProtoDataTest.java
+++ /dev/null
@@ -1,193 +0,0 @@
-/*
- * 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.InvalidProtocolBufferException;
-import com.google.protobuf.UInt32Value;
-import io.envoyproxy.envoy.config.core.v3.Address;
-import io.envoyproxy.envoy.config.core.v3.CidrRange;
-import io.envoyproxy.envoy.config.core.v3.SocketAddress;
-import io.envoyproxy.envoy.config.core.v3.TransportSocket;
-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.extensions.transport_sockets.tls.v3.CommonTlsContext;
-import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.SdsSecretConfig;
-import io.grpc.xds.EnvoyServerProtoData.DownstreamTlsContext;
-import io.grpc.xds.EnvoyServerProtoData.Listener;
-import io.grpc.xds.internal.sds.CommonTlsContextTestsUtil;
-import java.util.List;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-
-/**
- * Unit tests for {@link EnvoyServerProtoData}.
- */
-@RunWith(JUnit4.class)
-public class EnvoyServerProtoDataTest {
-
-  @Test
-  public void listener_convertFromListenerProto() throws InvalidProtocolBufferException {
-    Address address =
-        Address.newBuilder()
-            .setSocketAddress(
-                SocketAddress.newBuilder().setPortValue(8000).setAddress("10.2.1.34").build())
-            .build();
-    io.envoyproxy.envoy.config.listener.v3.Listener listener =
-        io.envoyproxy.envoy.config.listener.v3.Listener.newBuilder()
-            .setName("8000")
-            .setAddress(address)
-            .addFilterChains(createOutFilter())
-            .addFilterChains(createInFilter())
-            .setDefaultFilterChain(createDefaultFilterChain())
-            .build();
-
-    Listener xdsListener = Listener.fromEnvoyProtoListener(listener);
-    assertThat(xdsListener.getName()).isEqualTo("8000");
-    assertThat(xdsListener.getAddress()).isEqualTo("10.2.1.34:8000");
-    List<EnvoyServerProtoData.FilterChain> filterChains = xdsListener.getFilterChains();
-    assertThat(filterChains).isNotNull();
-    assertThat(filterChains.size()).isEqualTo(2);
-    EnvoyServerProtoData.FilterChain outFilter = filterChains.get(0);
-    assertThat(outFilter).isNotNull();
-    EnvoyServerProtoData.FilterChainMatch outFilterChainMatch = outFilter.getFilterChainMatch();
-    assertThat(outFilterChainMatch).isNotNull();
-    assertThat(outFilterChainMatch.getDestinationPort()).isEqualTo(8000);
-    assertThat(outFilterChainMatch.getApplicationProtocols()).isEmpty();
-    assertThat(outFilterChainMatch.getPrefixRanges()).isEmpty();
-    assertThat(outFilter.getDownstreamTlsContext())
-        .isNull();
-
-    EnvoyServerProtoData.FilterChain inFilter = filterChains.get(1);
-    assertThat(inFilter).isNotNull();
-    EnvoyServerProtoData.FilterChainMatch inFilterChainMatch = inFilter.getFilterChainMatch();
-    assertThat(inFilterChainMatch).isNotNull();
-    assertThat(inFilterChainMatch.getDestinationPort()).isEqualTo(8000);
-    assertThat(inFilterChainMatch.getApplicationProtocols()).containsExactly("managed-mtls");
-    assertThat(inFilterChainMatch.getPrefixRanges())
-        .containsExactly(new EnvoyServerProtoData.CidrRange("10.20.0.15", 32));
-    assertThat(inFilterChainMatch.getSourcePrefixRanges())
-        .containsExactly(new EnvoyServerProtoData.CidrRange("10.30.3.0", 24));
-    assertThat(inFilterChainMatch.getConnectionSourceType())
-        .isEqualTo(EnvoyServerProtoData.ConnectionSourceType.EXTERNAL);
-    assertThat(inFilterChainMatch.getSourcePorts()).containsExactly(200, 300);
-    DownstreamTlsContext inFilterTlsContext = inFilter.getDownstreamTlsContext();
-    assertThat(inFilterTlsContext.getCommonTlsContext()).isNotNull();
-    CommonTlsContext commonTlsContext = inFilterTlsContext.getCommonTlsContext();
-    List<SdsSecretConfig> tlsCertSdsConfigs = commonTlsContext
-        .getTlsCertificateSdsSecretConfigsList();
-    assertThat(tlsCertSdsConfigs).hasSize(1);
-    assertThat(tlsCertSdsConfigs.get(0).getName()).isEqualTo("google-sds-config-default");
-
-    EnvoyServerProtoData.FilterChain defaultFilter = xdsListener.getDefaultFilterChain();
-    assertThat(defaultFilter).isNotNull();
-    EnvoyServerProtoData.FilterChainMatch defaultFilterChainMatch =
-        defaultFilter.getFilterChainMatch();
-    assertThat(defaultFilterChainMatch).isNotNull();
-    assertThat(defaultFilterChainMatch.getDestinationPort()).isEqualTo(8001);
-    assertThat(defaultFilterChainMatch.getPrefixRanges())
-        .containsExactly(new EnvoyServerProtoData.CidrRange("10.20.0.16", 30));
-  }
-
-  private static FilterChain createOutFilter() {
-    FilterChain filterChain =
-        FilterChain.newBuilder()
-            .setFilterChainMatch(
-                FilterChainMatch.newBuilder()
-                    .setDestinationPort(UInt32Value.of(8000))
-                    .build())
-            .addFilters(Filter.newBuilder()
-                .setName("envoy.http_connection_manager")
-                .build())
-            .build();
-    return filterChain;
-  }
-
-  private static FilterChain createInFilter() {
-    FilterChain filterChain =
-        FilterChain.newBuilder()
-            .setFilterChainMatch(
-                FilterChainMatch.newBuilder()
-                    .setDestinationPort(UInt32Value.of(8000))
-                    .addPrefixRanges(CidrRange.newBuilder()
-                        .setAddressPrefix("10.20.0.15")
-                        .setPrefixLen(UInt32Value.of(32))
-                        .build())
-                    .addSourcePrefixRanges(
-                        CidrRange.newBuilder()
-                            .setAddressPrefix("10.30.3.0")
-                            .setPrefixLen(UInt32Value.of(24))
-                            .build())
-                    .addApplicationProtocols("managed-mtls")
-                    .setSourceType(FilterChainMatch.ConnectionSourceType.EXTERNAL)
-                    .addSourcePorts(200)
-                    .addSourcePorts(300)
-                    .build())
-            .setTransportSocket(TransportSocket.newBuilder().setName("envoy.transport_sockets.tls")
-                .setTypedConfig(
-                    Any.pack(CommonTlsContextTestsUtil.buildTestDownstreamTlsContext(
-                        "google-sds-config-default", "ROOTCA")))
-                .build())
-            .addFilters(Filter.newBuilder()
-                .setName("envoy.http_connection_manager")
-                .setTypedConfig(Any.newBuilder()
-                    .setTypeUrl(
-                        "type.googleapis.com/envoy.config.filter.network.http_connection_manager"
-                            + ".v2.HttpConnectionManager"))
-                .build())
-            .build();
-    return filterChain;
-  }
-
-  private static FilterChain createDefaultFilterChain() {
-    FilterChain filterChain =
-        FilterChain.newBuilder()
-            .setFilterChainMatch(
-                FilterChainMatch.newBuilder()
-                    .setDestinationPort(UInt32Value.of(8001))
-                    .addPrefixRanges(
-                        CidrRange.newBuilder()
-                            .setAddressPrefix("10.20.0.16")
-                            .setPrefixLen(UInt32Value.of(30))
-                            .build())
-                    .build())
-            .setTransportSocket(
-                TransportSocket.newBuilder()
-                    .setName("envoy.transport_sockets.tls")
-                    .setTypedConfig(
-                        Any.pack(
-                            CommonTlsContextTestsUtil.buildTestDownstreamTlsContext(
-                                "google-sds-config-default", "ROOTCA")))
-                    .build())
-            .addFilters(
-                Filter.newBuilder()
-                    .setName("envoy.http_connection_manager")
-                    .setTypedConfig(
-                        Any.newBuilder()
-                            .setTypeUrl(
-                                "type.googleapis.com/"
-                                    + "envoy.config.filter.network.http_connection_manager"
-                                    + ".v2.HttpConnectionManager"))
-                    .build())
-            .build();
-    return filterChain;
-  }
-}
diff --git a/xds/src/test/java/io/grpc/xds/ExtAuthzConfigParserTest.java b/xds/src/test/java/io/grpc/xds/ExtAuthzConfigParserTest.java
new file mode 100644
index 00000000000..fa2718cbe63
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/ExtAuthzConfigParserTest.java
@@ -0,0 +1,297 @@
+/*
+ * 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 static org.junit.Assert.fail;
+
+import com.google.protobuf.Any;
+import com.google.protobuf.BoolValue;
+import io.envoyproxy.envoy.config.common.mutation_rules.v3.HeaderMutationRules;
+import io.envoyproxy.envoy.config.core.v3.GrpcService;
+import io.envoyproxy.envoy.config.core.v3.HeaderValue;
+import io.envoyproxy.envoy.config.core.v3.RuntimeFeatureFlag;
+import io.envoyproxy.envoy.config.core.v3.RuntimeFractionalPercent;
+import io.envoyproxy.envoy.extensions.filters.http.ext_authz.v3.ExtAuthz;
+import io.envoyproxy.envoy.extensions.grpc_service.call_credentials.access_token.v3.AccessTokenCredentials;
+import io.envoyproxy.envoy.extensions.grpc_service.channel_credentials.google_default.v3.GoogleDefaultCredentials;
+import io.envoyproxy.envoy.type.matcher.v3.ListStringMatcher;
+import io.envoyproxy.envoy.type.matcher.v3.RegexMatcher;
+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.grpc.Status;
+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.internal.Matchers;
+import io.grpc.xds.internal.extauthz.ExtAuthzConfig;
+import io.grpc.xds.internal.extauthz.ExtAuthzParseException;
+import io.grpc.xds.internal.headermutations.HeaderMutationRulesConfig;
+import java.util.Collections;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class ExtAuthzConfigParserTest {
+
+  private static final Any GOOGLE_DEFAULT_CHANNEL_CREDS =
+      Any.pack(GoogleDefaultCredentials.newBuilder().build());
+  private static final Any FAKE_ACCESS_TOKEN_CALL_CREDS =
+      Any.pack(AccessTokenCredentials.newBuilder().setToken("fake-token").build());
+
+  private static BootstrapInfo dummyBootstrapInfo() {
+    return BootstrapInfo.builder()
+        .servers(
+            Collections.singletonList(ServerInfo.create("test_target", Collections.emptyMap())))
+        .node(Node.newBuilder().build()).build();
+  }
+
+  private static ServerInfo dummyServerInfo() {
+    return ServerInfo.create("test_target", Collections.emptyMap(), false, true, false, false);
+  }
+
+  private ExtAuthz.Builder extAuthzBuilder;
+
+  @Before
+  public void setUp() {
+    extAuthzBuilder = ExtAuthz.newBuilder()
+        .setGrpcService(GrpcService.newBuilder().setGoogleGrpc(GrpcService.GoogleGrpc.newBuilder()
+                .setTargetUri("test-cluster")
+                .addChannelCredentialsPlugin(GOOGLE_DEFAULT_CHANNEL_CREDS)
+                .addCallCredentialsPlugin(FAKE_ACCESS_TOKEN_CALL_CREDS).build())
+            .build());
+  }
+
+  @Test
+  public void parse_missingGrpcService_throws() {
+    ExtAuthz extAuthz = ExtAuthz.newBuilder().build();
+    try {
+      ExtAuthzConfigParser.parse(extAuthz, 
+          dummyBootstrapInfo(),
+          dummyServerInfo());
+      fail("Expected ExtAuthzParseException");
+    } catch (ExtAuthzParseException e) {
+      assertThat(e).hasMessageThat()
+          .isEqualTo("unsupported ExtAuthz service type: only grpc_service is supported");
+    }
+  }
+
+  @Test
+  public void parse_invalidGrpcService_throws() {
+    ExtAuthz extAuthz = ExtAuthz.newBuilder()
+        .setGrpcService(GrpcService.newBuilder().build())
+        .build();
+    try {
+      ExtAuthzConfigParser.parse(extAuthz, 
+          dummyBootstrapInfo(),
+          dummyServerInfo());
+      fail("Expected ExtAuthzParseException");
+    } catch (ExtAuthzParseException e) {
+      assertThat(e).hasMessageThat().startsWith("Failed to parse GrpcService config:");
+    }
+  }
+
+  @Test
+  public void parse_invalidAllowExpression_throws() {
+    ExtAuthz extAuthz = extAuthzBuilder
+        .setDecoderHeaderMutationRules(HeaderMutationRules.newBuilder()
+            .setAllowExpression(RegexMatcher.newBuilder().setRegex("[invalid").build()).build())
+        .build();
+    try {
+      ExtAuthzConfigParser.parse(extAuthz, 
+          dummyBootstrapInfo(),
+          dummyServerInfo());
+      fail("Expected ExtAuthzParseException");
+    } catch (ExtAuthzParseException e) {
+      assertThat(e).hasMessageThat().startsWith("Invalid regex pattern for allow_expression:");
+    }
+  }
+
+  @Test
+  public void parse_invalidDisallowExpression_throws() {
+    ExtAuthz extAuthz = extAuthzBuilder
+        .setDecoderHeaderMutationRules(HeaderMutationRules.newBuilder()
+            .setDisallowExpression(RegexMatcher.newBuilder().setRegex("[invalid").build()).build())
+        .build();
+    try {
+      ExtAuthzConfigParser.parse(extAuthz, 
+          dummyBootstrapInfo(),
+          dummyServerInfo());
+      fail("Expected ExtAuthzParseException");
+    } catch (ExtAuthzParseException e) {
+      assertThat(e).hasMessageThat().startsWith("Invalid regex pattern for disallow_expression:");
+    }
+  }
+
+  @Test
+  public void parse_success() throws ExtAuthzParseException {
+    ExtAuthz extAuthz =
+        extAuthzBuilder
+            .setGrpcService(extAuthzBuilder.getGrpcServiceBuilder()
+                .setTimeout(com.google.protobuf.Duration.newBuilder().setSeconds(5).build())
+                .addInitialMetadata(
+                    HeaderValue.newBuilder().setKey("key").setValue("value").build())
+                .build())
+            .setFailureModeAllow(true).setFailureModeAllowHeaderAdd(true)
+            .setIncludePeerCertificate(true)
+            .setStatusOnError(
+                io.envoyproxy.envoy.type.v3.HttpStatus.newBuilder().setCodeValue(403).build())
+            .setDenyAtDisable(
+                RuntimeFeatureFlag.newBuilder().setDefaultValue(BoolValue.of(true)).build())
+            .setFilterEnabled(RuntimeFractionalPercent.newBuilder()
+                .setDefaultValue(FractionalPercent.newBuilder().setNumerator(50)
+                    .setDenominator(DenominatorType.TEN_THOUSAND).build())
+                .build())
+            .setAllowedHeaders(ListStringMatcher.newBuilder()
+                .addPatterns(StringMatcher.newBuilder().setExact("allowed-header").build()).build())
+            .setDisallowedHeaders(ListStringMatcher.newBuilder()
+                .addPatterns(StringMatcher.newBuilder().setPrefix("disallowed-").build()).build())
+            .setDecoderHeaderMutationRules(HeaderMutationRules.newBuilder()
+                .setAllowExpression(RegexMatcher.newBuilder().setRegex("allow.*").build())
+                .setDisallowExpression(RegexMatcher.newBuilder().setRegex("disallow.*").build())
+                .setDisallowAll(BoolValue.of(true)).setDisallowIsError(BoolValue.of(true)).build())
+            .build();
+
+    ExtAuthzConfig config = ExtAuthzConfigParser.parse(extAuthz, 
+          dummyBootstrapInfo(),
+          dummyServerInfo());
+
+    assertThat(config.grpcService().googleGrpc().target()).isEqualTo("test-cluster");
+    assertThat(config.grpcService().timeout().get().getSeconds()).isEqualTo(5);
+    assertThat(config.grpcService().initialMetadata()).isNotEmpty();
+    assertThat(config.failureModeAllow()).isTrue();
+    assertThat(config.failureModeAllowHeaderAdd()).isTrue();
+    assertThat(config.includePeerCertificate()).isTrue();
+    assertThat(config.statusOnError().getCode()).isEqualTo(Status.PERMISSION_DENIED.getCode());
+    assertThat(config.statusOnError().getDescription()).isEqualTo("HTTP status code 403");
+    assertThat(config.denyAtDisable()).isTrue();
+    assertThat(config.filterEnabled()).isEqualTo(Matchers.FractionMatcher.create(50, 10_000));
+    assertThat(config.allowedHeaders()).hasSize(1);
+    assertThat(config.allowedHeaders().get(0).matches("allowed-header")).isTrue();
+    assertThat(config.disallowedHeaders()).hasSize(1);
+    assertThat(config.disallowedHeaders().get(0).matches("disallowed-foo")).isTrue();
+    assertThat(config.decoderHeaderMutationRules().isPresent()).isTrue();
+    HeaderMutationRulesConfig rules = config.decoderHeaderMutationRules().get();
+    assertThat(rules.allowExpression().get().pattern()).isEqualTo("allow.*");
+    assertThat(rules.disallowExpression().get().pattern()).isEqualTo("disallow.*");
+    assertThat(rules.disallowAll()).isTrue();
+    assertThat(rules.disallowIsError()).isTrue();
+  }
+
+  @Test
+  public void parse_saneDefaults() throws ExtAuthzParseException {
+    ExtAuthz extAuthz = extAuthzBuilder.build();
+
+    ExtAuthzConfig config = ExtAuthzConfigParser.parse(extAuthz, 
+          dummyBootstrapInfo(),
+          dummyServerInfo());
+
+    assertThat(config.failureModeAllow()).isFalse();
+    assertThat(config.failureModeAllowHeaderAdd()).isFalse();
+    assertThat(config.includePeerCertificate()).isFalse();
+    assertThat(config.statusOnError()).isEqualTo(Status.PERMISSION_DENIED);
+    assertThat(config.denyAtDisable()).isFalse();
+    assertThat(config.filterEnabled()).isEqualTo(Matchers.FractionMatcher.create(100, 100));
+    assertThat(config.allowedHeaders()).isEmpty();
+    assertThat(config.disallowedHeaders()).isEmpty();
+    assertThat(config.decoderHeaderMutationRules().isPresent()).isFalse();
+  }
+
+  @Test
+  public void parse_headerMutationRules_allowExpressionOnly() throws ExtAuthzParseException {
+    ExtAuthz extAuthz = extAuthzBuilder
+        .setDecoderHeaderMutationRules(HeaderMutationRules.newBuilder()
+            .setAllowExpression(RegexMatcher.newBuilder().setRegex("allow.*").build()).build())
+        .build();
+
+    ExtAuthzConfig config = ExtAuthzConfigParser.parse(extAuthz, 
+          dummyBootstrapInfo(),
+          dummyServerInfo());
+
+    assertThat(config.decoderHeaderMutationRules().isPresent()).isTrue();
+    HeaderMutationRulesConfig rules = config.decoderHeaderMutationRules().get();
+    assertThat(rules.allowExpression().get().pattern()).isEqualTo("allow.*");
+    assertThat(rules.disallowExpression().isPresent()).isFalse();
+  }
+
+  @Test
+  public void parse_headerMutationRules_disallowExpressionOnly() throws ExtAuthzParseException {
+    ExtAuthz extAuthz =
+        extAuthzBuilder.setDecoderHeaderMutationRules(HeaderMutationRules.newBuilder()
+            .setDisallowExpression(RegexMatcher.newBuilder().setRegex("disallow.*").build())
+            .build()).build();
+
+    ExtAuthzConfig config = ExtAuthzConfigParser.parse(extAuthz, 
+          dummyBootstrapInfo(),
+          dummyServerInfo());
+
+    assertThat(config.decoderHeaderMutationRules().isPresent()).isTrue();
+    HeaderMutationRulesConfig rules = config.decoderHeaderMutationRules().get();
+    assertThat(rules.allowExpression().isPresent()).isFalse();
+    assertThat(rules.disallowExpression().get().pattern()).isEqualTo("disallow.*");
+  }
+
+  @Test
+  public void parse_filterEnabled_hundred() throws ExtAuthzParseException {
+    ExtAuthz extAuthz = extAuthzBuilder
+        .setFilterEnabled(RuntimeFractionalPercent.newBuilder().setDefaultValue(FractionalPercent
+            .newBuilder().setNumerator(25).setDenominator(DenominatorType.HUNDRED).build()).build())
+        .build();
+
+    ExtAuthzConfig config = ExtAuthzConfigParser.parse(extAuthz, 
+          dummyBootstrapInfo(),
+          dummyServerInfo());
+
+    assertThat(config.filterEnabled()).isEqualTo(Matchers.FractionMatcher.create(25, 100));
+  }
+
+  @Test
+  public void parse_filterEnabled_million() throws ExtAuthzParseException {
+    ExtAuthz extAuthz = extAuthzBuilder
+        .setFilterEnabled(
+            RuntimeFractionalPercent.newBuilder().setDefaultValue(FractionalPercent.newBuilder()
+                .setNumerator(123456).setDenominator(DenominatorType.MILLION).build()).build())
+        .build();
+
+    ExtAuthzConfig config = ExtAuthzConfigParser.parse(extAuthz, 
+          dummyBootstrapInfo(),
+          dummyServerInfo());
+
+    assertThat(config.filterEnabled())
+        .isEqualTo(Matchers.FractionMatcher.create(123456, 1_000_000));
+  }
+
+  @Test
+  public void parse_filterEnabled_unrecognizedDenominator() {
+    ExtAuthz extAuthz = extAuthzBuilder.setFilterEnabled(RuntimeFractionalPercent.newBuilder()
+        .setDefaultValue(
+            FractionalPercent.newBuilder().setNumerator(1).setDenominatorValue(4).build())
+        .build()).build();
+
+    try {
+      ExtAuthzConfigParser.parse(extAuthz, 
+          dummyBootstrapInfo(),
+          dummyServerInfo());
+      fail("Expected ExtAuthzParseException");
+    } catch (ExtAuthzParseException e) {
+      assertThat(e).hasMessageThat().isEqualTo("Unknown denominator type: UNRECOGNIZED");
+    }
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/FailingClientInterceptor.java b/xds/src/test/java/io/grpc/xds/FailingClientInterceptor.java
new file mode 100644
index 00000000000..c8b32f376ee
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/FailingClientInterceptor.java
@@ -0,0 +1,50 @@
+/*
+ * 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.xds;
+
+import static java.util.Objects.requireNonNull;
+
+import io.grpc.CallOptions;
+import io.grpc.Channel;
+import io.grpc.ClientCall;
+import io.grpc.ClientInterceptor;
+import io.grpc.Metadata;
+import io.grpc.MethodDescriptor;
+import io.grpc.NoopClientCall;
+import io.grpc.Status;
+
+/**
+ * An interceptor that fails all RPCs with the provided status.
+ */
+final class FailingClientInterceptor implements ClientInterceptor {
+  private final Status status;
+
+  public FailingClientInterceptor(Status status) {
+    this.status = requireNonNull(status, "status");
+  }
+
+  @Override
+  public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
+      MethodDescriptor<ReqT, RespT> method, CallOptions callOptions, Channel next) {
+    return new NoopClientCall<ReqT, RespT>() {
+      @Override
+      public void start(Listener<RespT> responseListener, Metadata headers) {
+        responseListener.onClose(status, new Metadata());
+      }
+    };
+  }
+}
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..a273c6f3ebf
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/FakeControlPlaneXdsIntegrationTest.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.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.FlagResetRule;
+import io.grpc.ForwardingClientCall.SimpleForwardingClientCall;
+import io.grpc.ForwardingClientCallListener;
+import io.grpc.InternalFeatureFlags;
+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 java.util.Arrays;
+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;
+
+/**
+ * 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(Parameterized.class)
+public class FakeControlPlaneXdsIntegrationTest {
+
+  @Rule(order = 0)
+  public ControlPlaneRule controlPlane = new ControlPlaneRule();
+  @Rule(order = 1)
+  public DataPlaneRule dataPlane = new DataPlaneRule(controlPlane);
+  @Rule(order = 2)
+  public final FlagResetRule flagResetRule = new FlagResetRule();
+
+  @Parameters(name = "enableRfc3986UrisParam={0}")
+  public static Iterable<Object[]> data() {
+    return Arrays.asList(new Object[][] {{true}, {false}});
+  }
+
+  @Parameter public boolean enableRfc3986UrisParam;
+
+  @Before
+  public void setupRfc3986UrisFeatureFlag() throws Exception {
+    flagResetRule.setFlagForTest(
+        InternalFeatureFlags::setRfc3986UrisEnabled, enableRfc3986UrisParam);
+  }
+
+  @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..9033d1e636e
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/FaultFilterTest.java
@@ -0,0 +1,120 @@
+/*
+ * 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 io.grpc.xds.client.Bootstrapper.BootstrapInfo;
+import io.grpc.xds.client.Bootstrapper.ServerInfo;
+import io.grpc.xds.client.EnvoyProtoData.Node;
+import java.util.Collections;
+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, getFilterContext()).config;
+    assertThat(faultConfig.faultAbort()).isNotNull();
+    assertThat(faultConfig.faultAbort().status().getCode())
+        .isEqualTo(GrpcUtil.httpStatusToGrpcStatus(404).getCode());
+
+    FaultConfig faultConfigOverride =
+        FILTER_PROVIDER.parseFilterConfigOverride(
+                    rawConfig, getFilterContext()).config;
+    assertThat(faultConfigOverride.faultAbort()).isNotNull();
+    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);
+  }
+
+  private static Filter.FilterConfigParseContext getFilterContext() {
+    return Filter.FilterConfigParseContext.builder()
+        .bootstrapInfo(BootstrapInfo.builder()
+            .servers(Collections.singletonList(
+                ServerInfo.create(
+                    "test_target", Collections.emptyMap())))
+            .node(Node.newBuilder().build())
+            .build())
+        .serverInfo(ServerInfo.create(
+            "test_target", Collections.emptyMap(), false, true, false, false))
+        .build();
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/FilterChainMatchTest.java b/xds/src/test/java/io/grpc/xds/FilterChainMatchTest.java
deleted file mode 100644
index 80ee5b8d304..00000000000
--- a/xds/src/test/java/io/grpc/xds/FilterChainMatchTest.java
+++ /dev/null
@@ -1,652 +0,0 @@
-/*
- * 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.Mockito.when;
-
-import com.google.protobuf.InvalidProtocolBufferException;
-import io.grpc.xds.EnvoyServerProtoData.DownstreamTlsContext;
-import io.grpc.xds.internal.sds.CommonTlsContextTestsUtil;
-import io.netty.channel.Channel;
-import java.io.IOException;
-import java.net.InetAddress;
-import java.net.InetSocketAddress;
-import java.net.UnknownHostException;
-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;
-import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
-
-/** Tests for {@link XdsClientWrapperForServerSds}. */
-@RunWith(JUnit4.class)
-public class FilterChainMatchTest {
-
-  private static final int PORT = 7000;
-  private static final String LOCAL_IP = "10.1.2.3";  // dest
-  private static final String REMOTE_IP = "10.4.2.3"; // source
-
-  @Mock private XdsClient xdsClient;
-  @Mock private Channel channel;
-
-  private XdsClientWrapperForServerSds xdsClientWrapperForServerSds;
-  private XdsClient.ListenerWatcher registeredWatcher;
-
-  @Before
-  public void setUp() throws IOException {
-    MockitoAnnotations.initMocks(this);
-    xdsClientWrapperForServerSds = new XdsClientWrapperForServerSds(PORT);
-    registeredWatcher =
-            XdsServerTestHelper.startAndGetWatcher(xdsClientWrapperForServerSds, xdsClient, PORT);
-  }
-
-  @After
-  public void tearDown() {
-    xdsClientWrapperForServerSds.shutdown();
-  }
-
-  @Test
-  public void singleFilterChainWithoutAlpn() throws UnknownHostException {
-    setupChannel(LOCAL_IP, REMOTE_IP, 15000);
-    EnvoyServerProtoData.FilterChainMatch filterChainMatch =
-        new EnvoyServerProtoData.FilterChainMatch(
-            0,
-            Arrays.<EnvoyServerProtoData.CidrRange>asList(),
-            Arrays.<String>asList(),
-            Arrays.<EnvoyServerProtoData.CidrRange>asList(),
-            EnvoyServerProtoData.ConnectionSourceType.ANY,
-            Arrays.<Integer>asList());
-    DownstreamTlsContext tlsContext =
-        CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT1", "VA1");
-    EnvoyServerProtoData.FilterChain filterChain =
-        new EnvoyServerProtoData.FilterChain(filterChainMatch, tlsContext);
-    EnvoyServerProtoData.Listener listener =
-        new EnvoyServerProtoData.Listener("listener1", LOCAL_IP, Arrays.asList(filterChain), null);
-    XdsClient.ListenerUpdate listenerUpdate =
-        XdsClient.ListenerUpdate.newBuilder().setListener(listener).build();
-    registeredWatcher.onListenerChanged(listenerUpdate);
-    DownstreamTlsContext tlsContext1 =
-        xdsClientWrapperForServerSds.getDownstreamTlsContext(channel);
-    assertThat(tlsContext1).isSameInstanceAs(tlsContext);
-  }
-
-  @Test
-  public void singleFilterChainWithAlpn() throws UnknownHostException {
-    setupChannel(LOCAL_IP, REMOTE_IP, 15000);
-    EnvoyServerProtoData.FilterChainMatch filterChainMatch =
-        new EnvoyServerProtoData.FilterChainMatch(
-            0,
-            Arrays.<EnvoyServerProtoData.CidrRange>asList(),
-            Arrays.asList("managed-mtls"),
-            Arrays.<EnvoyServerProtoData.CidrRange>asList(),
-            EnvoyServerProtoData.ConnectionSourceType.ANY,
-            Arrays.<Integer>asList());
-    DownstreamTlsContext tlsContext =
-        CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT1", "VA1");
-    EnvoyServerProtoData.FilterChain filterChain =
-        new EnvoyServerProtoData.FilterChain(filterChainMatch, tlsContext);
-    EnvoyServerProtoData.Listener listener =
-        new EnvoyServerProtoData.Listener("listener1", LOCAL_IP, Arrays.asList(filterChain), null);
-    XdsClient.ListenerUpdate listenerUpdate =
-        XdsClient.ListenerUpdate.newBuilder().setListener(listener).build();
-    registeredWatcher.onListenerChanged(listenerUpdate);
-    DownstreamTlsContext tlsContext1 =
-        xdsClientWrapperForServerSds.getDownstreamTlsContext(channel);
-    assertThat(tlsContext1).isSameInstanceAs(tlsContext);
-  }
-
-  @Test
-  public void defaultFilterChain() throws UnknownHostException {
-    setupChannel(LOCAL_IP, REMOTE_IP, 15000);
-    DownstreamTlsContext tlsContext =
-        CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT1", "VA1");
-    EnvoyServerProtoData.FilterChain filterChain =
-        new EnvoyServerProtoData.FilterChain(null, tlsContext);
-    EnvoyServerProtoData.Listener listener =
-        new EnvoyServerProtoData.Listener(
-            "listener1", LOCAL_IP, Arrays.<EnvoyServerProtoData.FilterChain>asList(), filterChain);
-    XdsClient.ListenerUpdate listenerUpdate =
-        XdsClient.ListenerUpdate.newBuilder().setListener(listener).build();
-    registeredWatcher.onListenerChanged(listenerUpdate);
-    DownstreamTlsContext tlsContext1 =
-        xdsClientWrapperForServerSds.getDownstreamTlsContext(channel);
-    assertThat(tlsContext1).isSameInstanceAs(tlsContext);
-  }
-
-  @Test
-  public void destPortFails_returnDefaultFilterChain() throws UnknownHostException {
-    setupChannel(LOCAL_IP, REMOTE_IP, 15000);
-    DownstreamTlsContext tlsContextWithDestPort =
-        CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT1", "VA1");
-    EnvoyServerProtoData.FilterChainMatch filterChainMatchWithDestPort =
-        new EnvoyServerProtoData.FilterChainMatch(
-            PORT,
-            Arrays.<EnvoyServerProtoData.CidrRange>asList(),
-            Arrays.asList("managed-mtls"),
-            Arrays.<EnvoyServerProtoData.CidrRange>asList(),
-            EnvoyServerProtoData.ConnectionSourceType.ANY,
-            Arrays.<Integer>asList());
-    EnvoyServerProtoData.FilterChain filterChainWithDestPort =
-        new EnvoyServerProtoData.FilterChain(filterChainMatchWithDestPort, tlsContextWithDestPort);
-    DownstreamTlsContext tlsContextForDefaultFilterChain =
-        CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT2", "VA2");
-    EnvoyServerProtoData.FilterChain defaultFilterChain =
-        new EnvoyServerProtoData.FilterChain(null, tlsContextForDefaultFilterChain);
-    EnvoyServerProtoData.Listener listener =
-        new EnvoyServerProtoData.Listener(
-            "listener1", LOCAL_IP, Arrays.asList(filterChainWithDestPort), defaultFilterChain);
-    XdsClient.ListenerUpdate listenerUpdate =
-        XdsClient.ListenerUpdate.newBuilder().setListener(listener).build();
-    registeredWatcher.onListenerChanged(listenerUpdate);
-    DownstreamTlsContext tlsContext1 =
-        xdsClientWrapperForServerSds.getDownstreamTlsContext(channel);
-    assertThat(tlsContext1).isSameInstanceAs(tlsContextForDefaultFilterChain);
-  }
-
-  @Test
-  public void destPrefixRangeMatch() throws UnknownHostException, InvalidProtocolBufferException {
-    setupChannel(LOCAL_IP, REMOTE_IP, 15000);
-    DownstreamTlsContext tlsContextMatch =
-        CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT1", "VA1");
-    EnvoyServerProtoData.FilterChainMatch filterChainMatchWithMatch =
-        new EnvoyServerProtoData.FilterChainMatch(
-            0,
-            Arrays.asList(new EnvoyServerProtoData.CidrRange("10.1.2.0", 24)),
-            Arrays.<String>asList(),
-            Arrays.<EnvoyServerProtoData.CidrRange>asList(),
-            EnvoyServerProtoData.ConnectionSourceType.ANY,
-            Arrays.<Integer>asList());
-    EnvoyServerProtoData.FilterChain filterChainWithMatch =
-        new EnvoyServerProtoData.FilterChain(filterChainMatchWithMatch, tlsContextMatch);
-    DownstreamTlsContext tlsContextForDefaultFilterChain =
-        CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT2", "VA2");
-    EnvoyServerProtoData.FilterChain defaultFilterChain =
-        new EnvoyServerProtoData.FilterChain(null, tlsContextForDefaultFilterChain);
-    EnvoyServerProtoData.Listener listener =
-        new EnvoyServerProtoData.Listener(
-            "listener1", LOCAL_IP, Arrays.asList(filterChainWithMatch), defaultFilterChain);
-    XdsClient.ListenerUpdate listenerUpdate =
-        XdsClient.ListenerUpdate.newBuilder().setListener(listener).build();
-    registeredWatcher.onListenerChanged(listenerUpdate);
-    DownstreamTlsContext tlsContext1 =
-        xdsClientWrapperForServerSds.getDownstreamTlsContext(channel);
-    assertThat(tlsContext1).isSameInstanceAs(tlsContextMatch);
-  }
-
-  @Test
-  public void destPrefixRangeMismatch_returnDefaultFilterChain()
-      throws UnknownHostException, InvalidProtocolBufferException {
-    setupChannel(LOCAL_IP, REMOTE_IP, 15000);
-    DownstreamTlsContext tlsContextMismatch =
-        CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT1", "VA1");
-    // 10.2.2.0/24 doesn't match LOCAL_IP
-    EnvoyServerProtoData.FilterChainMatch filterChainMatchWithMismatch =
-        new EnvoyServerProtoData.FilterChainMatch(
-            0,
-            Arrays.asList(new EnvoyServerProtoData.CidrRange("10.2.2.0", 24)),
-            Arrays.<String>asList(),
-            Arrays.<EnvoyServerProtoData.CidrRange>asList(),
-            EnvoyServerProtoData.ConnectionSourceType.ANY,
-            Arrays.<Integer>asList());
-    EnvoyServerProtoData.FilterChain filterChainWithMismatch =
-        new EnvoyServerProtoData.FilterChain(filterChainMatchWithMismatch, tlsContextMismatch);
-    DownstreamTlsContext tlsContextForDefaultFilterChain =
-        CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT2", "VA2");
-    EnvoyServerProtoData.FilterChain defaultFilterChain =
-        new EnvoyServerProtoData.FilterChain(null, tlsContextForDefaultFilterChain);
-    EnvoyServerProtoData.Listener listener =
-        new EnvoyServerProtoData.Listener(
-            "listener1", LOCAL_IP, Arrays.asList(filterChainWithMismatch), defaultFilterChain);
-    XdsClient.ListenerUpdate listenerUpdate =
-        XdsClient.ListenerUpdate.newBuilder().setListener(listener).build();
-    registeredWatcher.onListenerChanged(listenerUpdate);
-    DownstreamTlsContext tlsContext1 =
-        xdsClientWrapperForServerSds.getDownstreamTlsContext(channel);
-    assertThat(tlsContext1).isSameInstanceAs(tlsContextForDefaultFilterChain);
-  }
-
-  @Test
-  public void destPrefixRange_moreSpecificWins()
-      throws UnknownHostException, InvalidProtocolBufferException {
-    setupChannel(LOCAL_IP, REMOTE_IP, 15000);
-    DownstreamTlsContext tlsContextLessSpecific =
-        CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT1", "VA1");
-    EnvoyServerProtoData.FilterChainMatch filterChainMatchLessSpecific =
-        new EnvoyServerProtoData.FilterChainMatch(
-            0,
-            Arrays.asList(new EnvoyServerProtoData.CidrRange("10.1.2.0", 24)),
-            Arrays.<String>asList(),
-            Arrays.<EnvoyServerProtoData.CidrRange>asList(),
-            EnvoyServerProtoData.ConnectionSourceType.ANY,
-            Arrays.<Integer>asList());
-    EnvoyServerProtoData.FilterChain filterChainLessSpecific =
-        new EnvoyServerProtoData.FilterChain(filterChainMatchLessSpecific, tlsContextLessSpecific);
-
-    DownstreamTlsContext tlsContextMoreSpecific =
-        CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT2", "VA2");
-    EnvoyServerProtoData.FilterChainMatch filterChainMatchMoreSpecific =
-        new EnvoyServerProtoData.FilterChainMatch(
-            0,
-            Arrays.asList(new EnvoyServerProtoData.CidrRange("10.1.2.2", 31)),
-            Arrays.<String>asList(),
-            Arrays.<EnvoyServerProtoData.CidrRange>asList(),
-            EnvoyServerProtoData.ConnectionSourceType.ANY,
-            Arrays.<Integer>asList());
-    EnvoyServerProtoData.FilterChain filterChainMoreSpecific =
-        new EnvoyServerProtoData.FilterChain(filterChainMatchMoreSpecific, tlsContextMoreSpecific);
-    EnvoyServerProtoData.FilterChain defaultFilterChain =
-        new EnvoyServerProtoData.FilterChain(null, null);
-    EnvoyServerProtoData.Listener listener =
-        new EnvoyServerProtoData.Listener(
-            "listener1",
-            LOCAL_IP,
-            Arrays.asList(filterChainLessSpecific, filterChainMoreSpecific),
-            defaultFilterChain);
-    XdsClient.ListenerUpdate listenerUpdate =
-        XdsClient.ListenerUpdate.newBuilder().setListener(listener).build();
-    registeredWatcher.onListenerChanged(listenerUpdate);
-    DownstreamTlsContext tlsContext1 =
-        xdsClientWrapperForServerSds.getDownstreamTlsContext(channel);
-    assertThat(tlsContext1).isSameInstanceAs(tlsContextMoreSpecific);
-  }
-
-  @Test
-  public void destPrefixRangeIpv6_moreSpecificWins()
-      throws UnknownHostException, InvalidProtocolBufferException {
-    setupChannel("FE80:0000:0000:0000:0202:B3FF:FE1E:8329", "2001:DB8::8:800:200C:417A", 15000);
-    DownstreamTlsContext tlsContextLessSpecific =
-        CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT1", "VA1");
-    EnvoyServerProtoData.FilterChainMatch filterChainMatchLessSpecific =
-        new EnvoyServerProtoData.FilterChainMatch(
-            0,
-            Arrays.asList(new EnvoyServerProtoData.CidrRange("FE80:0:0:0:0:0:0:0", 60)),
-            Arrays.<String>asList(),
-            Arrays.<EnvoyServerProtoData.CidrRange>asList(),
-            EnvoyServerProtoData.ConnectionSourceType.ANY,
-            Arrays.<Integer>asList());
-    EnvoyServerProtoData.FilterChain filterChainLessSpecific =
-        new EnvoyServerProtoData.FilterChain(filterChainMatchLessSpecific, tlsContextLessSpecific);
-
-    DownstreamTlsContext tlsContextMoreSpecific =
-        CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT2", "VA2");
-    EnvoyServerProtoData.FilterChainMatch filterChainMatchMoreSpecific =
-        new EnvoyServerProtoData.FilterChainMatch(
-            0,
-            Arrays.asList(new EnvoyServerProtoData.CidrRange("FE80:0000:0000:0000:0202:0:0:0", 80)),
-            Arrays.<String>asList(),
-            Arrays.<EnvoyServerProtoData.CidrRange>asList(),
-            EnvoyServerProtoData.ConnectionSourceType.ANY,
-            Arrays.<Integer>asList());
-    EnvoyServerProtoData.FilterChain filterChainMoreSpecific =
-        new EnvoyServerProtoData.FilterChain(filterChainMatchMoreSpecific, tlsContextMoreSpecific);
-    EnvoyServerProtoData.FilterChain defaultFilterChain =
-        new EnvoyServerProtoData.FilterChain(null, null);
-    EnvoyServerProtoData.Listener listener =
-        new EnvoyServerProtoData.Listener(
-            "listener1",
-            "FE80:0000:0000:0000:0202:B3FF:FE1E:8329",
-            Arrays.asList(filterChainLessSpecific, filterChainMoreSpecific),
-            defaultFilterChain);
-    XdsClient.ListenerUpdate listenerUpdate =
-        XdsClient.ListenerUpdate.newBuilder().setListener(listener).build();
-    registeredWatcher.onListenerChanged(listenerUpdate);
-    DownstreamTlsContext tlsContext1 =
-        xdsClientWrapperForServerSds.getDownstreamTlsContext(channel);
-    assertThat(tlsContext1).isSameInstanceAs(tlsContextMoreSpecific);
-  }
-
-  @Test
-  public void destPrefixRange_moreSpecificWith2Wins()
-      throws UnknownHostException, InvalidProtocolBufferException {
-    setupChannel(LOCAL_IP, REMOTE_IP, 15000);
-    DownstreamTlsContext tlsContextMoreSpecificWith2 =
-        CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT1", "VA1");
-    EnvoyServerProtoData.FilterChainMatch filterChainMatchMoreSpecificWith2 =
-        new EnvoyServerProtoData.FilterChainMatch(
-            0,
-            Arrays.asList(
-                new EnvoyServerProtoData.CidrRange("10.1.2.0", 24),
-                new EnvoyServerProtoData.CidrRange(LOCAL_IP, 32)),
-            Arrays.<String>asList(),
-            Arrays.<EnvoyServerProtoData.CidrRange>asList(),
-            EnvoyServerProtoData.ConnectionSourceType.ANY,
-            Arrays.<Integer>asList());
-    EnvoyServerProtoData.FilterChain filterChainMoreSpecificWith2 =
-        new EnvoyServerProtoData.FilterChain(
-            filterChainMatchMoreSpecificWith2, tlsContextMoreSpecificWith2);
-
-    DownstreamTlsContext tlsContextLessSpecific =
-        CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT2", "VA2");
-    EnvoyServerProtoData.FilterChainMatch filterChainMatchLessSpecific =
-        new EnvoyServerProtoData.FilterChainMatch(
-            0,
-            Arrays.asList(new EnvoyServerProtoData.CidrRange("10.1.2.2", 31)),
-            Arrays.<String>asList(),
-            Arrays.<EnvoyServerProtoData.CidrRange>asList(),
-            EnvoyServerProtoData.ConnectionSourceType.ANY,
-            Arrays.<Integer>asList());
-    EnvoyServerProtoData.FilterChain filterChainLessSpecific =
-        new EnvoyServerProtoData.FilterChain(filterChainMatchLessSpecific, tlsContextLessSpecific);
-    EnvoyServerProtoData.FilterChain defaultFilterChain =
-        new EnvoyServerProtoData.FilterChain(null, null);
-    EnvoyServerProtoData.Listener listener =
-        new EnvoyServerProtoData.Listener(
-            "listener1",
-            LOCAL_IP,
-            Arrays.asList(filterChainMoreSpecificWith2, filterChainLessSpecific),
-            defaultFilterChain);
-    XdsClient.ListenerUpdate listenerUpdate =
-        XdsClient.ListenerUpdate.newBuilder().setListener(listener).build();
-    registeredWatcher.onListenerChanged(listenerUpdate);
-    DownstreamTlsContext tlsContext1 =
-        xdsClientWrapperForServerSds.getDownstreamTlsContext(channel);
-    assertThat(tlsContext1).isSameInstanceAs(tlsContextMoreSpecificWith2);
-  }
-
-  @Test
-  public void sourceTypeMismatch_returnDefaultFilterChain() throws UnknownHostException {
-    setupChannel(LOCAL_IP, REMOTE_IP, 15000);
-    DownstreamTlsContext tlsContextMismatch =
-        CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT1", "VA1");
-    EnvoyServerProtoData.FilterChainMatch filterChainMatchWithMismatch =
-        new EnvoyServerProtoData.FilterChainMatch(
-            0,
-            Arrays.<EnvoyServerProtoData.CidrRange>asList(),
-            Arrays.<String>asList(),
-            Arrays.<EnvoyServerProtoData.CidrRange>asList(),
-            EnvoyServerProtoData.ConnectionSourceType.SAME_IP_OR_LOOPBACK,
-            Arrays.<Integer>asList());
-    EnvoyServerProtoData.FilterChain filterChainWithMismatch =
-        new EnvoyServerProtoData.FilterChain(filterChainMatchWithMismatch, tlsContextMismatch);
-    DownstreamTlsContext tlsContextForDefaultFilterChain =
-        CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT2", "VA2");
-    EnvoyServerProtoData.FilterChain defaultFilterChain =
-        new EnvoyServerProtoData.FilterChain(null, tlsContextForDefaultFilterChain);
-    EnvoyServerProtoData.Listener listener =
-        new EnvoyServerProtoData.Listener(
-            "listener1", LOCAL_IP, Arrays.asList(filterChainWithMismatch), defaultFilterChain);
-    XdsClient.ListenerUpdate listenerUpdate =
-        XdsClient.ListenerUpdate.newBuilder().setListener(listener).build();
-    registeredWatcher.onListenerChanged(listenerUpdate);
-    DownstreamTlsContext tlsContext1 =
-        xdsClientWrapperForServerSds.getDownstreamTlsContext(channel);
-    assertThat(tlsContext1).isSameInstanceAs(tlsContextForDefaultFilterChain);
-  }
-
-  @Test
-  public void sourceTypeLocal() throws UnknownHostException {
-    setupChannel(LOCAL_IP, LOCAL_IP, 15000);
-    DownstreamTlsContext tlsContextMatch =
-        CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT1", "VA1");
-    EnvoyServerProtoData.FilterChainMatch filterChainMatchWithMatch =
-        new EnvoyServerProtoData.FilterChainMatch(
-            0,
-            Arrays.<EnvoyServerProtoData.CidrRange>asList(),
-            Arrays.<String>asList(),
-            Arrays.<EnvoyServerProtoData.CidrRange>asList(),
-            EnvoyServerProtoData.ConnectionSourceType.SAME_IP_OR_LOOPBACK,
-            Arrays.<Integer>asList());
-    EnvoyServerProtoData.FilterChain filterChainWithMatch =
-        new EnvoyServerProtoData.FilterChain(filterChainMatchWithMatch, tlsContextMatch);
-    DownstreamTlsContext tlsContextForDefaultFilterChain =
-        CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT2", "VA2");
-    EnvoyServerProtoData.FilterChain defaultFilterChain =
-        new EnvoyServerProtoData.FilterChain(null, tlsContextForDefaultFilterChain);
-    EnvoyServerProtoData.Listener listener =
-        new EnvoyServerProtoData.Listener(
-            "listener1", LOCAL_IP, Arrays.asList(filterChainWithMatch), defaultFilterChain);
-    XdsClient.ListenerUpdate listenerUpdate =
-        XdsClient.ListenerUpdate.newBuilder().setListener(listener).build();
-    registeredWatcher.onListenerChanged(listenerUpdate);
-    DownstreamTlsContext tlsContext1 =
-        xdsClientWrapperForServerSds.getDownstreamTlsContext(channel);
-    assertThat(tlsContext1).isSameInstanceAs(tlsContextMatch);
-  }
-
-  @Test
-  public void sourcePrefixRange_moreSpecificWith2Wins()
-      throws UnknownHostException, InvalidProtocolBufferException {
-    setupChannel(LOCAL_IP, REMOTE_IP, 15000);
-    DownstreamTlsContext tlsContextMoreSpecificWith2 =
-        CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT1", "VA1");
-    EnvoyServerProtoData.FilterChainMatch filterChainMatchMoreSpecificWith2 =
-        new EnvoyServerProtoData.FilterChainMatch(
-            0,
-            Arrays.<EnvoyServerProtoData.CidrRange>asList(),
-            Arrays.<String>asList(),
-            Arrays.asList(
-                new EnvoyServerProtoData.CidrRange("10.4.2.0", 24),
-                new EnvoyServerProtoData.CidrRange(REMOTE_IP, 32)),
-            EnvoyServerProtoData.ConnectionSourceType.ANY,
-            Arrays.<Integer>asList());
-    EnvoyServerProtoData.FilterChain filterChainMoreSpecificWith2 =
-        new EnvoyServerProtoData.FilterChain(
-            filterChainMatchMoreSpecificWith2, tlsContextMoreSpecificWith2);
-
-    DownstreamTlsContext tlsContextLessSpecific =
-        CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT2", "VA2");
-    EnvoyServerProtoData.FilterChainMatch filterChainMatchLessSpecific =
-        new EnvoyServerProtoData.FilterChainMatch(
-            0,
-            Arrays.<EnvoyServerProtoData.CidrRange>asList(),
-            Arrays.<String>asList(),
-            Arrays.asList(new EnvoyServerProtoData.CidrRange("10.4.2.2", 31)),
-            EnvoyServerProtoData.ConnectionSourceType.ANY,
-            Arrays.<Integer>asList());
-    EnvoyServerProtoData.FilterChain filterChainLessSpecific =
-        new EnvoyServerProtoData.FilterChain(filterChainMatchLessSpecific, tlsContextLessSpecific);
-    EnvoyServerProtoData.FilterChain defaultFilterChain =
-        new EnvoyServerProtoData.FilterChain(null, null);
-    EnvoyServerProtoData.Listener listener =
-        new EnvoyServerProtoData.Listener(
-            "listener1",
-            LOCAL_IP,
-            Arrays.asList(filterChainMoreSpecificWith2, filterChainLessSpecific),
-            defaultFilterChain);
-    XdsClient.ListenerUpdate listenerUpdate =
-        XdsClient.ListenerUpdate.newBuilder().setListener(listener).build();
-    registeredWatcher.onListenerChanged(listenerUpdate);
-    DownstreamTlsContext tlsContext1 =
-        xdsClientWrapperForServerSds.getDownstreamTlsContext(channel);
-    assertThat(tlsContext1).isSameInstanceAs(tlsContextMoreSpecificWith2);
-  }
-
-  @Test
-  public void sourcePortMatch_exactMatchWinsOverEmptyList()
-      throws UnknownHostException, InvalidProtocolBufferException {
-    setupChannel(LOCAL_IP, REMOTE_IP, 15000);
-    DownstreamTlsContext tlsContextEmptySourcePorts =
-        CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT1", "VA1");
-    EnvoyServerProtoData.FilterChainMatch filterChainMatchEmptySourcePorts =
-        new EnvoyServerProtoData.FilterChainMatch(
-            0,
-            Arrays.<EnvoyServerProtoData.CidrRange>asList(),
-            Arrays.<String>asList(),
-            Arrays.asList(
-                new EnvoyServerProtoData.CidrRange("10.4.2.0", 24),
-                new EnvoyServerProtoData.CidrRange("10.4.2.2", 31)),
-            EnvoyServerProtoData.ConnectionSourceType.ANY,
-            Arrays.<Integer>asList());
-    EnvoyServerProtoData.FilterChain filterChainEmptySourcePorts =
-        new EnvoyServerProtoData.FilterChain(
-            filterChainMatchEmptySourcePorts, tlsContextEmptySourcePorts);
-
-    DownstreamTlsContext tlsContextSourcePortMatch =
-        CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT2", "VA2");
-    EnvoyServerProtoData.FilterChainMatch filterChainMatchSourcePortMatch =
-        new EnvoyServerProtoData.FilterChainMatch(
-            0,
-            Arrays.<EnvoyServerProtoData.CidrRange>asList(),
-            Arrays.<String>asList(),
-            Arrays.asList(new EnvoyServerProtoData.CidrRange("10.4.2.2", 31)),
-            EnvoyServerProtoData.ConnectionSourceType.ANY,
-            Arrays.asList(7000, 15000));
-    EnvoyServerProtoData.FilterChain filterChainSourcePortMatch =
-        new EnvoyServerProtoData.FilterChain(
-            filterChainMatchSourcePortMatch, tlsContextSourcePortMatch);
-    EnvoyServerProtoData.FilterChain defaultFilterChain =
-        new EnvoyServerProtoData.FilterChain(null, null);
-    EnvoyServerProtoData.Listener listener =
-        new EnvoyServerProtoData.Listener(
-            "listener1",
-            LOCAL_IP,
-            Arrays.asList(filterChainEmptySourcePorts, filterChainSourcePortMatch),
-            defaultFilterChain);
-    XdsClient.ListenerUpdate listenerUpdate =
-        XdsClient.ListenerUpdate.newBuilder().setListener(listener).build();
-    registeredWatcher.onListenerChanged(listenerUpdate);
-    DownstreamTlsContext tlsContext1 =
-        xdsClientWrapperForServerSds.getDownstreamTlsContext(channel);
-    assertThat(tlsContext1).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 UnknownHostException, InvalidProtocolBufferException {
-    setupChannel(LOCAL_IP, REMOTE_IP, 15000);
-    DownstreamTlsContext tlsContext1 =
-        CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT1", "VA1");
-    DownstreamTlsContext tlsContext2 =
-        CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT2", "VA2");
-    DownstreamTlsContext tlsContext3 =
-        CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT3", "VA3");
-    DownstreamTlsContext tlsContext4 =
-        CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT4", "VA4");
-    DownstreamTlsContext tlsContext5 =
-        CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT5", "VA5");
-    DownstreamTlsContext tlsContext6 =
-        CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT6", "VA6");
-
-    // has dest port and specific prefix ranges: gets eliminated in step 1
-    EnvoyServerProtoData.FilterChainMatch filterChainMatch1 =
-        new EnvoyServerProtoData.FilterChainMatch(
-            PORT,
-            Arrays.<EnvoyServerProtoData.CidrRange>asList(),
-            Arrays.<String>asList(),
-            Arrays.asList(new EnvoyServerProtoData.CidrRange(REMOTE_IP, 32)),
-            EnvoyServerProtoData.ConnectionSourceType.ANY,
-            Arrays.<Integer>asList());
-    EnvoyServerProtoData.FilterChain filterChain1 =
-        new EnvoyServerProtoData.FilterChain(filterChainMatch1, tlsContext1);
-
-    // 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 =
-        new EnvoyServerProtoData.FilterChainMatch(
-            0,
-            Arrays.asList(new EnvoyServerProtoData.CidrRange("10.1.2.0", 30)),
-            Arrays.<String>asList(),
-            Arrays.asList(new EnvoyServerProtoData.CidrRange("10.4.0.0", 16)),
-            EnvoyServerProtoData.ConnectionSourceType.ANY,
-            Arrays.<Integer>asList());
-    EnvoyServerProtoData.FilterChain filterChain2 =
-        new EnvoyServerProtoData.FilterChain(filterChainMatch2, tlsContext2);
-
-    // has prefix ranges with one not matching and source type local: gets eliminated in step 3
-    EnvoyServerProtoData.FilterChainMatch filterChainMatch3 =
-        new EnvoyServerProtoData.FilterChainMatch(
-            0,
-            Arrays.asList(
-                new EnvoyServerProtoData.CidrRange("192.168.2.0", 24),
-                new EnvoyServerProtoData.CidrRange("10.1.2.0", 30)),
-            Arrays.<String>asList(),
-            Arrays.<EnvoyServerProtoData.CidrRange>asList(),
-            EnvoyServerProtoData.ConnectionSourceType.SAME_IP_OR_LOOPBACK,
-            Arrays.<Integer>asList());
-    EnvoyServerProtoData.FilterChain filterChain3 =
-        new EnvoyServerProtoData.FilterChain(filterChainMatch3, tlsContext3);
-
-    // has prefix ranges with both matching and source type external but non matching source port:
-    // gets eliminated in step 5
-    EnvoyServerProtoData.FilterChainMatch filterChainMatch4 =
-        new EnvoyServerProtoData.FilterChainMatch(
-            0,
-            Arrays.asList(
-                new EnvoyServerProtoData.CidrRange("10.1.0.0", 16),
-                new EnvoyServerProtoData.CidrRange("10.1.2.0", 30)),
-            Arrays.<String>asList(),
-            Arrays.asList(new EnvoyServerProtoData.CidrRange("10.4.2.0", 24)),
-            EnvoyServerProtoData.ConnectionSourceType.EXTERNAL,
-            Arrays.asList(16000, 9000));
-    EnvoyServerProtoData.FilterChain filterChain4 =
-        new EnvoyServerProtoData.FilterChain(filterChainMatch4, tlsContext4);
-
-    // has prefix ranges with both matching and source type external and matching source port: this
-    // gets selected
-    EnvoyServerProtoData.FilterChainMatch filterChainMatch5 =
-        new EnvoyServerProtoData.FilterChainMatch(
-            0,
-            Arrays.asList(
-                new EnvoyServerProtoData.CidrRange("10.1.0.0", 16),
-                new EnvoyServerProtoData.CidrRange("10.1.2.0", 30)),
-            Arrays.<String>asList(),
-            Arrays.asList(
-                new EnvoyServerProtoData.CidrRange("10.4.2.0", 24),
-                new EnvoyServerProtoData.CidrRange("192.168.2.0", 24)),
-            EnvoyServerProtoData.ConnectionSourceType.ANY,
-            Arrays.asList(15000, 8000));
-    EnvoyServerProtoData.FilterChain filterChain5 =
-        new EnvoyServerProtoData.FilterChain(filterChainMatch5, tlsContext5);
-
-    // has prefix range with prefixLen of 29: gets eliminated in step 2
-    EnvoyServerProtoData.FilterChainMatch filterChainMatch6 =
-        new EnvoyServerProtoData.FilterChainMatch(
-            0,
-            Arrays.asList(new EnvoyServerProtoData.CidrRange("10.1.2.0", 29)),
-            Arrays.<String>asList(),
-            Arrays.<EnvoyServerProtoData.CidrRange>asList(),
-            EnvoyServerProtoData.ConnectionSourceType.ANY,
-            Arrays.<Integer>asList());
-    EnvoyServerProtoData.FilterChain filterChain6 =
-        new EnvoyServerProtoData.FilterChain(filterChainMatch6, tlsContext6);
-
-    EnvoyServerProtoData.FilterChain defaultFilterChain =
-        new EnvoyServerProtoData.FilterChain(null, null);
-    EnvoyServerProtoData.Listener listener =
-        new EnvoyServerProtoData.Listener(
-            "listener1",
-            LOCAL_IP,
-            Arrays.asList(
-                filterChain1, filterChain2, filterChain3, filterChain4, filterChain5, filterChain6),
-            defaultFilterChain);
-    XdsClient.ListenerUpdate listenerUpdate =
-        XdsClient.ListenerUpdate.newBuilder().setListener(listener).build();
-    registeredWatcher.onListenerChanged(listenerUpdate);
-    DownstreamTlsContext tlsContextPicked =
-        xdsClientWrapperForServerSds.getDownstreamTlsContext(channel);
-    assertThat(tlsContextPicked).isSameInstanceAs(tlsContext5);
-  }
-
-  private void setupChannel(String localIp, String remoteIp, int remotePort)
-      throws UnknownHostException {
-    when(channel.localAddress())
-        .thenReturn(new InetSocketAddress(InetAddress.getByName(localIp), PORT));
-    when(channel.remoteAddress())
-        .thenReturn(new InetSocketAddress(InetAddress.getByName(remoteIp), remotePort));
-  }
-}
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..788ab54726c
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/GcpAuthenticationFilterTest.java
@@ -0,0 +1,541 @@
+/*
+ * 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.Bootstrapper.BootstrapInfo;
+import io.grpc.xds.client.Bootstrapper.ServerInfo;
+import io.grpc.xds.client.EnvoyProtoData.Node;
+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, getFilterContext());
+    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, getFilterContext());
+    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, getFilterContext());
+
+    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",
+            XdsTestUtils.EMPTY_BOOTSTRAP, 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();
+  }
+
+  private static Filter.FilterConfigParseContext getFilterContext() {
+    return Filter.FilterConfigParseContext.builder()
+        .bootstrapInfo(BootstrapInfo.builder()
+            .servers(Collections.singletonList(
+                ServerInfo.create(
+                    "test_target", Collections.emptyMap())))
+            .node(Node.newBuilder().build())
+            .build())
+        .serverInfo(ServerInfo.create(
+            "test_target", Collections.emptyMap(), false, true, false, false))
+        .build();
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/GoogleCloudToProdNameResolverProviderTest.java b/xds/src/test/java/io/grpc/xds/GoogleCloudToProdNameResolverProviderTest.java
deleted file mode 100644
index 372c8af8f41..00000000000
--- a/xds/src/test/java/io/grpc/xds/GoogleCloudToProdNameResolverProviderTest.java
+++ /dev/null
@@ -1,79 +0,0 @@
-/*
- * 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 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 newNameResolver() {
-    assertThat(provider.newNameResolver(URI.create("google-c2p:///foo.googleapis.com"), args))
-        .isInstanceOf(GoogleCloudToProdNameResolver.class);
-  }
-}
diff --git a/xds/src/test/java/io/grpc/xds/GoogleCloudToProdNameResolverTest.java b/xds/src/test/java/io/grpc/xds/GoogleCloudToProdNameResolverTest.java
deleted file mode 100644
index 7246dea9238..00000000000
--- a/xds/src/test/java/io/grpc/xds/GoogleCloudToProdNameResolverTest.java
+++ /dev/null
@@ -1,256 +0,0 @@
-/*
- * 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.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.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.internal.FakeClock;
-import io.grpc.internal.GrpcUtil;
-import io.grpc.internal.ObjectPool;
-import io.grpc.internal.SharedResourceHolder.Resource;
-import io.grpc.xds.GoogleCloudToProdNameResolver.HttpConnectionProvider;
-import io.grpc.xds.XdsNameResolverProvider.XdsClientPoolFactory;
-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.concurrent.Executor;
-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.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 NameResolver.Args args = NameResolver.Args.newBuilder()
-      .setDefaultPort(DEFAULT_PORT)
-      .setProxyDetector(GrpcUtil.DEFAULT_PROXY_DETECTOR)
-      .setSynchronizationContext(syncContext)
-      .setServiceConfigParser(mock(ServiceConfigParser.class))
-      .setChannelLogger(mock(ChannelLogger.class))
-      .build();
-  private final FakeClock fakeExecutor = new FakeClock();
-  private final FakeXdsClientPoolFactory fakeXdsClientPoolFactory = new FakeXdsClientPoolFactory();
-  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 boolean originalXdsBootstrapProvided;
-  private GoogleCloudToProdNameResolver resolver;
-
-  @Before
-  public void setUp() {
-    nsRegistry.register(new FakeNsProvider("dns"));
-    nsRegistry.register(new FakeNsProvider("xds"));
-    originalIsOnGcp = GoogleCloudToProdNameResolver.isOnGcp;
-    originalXdsBootstrapProvided = GoogleCloudToProdNameResolver.xdsBootstrapProvided;
-  }
-
-  @After
-  public void tearDown() {
-    GoogleCloudToProdNameResolver.isOnGcp = originalIsOnGcp;
-    GoogleCloudToProdNameResolver.xdsBootstrapProvided = originalXdsBootstrapProvided;
-    resolver.shutdown();
-    verify(Iterables.getOnlyElement(delegatedResolver.values())).shutdown();
-  }
-
-  private void createResolver() {
-    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)) {
-          return con;
-        }
-        throw new AssertionError("Unknown http query");
-      }
-    };
-    resolver = new GoogleCloudToProdNameResolver(
-        TARGET_URI, args, fakeExecutorResource, fakeXdsClientPoolFactory, nsRegistry.asFactory());
-    resolver.setHttpConnectionProvider(httpConnections);
-  }
-
-  @Test
-  public void notOnGcpDelegateToDns() {
-    GoogleCloudToProdNameResolver.isOnGcp = false;
-    createResolver();
-    resolver.start(mockListener);
-    assertThat(delegatedResolver.keySet()).containsExactly("dns");
-    verify(Iterables.getOnlyElement(delegatedResolver.values())).start(mockListener);
-  }
-
-  @Test
-  public void hasProvidedBootstrapDelegateToDns() {
-    GoogleCloudToProdNameResolver.isOnGcp = true;
-    GoogleCloudToProdNameResolver.xdsBootstrapProvided = true;
-    createResolver();
-    resolver.start(mockListener);
-    assertThat(delegatedResolver.keySet()).containsExactly("dns");
-    verify(Iterables.getOnlyElement(delegatedResolver.values())).start(mockListener);
-  }
-
-  @SuppressWarnings("unchecked")
-  @Test
-  public void onGcpAndNoProvidedBootstrapDelegateToXds() {
-    GoogleCloudToProdNameResolver.isOnGcp = true;
-    GoogleCloudToProdNameResolver.xdsBootstrapProvided = false;
-    createResolver();
-    resolver.start(mockListener);
-    fakeExecutor.runDueTasks();
-    assertThat(delegatedResolver.keySet()).containsExactly("xds");
-    verify(Iterables.getOnlyElement(delegatedResolver.values())).start(mockListener);
-    Map<String, ?> bootstrap = fakeXdsClientPoolFactory.bootstrapRef.get();
-    Map<String, ?> node = (Map<String, ?>) bootstrap.get("node");
-    assertThat(node).containsExactly(
-        "id", "C2P", "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-trafficdirector.googleapis.com",
-        "channel_creds", ImmutableList.of(ImmutableMap.of("type", "google_default")));
-  }
-
-  @Test
-  public void failToQueryMetadata() {
-    GoogleCloudToProdNameResolver.isOnGcp = true;
-    GoogleCloudToProdNameResolver.xdsBootstrapProvided = false;
-    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;
-      }
-    };
-    resolver.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;
-    }
-  }
-
-  private static final class FakeXdsClientPoolFactory implements XdsClientPoolFactory {
-    private final AtomicReference<Map<String, ?>> bootstrapRef = new AtomicReference<>();
-
-    @Override
-    public void setBootstrapOverride(Map<String, ?> bootstrap) {
-      bootstrapRef.set(bootstrap);
-    }
-
-    @Override
-    public ObjectPool<XdsClient> getXdsClientPool() {
-      throw new UnsupportedOperationException("Should not be called");
-    }
-  }
-}
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..d4ee4159bc2
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/GrpcBootstrapperImplTest.java
@@ -0,0 +1,1061 @@
+/*
+ * 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.AllowedGrpcServices;
+import io.grpc.xds.client.AllowedGrpcServices.AllowedGrpcService;
+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_allowedGrpcServices() throws XdsInitializationException {
+    String rawData = "{\n"
+        + "  \"xds_servers\": [\n"
+        + "    {\n"
+        + "      \"server_uri\": \"" + SERVER_URI + "\",\n"
+        + "      \"channel_creds\": [{\"type\": \"insecure\"}]\n"
+        + "    }\n"
+        + "  ],\n"
+        + "  \"allowed_grpc_services\": {\n"
+        + "    \"dns:///foo.com:443\": {\n"
+        + "      \"channel_creds\": [{\"type\": \"insecure\"}],\n"
+        + "      \"call_creds\": [{\"type\": \"access_token\"}]\n"
+        + "    }\n"
+        + "  }\n"
+        + "}";
+
+    bootstrapper.setFileReader(createFileReader(BOOTSTRAP_FILE_PATH, rawData));
+    BootstrapInfo info = bootstrapper.bootstrap();
+    GrpcBootstrapImplConfig customConfig =
+        (GrpcBootstrapImplConfig) info.implSpecificObject().get();
+    AllowedGrpcServices allowed = customConfig.allowedGrpcServices();
+    assertThat(allowed).isNotNull();
+    assertThat(allowed.services()).containsKey("dns:///foo.com:443");
+    AllowedGrpcService service = allowed.services().get("dns:///foo.com:443");
+    assertThat(service.configuredChannelCredentials().channelCredentials())
+        .isInstanceOf(InsecureChannelCredentials.class);
+    assertThat(service.callCredentials().isPresent()).isFalse();
+  }
+
+  @Test
+  public void parseBootstrap_allowedGrpcServices_invalidChannelCreds() {
+    String rawData = "{\n"
+        + "  \"xds_servers\": [\n"
+        + "    {\n"
+        + "      \"server_uri\": \"" + SERVER_URI + "\",\n"
+        + "      \"channel_creds\": [{\"type\": \"insecure\"}]\n"
+        + "    }\n"
+        + "  ],\n"
+        + "  \"allowed_grpc_services\": {\n"
+        + "    \"dns:///foo.com:443\": {\n"
+        + "      \"channel_creds\": []\n"
+        + "    }\n"
+        + "  }\n"
+        + "}";
+
+    bootstrapper.setFileReader(createFileReader(BOOTSTRAP_FILE_PATH, rawData));
+    XdsInitializationException e = assertThrows(XdsInitializationException.class,
+        bootstrapper::bootstrap);
+    assertThat(e).hasMessageThat()
+        .isEqualTo("Invalid bootstrap: server dns:///foo.com:443 'channel_creds' required");
+  }
+
+  @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/GrpcServiceConfigParserTest.java b/xds/src/test/java/io/grpc/xds/GrpcServiceConfigParserTest.java
new file mode 100644
index 00000000000..ddfd0f19498
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/GrpcServiceConfigParserTest.java
@@ -0,0 +1,757 @@
+/*
+ * 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 static org.junit.Assert.assertThrows;
+
+import com.google.common.collect.ImmutableMap;
+import com.google.protobuf.Any;
+import com.google.protobuf.ByteString;
+import com.google.protobuf.Duration;
+import io.envoyproxy.envoy.config.core.v3.GrpcService;
+import io.envoyproxy.envoy.config.core.v3.HeaderValue;
+import io.envoyproxy.envoy.extensions.grpc_service.call_credentials.access_token.v3.AccessTokenCredentials;
+import io.envoyproxy.envoy.extensions.grpc_service.channel_credentials.google_default.v3.GoogleDefaultCredentials;
+import io.envoyproxy.envoy.extensions.grpc_service.channel_credentials.insecure.v3.InsecureCredentials;
+import io.envoyproxy.envoy.extensions.grpc_service.channel_credentials.local.v3.LocalCredentials;
+import io.envoyproxy.envoy.extensions.grpc_service.channel_credentials.xds.v3.XdsCredentials;
+import io.grpc.Attributes;
+import io.grpc.CallCredentials;
+import io.grpc.CompositeCallCredentials;
+import io.grpc.CompositeChannelCredentials;
+import io.grpc.InsecureChannelCredentials;
+import io.grpc.Metadata;
+import io.grpc.MethodDescriptor;
+import io.grpc.SecurityLevel;
+import io.grpc.Status;
+import io.grpc.alts.GoogleDefaultChannelCredentials;
+import io.grpc.xds.client.AllowedGrpcServices;
+import io.grpc.xds.client.AllowedGrpcServices.AllowedGrpcService;
+import io.grpc.xds.client.Bootstrapper.BootstrapInfo;
+import io.grpc.xds.client.Bootstrapper.ServerInfo;
+import io.grpc.xds.client.ConfiguredChannelCredentials;
+import io.grpc.xds.client.EnvoyProtoData.Node;
+import io.grpc.xds.internal.grpcservice.GrpcServiceConfig;
+import io.grpc.xds.internal.grpcservice.GrpcServiceParseException;
+import java.io.InputStream;
+import java.nio.charset.StandardCharsets;
+import java.util.Collections;
+import java.util.Optional;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.Mockito;
+
+@RunWith(JUnit4.class)
+public class GrpcServiceConfigParserTest {
+
+  private static final String CALL_CREDENTIALS_CLASS_NAME =
+      "io.grpc.xds.GrpcServiceConfigParser$SecurityAwareAccessTokenCredentials";
+
+  private static BootstrapInfo dummyBootstrapInfo() {
+    return dummyBootstrapInfo(Optional.empty());
+  }
+
+  private static BootstrapInfo dummyBootstrapInfo(Optional<Object> implSpecificObject) {
+    return BootstrapInfo.builder()
+        .servers(Collections
+            .singletonList(ServerInfo.create("test_target", Collections.emptyMap())))
+        .node(Node.newBuilder().build()).implSpecificObject(implSpecificObject).build();
+  }
+
+  private static ServerInfo dummyServerInfo() {
+    return dummyServerInfo(true);
+  }
+
+  private static ServerInfo dummyServerInfo(boolean isTrusted) {
+    return ServerInfo.create("test_target", Collections.emptyMap(), false, isTrusted, false,
+        false);
+  }
+
+  private static GrpcServiceConfig parse(
+      GrpcService grpcServiceProto, BootstrapInfo bootstrapInfo,
+      ServerInfo serverInfo)
+      throws GrpcServiceParseException {
+    return GrpcServiceConfigParser.parse(grpcServiceProto, bootstrapInfo, serverInfo);
+  }
+
+  private static GrpcServiceConfig.GoogleGrpcConfig parseGoogleGrpcConfig(
+      GrpcService.GoogleGrpc googleGrpcProto, BootstrapInfo bootstrapInfo,
+      ServerInfo serverInfo)
+      throws GrpcServiceParseException {
+    return GrpcServiceConfigParser.parseGoogleGrpcConfig(
+        googleGrpcProto, bootstrapInfo, serverInfo);
+  }
+
+  @Test
+  public void parse_success() throws GrpcServiceParseException {
+    Any insecureCreds = Any.pack(InsecureCredentials.getDefaultInstance());
+    Any accessTokenCreds =
+        Any.pack(AccessTokenCredentials.newBuilder().setToken("test_token").build());
+    GrpcService.GoogleGrpc googleGrpc = GrpcService.GoogleGrpc.newBuilder().setTargetUri("test_uri")
+        .addChannelCredentialsPlugin(insecureCreds).addCallCredentialsPlugin(accessTokenCreds)
+        .build();
+    HeaderValue asciiHeader =
+        HeaderValue.newBuilder().setKey("test_key").setValue("test_value").build();
+    HeaderValue binaryHeader =
+        HeaderValue.newBuilder().setKey("test_key-bin").setRawValue(ByteString
+            .copyFrom("test_value_binary".getBytes(StandardCharsets.UTF_8))).build();
+    Duration timeout = Duration.newBuilder().setSeconds(10).build();
+    GrpcService grpcService =
+        GrpcService.newBuilder().setGoogleGrpc(googleGrpc).addInitialMetadata(asciiHeader)
+            .addInitialMetadata(binaryHeader).setTimeout(timeout).build();
+
+    GrpcServiceConfig config = parse(grpcService,
+            dummyBootstrapInfo(),
+            dummyServerInfo());
+
+    // Assert target URI
+    assertThat(config.googleGrpc().target()).isEqualTo("test_uri");
+
+    // Assert channel credentials
+    assertThat(config.googleGrpc().configuredChannelCredentials().channelCredentials())
+        .isInstanceOf(InsecureChannelCredentials.class);
+    GrpcServiceConfigParser.ProtoChannelCredsConfig credsConfig =
+        (GrpcServiceConfigParser.ProtoChannelCredsConfig)
+            config.googleGrpc().configuredChannelCredentials().channelCredsConfig();
+    assertThat(credsConfig.configProto()).isEqualTo(insecureCreds);
+
+    // Assert call credentials
+    assertThat(config.googleGrpc().callCredentials().isPresent()).isTrue();
+    assertThat(config.googleGrpc().callCredentials().get().getClass().getName())
+        .isEqualTo(CALL_CREDENTIALS_CLASS_NAME);
+
+    // Assert initial metadata
+    assertThat(config.initialMetadata()).isNotEmpty();
+    assertThat(config.initialMetadata().get(0).key()).isEqualTo("test_key");
+    assertThat(config.initialMetadata().get(0).value().get()).isEqualTo("test_value");
+    assertThat(config.initialMetadata().get(1).key()).isEqualTo("test_key-bin");
+    assertThat(config.initialMetadata().get(1).rawValue().get().toByteArray())
+        .isEqualTo("test_value_binary".getBytes(StandardCharsets.UTF_8));
+
+    // Assert timeout
+    assertThat(config.timeout().isPresent()).isTrue();
+    assertThat(config.timeout().get()).isEqualTo(java.time.Duration.ofSeconds(10));
+  }
+
+  @Test
+  public void parse_minimalSuccess_defaults() throws GrpcServiceParseException {
+    Any insecureCreds = Any.pack(InsecureCredentials.getDefaultInstance());
+    Any accessTokenCreds =
+        Any.pack(AccessTokenCredentials.newBuilder().setToken("test_token").build());
+    GrpcService.GoogleGrpc googleGrpc = GrpcService.GoogleGrpc.newBuilder().setTargetUri("test_uri")
+        .addChannelCredentialsPlugin(insecureCreds).addCallCredentialsPlugin(accessTokenCreds)
+        .build();
+    GrpcService grpcService = GrpcService.newBuilder().setGoogleGrpc(googleGrpc).build();
+
+    GrpcServiceConfig config = parse(grpcService,
+            dummyBootstrapInfo(),
+            dummyServerInfo());
+
+    assertThat(config.googleGrpc().target()).isEqualTo("test_uri");
+    assertThat(config.initialMetadata()).isEmpty();
+    assertThat(config.timeout().isPresent()).isFalse();
+  }
+
+  @Test
+  public void parse_missingGoogleGrpc() {
+    GrpcService grpcService = GrpcService.newBuilder().build();
+    GrpcServiceParseException exception = assertThrows(GrpcServiceParseException.class,
+        () -> parse(grpcService,
+                    dummyBootstrapInfo(),
+            dummyServerInfo()));
+    assertThat(exception).hasMessageThat()
+        .startsWith("Unsupported: GrpcService must have GoogleGrpc, got: ");
+  }
+
+  @Test
+  public void parse_emptyCallCredentials() throws GrpcServiceParseException {
+    Any insecureCreds = Any.pack(InsecureCredentials.getDefaultInstance());
+    GrpcService.GoogleGrpc googleGrpc = GrpcService.GoogleGrpc.newBuilder().setTargetUri("test_uri")
+        .addChannelCredentialsPlugin(insecureCreds).build();
+    GrpcService grpcService = GrpcService.newBuilder().setGoogleGrpc(googleGrpc).build();
+
+    GrpcServiceConfig config = parse(grpcService,
+            dummyBootstrapInfo(),
+            dummyServerInfo());
+
+    assertThat(config.googleGrpc().callCredentials().isPresent()).isFalse();
+  }
+
+  @Test
+  public void parse_emptyChannelCredentials() {
+    Any accessTokenCreds =
+        Any.pack(AccessTokenCredentials.newBuilder().setToken("test_token").build());
+    GrpcService.GoogleGrpc googleGrpc = GrpcService.GoogleGrpc.newBuilder().setTargetUri("test_uri")
+        .addCallCredentialsPlugin(accessTokenCreds).build();
+    GrpcService grpcService = GrpcService.newBuilder().setGoogleGrpc(googleGrpc).build();
+    GrpcServiceParseException exception = assertThrows(GrpcServiceParseException.class,
+        () -> parse(grpcService,
+                    dummyBootstrapInfo(),
+            dummyServerInfo()));
+    assertThat(exception).hasMessageThat()
+        .isEqualTo("No valid supported channel_credentials found");
+  }
+
+  @Test
+  public void parse_googleDefaultCredentials() throws GrpcServiceParseException {
+    Any googleDefaultCreds = Any.pack(GoogleDefaultCredentials.getDefaultInstance());
+    Any accessTokenCreds =
+        Any.pack(AccessTokenCredentials.newBuilder().setToken("test_token").build());
+    GrpcService.GoogleGrpc googleGrpc = GrpcService.GoogleGrpc.newBuilder().setTargetUri("test_uri")
+        .addChannelCredentialsPlugin(googleDefaultCreds).addCallCredentialsPlugin(accessTokenCreds)
+        .build();
+    GrpcService grpcService = GrpcService.newBuilder().setGoogleGrpc(googleGrpc).build();
+
+    GrpcServiceConfig config = parse(grpcService,
+            dummyBootstrapInfo(),
+            dummyServerInfo());
+
+    assertThat(config.googleGrpc().configuredChannelCredentials().channelCredentials())
+        .isInstanceOf(CompositeChannelCredentials.class);
+    GrpcServiceConfigParser.ProtoChannelCredsConfig credsConfig =
+        (GrpcServiceConfigParser.ProtoChannelCredsConfig)
+            config.googleGrpc().configuredChannelCredentials().channelCredsConfig();
+    assertThat(credsConfig.configProto()).isEqualTo(googleDefaultCreds);
+  }
+
+  @Test
+  public void parse_localCredentials() throws GrpcServiceParseException {
+    Any localCreds = Any.pack(LocalCredentials.getDefaultInstance());
+    Any accessTokenCreds =
+        Any.pack(AccessTokenCredentials.newBuilder().setToken("test_token").build());
+    GrpcService.GoogleGrpc googleGrpc = GrpcService.GoogleGrpc.newBuilder().setTargetUri("test_uri")
+        .addChannelCredentialsPlugin(localCreds).addCallCredentialsPlugin(accessTokenCreds).build();
+    GrpcService grpcService = GrpcService.newBuilder().setGoogleGrpc(googleGrpc).build();
+
+    GrpcServiceParseException exception = assertThrows(GrpcServiceParseException.class,
+            () -> parse(grpcService,
+                    dummyBootstrapInfo(),
+            dummyServerInfo()));
+    assertThat(exception).hasMessageThat()
+        .contains("LocalCredentials are not supported in grpc-java");
+  }
+
+  @Test
+  public void parse_xdsCredentials_withInsecureFallback() throws GrpcServiceParseException {
+    Any insecureCreds = Any.pack(InsecureCredentials.getDefaultInstance());
+    XdsCredentials xdsCreds =
+        XdsCredentials.newBuilder().setFallbackCredentials(insecureCreds).build();
+    Any xdsCredsAny = Any.pack(xdsCreds);
+    Any accessTokenCreds =
+        Any.pack(AccessTokenCredentials.newBuilder().setToken("test_token").build());
+    GrpcService.GoogleGrpc googleGrpc = GrpcService.GoogleGrpc.newBuilder().setTargetUri("test_uri")
+        .addChannelCredentialsPlugin(xdsCredsAny).addCallCredentialsPlugin(accessTokenCreds)
+        .build();
+    GrpcService grpcService = GrpcService.newBuilder().setGoogleGrpc(googleGrpc).build();
+
+    GrpcServiceConfig config = GrpcServiceConfigParser.parse(grpcService,
+            dummyBootstrapInfo(),
+            dummyServerInfo());
+
+    assertThat(config.googleGrpc().configuredChannelCredentials().channelCredentials())
+        .isNotNull();
+    GrpcServiceConfigParser.ProtoChannelCredsConfig credsConfig =
+        (GrpcServiceConfigParser.ProtoChannelCredsConfig)
+            config.googleGrpc().configuredChannelCredentials().channelCredsConfig();
+    assertThat(credsConfig.configProto()).isEqualTo(xdsCredsAny);
+  }
+
+  @Test
+  public void parse_tlsCredentials_notSupported() {
+    Any tlsCreds = Any
+        .pack(io.envoyproxy.envoy.extensions.grpc_service.channel_credentials.tls.v3.TlsCredentials
+            .getDefaultInstance());
+    Any accessTokenCreds =
+        Any.pack(AccessTokenCredentials.newBuilder().setToken("test_token").build());
+    GrpcService.GoogleGrpc googleGrpc = GrpcService.GoogleGrpc.newBuilder().setTargetUri("test_uri")
+        .addChannelCredentialsPlugin(tlsCreds).addCallCredentialsPlugin(accessTokenCreds).build();
+    GrpcService grpcService = GrpcService.newBuilder().setGoogleGrpc(googleGrpc).build();
+
+    GrpcServiceParseException exception = assertThrows(GrpcServiceParseException.class,
+            () -> parse(grpcService,
+                    dummyBootstrapInfo(),
+            dummyServerInfo()));
+    assertThat(exception).hasMessageThat()
+        .contains("TlsCredentials input stream construction pending");
+  }
+
+  @Test
+  public void parse_invalidChannelCredentialsProto() {
+    // Pack a Duration proto, but try to unpack it as GoogleDefaultCredentials
+    Any invalidCreds = Any.pack(Duration.getDefaultInstance());
+    Any accessTokenCreds =
+        Any.pack(AccessTokenCredentials.newBuilder().setToken("test_token").build());
+    GrpcService.GoogleGrpc googleGrpc = GrpcService.GoogleGrpc.newBuilder().setTargetUri("test_uri")
+        .addChannelCredentialsPlugin(invalidCreds).addCallCredentialsPlugin(accessTokenCreds)
+        .build();
+    GrpcService grpcService = GrpcService.newBuilder().setGoogleGrpc(googleGrpc).build();
+
+    GrpcServiceParseException exception = assertThrows(GrpcServiceParseException.class,
+        () -> parse(grpcService,
+                    dummyBootstrapInfo(),
+            dummyServerInfo()));
+    assertThat(exception).hasMessageThat().contains("No valid supported channel_credentials found");
+  }
+
+  @Test
+  public void parse_ignoredUnsupportedCallCredentialsProto() throws GrpcServiceParseException {
+    // Pack a Duration proto, but try to unpack it as AccessTokenCredentials
+    Any insecureCreds = Any.pack(InsecureCredentials.getDefaultInstance());
+    Any invalidCallCredentials = Any.pack(Duration.getDefaultInstance());
+    GrpcService.GoogleGrpc googleGrpc = GrpcService.GoogleGrpc.newBuilder().setTargetUri("test_uri")
+        .addChannelCredentialsPlugin(insecureCreds).addCallCredentialsPlugin(invalidCallCredentials)
+        .build();
+    GrpcService grpcService = GrpcService.newBuilder().setGoogleGrpc(googleGrpc).build();
+
+    GrpcServiceConfig config = parse(grpcService,
+            dummyBootstrapInfo(),
+            dummyServerInfo());
+    assertThat(config.googleGrpc().callCredentials().isPresent()).isFalse();
+  }
+
+  @Test
+  public void parse_invalidAccessTokenCallCredentialsProto() {
+    Any insecureCreds = Any.pack(InsecureCredentials.getDefaultInstance());
+    Any invalidCallCredentials = Any.pack(AccessTokenCredentials.newBuilder().setToken("").build());
+    GrpcService.GoogleGrpc googleGrpc = GrpcService.GoogleGrpc.newBuilder().setTargetUri("test_uri")
+        .addChannelCredentialsPlugin(insecureCreds).addCallCredentialsPlugin(invalidCallCredentials)
+        .build();
+    GrpcService grpcService = GrpcService.newBuilder().setGoogleGrpc(googleGrpc).build();
+
+    GrpcServiceParseException exception = assertThrows(GrpcServiceParseException.class,
+        () -> parse(grpcService,
+                    dummyBootstrapInfo(),
+            dummyServerInfo()));
+    assertThat(exception).hasMessageThat()
+        .contains("Missing or empty access token in call credentials");
+  }
+
+  @Test
+  public void parse_multipleCallCredentials() throws GrpcServiceParseException {
+    Any insecureCreds = Any.pack(InsecureCredentials.getDefaultInstance());
+    Any accessTokenCreds1 =
+        Any.pack(AccessTokenCredentials.newBuilder().setToken("token1").build());
+    Any accessTokenCreds2 =
+        Any.pack(AccessTokenCredentials.newBuilder().setToken("token2").build());
+    GrpcService.GoogleGrpc googleGrpc = GrpcService.GoogleGrpc.newBuilder().setTargetUri("test_uri")
+        .addChannelCredentialsPlugin(insecureCreds).addCallCredentialsPlugin(accessTokenCreds1)
+        .addCallCredentialsPlugin(accessTokenCreds2).build();
+    GrpcService grpcService = GrpcService.newBuilder().setGoogleGrpc(googleGrpc).build();
+
+    GrpcServiceConfig config = parse(grpcService,
+            dummyBootstrapInfo(),
+            dummyServerInfo());
+
+    assertThat(config.googleGrpc().callCredentials().isPresent()).isTrue();
+    assertThat(config.googleGrpc().callCredentials().get())
+        .isInstanceOf(CompositeCallCredentials.class);
+  }
+
+  @Test
+  public void parse_untrustedControlPlane_withoutOverride() {
+    Any insecureCreds = Any.pack(InsecureCredentials.getDefaultInstance());
+    GrpcService.GoogleGrpc googleGrpc = GrpcService.GoogleGrpc.newBuilder().setTargetUri("test_uri")
+        .addChannelCredentialsPlugin(insecureCreds).build();
+    GrpcService grpcService = GrpcService.newBuilder().setGoogleGrpc(googleGrpc).build();
+
+    BootstrapInfo untrustedBootstrapInfo = dummyBootstrapInfo(Optional.empty());
+    ServerInfo untrustedServerInfo =
+        dummyServerInfo(false);
+
+    GrpcServiceParseException exception = assertThrows(GrpcServiceParseException.class,
+            () -> parse(
+            grpcService, untrustedBootstrapInfo, untrustedServerInfo));
+    assertThat(exception).hasMessageThat()
+        .contains("Untrusted xDS server & URI not found in allowed_grpc_services");
+  }
+
+  @Test
+  public void parse_untrustedControlPlane_withOverride() throws GrpcServiceParseException {
+    // The proto credentials (insecure) should be ignored in favor of the override (google default)
+    Any insecureCreds = Any.pack(InsecureCredentials.getDefaultInstance());
+    GrpcService.GoogleGrpc googleGrpc = GrpcService.GoogleGrpc.newBuilder().setTargetUri("test_uri")
+        .addChannelCredentialsPlugin(insecureCreds).build();
+    GrpcService grpcService = GrpcService.newBuilder().setGoogleGrpc(googleGrpc).build();
+
+    ConfiguredChannelCredentials overrideChannelCreds = ConfiguredChannelCredentials.create(
+            GoogleDefaultChannelCredentials.create(),
+            new GrpcServiceConfigParser.ProtoChannelCredsConfig(
+                GrpcServiceConfigParser.GOOGLE_DEFAULT_CREDENTIALS_TYPE_URL,
+                Any.pack(GoogleDefaultCredentials.getDefaultInstance())));
+    AllowedGrpcService override = AllowedGrpcService.builder()
+            .configuredChannelCredentials(overrideChannelCreds).build();
+    AllowedGrpcServices servicesMap =
+            AllowedGrpcServices.create(
+                ImmutableMap.of("test_uri", override));
+
+    BootstrapInfo untrustedBootstrapInfo =
+        dummyBootstrapInfo(Optional.of(GrpcBootstrapImplConfig.create(servicesMap)));
+    ServerInfo untrustedServerInfo =
+        dummyServerInfo(false);
+
+    GrpcServiceConfig config =
+            parse(grpcService, untrustedBootstrapInfo, untrustedServerInfo);
+
+    // Assert channel credentials are the override, not the proto's insecure creds
+    assertThat(config.googleGrpc().configuredChannelCredentials().channelCredentials())
+            .isInstanceOf(CompositeChannelCredentials.class);
+  }
+
+  @Test
+  public void parse_invalidTimeout() {
+    Any insecureCreds = Any.pack(InsecureCredentials.getDefaultInstance());
+    GrpcService.GoogleGrpc googleGrpc = GrpcService.GoogleGrpc.newBuilder().setTargetUri("test_uri")
+        .addChannelCredentialsPlugin(insecureCreds).build();
+
+    // Negative timeout
+    Duration timeout = Duration.newBuilder().setSeconds(-10).build();
+    GrpcService grpcService = GrpcService.newBuilder()
+        .setGoogleGrpc(googleGrpc).setTimeout(timeout).build();
+
+    GrpcServiceParseException exception = assertThrows(GrpcServiceParseException.class,
+            () -> parse(grpcService,
+                    dummyBootstrapInfo(),
+            dummyServerInfo()));
+    assertThat(exception).hasMessageThat()
+        .contains("Timeout must be strictly positive");
+
+    // Zero timeout
+    timeout = Duration.newBuilder().setSeconds(0).setNanos(0).build();
+    GrpcService grpcServiceZero = GrpcService.newBuilder()
+        .setGoogleGrpc(googleGrpc).setTimeout(timeout).build();
+
+    exception = assertThrows(GrpcServiceParseException.class,
+            () -> parse(grpcServiceZero,
+                    dummyBootstrapInfo(),
+            dummyServerInfo()));
+    assertThat(exception).hasMessageThat()
+        .contains("Timeout must be strictly positive");
+  }
+
+  @Test
+  public void parseGoogleGrpcConfig_unsupportedScheme() {
+    Any insecureCreds = Any.pack(InsecureCredentials.getDefaultInstance());
+    GrpcService.GoogleGrpc googleGrpc = GrpcService.GoogleGrpc.newBuilder()
+        .setTargetUri("unknown://test")
+        .addChannelCredentialsPlugin(insecureCreds).build();
+
+    BootstrapInfo bootstrapInfo = dummyBootstrapInfo();
+    ServerInfo serverInfo = dummyServerInfo();
+
+    GrpcServiceParseException exception = assertThrows(GrpcServiceParseException.class,
+        () -> parseGoogleGrpcConfig(
+            googleGrpc, bootstrapInfo, serverInfo));
+    assertThat(exception).hasMessageThat()
+        .contains("Target URI scheme is not resolvable");
+  }
+
+  @Test
+  public void parse_disallowedInitialMetadata() {
+    Any insecureCreds = Any.pack(InsecureCredentials.getDefaultInstance());
+    GrpcService.GoogleGrpc googleGrpc = GrpcService.GoogleGrpc.newBuilder().setTargetUri("test_uri")
+        .addChannelCredentialsPlugin(insecureCreds).build();
+    HeaderValue disallowedHeader =
+        HeaderValue.newBuilder().setKey("host").setValue("test_value").build();
+    GrpcService grpcService = GrpcService.newBuilder().setGoogleGrpc(googleGrpc)
+        .addInitialMetadata(disallowedHeader).build();
+
+    GrpcServiceParseException exception = assertThrows(GrpcServiceParseException.class,
+        () -> parse(grpcService, dummyBootstrapInfo(), dummyServerInfo()));
+    assertThat(exception).hasMessageThat().contains("Invalid initial metadata header: host");
+  }
+
+  @Test
+  public void parse_invalidDuration() {
+    Any insecureCreds = Any.pack(InsecureCredentials.getDefaultInstance());
+    GrpcService.GoogleGrpc googleGrpc = GrpcService.GoogleGrpc.newBuilder().setTargetUri("test_uri")
+        .addChannelCredentialsPlugin(insecureCreds).build();
+
+    Duration timeout = Duration.newBuilder().setSeconds(10).setNanos(1_000_000_000).build();
+    GrpcService grpcService = GrpcService.newBuilder()
+        .setGoogleGrpc(googleGrpc).setTimeout(timeout).build();
+
+    GrpcServiceParseException exception = assertThrows(GrpcServiceParseException.class,
+        () -> parse(grpcService, dummyBootstrapInfo(), dummyServerInfo()));
+    assertThat(exception).hasMessageThat()
+        .contains("Timeout must be strictly positive and valid");
+  }
+
+  @Test
+  public void parse_invalidChannelCredsProto() {
+    Any invalidCreds = Any.newBuilder()
+        .setTypeUrl(GrpcServiceConfigParser.XDS_CREDENTIALS_TYPE_URL)
+        .setValue(ByteString.copyFrom(new byte[]{1, 2, 3})).build();
+    GrpcService.GoogleGrpc googleGrpc = GrpcService.GoogleGrpc.newBuilder().setTargetUri("test_uri")
+        .addChannelCredentialsPlugin(invalidCreds).build();
+    GrpcService grpcService = GrpcService.newBuilder().setGoogleGrpc(googleGrpc).build();
+
+    GrpcServiceParseException exception = assertThrows(GrpcServiceParseException.class,
+        () -> parse(grpcService, dummyBootstrapInfo(), dummyServerInfo()));
+    assertThat(exception).hasMessageThat().contains("Failed to parse channel credentials");
+  }
+
+  @Test
+  public void parse_unsupportedXdsFallbackCreds() {
+    Any unsupportedFallback = Any.pack(Duration.getDefaultInstance());
+    XdsCredentials xds =
+        XdsCredentials.newBuilder().setFallbackCredentials(unsupportedFallback).build();
+    Any xdsCredsAny = Any.newBuilder()
+        .setTypeUrl(GrpcServiceConfigParser.XDS_CREDENTIALS_TYPE_URL)
+        .setValue(xds.toByteString()).build();
+    GrpcService.GoogleGrpc googleGrpc = GrpcService.GoogleGrpc.newBuilder().setTargetUri("test_uri")
+        .addChannelCredentialsPlugin(xdsCredsAny).build();
+    GrpcService grpcService = GrpcService.newBuilder().setGoogleGrpc(googleGrpc).build();
+
+    GrpcServiceParseException exception = assertThrows(GrpcServiceParseException.class,
+        () -> parse(grpcService, dummyBootstrapInfo(), dummyServerInfo()));
+    assertThat(exception).hasMessageThat()
+        .contains("Unsupported fallback credentials type for XdsCredentials");
+  }
+
+  @Test
+  public void parse_invalidCallCredsProto() {
+    Any insecureCreds = Any.pack(InsecureCredentials.getDefaultInstance());
+    // We just create an Any representing AccessTokenCredentials but with invalid bytes
+    Any invalidCallCreds = Any.newBuilder()
+        .setTypeUrl(Any.pack(AccessTokenCredentials.getDefaultInstance()).getTypeUrl())
+        .setValue(ByteString.copyFrom(new byte[]{1, 2, 3})).build();
+
+    GrpcService.GoogleGrpc googleGrpc = GrpcService.GoogleGrpc.newBuilder().setTargetUri("test_uri")
+        .addChannelCredentialsPlugin(insecureCreds).addCallCredentialsPlugin(invalidCallCreds)
+        .build();
+    GrpcService grpcService = GrpcService.newBuilder().setGoogleGrpc(googleGrpc).build();
+
+    GrpcServiceParseException exception = assertThrows(GrpcServiceParseException.class,
+        () -> parse(grpcService, dummyBootstrapInfo(), dummyServerInfo()));
+    assertThat(exception).hasMessageThat().contains("Failed to parse access token credentials");
+  }
+
+  @Test
+  public void parseGoogleGrpcConfig_malformedUriThrows() {
+    Any insecureCreds = Any.pack(InsecureCredentials.getDefaultInstance());
+    GrpcService.GoogleGrpc googleGrpc = GrpcService.GoogleGrpc.newBuilder().setTargetUri(":::::")
+        .addChannelCredentialsPlugin(insecureCreds).build();
+
+    BootstrapInfo bootstrapInfo = dummyBootstrapInfo();
+    ServerInfo serverInfo = dummyServerInfo();
+
+    GrpcServiceParseException exception = assertThrows(GrpcServiceParseException.class,
+        () -> parseGoogleGrpcConfig(googleGrpc, bootstrapInfo, serverInfo));
+    assertThat(exception).hasMessageThat().contains("Target URI scheme is not resolvable");
+  }
+
+  @Test
+  public void parseGoogleGrpcConfig_untrustedWithCallCredentialsOverride() throws Exception {
+    Any insecureCreds = Any.pack(InsecureCredentials.getDefaultInstance());
+    GrpcService.GoogleGrpc googleGrpc = GrpcService.GoogleGrpc.newBuilder().setTargetUri("test_uri")
+        .addChannelCredentialsPlugin(insecureCreds).build();
+
+    ConfiguredChannelCredentials overrideChannelCreds =
+        ConfiguredChannelCredentials.create(GoogleDefaultChannelCredentials.create(),
+            new GrpcServiceConfigParser.ProtoChannelCredsConfig(
+                GrpcServiceConfigParser.GOOGLE_DEFAULT_CREDENTIALS_TYPE_URL,
+                Any.pack(GoogleDefaultCredentials.getDefaultInstance())));
+
+    CallCredentials fakeCallCreds = Mockito.mock(CallCredentials.class);
+    AllowedGrpcService override = AllowedGrpcService.builder()
+        .configuredChannelCredentials(overrideChannelCreds).callCredentials(fakeCallCreds).build();
+
+    AllowedGrpcServices servicesMap =
+        AllowedGrpcServices
+            .create(ImmutableMap.of("test_uri", override));
+
+    BootstrapInfo untrustedBootstrapInfo =
+        dummyBootstrapInfo(Optional.of(GrpcBootstrapImplConfig.create(servicesMap)));
+    ServerInfo untrustedServerInfo = dummyServerInfo(false);
+
+    GrpcServiceConfig.GoogleGrpcConfig config =
+        parseGoogleGrpcConfig(googleGrpc, untrustedBootstrapInfo, untrustedServerInfo);
+
+    assertThat(config.callCredentials().isPresent()).isTrue();
+    assertThat(config.callCredentials().get()).isSameInstanceAs(fakeCallCreds);
+  }
+
+  @Test
+  public void protoChannelCredsConfig_equalsAndHashCode() {
+    Any insecureCreds1 = Any.pack(InsecureCredentials.getDefaultInstance());
+    Any insecureCreds2 = Any.pack(InsecureCredentials.getDefaultInstance());
+    Any localCreds = Any.pack(LocalCredentials.getDefaultInstance());
+
+    GrpcServiceConfigParser.ProtoChannelCredsConfig config1 =
+        new GrpcServiceConfigParser.ProtoChannelCredsConfig("type1", insecureCreds1);
+    GrpcServiceConfigParser.ProtoChannelCredsConfig config1Equivalent =
+        new GrpcServiceConfigParser.ProtoChannelCredsConfig("type1", insecureCreds2);
+    GrpcServiceConfigParser.ProtoChannelCredsConfig configDifferentType =
+        new GrpcServiceConfigParser.ProtoChannelCredsConfig("type2", insecureCreds1);
+    GrpcServiceConfigParser.ProtoChannelCredsConfig configDifferentProto =
+        new GrpcServiceConfigParser.ProtoChannelCredsConfig("type1", localCreds);
+
+    assertThat(config1.type()).isEqualTo("type1");
+    assertThat(config1.equals(config1)).isTrue();
+    assertThat(config1.equals(null)).isFalse();
+    assertThat(config1.equals(new Object())).isFalse();
+    assertThat(config1.equals(config1Equivalent)).isTrue();
+    assertThat(config1.hashCode()).isEqualTo(config1Equivalent.hashCode());
+    assertThat(config1.equals(configDifferentType)).isFalse();
+    assertThat(config1.equals(configDifferentProto)).isFalse();
+  }
+
+  static class RecordingMetadataApplier extends CallCredentials.MetadataApplier {
+    boolean applied = false;
+    boolean failed = false;
+    Metadata appliedHeaders = null;
+
+    @Override
+    public void apply(Metadata headers) {
+      applied = true;
+      appliedHeaders = headers;
+    }
+
+    @Override
+    public void fail(Status status) {
+      failed = true;
+    }
+  }
+
+  static class FakeRequestInfo extends CallCredentials.RequestInfo {
+    private final SecurityLevel securityLevel;
+    private final MethodDescriptor<?, ?> methodDescriptor;
+
+    FakeRequestInfo(SecurityLevel securityLevel) {
+      this.securityLevel = securityLevel;
+      this.methodDescriptor = MethodDescriptor.<Void, Void>newBuilder()
+          .setType(MethodDescriptor.MethodType.UNARY)
+          .setFullMethodName("test_service/test_method")
+          .setRequestMarshaller(new NoopMarshaller<Void>())
+          .setResponseMarshaller(new NoopMarshaller<Void>())
+          .build();
+    }
+
+    private static class NoopMarshaller<T> implements MethodDescriptor.Marshaller<T> {
+      @Override
+      public InputStream stream(T value) {
+        return null;
+      }
+
+      @Override
+      public T parse(InputStream stream) {
+        return null;
+      }
+    }
+
+    @Override
+    public MethodDescriptor<?, ?> getMethodDescriptor() {
+      return methodDescriptor;
+    }
+
+    @Override
+    public SecurityLevel getSecurityLevel() {
+      return securityLevel;
+    }
+
+    @Override
+    public String getAuthority() {
+      return "dummy-authority";
+    }
+
+    @Override
+    public Attributes getTransportAttrs() {
+      return Attributes.EMPTY;
+    }
+  }
+
+
+  @Test
+  public void securityAwareCredentials_secureConnection_appliesToken() throws Exception {
+    Any insecureCreds = Any.pack(InsecureCredentials.getDefaultInstance());
+    Any accessTokenCreds =
+        Any.pack(AccessTokenCredentials.newBuilder().setToken("test_token").build());
+    GrpcService.GoogleGrpc googleGrpc = GrpcService.GoogleGrpc.newBuilder()
+        .setTargetUri("test_uri")
+        .addChannelCredentialsPlugin(insecureCreds)
+        .addCallCredentialsPlugin(accessTokenCreds)
+        .build();
+    GrpcService grpcService = GrpcService.newBuilder().setGoogleGrpc(googleGrpc).build();
+
+    GrpcServiceConfig config = parse(grpcService,
+        dummyBootstrapInfo(),
+            dummyServerInfo());
+
+    CallCredentials creds = config.googleGrpc().callCredentials().get();
+    RecordingMetadataApplier applier = new RecordingMetadataApplier();
+    CountDownLatch latch = new CountDownLatch(1);
+
+    creds.applyRequestMetadata(
+        new FakeRequestInfo(SecurityLevel.PRIVACY_AND_INTEGRITY),
+        Runnable::run, // Use direct executor to avoid async issues in test
+        new CallCredentials.MetadataApplier() {
+          @Override
+          public void apply(Metadata headers) {
+            applier.apply(headers);
+            latch.countDown();
+          }
+
+          @Override
+          public void fail(Status status) {
+            applier.fail(status);
+            latch.countDown();
+          }
+        });
+
+    latch.await(5, TimeUnit.SECONDS);
+    assertThat(applier.applied).isTrue();
+    assertThat(applier.appliedHeaders.get(
+        Metadata.Key.of("Authorization", Metadata.ASCII_STRING_MARSHALLER)))
+        .isEqualTo("Bearer test_token");
+  }
+
+  @Test
+  public void securityAwareCredentials_insecureConnection_appliesEmptyMetadata() throws Exception {
+    Any insecureCreds = Any.pack(InsecureCredentials.getDefaultInstance());
+    Any accessTokenCreds =
+        Any.pack(AccessTokenCredentials.newBuilder().setToken("test_token").build());
+    GrpcService.GoogleGrpc googleGrpc = GrpcService.GoogleGrpc.newBuilder()
+        .setTargetUri("test_uri")
+        .addChannelCredentialsPlugin(insecureCreds)
+        .addCallCredentialsPlugin(accessTokenCreds)
+        .build();
+    GrpcService grpcService = GrpcService.newBuilder().setGoogleGrpc(googleGrpc).build();
+
+    GrpcServiceConfig config = parse(grpcService,
+        dummyBootstrapInfo(),
+            dummyServerInfo());
+
+    CallCredentials creds = config.googleGrpc().callCredentials().get();
+    RecordingMetadataApplier applier = new RecordingMetadataApplier();
+
+    creds.applyRequestMetadata(
+        new FakeRequestInfo(SecurityLevel.NONE),
+        Runnable::run,
+        applier);
+
+    assertThat(applier.applied).isTrue();
+    assertThat(applier.appliedHeaders.get(
+        Metadata.Key.of("Authorization", Metadata.ASCII_STRING_MARSHALLER)))
+        .isNull();
+  }
+
+
+}
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..aa8ff68b760
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/GrpcXdsClientImplDataTest.java
@@ -0,0 +1,3637 @@
+/*
+ * 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.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, getXdsResourceTypeArgs(true))
+                    .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,
+            getXdsResourceTypeArgs(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,
+              FilterConfigParseContext context) {
+        return ConfigOrError.fromConfig(new SimpleFilterConfig(rawProtoMessage));
+      }
+
+      @Override
+      public ConfigOrError<SimpleFilterConfig> parseFilterConfigOverride(Message rawProtoMessage,
+              FilterConfigParseContext context) {
+        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, getXdsResourceTypeArgs(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, getXdsResourceTypeArgs(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, getXdsResourceTypeArgs(true)).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, getXdsResourceTypeArgs(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 */, getXdsResourceTypeArgs(true))
+            .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 */, getXdsResourceTypeArgs(false))
+            .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 */, getXdsResourceTypeArgs(true))
+            .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 */,
+                    getXdsResourceTypeArgs(false));
+    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 */, getXdsResourceTypeArgs(false))
+            .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 */,
+                    getXdsResourceTypeArgs(true));
+    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,
+                    getXdsResourceTypeArgs(true))
+            .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,
+                    getXdsResourceTypeArgs(true))
+            .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,
+                    getXdsResourceTypeArgs(true))
+        .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,
+                    getXdsResourceTypeArgs(true))
+        .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("envoy.transport_sockets.http_11_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, XdsTestUtils.EMPTY_BOOTSTRAP, 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..9c606a962f6
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/GrpcXdsTransportFactoryTest.java
@@ -0,0 +1,200 @@
+/*
+ * 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.testing.GrpcCleanupRule;
+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.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class GrpcXdsTransportFactoryTest {
+
+  @Rule public final GrpcCleanupRule grpcCleanupRule = new GrpcCleanupRule();
+
+  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();
+  }
+
+  @Test
+  public void refCountedXdsTransport_sameXdsServerAddress_returnsExistingTransport() {
+    Bootstrapper.ServerInfo xdsServerInfo =
+        Bootstrapper.ServerInfo.create(
+            "localhost:" + server.getPort(), InsecureChannelCredentials.create());
+    GrpcXdsTransportFactory xdsTransportFactory = new GrpcXdsTransportFactory(null);
+    // Calling create() for the first time creates a new GrpcXdsTransport instance.
+    // The ref count was previously 0 and now is 1.
+    XdsTransportFactory.XdsTransport transport1 = xdsTransportFactory.create(xdsServerInfo);
+    // Calling create() for the second time to the same xDS server address returns the same
+    // GrpcXdsTransport instance. The ref count was previously 1 and now is 2.
+    XdsTransportFactory.XdsTransport transport2 = xdsTransportFactory.create(xdsServerInfo);
+    assertThat(transport1).isSameInstanceAs(transport2);
+    // Calling shutdown() for the first time does not shut down the GrpcXdsTransport instance.
+    // The ref count was previously 2 and now is 1.
+    transport1.shutdown();
+    // Calling shutdown() for the second time shuts down the GrpcXdsTransport instance.
+    // The ref count was previously 1 and now is 0.
+    transport2.shutdown();
+  }
+
+  @Test
+  public void refCountedXdsTransport_differentXdsServerAddress_returnsDifferentTransport()
+      throws Exception {
+    // Create and start a second xDS server on a different port.
+    Server server2 =
+        grpcCleanupRule.register(
+            Grpc.newServerBuilderForPort(0, InsecureServerCredentials.create())
+                .addService(echoAdsService())
+                .build()
+                .start());
+    Bootstrapper.ServerInfo xdsServerInfo1 =
+        Bootstrapper.ServerInfo.create(
+            "localhost:" + server.getPort(), InsecureChannelCredentials.create());
+    Bootstrapper.ServerInfo xdsServerInfo2 =
+        Bootstrapper.ServerInfo.create(
+            "localhost:" + server2.getPort(), InsecureChannelCredentials.create());
+    GrpcXdsTransportFactory xdsTransportFactory = new GrpcXdsTransportFactory(null);
+    // Calling create() to the first xDS server creates a new GrpcXdsTransport instance.
+    // The ref count was previously 0 and now is 1.
+    XdsTransportFactory.XdsTransport transport1 = xdsTransportFactory.create(xdsServerInfo1);
+    // Calling create() to the second xDS server creates a different GrpcXdsTransport instance.
+    // The ref count was previously 0 and now is 1.
+    XdsTransportFactory.XdsTransport transport2 = xdsTransportFactory.create(xdsServerInfo2);
+    assertThat(transport1).isNotSameInstanceAs(transport2);
+    // Calling shutdown() shuts down the GrpcXdsTransport instance for the first xDS server.
+    // The ref count was previously 1 and now is 0.
+    transport1.shutdown();
+    // Calling shutdown() shuts down the GrpcXdsTransport instance for the second xDS server.
+    // The ref count was previously 1 and now is 0.
+    transport2.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..b8b20248026
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/LoadBalancerConfigFactoryTest.java
@@ -0,0 +1,448 @@
+/*
+ * 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 Policy WRR_POLICY_WITH_METRICS = 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())
+                          .addMetricNamesForComputingUtilization("foo")
+                          .addMetricNamesForComputingUtilization("bar")
+                          .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_WRR_CONFIG_WITH_METRICS =
+      new LbConfig("wrr_locality_experimental",
+          ImmutableMap.of("childPolicy",
+              ImmutableList.of(ImmutableMap.of("weighted_round_robin",
+                  ImmutableMap.of("blackoutPeriod", "287s", "enableOobLoadReport", true,
+                      "errorUtilizationPenalty", 1.75F,
+                      LoadBalancerConfigFactory.METRIC_NAMES_FOR_COMPUTING_UTILIZATION,
+                      ImmutableList.of("foo", "bar"))))));
+  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_withMetrics() throws ResourceInvalidException {
+    Cluster cluster = newCluster(buildWrrPolicy(WRR_POLICY_WITH_METRICS));
+
+    assertThat(newLbConfig(cluster, true)).isEqualTo(VALID_WRR_CONFIG_WITH_METRICS);
+  }
+
+  @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
index cc46d572020..9bdf86132b6 100644
--- a/xds/src/test/java/io/grpc/xds/LoadReportClientTest.java
+++ b/xds/src/test/java/io/grpc/xds/LoadReportClientTest.java
@@ -33,12 +33,13 @@
 import com.google.protobuf.Struct;
 import com.google.protobuf.Value;
 import com.google.protobuf.util.Durations;
-import io.envoyproxy.envoy.api.v2.core.Node;
-import io.envoyproxy.envoy.api.v2.endpoint.ClusterStats;
-import io.envoyproxy.envoy.api.v2.endpoint.UpstreamLocalityStats;
-import io.envoyproxy.envoy.service.load_stats.v2.LoadReportingServiceGrpc;
-import io.envoyproxy.envoy.service.load_stats.v2.LoadStatsRequest;
-import io.envoyproxy.envoy.service.load_stats.v2.LoadStatsResponse;
+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;
@@ -50,8 +51,12 @@
 import io.grpc.internal.FakeClock;
 import io.grpc.stub.StreamObserver;
 import io.grpc.testing.GrpcCleanupRule;
-import io.grpc.xds.LoadStatsManager2.ClusterDropStats;
-import io.grpc.xds.LoadStatsManager2.ClusterLocalityStats;
+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;
@@ -66,12 +71,12 @@
 import org.mockito.Captor;
 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 LoadReportClient}.
  */
-// TODO(chengyuanzhang): missing LRS V3 test.
 @RunWith(JUnit4.class)
 public class LoadReportClientTest {
   // bootstrap node identifier
@@ -91,7 +96,7 @@ public class LoadReportClientTest {
         @Override
         public boolean shouldAccept(Runnable command) {
           return command.toString()
-              .contains(LoadReportClient.LoadReportingTask.class.getSimpleName());
+              .contains("LoadReportingTask");
         }
       };
   private static final FakeClock.TaskFilter LRS_RPC_RETRY_TASK_FILTER =
@@ -99,12 +104,14 @@ public boolean shouldAccept(Runnable command) {
         @Override
         public boolean shouldAccept(Runnable command) {
           return command.toString()
-              .contains(LoadReportClient.LrsRpcRetryTask.class.getSimpleName());
+              .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
@@ -139,7 +146,6 @@ public void uncaughtException(Thread t, Throwable e) {
   @SuppressWarnings("unchecked")
   @Before
   public void setUp() throws Exception {
-    MockitoAnnotations.initMocks(this);
     mockLoadReportingService = mock(LoadReportingServiceGrpc.LoadReportingServiceImplBase.class,
         delegatesTo(
             new LoadReportingServiceGrpc.LoadReportingServiceImplBase() {
@@ -172,9 +178,15 @@ public void cancelled(Context context) {
     when(backoffPolicy2.nextBackoffNanos())
         .thenReturn(TimeUnit.SECONDS.toNanos(2L), TimeUnit.SECONDS.toNanos(20L));
     addFakeStatsData();
-    lrsClient = new LoadReportClient(loadStatsManager, channel, false, NODE, syncContext,
-        fakeClock.getScheduledExecutorService(), backoffPolicyProvider,
-        fakeClock.getStopwatchSupplier());
+    lrsClient =
+        new LoadReportClient(
+            loadStatsManager,
+            new GrpcXdsTransportFactory(null).createForTest(channel),
+            NODE,
+            syncContext,
+            fakeClock.getScheduledExecutorService(),
+            backoffPolicyProvider,
+            fakeClock.getStopwatchSupplier());
     syncContext.execute(new Runnable() {
       @Override
       public void run() {
@@ -197,11 +209,15 @@ private void addFakeStatsData() {
     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);
   }
 
@@ -244,6 +260,12 @@ public void periodicLoadReporting() {
     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());
@@ -262,6 +284,7 @@ public void periodicLoadReporting() {
     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.
@@ -286,6 +309,7 @@ public void periodicLoadReporting() {
     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)
@@ -308,6 +332,7 @@ public void periodicLoadReporting() {
     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);
@@ -325,6 +350,12 @@ public void periodicLoadReporting() {
     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)
@@ -347,6 +378,7 @@ public void periodicLoadReporting() {
     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());
@@ -365,6 +397,7 @@ public void periodicLoadReporting() {
     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")
@@ -434,8 +467,15 @@ public void lrsStreamClosedAndRetried() {
     // Then breaks the RPC
     responseObserver.onError(Status.UNAVAILABLE.asException());
 
-    // Will reset the retry sequence and retry immediately, because balancer has responded.
+    // 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);
@@ -446,12 +486,12 @@ public void lrsStreamClosedAndRetried() {
     fakeClock.forwardNanos(4);
     responseObserver.onError(Status.UNAVAILABLE.asException());
 
-    // Will be on the first retry (2s) of backoff sequence 2.
+    // 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(2) - 4 - 1);
+    fakeClock.forwardNanos(TimeUnit.SECONDS.toNanos(20) - 4 - 1);
     verifyNoMoreInteractions(mockLoadReportingService);
     // Then time for retry
     fakeClock.forwardNanos(1);
@@ -471,7 +511,8 @@ public void lrsStreamClosedAndRetried() {
     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);
+    assertThat(Durations.toSeconds(clusterStats.getLoadReportInterval()))
+        .isEqualTo(1L + 10L + 2L + 20L);
     assertThat(Iterables.getOnlyElement(clusterStats.getDroppedRequestsList()).getCategory())
         .isEqualTo("lb");
     assertThat(Iterables.getOnlyElement(clusterStats.getDroppedRequestsList()).getDroppedCount())
@@ -486,11 +527,17 @@ public void lrsStreamClosedAndRetried() {
     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(1)).nextBackoffNanos();
+    verify(backoffPolicy2, times(2)).nextBackoffNanos();
   }
 
   @Test
diff --git a/xds/src/test/java/io/grpc/xds/LoadStatsManager2Test.java b/xds/src/test/java/io/grpc/xds/LoadStatsManager2Test.java
deleted file mode 100644
index 0cfb7f46a22..00000000000
--- a/xds/src/test/java/io/grpc/xds/LoadStatsManager2Test.java
+++ /dev/null
@@ -1,284 +0,0 @@
-/*
- * 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.Iterables;
-import io.grpc.Status;
-import io.grpc.internal.FakeClock;
-import io.grpc.xds.LoadStatsManager2.ClusterDropStats;
-import io.grpc.xds.LoadStatsManager2.ClusterLocalityStats;
-import io.grpc.xds.Stats.ClusterStats;
-import io.grpc.xds.Stats.DroppedRequests;
-import io.grpc.xds.Stats.UpstreamLocalityStats;
-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 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();
-    }
-    fakeClock.forwardTime(5L, TimeUnit.SECONDS);
-    dropCounter2.recordDroppedRequest();
-    loadCounter1.recordCallFinished(Status.OK);
-    for (int i = 0; i < 9; i++) {
-      loadCounter2.recordCallStarted();
-    }
-    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.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.totalIssuedRequests()).isEqualTo(19L);
-    assertThat(loadStats1.totalSuccessfulRequests()).isEqualTo(1L);
-    assertThat(loadStats1.totalErrorRequests()).isEqualTo(0L);
-    assertThat(loadStats1.totalRequestsInProgress()).isEqualTo(19L - 1L);
-
-    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);
-
-    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);
-
-    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
-    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
-
-    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.recordCallFinished(Status.OK);
-    ref2.recordCallStarted();
-    ref2.recordCallStarted();
-    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);
-  }
-
-  @Test
-  public void loadCounterDelayedDeletionAfterAllInProgressRequestsReported() {
-    ClusterLocalityStats counter = loadStatsManager.getClusterLocalityStats(
-        CLUSTER_NAME1, EDS_SERVICE_NAME1, LOCALITY1);
-    counter.recordCallStarted();
-    counter.recordCallStarted();
-
-    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);
-
-    // 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
-
-    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(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/MessagePrinterTest.java b/xds/src/test/java/io/grpc/xds/MessagePrinterTest.java
index bb6c5517ab9..6d8904b4a4f 100644
--- a/xds/src/test/java/io/grpc/xds/MessagePrinterTest.java
+++ b/xds/src/test/java/io/grpc/xds/MessagePrinterTest.java
@@ -64,7 +64,6 @@
  */
 @RunWith(JUnit4.class)
 public class MessagePrinterTest {
-  private final MessagePrinter printer = new MessagePrinter();
 
   @Test
   public void printLdsResponse_v3() {
@@ -151,7 +150,7 @@ public void printLdsResponse_v3() {
         + "  \"typeUrl\": \"type.googleapis.com/envoy.config.listener.v3.Listener\",\n"
         + "  \"nonce\": \"0000\"\n"
         + "}";
-    String res = printer.print(response);
+    String res = MessagePrinter.INSTANCE.print(response);
     assertThat(res).isEqualTo(expectedString);
   }
 
@@ -202,7 +201,7 @@ public void printRdsResponse_v3() {
         + "  \"typeUrl\": \"type.googleapis.com/envoy.config.route.v3.RouteConfiguration\",\n"
         + "  \"nonce\": \"0000\"\n"
         + "}";
-    String res = printer.print(response);
+    String res = MessagePrinter.INSTANCE.print(response);
     assertThat(res).isEqualTo(expectedString);
   }
 
@@ -267,7 +266,7 @@ public void printCdsResponse_v3() {
         + "  \"typeUrl\": \"type.googleapis.com/envoy.config.cluster.v3.Cluster\",\n"
         + "  \"nonce\": \"0000\"\n"
         + "}";
-    String res = printer.print(response);
+    String res = MessagePrinter.INSTANCE.print(response);
     assertThat(res).isEqualTo(expectedString);
   }
 
@@ -356,7 +355,7 @@ public void printEdsResponse_v3() {
         + ".ClusterLoadAssignment\",\n"
         + "  \"nonce\": \"0000\"\n"
         + "}";
-    String res = printer.print(response);
+    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..0499bafdb23
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/MetadataLoadBalancerProvider.java
@@ -0,0 +1,182 @@
+/*
+ * 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;
+    }
+
+    @Deprecated
+    @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/OrcaMetricReportingServerInterceptorTest.java b/xds/src/test/java/io/grpc/xds/OrcaMetricReportingServerInterceptorTest.java
deleted file mode 100644
index b59871f5437..00000000000
--- a/xds/src/test/java/io/grpc/xds/OrcaMetricReportingServerInterceptorTest.java
+++ /dev/null
@@ -1,223 +0,0 @@
-/*
- * 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.github.udpa.udpa.data.orca.v1.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.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> applicationMetrics = new HashMap<>();
-
-  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 : applicationMetrics.entrySet()) {
-              CallMetricRecorder.getCurrent().recordCallMetric(entry.getKey(), entry.getValue());
-            }
-            SimpleResponse response =
-                SimpleResponse.newBuilder().setResponseMessage("Simple response").build();
-            responseObserver.onNext(response);
-            responseObserver.onCompleted();
-          }
-        };
-
-    ServerInterceptor metricReportingServerInterceptor = new OrcaMetricReportingServerInterceptor();
-    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 =
-        InternalCallMetricRecorder.newCallMetricRecorder();
-    ServerStreamTracer.Factory 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 = new OrcaMetricReportingServerInterceptor();
-    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 responseTrailersContainAllReportedMetrics() {
-    applicationMetrics.put("cost1", 1231.4543);
-    applicationMetrics.put("cost2", 0.1367);
-    applicationMetrics.put("cost3", 7614.145);
-    ClientCalls.blockingUnaryCall(channelToUse, SIMPLE_METHOD, CallOptions.DEFAULT, REQUEST);
-    Metadata receivedTrailers = trailersCapture.get();
-    OrcaLoadReport report =
-        receivedTrailers.get(OrcaMetricReportingServerInterceptor.ORCA_ENDPOINT_LOAD_METRICS_KEY);
-    assertThat(report.getRequestCostMap())
-        .containsExactly("cost1", 1231.4543, "cost2", 0.1367, "cost3", 7614.145);
-  }
-
-  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/OrcaPerRequestUtilTest.java b/xds/src/test/java/io/grpc/xds/OrcaPerRequestUtilTest.java
deleted file mode 100644
index bee68c9e634..00000000000
--- a/xds/src/test/java/io/grpc/xds/OrcaPerRequestUtilTest.java
+++ /dev/null
@@ -1,170 +0,0 @@
-/*
- * 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.mockito.AdditionalAnswers.delegatesTo;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.eq;
-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.udpa.udpa.data.orca.v1.OrcaLoadReport;
-import io.grpc.ClientStreamTracer;
-import io.grpc.Metadata;
-import io.grpc.xds.OrcaPerRequestUtil.OrcaPerRequestReportListener;
-import io.grpc.xds.OrcaPerRequestUtil.OrcaReportingTracerFactory;
-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.Mock;
-import org.mockito.MockitoAnnotations;
-
-/**
- * Unit tests for {@link OrcaPerRequestUtil} class.
- */
-@RunWith(JUnit4.class)
-public class OrcaPerRequestUtilTest {
-
-  private static final ClientStreamTracer.StreamInfo STREAM_INFO =
-      ClientStreamTracer.StreamInfo.newBuilder().build();
-
-  @Mock
-  private OrcaPerRequestReportListener orcaListener1;
-  @Mock
-  private OrcaPerRequestReportListener orcaListener2;
-
-  @Before
-  public void setUp() {
-    MockitoAnnotations.initMocks(this);
-  }
-
-  /**
-   * 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(null);
-    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<OrcaLoadReport> reportCaptor = ArgumentCaptor.forClass(null);
-    verify(orcaListener1).onLoadReport(reportCaptor.capture());
-    assertThat(reportCaptor.getValue()).isEqualTo(OrcaLoadReport.getDefaultInstance());
-  }
-
-  /**
-   * 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(null);
-    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<OrcaLoadReport> parentReportCap = ArgumentCaptor.forClass(null);
-    ArgumentCaptor<OrcaLoadReport> childReportCap = ArgumentCaptor.forClass(null);
-    verify(orcaListener1).onLoadReport(parentReportCap.capture());
-    verify(orcaListener2).onLoadReport(childReportCap.capture());
-    assertThat(parentReportCap.getValue()).isEqualTo(OrcaLoadReport.getDefaultInstance());
-    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();
-    trailer.put(
-        OrcaReportingTracerFactory.ORCA_ENDPOINT_LOAD_METRICS_KEY,
-        OrcaLoadReport.getDefaultInstance());
-    parentTracer.inboundTrailers(trailer);
-    verify(orcaListener1).onLoadReport(eq(OrcaLoadReport.getDefaultInstance()));
-    verifyNoInteractions(childFactory);
-    verifyNoInteractions(orcaListener2);
-  }
-}
diff --git a/xds/src/test/java/io/grpc/xds/PriorityLoadBalancerProviderTest.java b/xds/src/test/java/io/grpc/xds/PriorityLoadBalancerProviderTest.java
index 5d96ed87949..37ea24b2aa9 100644
--- a/xds/src/test/java/io/grpc/xds/PriorityLoadBalancerProviderTest.java
+++ b/xds/src/test/java/io/grpc/xds/PriorityLoadBalancerProviderTest.java
@@ -16,27 +16,24 @@
 
 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.internal.ServiceConfigUtil.PolicySelection;
+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.Rule;
 import org.junit.Test;
-import org.junit.rules.ExpectedException;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 
 /** Tests for {@link PriorityLoadBalancerProvider}. */
 @RunWith(JUnit4.class)
 public class PriorityLoadBalancerProviderTest {
-  @SuppressWarnings("deprecation") // https://github.com/grpc/grpc-java/issues/7467
-  @Rule public final ExpectedException thrown = ExpectedException.none();
 
   @SuppressWarnings("ExpectedExceptionChecker")
   @Test
@@ -45,11 +42,11 @@ public void priorityLbConfig_emptyPriorities() {
         ImmutableMap.of(
             "p0",
             new PriorityChildConfig(
-                new PolicySelection(mock(LoadBalancerProvider.class), null), true));
+                newChildConfig(mock(LoadBalancerProvider.class), null), true));
     List<String> priorities = ImmutableList.of();
 
-    thrown.expect(IllegalArgumentException.class);
-    new PriorityLbConfig(childConfigs, priorities);
+    assertThrows(IllegalArgumentException.class,
+        () -> new PriorityLbConfig(childConfigs, priorities));
   }
 
   @SuppressWarnings("ExpectedExceptionChecker")
@@ -59,10 +56,14 @@ public void priorityLbConfig_missingChildConfig() {
         ImmutableMap.of(
             "p1",
             new PriorityChildConfig(
-                new PolicySelection(mock(LoadBalancerProvider.class), null), true));
+                newChildConfig(mock(LoadBalancerProvider.class), null), true));
     List<String> priorities = ImmutableList.of("p0", "p1");
 
-    thrown.expect(IllegalArgumentException.class);
-    new PriorityLbConfig(childConfigs, priorities);
+    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
index 2a030e3d30f..988bc720e45 100644
--- a/xds/src/test/java/io/grpc/xds/PriorityLoadBalancerTest.java
+++ b/xds/src/test/java/io/grpc/xds/PriorityLoadBalancerTest.java
@@ -18,14 +18,23 @@
 
 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;
@@ -34,6 +43,7 @@
 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;
@@ -44,11 +54,10 @@
 import io.grpc.Status;
 import io.grpc.SynchronizationContext;
 import io.grpc.internal.FakeClock;
-import io.grpc.internal.ServiceConfigUtil.PolicySelection;
 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 io.grpc.xds.XdsSubchannelPickers.ErrorPicker;
 import java.net.InetSocketAddress;
 import java.net.SocketAddress;
 import java.util.ArrayList;
@@ -62,6 +71,7 @@
 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;
@@ -69,6 +79,9 @@
 /** 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<>();
@@ -87,6 +100,8 @@ public void uncaughtException(Thread t, Throwable e) {
         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;
         }
@@ -97,6 +112,8 @@ public LoadBalancer newLoadBalancer(Helper helper) {
         @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;
         }
@@ -115,6 +132,7 @@ public void setUp() {
     doReturn(syncContext).when(helper).getSynchronizationContext();
     doReturn(fakeClock.getScheduledExecutorService()).when(helper).getScheduledExecutorService();
     priorityLb = new PriorityLoadBalancer(helper);
+    clearInvocations(helper);
   }
 
   @After
@@ -130,7 +148,107 @@ public void tearDown() {
   }
 
   @Test
-  public void handleResolvedAddresses() {
+  public void acceptResolvedAddresses() {
+    boolean originalFlagVal = PriorityLoadBalancer.enablePriorityLbChildPolicyCache;
+    PriorityLoadBalancer.enablePriorityLbChildPolicyCache = true;
+    try {
+      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();
+    } finally {
+      PriorityLoadBalancer.enablePriorityLbChildPolicyCache = originalFlagVal;
+    }
+  }
+
+  @Test
+  public void acceptResolvedAddresses_cacheDisabled() {
     SocketAddress socketAddress = new InetSocketAddress(8080);
     EquivalentAddressGroup eag = new EquivalentAddressGroup(socketAddress);
     eag = AddressFilter.setPathFilter(eag, ImmutableList.of("p1"));
@@ -139,28 +257,29 @@ public void handleResolvedAddresses() {
         Attributes.newBuilder().set(Attributes.Key.create("fakeKey"), "fakeValue").build();
     Object fooConfig0 = new Object();
     PriorityChildConfig priorityChildConfig0 =
-        new PriorityChildConfig(new PolicySelection(fooLbProvider, fooConfig0), true);
+        new PriorityChildConfig(newChildConfig(fooLbProvider, fooConfig0), true);
     Object barConfig0 = new Object();
     PriorityChildConfig priorityChildConfig1 =
-        new PriorityChildConfig(new PolicySelection(barLbProvider, barConfig0), true);
+        new PriorityChildConfig(newChildConfig(barLbProvider, barConfig0), true);
     Object fooConfig1 = new Object();
     PriorityChildConfig priorityChildConfig2 =
-        new PriorityChildConfig(new PolicySelection(fooLbProvider, fooConfig1), true);
+        new PriorityChildConfig(newChildConfig(fooLbProvider, fooConfig1), true);
     PriorityLbConfig priorityLbConfig =
         new PriorityLbConfig(
             ImmutableMap.of("p0", priorityChildConfig0, "p1", priorityChildConfig1,
                 "p2", priorityChildConfig2),
             ImmutableList.of("p0", "p1", "p2"));
-    priorityLb.handleResolvedAddresses(
+    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).handleResolvedAddresses(resolvedAddressesCaptor.capture());
+    verify(fooBalancer0).acceptResolvedAddresses(resolvedAddressesCaptor.capture());
     ResolvedAddresses addressesReceived = resolvedAddressesCaptor.getValue();
     assertThat(addressesReceived.getAddresses()).isEmpty();
     assertThat(addressesReceived.getAttributes()).isEqualTo(attributes);
@@ -171,7 +290,7 @@ public void handleResolvedAddresses() {
     assertThat(fooBalancers).hasSize(1);
     assertThat(barBalancers).hasSize(1);
     LoadBalancer barBalancer0 = Iterables.getOnlyElement(barBalancers);
-    verify(barBalancer0).handleResolvedAddresses(resolvedAddressesCaptor.capture());
+    verify(barBalancer0).acceptResolvedAddresses(resolvedAddressesCaptor.capture());
     addressesReceived = resolvedAddressesCaptor.getValue();
     assertThat(Iterables.getOnlyElement(addressesReceived.getAddresses()).getAddresses())
         .containsExactly(socketAddress);
@@ -183,7 +302,7 @@ public void handleResolvedAddresses() {
     assertThat(fooBalancers).hasSize(2);
     assertThat(barBalancers).hasSize(1);
     LoadBalancer fooBalancer1 = Iterables.getLast(fooBalancers);
-    verify(fooBalancer1).handleResolvedAddresses(resolvedAddressesCaptor.capture());
+    verify(fooBalancer1).acceptResolvedAddresses(resolvedAddressesCaptor.capture());
     addressesReceived = resolvedAddressesCaptor.getValue();
     assertThat(addressesReceived.getAddresses()).isEmpty();
     assertThat(addressesReceived.getAttributes()).isEqualTo(attributes);
@@ -198,84 +317,142 @@ public void handleResolvedAddresses() {
     PriorityLbConfig newPriorityLbConfig =
         new PriorityLbConfig(
             ImmutableMap.of("p1",
-                new PriorityChildConfig(new PolicySelection(barLbProvider, newBarConfig), true)),
+                new PriorityChildConfig(newChildConfig(barLbProvider, newBarConfig), true)),
             ImmutableList.of("p1"));
-    priorityLb.handleResolvedAddresses(
+    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)).handleResolvedAddresses(resolvedAddressesCaptor.capture());
+    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(new PolicySelection(fooLbProvider, fooConfig0), true);
-    Object fooConfig1 = new Object();
-    PriorityChildConfig priorityChildConfig1 =
-        new PriorityChildConfig(new PolicySelection(fooLbProvider, fooConfig1), true);
+    boolean originalFlagVal = PriorityLoadBalancer.enablePriorityLbChildPolicyCache;
+    PriorityLoadBalancer.enablePriorityLbChildPolicyCache = true;
+    try {
+      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.handleResolvedAddresses(
-        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 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.handleResolvedAddresses(
-        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);
+      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);
+    } finally {
+      PriorityLoadBalancer.enablePriorityLbChildPolicyCache = originalFlagVal;
+    }
   }
 
   @Test
   public void typicalPriorityFailOverFlow() {
     PriorityChildConfig priorityChildConfig0 =
-        new PriorityChildConfig(new PolicySelection(fooLbProvider, new Object()), true);
+        new PriorityChildConfig(newChildConfig(fooLbProvider, new Object()), true);
     PriorityChildConfig priorityChildConfig1 =
-        new PriorityChildConfig(new PolicySelection(fooLbProvider, new Object()), true);
+        new PriorityChildConfig(newChildConfig(fooLbProvider, new Object()), true);
     PriorityChildConfig priorityChildConfig2 =
-        new PriorityChildConfig(new PolicySelection(fooLbProvider, new Object()), true);
+        new PriorityChildConfig(newChildConfig(fooLbProvider, new Object()), true);
     PriorityChildConfig priorityChildConfig3 =
-        new PriorityChildConfig(new PolicySelection(fooLbProvider, new Object()), true);
+        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.handleResolvedAddresses(
+    priorityLb.acceptResolvedAddresses(
         ResolvedAddresses.newBuilder()
             .setAddresses(ImmutableList.<EquivalentAddressGroup>of())
             .setLoadBalancingPolicyConfig(priorityLbConfig)
@@ -298,11 +475,13 @@ public PickResult pickSubchannel(PickSubchannelArgs args) {
     assertCurrentPickerPicksSubchannel(subchannel0);
 
     // p0 fails over to p1 immediately.
-    helper0.updateBalancingState(TRANSIENT_FAILURE, new ErrorPicker(Status.ABORTED));
+    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);
@@ -337,24 +516,33 @@ public PickResult pickSubchannel(PickSubchannelArgs args) {
     assertCurrentPickerPicksSubchannel(subchannel2);
 
     // p2 fails but does not affect overall picker
-    helper2.updateBalancingState(TRANSIENT_FAILURE, new ErrorPicker(Status.UNAVAILABLE));
+    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 ErrorPicker(Status.UNAVAILABLE));
+    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 go to TRANSIENT_FAILURE
+    // p3 timeout then the channel should stay in CONNECTING
     fakeClock.forwardTime(10, TimeUnit.SECONDS);
-    assertCurrentPickerReturnsError(Status.Code.UNAVAILABLE, "timeout");
+    assertCurrentPicker(CONNECTING, PickResult.withNoResult());
 
-    // p3 fails then the picker should have error status updated
+    // p3 fails then the picker should still be waiting on p1
     helper3.updateBalancingState(
-        TRANSIENT_FAILURE, new ErrorPicker(Status.DATA_LOSS.withDescription("foo")));
+        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
@@ -382,7 +570,8 @@ public PickResult pickSubchannel(PickSubchannelArgs args) {
     assertCurrentPickerPicksSubchannel(subchannel4);
 
     // p0 fails over to p2 and picker is updated to p2's existing picker.
-    helper0.updateBalancingState(TRANSIENT_FAILURE, new ErrorPicker(Status.UNAVAILABLE));
+    helper0.updateBalancingState(
+        TRANSIENT_FAILURE, new FixedResultPicker(PickResult.withError(Status.UNAVAILABLE)));
     assertCurrentPickerPicksSubchannel(subchannel3);
 
     // Deactivate child balancer get deleted.
@@ -393,17 +582,364 @@ public PickResult pickSubchannel(PickSubchannelArgs args) {
     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(new PolicySelection(fooLbProvider, new Object()), true);
+        new PriorityChildConfig(newChildConfig(fooLbProvider, new Object()), true);
     PriorityChildConfig priorityChildConfig1 =
-        new PriorityChildConfig(new PolicySelection(fooLbProvider, new Object()), false);
+        new PriorityChildConfig(newChildConfig(fooLbProvider, new Object()), false);
     PriorityLbConfig priorityLbConfig =
         new PriorityLbConfig(
             ImmutableMap.of("p0", priorityChildConfig0, "p1", priorityChildConfig1),
             ImmutableList.of("p0", "p1"));
-    priorityLb.handleResolvedAddresses(
+    priorityLb.acceptResolvedAddresses(
         ResolvedAddresses.newBuilder()
             .setAddresses(ImmutableList.<EquivalentAddressGroup>of())
             .setLoadBalancingPolicyConfig(priorityLbConfig)
@@ -413,13 +949,70 @@ public void bypassReresolutionRequestsIfConfiged() {
     verify(helper, never()).refreshNameResolution();
 
     // Simulate fallback to priority p1.
-    priorityHelper0.updateBalancingState(TRANSIENT_FAILURE, new ErrorPicker(Status.UNAVAILABLE));
+    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());
@@ -438,8 +1031,115 @@ private void assertCurrentPickerReturnsError(
   }
 
   private void assertCurrentPickerPicksSubchannel(Subchannel expectedSubchannelToPick) {
-    assertLatestConnectivityState(READY);
+    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.getSubchannel()).isEqualTo(expectedSubchannelToPick);
+    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..0f6920b18eb
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/RbacFilterTest.java
@@ -0,0 +1,484 @@
+/*
+ * 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.client.Bootstrapper.BootstrapInfo;
+import io.grpc.xds.client.Bootstrapper.ServerInfo;
+import io.grpc.xds.client.EnvoyProtoData.Node;
+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")
+  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), getFilterContext());
+    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),
+                    getFilterContext()).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), getFilterContext());
+    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), getFilterContext());
+
+    rawProto = buildComplexRbac(ImmutableList.of(1, 2, 3, 4, 5, 6), false);
+    ConfigOrError<RbacConfig> ascLast =
+                    FILTER_PROVIDER.parseFilterConfig(Any.pack(rawProto), getFilterContext());
+
+    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), getFilterContext());
+
+    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, getFilterContext());
+  }
+
+  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, getFilterContext());
+  }
+
+  private Filter.FilterConfigParseContext getFilterContext() {
+    return Filter.FilterConfigParseContext.builder()
+        .bootstrapInfo(BootstrapInfo.builder()
+            .servers(Collections.singletonList(
+                ServerInfo.create(
+                    "test_target", Collections.emptyMap())))
+            .node(Node.newBuilder().build())
+            .build())
+        .serverInfo(ServerInfo.create(
+            "test_target", Collections.emptyMap(), false, true, false, false))
+        .build();
+  }
+}
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/ServerXdsClientNewServerApiTest.java b/xds/src/test/java/io/grpc/xds/ServerXdsClientNewServerApiTest.java
deleted file mode 100644
index 32619d75ff6..00000000000
--- a/xds/src/test/java/io/grpc/xds/ServerXdsClientNewServerApiTest.java
+++ /dev/null
@@ -1,780 +0,0 @@
-/*
- * 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.XdsClientTestHelper.buildDiscoveryResponse;
-import static io.grpc.xds.XdsClientTestHelper.buildListener;
-import static io.grpc.xds.XdsClientTestHelper.buildRouteConfiguration;
-import static io.grpc.xds.XdsClientTestHelper.buildVirtualHost;
-import static org.mockito.AdditionalAnswers.delegatesTo;
-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.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.Iterables;
-import com.google.common.util.concurrent.MoreExecutors;
-import com.google.protobuf.Any;
-import com.google.protobuf.InvalidProtocolBufferException;
-import com.google.protobuf.UInt32Value;
-import io.envoyproxy.envoy.config.core.v3.CidrRange;
-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.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.extensions.filters.network.http_connection_manager.v3.HttpConnectionManager;
-import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.CommonTlsContext;
-import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.DownstreamTlsContext;
-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.grpc.Context;
-import io.grpc.Context.CancellationListener;
-import io.grpc.ManagedChannel;
-import io.grpc.Status;
-import io.grpc.Status.Code;
-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.TaskFilter;
-import io.grpc.stub.StreamObserver;
-import io.grpc.testing.GrpcCleanupRule;
-import io.grpc.xds.AbstractXdsClient.ResourceType;
-import io.grpc.xds.EnvoyProtoData.Node;
-import io.grpc.xds.XdsClient.ListenerUpdate;
-import io.grpc.xds.XdsClient.ListenerWatcher;
-import io.grpc.xds.internal.sds.CommonTlsContextTestsUtil;
-import java.io.IOException;
-import java.util.ArrayDeque;
-import java.util.Arrays;
-import java.util.List;
-import java.util.Queue;
-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.InOrder;
-import org.mockito.Mock;
-import org.mockito.Mockito;
-import org.mockito.MockitoAnnotations;
-
-/**
- * Tests for {@link ServerXdsClient for server side Listeners using newServerApi}.
- */
-@RunWith(JUnit4.class)
-public class ServerXdsClientNewServerApiTest {
-
-  private static final int PORT = 7000;
-  private static final String LOCAL_IP = "192.168.3.5";
-  private static final String INSTANCE_IP = "192.168.3.7";
-  private static final String TYPE_URL_HCM =
-      "type.googleapis.com/"
-          + "envoy.extensions.filters.network.http_connection_manager.v3.HttpConnectionManager";
-
-  private static final Node NODE = Node.newBuilder().build();
-  private static final TaskFilter RPC_RETRY_TASK_FILTER =
-      new TaskFilter() {
-        @Override
-        public boolean shouldAccept(Runnable command) {
-          return command.toString().contains(AbstractXdsClient.RpcRetryTask.class.getSimpleName());
-        }
-      };
-  private static final TaskFilter LISTENER_RESOURCE_FETCH_TIMEOUT_TASK_FILTER =
-      new TaskFilter() {
-        @Override
-        public boolean shouldAccept(Runnable command) {
-          return command.toString()
-              .contains(ServerXdsClient.ListenerResourceFetchTimeoutTask.class.getSimpleName());
-        }
-      };
-  private static final String LISTENER_NAME = "TRAFFICDIRECTOR_INBOUND_LISTENER";
-
-  @Rule
-  public final GrpcCleanupRule cleanupRule = new GrpcCleanupRule();
-
-  private final FakeClock fakeClock = new FakeClock();
-
-  private final Queue<StreamObserver<DiscoveryResponse>> responseObservers = new ArrayDeque<>();
-  private final Queue<StreamObserver<DiscoveryRequest>> requestObservers = new ArrayDeque<>();
-  private final AtomicBoolean callEnded = new AtomicBoolean(true);
-
-  @Mock
-  private AggregatedDiscoveryServiceImplBase mockedDiscoveryService;
-  @Mock
-  private BackoffPolicy.Provider backoffPolicyProvider;
-  @Mock
-  private BackoffPolicy backoffPolicy1;
-  @Mock
-  private BackoffPolicy backoffPolicy2;
-  @Mock
-  private ListenerWatcher listenerWatcher;
-
-  private ManagedChannel channel;
-  private ServerXdsClient xdsClient;
-
-  @Before
-  public void setUp() throws IOException {
-    MockitoAnnotations.initMocks(this);
-    when(backoffPolicyProvider.get()).thenReturn(backoffPolicy1, backoffPolicy2);
-    when(backoffPolicy1.nextBackoffNanos()).thenReturn(10L, 100L);
-    when(backoffPolicy2.nextBackoffNanos()).thenReturn(20L, 200L);
-
-    final String serverName = InProcessServerBuilder.generateName();
-    AggregatedDiscoveryServiceImplBase adsServiceImpl = new AggregatedDiscoveryServiceImplBase() {
-      @Override
-      public StreamObserver<DiscoveryRequest> streamAggregatedResources(
-          final StreamObserver<DiscoveryResponse> 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());
-        responseObservers.offer(responseObserver);
-        @SuppressWarnings("unchecked")
-        StreamObserver<DiscoveryRequest> requestObserver = mock(StreamObserver.class);
-        requestObservers.offer(requestObserver);
-        return requestObserver;
-      }
-    };
-    mockedDiscoveryService =
-        mock(AggregatedDiscoveryServiceImplBase.class, delegatesTo(adsServiceImpl));
-
-    cleanupRule.register(
-        InProcessServerBuilder
-            .forName(serverName)
-            .addService(mockedDiscoveryService)
-            .directExecutor()
-            .build()
-            .start());
-    channel =
-        cleanupRule.register(InProcessChannelBuilder.forName(serverName).directExecutor().build());
-
-    xdsClient =
-        new ServerXdsClient(channel, true, NODE,
-            fakeClock.getScheduledExecutorService(), backoffPolicyProvider,
-            fakeClock.getStopwatchSupplier(), INSTANCE_IP, "test/value");
-    // Only the connection to management server is established, no RPC request is sent until at
-    // least one watcher is registered.
-    assertThat(responseObservers).isEmpty();
-    assertThat(requestObservers).isEmpty();
-  }
-
-  @After
-  public void tearDown() {
-    xdsClient.shutdown();
-    channel.shutdownNow();
-    assertThat(callEnded.get()).isTrue();
-    assertThat(fakeClock.getPendingTasks()).isEmpty();
-  }
-
-  private static DiscoveryRequest buildDiscoveryRequest(
-          Node node, String versionInfo, List<String> resourceNames, String typeUrl, String nonce) {
-    return DiscoveryRequest.newBuilder()
-        .setVersionInfo(versionInfo)
-        .setNode(node.toEnvoyProtoNode())
-        .setTypeUrl(typeUrl)
-        .setResponseNonce(nonce)
-        .addAllResourceNames(resourceNames)
-        .build();
-  }
-
-  /**
-   * Client receives an LDS response that contains listener with no match i.e. no port match.
-   */
-  @Test
-  public void ldsResponse_nonMatchingFilterChain_notFoundError() {
-    xdsClient.watchListenerData(PORT, listenerWatcher);
-    StreamObserver<DiscoveryResponse> responseObserver = responseObservers.poll();
-    StreamObserver<DiscoveryRequest> requestObserver = requestObservers.poll();
-
-    verify(requestObserver)
-        .onNext(eq(XdsClientTestHelper.buildDiscoveryRequest(NODE, "",
-                ImmutableList.of("test/value?udpa.resource.listening_address=192.168.3.7:7000"),
-                ResourceType.LDS.typeUrl(), "")));
-    assertThat(fakeClock.getPendingTasks(LISTENER_RESOURCE_FETCH_TIMEOUT_TASK_FILTER)).hasSize(1);
-
-    List<Any> listeners = ImmutableList.of(
-        Any.pack(buildListener("bar.googleapis.com",
-            Any.pack(HttpConnectionManager.newBuilder()
-                .setRouteConfig(
-                    buildRouteConfiguration("route-bar.googleapis.com",
-                        ImmutableList.of(
-                            buildVirtualHost(
-                                ImmutableList.of("bar.googleapis.com"),
-                                "cluster-bar.googleapis.com"))))
-                .build()))),
-        Any.pack(buildListener(LISTENER_NAME,
-            Any.pack(HttpConnectionManager.newBuilder()
-                .setRouteConfig(
-                    buildRouteConfiguration("route-baz.googleapis.com",
-                        ImmutableList.of(
-                            buildVirtualHost(
-                                ImmutableList.of("baz.googleapis.com"),
-                                "cluster-baz.googleapis.com"))))
-                .build()))));
-    DiscoveryResponse response =
-        buildDiscoveryResponse("0", listeners, ResourceType.LDS.typeUrl(), "0000");
-    responseObserver.onNext(response);
-
-    // Client sends an ACK LDS request.
-    verify(requestObserver)
-        .onNext(eq(XdsClientTestHelper.buildDiscoveryRequest(NODE, "0",
-                ImmutableList.of("test/value?udpa.resource.listening_address=192.168.3.7:7000"),
-                ResourceType.LDS.typeUrl(), "0000")));
-
-    verify(listenerWatcher, never()).onListenerChanged(any(ListenerUpdate.class));
-    verify(listenerWatcher, never()).onResourceDoesNotExist(":" + PORT);
-    verify(listenerWatcher, never()).onError(any(Status.class));
-    fakeClock.forwardTime(ServerXdsClient.INITIAL_RESOURCE_FETCH_TIMEOUT_SEC, TimeUnit.SECONDS);
-    verify(listenerWatcher)
-        .onResourceDoesNotExist("test/value?udpa.resource.listening_address=192.168.3.7:" + PORT);
-    assertThat(fakeClock.getPendingTasks(LISTENER_RESOURCE_FETCH_TIMEOUT_TASK_FILTER)).isEmpty();
-  }
-
-  /** Client receives a Listener with all match. */
-  @Test
-  public void ldsResponseWith_matchingListenerFound() throws InvalidProtocolBufferException {
-    xdsClient.watchListenerData(PORT, listenerWatcher);
-    StreamObserver<DiscoveryResponse> responseObserver = responseObservers.poll();
-    StreamObserver<DiscoveryRequest> requestObserver = requestObservers.poll();
-
-    verify(requestObserver)
-        .onNext(
-            eq(
-                XdsClientTestHelper.buildDiscoveryRequest(
-                    NODE,
-                    "",
-                    ImmutableList.of(
-                        "test/value?udpa.resource.listening_address=192.168.3.7:7000"),
-                    ResourceType.LDS.typeUrl(),
-                    "")));
-    assertThat(fakeClock.getPendingTasks(LISTENER_RESOURCE_FETCH_TIMEOUT_TASK_FILTER)).hasSize(1);
-
-    final FilterChain filterChainInbound = buildFilterChain(buildFilterChainMatch("managed-mtls"),
-        CommonTlsContextTestsUtil.buildTestDownstreamTlsContext("google-sds-config-default",
-            "ROOTCA"),
-        buildTestFilter("envoy.http_connection_manager"));
-    List<Any> listeners =
-        ImmutableList.of(
-            Any.pack(
-                buildListener(
-                    "bar.googleapis.com",
-                    Any.pack(
-                        HttpConnectionManager.newBuilder()
-                            .setRouteConfig(
-                                buildRouteConfiguration(
-                                    "route-bar.googleapis.com",
-                                    ImmutableList.of(
-                                        buildVirtualHost(
-                                            ImmutableList.of("bar.googleapis.com"),
-                                            "cluster-bar.googleapis.com"))))
-                            .build()))),
-            Any.pack(
-                buildListenerWithFilterChain(
-                    "test/value?udpa.resource.listening_address=192.168.3.7:7000",
-                    7000,
-                    "0.0.0.0",
-                    filterChainInbound)));
-    DiscoveryResponse response =
-        buildDiscoveryResponse("0", listeners, ResourceType.LDS.typeUrl(), "0000");
-    responseObserver.onNext(response);
-
-    // Client sends an ACK LDS request.
-    verify(requestObserver)
-        .onNext(
-            eq(
-                XdsClientTestHelper.buildDiscoveryRequest(
-                    NODE,
-                    "0",
-                    ImmutableList.of(
-                        "test/value?udpa.resource.listening_address=192.168.3.7:7000"),
-                    ResourceType.LDS.typeUrl(),
-                    "0000")));
-
-    ArgumentCaptor<ListenerUpdate> listenerUpdateCaptor = ArgumentCaptor.forClass(null);
-    verify(listenerWatcher, times(1)).onListenerChanged(listenerUpdateCaptor.capture());
-    ListenerUpdate configUpdate = listenerUpdateCaptor.getValue();
-    EnvoyServerProtoData.Listener listener = configUpdate.getListener();
-    assertThat(listener.getName())
-        .isEqualTo("test/value?udpa.resource.listening_address=192.168.3.7:7000");
-    assertThat(listener.getAddress()).isEqualTo("0.0.0.0:7000");
-    assertThat(listener.getFilterChains()).hasSize(1);
-    EnvoyServerProtoData.FilterChain filterChainInboundInListenerUpdate
-        = listener.getFilterChains().get(0);
-    CommonTlsContext downstreamCommonTlsContext =
-        filterChainInboundInListenerUpdate.getDownstreamTlsContext().getCommonTlsContext();
-    assertThat(downstreamCommonTlsContext.getTlsCertificateSdsSecretConfigs(0).getName())
-        .isEqualTo("google-sds-config-default");
-    assertThat(
-            downstreamCommonTlsContext
-                .getCombinedValidationContext()
-                .getValidationContextSdsSecretConfig()
-                .getName())
-        .isEqualTo("ROOTCA");
-    assertThat(fakeClock.getPendingTasks(LISTENER_RESOURCE_FETCH_TIMEOUT_TASK_FILTER)).isEmpty();
-  }
-
-  @Test
-  public void ldsResponseWith_defaultFilterChainListener() throws InvalidProtocolBufferException {
-    xdsClient.watchListenerData(PORT, listenerWatcher);
-    StreamObserver<DiscoveryResponse> responseObserver = responseObservers.poll();
-    StreamObserver<DiscoveryRequest> requestObserver = requestObservers.poll();
-
-    verify(requestObserver)
-        .onNext(
-            eq(
-                XdsClientTestHelper.buildDiscoveryRequest(
-                    NODE,
-                    "",
-                    ImmutableList.of("test/value?udpa.resource.listening_address=192.168.3.7:7000"),
-                    ResourceType.LDS.typeUrl(),
-                    "")));
-    assertThat(fakeClock.getPendingTasks(LISTENER_RESOURCE_FETCH_TIMEOUT_TASK_FILTER)).hasSize(1);
-
-    final FilterChain defaultFilterChain =
-        buildFilterChain(
-            buildFilterChainMatch("managed-mtls"),
-            CommonTlsContextTestsUtil.buildTestDownstreamTlsContext(
-                "google-sds-config-default", "ROOTCA"),
-            buildTestFilter("envoy.http_connection_manager"));
-    List<Any> listeners =
-        ImmutableList.of(
-            Any.pack(
-                buildListener(
-                    "bar.googleapis.com",
-                    Any.pack(
-                        HttpConnectionManager.newBuilder()
-                            .setRouteConfig(
-                                buildRouteConfiguration(
-                                    "route-bar.googleapis.com",
-                                    ImmutableList.of(
-                                        buildVirtualHost(
-                                            ImmutableList.of("bar.googleapis.com"),
-                                            "cluster-bar.googleapis.com"))))
-                            .build()))),
-            Any.pack(
-                buildListenerWithDefaultFilterChain(
-                    "test/value?udpa.resource.listening_address=192.168.3.7:7000",
-                    7000,
-                    "0.0.0.0",
-                    defaultFilterChain)));
-    DiscoveryResponse response =
-        buildDiscoveryResponse("0", listeners, ResourceType.LDS.typeUrl(), "0000");
-    responseObserver.onNext(response);
-
-    // Client sends an ACK LDS request.
-    verify(requestObserver)
-        .onNext(
-            eq(
-                XdsClientTestHelper.buildDiscoveryRequest(
-                    NODE,
-                    "0",
-                    ImmutableList.of("test/value?udpa.resource.listening_address=192.168.3.7:7000"),
-                    ResourceType.LDS.typeUrl(),
-                    "0000")));
-
-    ArgumentCaptor<ListenerUpdate> listenerUpdateCaptor = ArgumentCaptor.forClass(null);
-    verify(listenerWatcher, times(1)).onListenerChanged(listenerUpdateCaptor.capture());
-    ListenerUpdate configUpdate = listenerUpdateCaptor.getValue();
-    EnvoyServerProtoData.Listener listener = configUpdate.getListener();
-    assertThat(listener.getName())
-        .isEqualTo("test/value?udpa.resource.listening_address=192.168.3.7:7000");
-    assertThat(listener.getAddress()).isEqualTo("0.0.0.0:7000");
-    assertThat(listener.getFilterChains()).hasSize(0);
-    EnvoyServerProtoData.FilterChain filterChainInboundInListenerUpdate =
-        listener.getDefaultFilterChain();
-    CommonTlsContext downstreamCommonTlsContext =
-        filterChainInboundInListenerUpdate.getDownstreamTlsContext().getCommonTlsContext();
-    assertThat(downstreamCommonTlsContext.getTlsCertificateSdsSecretConfigs(0).getName())
-        .isEqualTo("google-sds-config-default");
-    assertThat(
-        downstreamCommonTlsContext
-            .getCombinedValidationContext()
-            .getValidationContextSdsSecretConfig()
-            .getName())
-        .isEqualTo("ROOTCA");
-    assertThat(fakeClock.getPendingTasks(LISTENER_RESOURCE_FETCH_TIMEOUT_TASK_FILTER)).isEmpty();
-  }
-
-  /** Client receives LDS responses for updating Listener previously received. */
-  @SuppressWarnings("unchecked")
-  @Test
-  public void notifyUpdatedListener() {
-    xdsClient.watchListenerData(PORT, listenerWatcher);
-    StreamObserver<DiscoveryResponse> responseObserver = responseObservers.poll();
-    StreamObserver<DiscoveryRequest> requestObserver = requestObservers.poll();
-
-    final FilterChain filterChainInbound = buildFilterChain(buildFilterChainMatch("managed-mtls"),
-        CommonTlsContextTestsUtil.buildTestDownstreamTlsContext("google-sds-config-default",
-            "ROOTCA"),
-        buildTestFilter("envoy.http_connection_manager"));
-    List<Any> listeners =
-        ImmutableList.of(
-            Any.pack(
-                buildListenerWithFilterChain(
-                    "test/value?udpa.resource.listening_address=192.168.3.7:7000",
-                    7000,
-                    "0.0.0.0",
-                    filterChainInbound)));
-    DiscoveryResponse response =
-        buildDiscoveryResponse("0", listeners, ResourceType.LDS.typeUrl(), "0000");
-    responseObserver.onNext(response);
-
-    ArgumentCaptor<ListenerUpdate> listenerUpdateCaptor = ArgumentCaptor.forClass(null);
-    verify(listenerWatcher, times(1)).onListenerChanged(listenerUpdateCaptor.capture());
-
-    reset(requestObserver);
-    // Management server sends another LDS response with updates for Listener.
-    final FilterChain filterChainNewInbound =
-        buildFilterChain(
-            buildFilterChainMatch("managed-mtls"),
-            CommonTlsContextTestsUtil.buildTestDownstreamTlsContext(
-                "google-sds-config-default1", "ROOTCA2"),
-            buildTestFilter("envoy.http_connection_manager"));
-    List<Any> listeners1 =
-        ImmutableList.of(
-            Any.pack(
-                buildListenerWithFilterChain(
-                    "test/value?udpa.resource.listening_address=192.168.3.7:7000",
-                    7000,
-                    "0.0.0.0",
-                    filterChainNewInbound)));
-    DiscoveryResponse response1 =
-        buildDiscoveryResponse("1", listeners1, ResourceType.LDS.typeUrl(), "0001");
-    responseObserver.onNext(response1);
-
-    // Client sends an ACK LDS request.
-    verify(requestObserver)
-        .onNext(
-            eq(
-                XdsClientTestHelper.buildDiscoveryRequest(
-                    NODE,
-                    "1",
-                    ImmutableList.of(
-                        "test/value?udpa.resource.listening_address=192.168.3.7:7000"),
-                    ResourceType.LDS.typeUrl(),
-                    "0001")));
-
-    // Updated listener is notified to listener watcher.
-    listenerUpdateCaptor = ArgumentCaptor.forClass(null);
-    verify(listenerWatcher, times(2)).onListenerChanged(listenerUpdateCaptor.capture());
-    ListenerUpdate configUpdate = listenerUpdateCaptor.getValue();
-    EnvoyServerProtoData.Listener listener = configUpdate.getListener();
-    assertThat(listener.getName())
-        .isEqualTo("test/value?udpa.resource.listening_address=192.168.3.7:7000");
-    assertThat(listener.getFilterChains()).hasSize(1);
-    EnvoyServerProtoData.FilterChain filterChain =
-        Iterables.getOnlyElement(listener.getFilterChains());
-    CommonTlsContext downstreamCommonTlsContext =
-        filterChain.getDownstreamTlsContext().getCommonTlsContext();
-    assertThat(downstreamCommonTlsContext.getTlsCertificateSdsSecretConfigs(0).getName())
-        .isEqualTo("google-sds-config-default1");
-    assertThat(
-            downstreamCommonTlsContext
-                .getCombinedValidationContext()
-                .getValidationContextSdsSecretConfig()
-                .getName())
-        .isEqualTo("ROOTCA2");
-  }
-
-  /** Client receives LDS response containing non-matching port. */
-  @Test
-  public void ldsResponse_nonMatchingPort() {
-    xdsClient.watchListenerData(PORT, listenerWatcher);
-    StreamObserver<DiscoveryResponse> responseObserver = responseObservers.poll();
-    requestObservers.poll();
-
-    final FilterChain filterChainInbound =
-        buildFilterChain(buildFilterChainMatch("managed-mtls"), null);
-
-    List<Any> listeners =
-        ImmutableList.of(
-            Any.pack(
-                buildListener(
-                    "bar.googleapis.com",
-                    Any.pack(
-                        HttpConnectionManager.newBuilder()
-                            .setRouteConfig(
-                                buildRouteConfiguration(
-                                    "route-bar.googleapis.com",
-                                    ImmutableList.of(
-                                        buildVirtualHost(
-                                            ImmutableList.of("bar.googleapis.com"),
-                                            "cluster-bar.googleapis.com"))))
-                            .build()))),
-            Any.pack(
-                buildListenerWithFilterChain(
-                    "test/value?udpa.resource.listening_address=192.168.3.7:7000",
-                    PORT + 1,
-                    "0.0.0.0",
-                    filterChainInbound)));
-    DiscoveryResponse response =
-        buildDiscoveryResponse("0", listeners, ResourceType.LDS.typeUrl(), "0000");
-    responseObserver.onNext(response);
-
-    verify(listenerWatcher, never()).onListenerChanged(any(ListenerUpdate.class));
-    verify(listenerWatcher, never())
-        .onResourceDoesNotExist("test/value?udpa.resource.listening_address=192.168.3.7:" + PORT);
-    verify(listenerWatcher, never()).onError(any(Status.class));
-    fakeClock.forwardTime(ServerXdsClient.INITIAL_RESOURCE_FETCH_TIMEOUT_SEC, TimeUnit.SECONDS);
-    verify(listenerWatcher)
-        .onResourceDoesNotExist("test/value?udpa.resource.listening_address=192.168.3.7:" + PORT);
-    assertThat(fakeClock.getPendingTasks(LISTENER_RESOURCE_FETCH_TIMEOUT_TASK_FILTER)).isEmpty();
-  }
-
-  /**
-   * RPC stream close and retry while there is listener watcher registered.
-   */
-  @Test
-  public void streamClosedAndRetry() {
-    InOrder inOrder =
-        Mockito.inOrder(mockedDiscoveryService, backoffPolicyProvider, backoffPolicy1,
-            backoffPolicy2);
-    xdsClient.watchListenerData(PORT, listenerWatcher);
-
-    ArgumentCaptor<StreamObserver<DiscoveryResponse>> responseObserverCaptor =
-        ArgumentCaptor.forClass(null);
-    inOrder.verify(mockedDiscoveryService)
-        .streamAggregatedResources(responseObserverCaptor.capture());
-    StreamObserver<DiscoveryResponse> responseObserver =
-        responseObserverCaptor.getValue();  // same as responseObservers.poll()
-    requestObservers.poll();
-
-    final FilterChain filterChainOutbound = buildFilterChain(buildFilterChainMatch(8000), null);
-    final FilterChain filterChainInbound = buildFilterChain(buildFilterChainMatch(PORT,
-        CidrRange.newBuilder().setAddressPrefix(LOCAL_IP)
-            .setPrefixLen(UInt32Value.of(32)).build()),
-        CommonTlsContextTestsUtil.buildTestDownstreamTlsContext("google-sds-config-default",
-            "ROOTCA"),
-        buildTestFilter("envoy.http_connection_manager"));
-    List<Any> listeners = ImmutableList.of(
-        Any.pack(buildListenerWithFilterChain(LISTENER_NAME, 15001, "0.0.0.0",
-            filterChainOutbound,
-            filterChainInbound
-        )));
-    DiscoveryResponse response =
-        buildDiscoveryResponse("0", listeners, ResourceType.LDS.typeUrl(), "0000");
-    responseObserver.onNext(response);
-
-    // Client sent an ACK CDS request (Omitted).
-
-    ArgumentCaptor<Status> statusCaptor = ArgumentCaptor.forClass(null);
-
-    // Management server closes the RPC stream with an error.
-    responseObserver.onError(Status.UNKNOWN.asException());
-    verify(listenerWatcher).onError(statusCaptor.capture());
-    assertThat(statusCaptor.getValue().getCode()).isEqualTo(Code.UNKNOWN);
-
-    // Resets backoff and retry immediately.
-    inOrder.verify(backoffPolicyProvider).get();
-    fakeClock.runDueTasks();
-    inOrder.verify(mockedDiscoveryService)
-        .streamAggregatedResources(responseObserverCaptor.capture());
-    responseObserver = responseObserverCaptor.getValue();
-    StreamObserver<DiscoveryRequest> requestObserver = requestObservers.poll();
-
-    // Retry resumes requests for all wanted resources.
-    verify(requestObserver)
-        .onNext(eq(buildDiscoveryRequest(NODE, "0",
-                ImmutableList.of("test/value?udpa.resource.listening_address=192.168.3.7:7000"),
-                ResourceType.LDS.typeUrl(), "")));
-    verifyNoMoreInteractions(requestObserver);
-
-    // Management server becomes unreachable.
-    responseObserver.onError(Status.UNAVAILABLE.asException());
-    verify(listenerWatcher, times(2)).onError(statusCaptor.capture());
-    assertThat(statusCaptor.getValue().getCode()).isEqualTo(Code.UNAVAILABLE);
-    inOrder.verify(backoffPolicy1).nextBackoffNanos();
-    assertThat(fakeClock.getPendingTasks(RPC_RETRY_TASK_FILTER)).hasSize(1);
-
-    // Retry after backoff.
-    fakeClock.forwardNanos(9L);
-    assertThat(requestObservers).isEmpty();
-    fakeClock.forwardNanos(1L);
-    inOrder.verify(mockedDiscoveryService)
-        .streamAggregatedResources(responseObserverCaptor.capture());
-    responseObserver = responseObserverCaptor.getValue();
-    requestObserver = requestObservers.poll();
-    verify(requestObserver)
-        .onNext(eq(buildDiscoveryRequest(NODE, "0",
-                ImmutableList.of("test/value?udpa.resource.listening_address=192.168.3.7:7000"),
-                ResourceType.LDS.typeUrl(), "")));
-    verifyNoMoreInteractions(requestObserver);
-
-    // Management server is still not reachable.
-    responseObserver.onError(Status.UNAVAILABLE.asException());
-    verify(listenerWatcher, times(3)).onError(statusCaptor.capture());
-    assertThat(statusCaptor.getValue().getCode()).isEqualTo(Code.UNAVAILABLE);
-    inOrder.verify(backoffPolicy1).nextBackoffNanos();
-    assertThat(fakeClock.getPendingTasks(RPC_RETRY_TASK_FILTER)).hasSize(1);
-
-    // Retry after backoff.
-    fakeClock.forwardNanos(99L);
-    assertThat(requestObservers).isEmpty();
-    fakeClock.forwardNanos(1L);
-    inOrder.verify(mockedDiscoveryService)
-        .streamAggregatedResources(responseObserverCaptor.capture());
-    responseObserver = responseObserverCaptor.getValue();
-    requestObserver = requestObservers.poll();
-    verify(requestObserver)
-        .onNext(eq(buildDiscoveryRequest(NODE, "0",
-                ImmutableList.of("test/value?udpa.resource.listening_address=192.168.3.7:7000"),
-                ResourceType.LDS.typeUrl(), "")));
-    verifyNoMoreInteractions(requestObserver);
-
-    // Management server sends back a LDS response.
-    response = buildDiscoveryResponse("1", listeners,
-        ResourceType.LDS.typeUrl(), "0001");
-    responseObserver.onNext(response);
-
-    // Client sent an LDS ACK request (Omitted).
-
-    // Management server closes the RPC stream.
-    responseObserver.onCompleted();
-    verify(listenerWatcher, times(4)).onError(any(Status.class));
-
-    // Resets backoff and retry immediately
-    inOrder.verify(backoffPolicyProvider).get();
-    fakeClock.runDueTasks();
-    inOrder.verify(mockedDiscoveryService)
-        .streamAggregatedResources(responseObserverCaptor.capture());
-    responseObserver = responseObserverCaptor.getValue();
-    requestObserver = requestObservers.poll();
-
-    verify(requestObserver)
-        .onNext(eq(buildDiscoveryRequest(NODE, "1",
-                ImmutableList.of("test/value?udpa.resource.listening_address=192.168.3.7:7000"),
-                ResourceType.LDS.typeUrl(), "")));
-    verifyNoMoreInteractions(requestObserver);
-
-    // Management server becomes unreachable again.
-    responseObserver.onError(Status.UNAVAILABLE.asException());
-    verify(listenerWatcher, times(5)).onError(statusCaptor.capture());
-    assertThat(statusCaptor.getValue().getCode()).isEqualTo(Code.UNAVAILABLE);
-    inOrder.verify(backoffPolicy2).nextBackoffNanos();
-    assertThat(fakeClock.getPendingTasks(RPC_RETRY_TASK_FILTER)).hasSize(1);
-
-    // Retry after backoff.
-    fakeClock.forwardNanos(19L);
-    assertThat(requestObservers).isEmpty();
-    fakeClock.forwardNanos(1L);
-    inOrder.verify(mockedDiscoveryService)
-        .streamAggregatedResources(responseObserverCaptor.capture());
-    requestObserver = requestObservers.poll();
-    verify(requestObserver)
-        .onNext(eq(buildDiscoveryRequest(NODE, "1",
-                ImmutableList.of("test/value?udpa.resource.listening_address=192.168.3.7:7000"),
-                ResourceType.LDS.typeUrl(), "")));
-
-    verifyNoMoreInteractions(mockedDiscoveryService, backoffPolicyProvider, backoffPolicy1,
-        backoffPolicy2, requestObserver);
-  }
-
-  static Listener buildListenerWithDefaultFilterChain(String name, int portValue, String address,
-      FilterChain defaultFilterChain) {
-    io.envoyproxy.envoy.config.core.v3.Address listenerAddress =
-        io.envoyproxy.envoy.config.core.v3.Address.newBuilder()
-            .setSocketAddress(
-                SocketAddress.newBuilder().setPortValue(portValue).setAddress(address))
-            .build();
-    if (defaultFilterChain == null) {
-      defaultFilterChain = FilterChain.getDefaultInstance();
-    }
-    return
-        Listener.newBuilder()
-            .setName(name)
-            .setAddress(listenerAddress)
-            .setDefaultFilterChain(defaultFilterChain)
-            .setTrafficDirection(TrafficDirection.INBOUND)
-            .build();
-  }
-
-  static Listener buildListenerWithFilterChain(String name, int portValue, String address,
-                                               FilterChain... 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();
-    return
-        Listener.newBuilder()
-            .setName(name)
-            .setAddress(listenerAddress)
-            .setDefaultFilterChain(FilterChain.getDefaultInstance())
-            .addAllFilterChains(Arrays.asList(filterChains))
-            .setTrafficDirection(TrafficDirection.INBOUND)
-            .build();
-  }
-
-  @SuppressWarnings("deprecation")
-  static FilterChain buildFilterChain(FilterChainMatch filterChainMatch,
-                                      DownstreamTlsContext tlsContext, Filter...filters) {
-    return FilterChain.newBuilder()
-        .setFilterChainMatch(filterChainMatch)
-        .setTransportSocket(
-            tlsContext == null
-                ? TransportSocket.getDefaultInstance()
-                : TransportSocket.newBuilder()
-                    .setName("envoy.transport_sockets.tls")
-                    .setTypedConfig(Any.pack(tlsContext))
-                    .build())
-        .addAllFilters(Arrays.asList(filters))
-        .build();
-  }
-
-  static FilterChainMatch buildFilterChainMatch(int destPort, CidrRange...prefixRanges) {
-    return
-        FilterChainMatch.newBuilder()
-            .setDestinationPort(UInt32Value.of(destPort))
-            .addAllPrefixRanges(Arrays.asList(prefixRanges))
-            .build();
-  }
-
-  static FilterChainMatch buildFilterChainMatch(String...values) {
-    return FilterChainMatch.newBuilder().addAllApplicationProtocols(Arrays.asList(values)).build();
-  }
-
-  static Filter buildTestFilter(String name) {
-    return
-        Filter.newBuilder()
-            .setName(name)
-            .setTypedConfig(
-                Any.newBuilder()
-                .setTypeUrl(TYPE_URL_HCM))
-            .build();
-  }
-}
diff --git a/xds/src/test/java/io/grpc/xds/ServerXdsClientTest.java b/xds/src/test/java/io/grpc/xds/ServerXdsClientTest.java
deleted file mode 100644
index a76aa321e0d..00000000000
--- a/xds/src/test/java/io/grpc/xds/ServerXdsClientTest.java
+++ /dev/null
@@ -1,814 +0,0 @@
-/*
- * 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.XdsClientTestHelper.buildDiscoveryResponseV2;
-import static io.grpc.xds.XdsClientTestHelper.buildListenerV2;
-import static io.grpc.xds.XdsClientTestHelper.buildRouteConfigurationV2;
-import static io.grpc.xds.XdsClientTestHelper.buildVirtualHostV2;
-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.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.Iterables;
-import com.google.common.util.concurrent.MoreExecutors;
-import com.google.protobuf.Any;
-import com.google.protobuf.InvalidProtocolBufferException;
-import com.google.protobuf.UInt32Value;
-import io.envoyproxy.envoy.api.v2.DiscoveryRequest;
-import io.envoyproxy.envoy.api.v2.DiscoveryResponse;
-import io.envoyproxy.envoy.api.v2.Listener;
-import io.envoyproxy.envoy.api.v2.auth.DownstreamTlsContext;
-import io.envoyproxy.envoy.api.v2.core.CidrRange;
-import io.envoyproxy.envoy.api.v2.core.SocketAddress;
-import io.envoyproxy.envoy.api.v2.core.TransportSocket;
-import io.envoyproxy.envoy.api.v2.listener.Filter;
-import io.envoyproxy.envoy.api.v2.listener.FilterChain;
-import io.envoyproxy.envoy.api.v2.listener.FilterChainMatch;
-import io.envoyproxy.envoy.config.filter.network.http_connection_manager.v2.HttpConnectionManager;
-import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.CommonTlsContext;
-import io.envoyproxy.envoy.service.discovery.v2.AggregatedDiscoveryServiceGrpc.AggregatedDiscoveryServiceImplBase;
-import io.grpc.Context;
-import io.grpc.Context.CancellationListener;
-import io.grpc.ManagedChannel;
-import io.grpc.Status;
-import io.grpc.Status.Code;
-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.TaskFilter;
-import io.grpc.stub.StreamObserver;
-import io.grpc.testing.GrpcCleanupRule;
-import io.grpc.xds.AbstractXdsClient.ResourceType;
-import io.grpc.xds.EnvoyProtoData.Node;
-import io.grpc.xds.XdsClient.ListenerUpdate;
-import io.grpc.xds.XdsClient.ListenerWatcher;
-import io.grpc.xds.internal.sds.CommonTlsContextTestsUtil;
-import java.io.IOException;
-import java.util.ArrayDeque;
-import java.util.Arrays;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Queue;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicBoolean;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Ignore;
-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.Mockito;
-import org.mockito.MockitoAnnotations;
-
-/**
- * Tests for {@link ServerXdsClient}.
- */
-@RunWith(JUnit4.class)
-public class ServerXdsClientTest {
-
-  private static final int PORT = 7000;
-  private static final String LOCAL_IP = "192.168.3.5";
-  private static final String DIFFERENT_IP = "192.168.3.6";
-  private static final String INSTANCE_IP = "192.168.3.7";
-  private static final String TYPE_URL_HCM =
-      "type.googleapis.com/"
-          + "envoy.config.filter.network.http_connection_manager.v2.HttpConnectionManager";
-
-  private static final Node NODE = Node.newBuilder().build();
-  private static final FakeClock.TaskFilter RPC_RETRY_TASK_FILTER =
-      new FakeClock.TaskFilter() {
-        @Override
-        public boolean shouldAccept(Runnable command) {
-          return command.toString().contains(AbstractXdsClient.RpcRetryTask.class.getSimpleName());
-        }
-      };
-  private static final TaskFilter LISTENER_RESOURCE_FETCH_TIMEOUT_TASK_FILTER =
-      new TaskFilter() {
-        @Override
-        public boolean shouldAccept(Runnable command) {
-          return command.toString()
-              .contains(ServerXdsClient.ListenerResourceFetchTimeoutTask.class.getSimpleName());
-        }
-      };
-  private static final String LISTENER_NAME = "INBOUND_LISTENER";
-
-  @Rule
-  public final GrpcCleanupRule cleanupRule = new GrpcCleanupRule();
-
-  private final FakeClock fakeClock = new FakeClock();
-
-  private final Queue<StreamObserver<DiscoveryResponse>> responseObservers = new ArrayDeque<>();
-  private final Queue<StreamObserver<DiscoveryRequest>> requestObservers = new ArrayDeque<>();
-  private final AtomicBoolean callEnded = new AtomicBoolean(true);
-
-  @Mock
-  private AggregatedDiscoveryServiceImplBase mockedDiscoveryService;
-  @Mock
-  private BackoffPolicy.Provider backoffPolicyProvider;
-  @Mock
-  private BackoffPolicy backoffPolicy1;
-  @Mock
-  private BackoffPolicy backoffPolicy2;
-  @Mock
-  private ListenerWatcher listenerWatcher;
-
-  private ManagedChannel channel;
-  private ServerXdsClient xdsClient;
-
-  @Before
-  public void setUp() throws IOException {
-    MockitoAnnotations.initMocks(this);
-    when(backoffPolicyProvider.get()).thenReturn(backoffPolicy1, backoffPolicy2);
-    when(backoffPolicy1.nextBackoffNanos()).thenReturn(10L, 100L);
-    when(backoffPolicy2.nextBackoffNanos()).thenReturn(20L, 200L);
-
-    final String serverName = InProcessServerBuilder.generateName();
-    AggregatedDiscoveryServiceImplBase adsServiceImpl = new AggregatedDiscoveryServiceImplBase() {
-      @Override
-      public StreamObserver<DiscoveryRequest> streamAggregatedResources(
-          final StreamObserver<DiscoveryResponse> 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());
-        responseObservers.offer(responseObserver);
-        @SuppressWarnings("unchecked")
-        StreamObserver<DiscoveryRequest> requestObserver = mock(StreamObserver.class);
-        requestObservers.offer(requestObserver);
-        return requestObserver;
-      }
-    };
-    mockedDiscoveryService =
-        mock(AggregatedDiscoveryServiceImplBase.class, delegatesTo(adsServiceImpl));
-
-    cleanupRule.register(
-        InProcessServerBuilder
-            .forName(serverName)
-            .addService(mockedDiscoveryService)
-            .directExecutor()
-            .build()
-            .start());
-    channel =
-        cleanupRule.register(InProcessChannelBuilder.forName(serverName).directExecutor().build());
-
-    xdsClient =
-        new ServerXdsClient(channel, /* useProtocolV3= */ false, NODE,
-            fakeClock.getScheduledExecutorService(), backoffPolicyProvider,
-            fakeClock.getStopwatchSupplier(), INSTANCE_IP, "grpc/server");
-    // Only the connection to management server is established, no RPC request is sent until at
-    // least one watcher is registered.
-    assertThat(responseObservers).isEmpty();
-    assertThat(requestObservers).isEmpty();
-  }
-
-  @After
-  public void tearDown() {
-    xdsClient.shutdown();
-    channel.shutdown();
-    assertThat(callEnded.get()).isTrue();
-    assertThat(fakeClock.getPendingTasks()).isEmpty();
-  }
-
-  private static Node getNodeToVerify() {
-    Map<String, Object> newMetadata = new HashMap<>();
-    if (NODE.getMetadata() != null) {
-      newMetadata.putAll(NODE.getMetadata());
-    }
-    newMetadata.put("TRAFFICDIRECTOR_INBOUND_INTERCEPTION_PORT", "15001");
-    newMetadata.put("TRAFFICDIRECTOR_INBOUND_BACKEND_PORTS", "" + PORT);
-    newMetadata.put("INSTANCE_IP", INSTANCE_IP);
-    return NODE.toBuilder()
-        .setMetadata(newMetadata)
-        .build();
-  }
-
-  private static DiscoveryRequest buildDiscoveryRequest(
-      Node node, String versionInfo, String typeUrl, String nonce) {
-    return DiscoveryRequest.newBuilder()
-        .setVersionInfo(versionInfo)
-        .setNode(node.toEnvoyProtoNodeV2())
-        .setTypeUrl(typeUrl)
-        .setResponseNonce(nonce)
-        .build();
-  }
-
-  @Test
-  public void ldsResponse_2listenerWatchers_expectError() {
-    xdsClient.watchListenerData(PORT, listenerWatcher);
-    try {
-      xdsClient.watchListenerData(80, listenerWatcher);
-      fail("expected exception");
-    } catch (IllegalStateException expected) {
-      assertThat(expected)
-          .hasMessageThat()
-          .isEqualTo("ListenerWatcher already registered");
-    }
-  }
-
-  /**
-   * Client receives an LDS response that contains listener with no match i.e. no port match.
-   */
-  @Test
-  public void ldsResponse_nonMatchingFilterChain_notFoundError() {
-    xdsClient.watchListenerData(PORT, listenerWatcher);
-    StreamObserver<DiscoveryResponse> responseObserver = responseObservers.poll();
-    StreamObserver<DiscoveryRequest> requestObserver = requestObservers.poll();
-
-    // Client sends an LDS request with null in lds resource name
-    verify(requestObserver)
-        .onNext(eq(buildDiscoveryRequest(getNodeToVerify(), "",
-            ResourceType.LDS.typeUrlV2(), "")));
-    assertThat(fakeClock.getPendingTasks(LISTENER_RESOURCE_FETCH_TIMEOUT_TASK_FILTER)).hasSize(1);
-
-    List<Any> listeners = ImmutableList.of(
-        Any.pack(buildListenerV2("bar.googleapis.com",
-            Any.pack(HttpConnectionManager.newBuilder()
-                .setRouteConfig(
-                    buildRouteConfigurationV2("route-bar.googleapis.com",
-                        ImmutableList.of(
-                            buildVirtualHostV2(
-                                ImmutableList.of("bar.googleapis.com"),
-                                "cluster-bar.googleapis.com"))))
-                .build()))),
-        Any.pack(buildListenerV2(LISTENER_NAME,
-            Any.pack(HttpConnectionManager.newBuilder()
-                .setRouteConfig(
-                    buildRouteConfigurationV2("route-baz.googleapis.com",
-                        ImmutableList.of(
-                            buildVirtualHostV2(
-                                ImmutableList.of("baz.googleapis.com"),
-                                "cluster-baz.googleapis.com"))))
-                .build()))));
-    DiscoveryResponse response =
-        buildDiscoveryResponseV2("0", listeners, ResourceType.LDS.typeUrlV2(), "0000");
-    responseObserver.onNext(response);
-
-    // Client sends an ACK LDS request.
-    verify(requestObserver)
-        .onNext(eq(buildDiscoveryRequest(getNodeToVerify(), "0",
-            ResourceType.LDS.typeUrlV2(), "0000")));
-
-    verify(listenerWatcher, never()).onListenerChanged(any(ListenerUpdate.class));
-    verify(listenerWatcher, never()).onResourceDoesNotExist(":" + PORT);
-    verify(listenerWatcher, never()).onError(any(Status.class));
-    fakeClock.forwardTime(ServerXdsClient.INITIAL_RESOURCE_FETCH_TIMEOUT_SEC, TimeUnit.SECONDS);
-    verify(listenerWatcher).onResourceDoesNotExist(":" + PORT);
-    assertThat(fakeClock.getPendingTasks(LISTENER_RESOURCE_FETCH_TIMEOUT_TASK_FILTER)).isEmpty();
-  }
-
-  /** Client receives a Listener with listener address and mismatched port. */
-  @Test
-  public void ldsResponseWith_listenerAddressPortMismatch() {
-    xdsClient.watchListenerData(PORT, listenerWatcher);
-    StreamObserver<DiscoveryResponse> responseObserver = responseObservers.poll();
-    StreamObserver<DiscoveryRequest> requestObserver = requestObservers.poll();
-
-    // Client sends an LDS request with null in lds resource name
-    verify(requestObserver)
-        .onNext(eq(buildDiscoveryRequest(getNodeToVerify(), "",
-            ResourceType.LDS.typeUrlV2(), "")));
-    assertThat(fakeClock.getPendingTasks(LISTENER_RESOURCE_FETCH_TIMEOUT_TASK_FILTER)).hasSize(1);
-
-    final FilterChain filterChainOutbound = buildFilterChain(buildFilterChainMatch(8000), null);
-    final FilterChain filterChainInbound = buildFilterChain(buildFilterChainMatch(PORT,
-        CidrRange.newBuilder().setAddressPrefix(LOCAL_IP)
-            .setPrefixLen(UInt32Value.of(32)).build()),
-        // Server is still speaking xds v2.
-        CommonTlsContextTestsUtil.buildTestDownstreamTlsContextV2("google-sds-config-default",
-            "ROOTCA"),
-        buildTestFilter("envoy.http_connection_manager"));
-    List<Any> listeners = ImmutableList.of(
-        Any.pack(buildListenerV2("bar.googleapis.com",
-            Any.pack(HttpConnectionManager.newBuilder()
-                .setRouteConfig(
-                    buildRouteConfigurationV2("route-bar.googleapis.com",
-                        ImmutableList.of(
-                            buildVirtualHostV2(
-                                ImmutableList.of("bar.googleapis.com"),
-                                "cluster-bar.googleapis.com"))))
-                .build()))),
-        Any.pack(buildListenerWithFilterChain(LISTENER_NAME, 15002, "0.0.0.0",
-            filterChainOutbound,
-            filterChainInbound
-        )));
-    DiscoveryResponse response =
-        buildDiscoveryResponseV2("0", listeners, ResourceType.LDS.typeUrlV2(), "0000");
-    responseObserver.onNext(response);
-
-    // Client sends an ACK LDS request.
-    verify(requestObserver)
-        .onNext(eq(buildDiscoveryRequest(getNodeToVerify(), "0",
-            ResourceType.LDS.typeUrlV2(), "0000")));
-
-    verify(listenerWatcher, never()).onListenerChanged(any(ListenerUpdate.class));
-    verify(listenerWatcher, never()).onResourceDoesNotExist(":" + PORT);
-    verify(listenerWatcher, never()).onError(any(Status.class));
-    fakeClock.forwardTime(ServerXdsClient.INITIAL_RESOURCE_FETCH_TIMEOUT_SEC, TimeUnit.SECONDS);
-    verify(listenerWatcher).onResourceDoesNotExist(":" + PORT);
-    assertThat(fakeClock.getPendingTasks(LISTENER_RESOURCE_FETCH_TIMEOUT_TASK_FILTER)).isEmpty();
-  }
-
-  /** Client receives a Listener with all match. */
-  @Test
-  public void ldsResponseWith_matchingListenerFound() throws InvalidProtocolBufferException {
-    xdsClient.watchListenerData(PORT, listenerWatcher);
-    StreamObserver<DiscoveryResponse> responseObserver = responseObservers.poll();
-    StreamObserver<DiscoveryRequest> requestObserver = requestObservers.poll();
-
-    // Client sends an LDS request with null in lds resource name
-    verify(requestObserver)
-        .onNext(eq(buildDiscoveryRequest(getNodeToVerify(), "",
-            ResourceType.LDS.typeUrlV2(), "")));
-    assertThat(fakeClock.getPendingTasks(LISTENER_RESOURCE_FETCH_TIMEOUT_TASK_FILTER)).hasSize(1);
-
-    final FilterChain filterChainOutbound = buildFilterChain(buildFilterChainMatch(8000), null);
-    final FilterChain filterChainInbound = buildFilterChain(buildFilterChainMatch(PORT,
-        CidrRange.newBuilder().setAddressPrefix(LOCAL_IP)
-            .setPrefixLen(UInt32Value.of(32)).build()),
-        // Server is still speaking xds v2.
-        CommonTlsContextTestsUtil.buildTestDownstreamTlsContextV2("google-sds-config-default",
-            "ROOTCA"),
-        buildTestFilter("envoy.http_connection_manager"));
-    List<Any> listeners = ImmutableList.of(
-        Any.pack(buildListenerV2("bar.googleapis.com",
-            Any.pack(HttpConnectionManager.newBuilder()
-                .setRouteConfig(
-                    buildRouteConfigurationV2("route-bar.googleapis.com",
-                        ImmutableList.of(
-                            buildVirtualHostV2(
-                                ImmutableList.of("bar.googleapis.com"),
-                                "cluster-bar.googleapis.com"))))
-                .build()))),
-        Any.pack(buildListenerWithFilterChain(LISTENER_NAME, 15001, "0.0.0.0",
-            filterChainOutbound,
-            filterChainInbound
-        )));
-    DiscoveryResponse response =
-        buildDiscoveryResponseV2("0", listeners, ResourceType.LDS.typeUrlV2(), "0000");
-    responseObserver.onNext(response);
-
-    // Client sends an ACK LDS request.
-    verify(requestObserver)
-        .onNext(eq(buildDiscoveryRequest(getNodeToVerify(), "0",
-            ResourceType.LDS.typeUrlV2(), "0000")));
-
-    ArgumentCaptor<ListenerUpdate> listenerUpdateCaptor = ArgumentCaptor.forClass(null);
-    verify(listenerWatcher, times(1)).onListenerChanged(listenerUpdateCaptor.capture());
-    ListenerUpdate configUpdate = listenerUpdateCaptor.getValue();
-    EnvoyServerProtoData.Listener listener = configUpdate.getListener();
-    assertThat(listener.getName()).isEqualTo(LISTENER_NAME);
-    assertThat(listener.getAddress()).isEqualTo("0.0.0.0:15001");
-    assertThat(listener.getFilterChains()).hasSize(2);
-    EnvoyServerProtoData.FilterChain filterChainOutboundInListenerUpdate
-        = listener.getFilterChains().get(0);
-    assertThat(filterChainOutboundInListenerUpdate.getFilterChainMatch().getDestinationPort())
-        .isEqualTo(8000);
-    EnvoyServerProtoData.FilterChain filterChainInboundInListenerUpdate
-        = listener.getFilterChains().get(1);
-    EnvoyServerProtoData.FilterChainMatch inBoundfilterChainMatch =
-        filterChainInboundInListenerUpdate.getFilterChainMatch();
-    assertThat(inBoundfilterChainMatch.getDestinationPort()).isEqualTo(PORT);
-    assertThat(inBoundfilterChainMatch.getPrefixRanges()).containsExactly(
-        new EnvoyServerProtoData.CidrRange(LOCAL_IP, 32));
-    CommonTlsContext downstreamCommonTlsContext =
-        filterChainInboundInListenerUpdate.getDownstreamTlsContext().getCommonTlsContext();
-    assertThat(downstreamCommonTlsContext.getTlsCertificateSdsSecretConfigs(0).getName())
-        .isEqualTo("google-sds-config-default");
-    assertThat(
-        downstreamCommonTlsContext
-            .getCombinedValidationContext()
-            .getValidationContextSdsSecretConfig()
-            .getName())
-        .isEqualTo("ROOTCA");
-    assertThat(fakeClock.getPendingTasks(LISTENER_RESOURCE_FETCH_TIMEOUT_TASK_FILTER)).isEmpty();
-  }
-
-  /** Client receives LDS responses for updating Listener previously received. */
-  @Test
-  public void notifyUpdatedListener() throws InvalidProtocolBufferException {
-    xdsClient.watchListenerData(PORT, listenerWatcher);
-    StreamObserver<DiscoveryResponse> responseObserver = responseObservers.poll();
-    StreamObserver<DiscoveryRequest> requestObserver = requestObservers.poll();
-
-    // Client sends an LDS request with null in lds resource name
-    verify(requestObserver)
-        .onNext(eq(buildDiscoveryRequest(getNodeToVerify(), "",
-            ResourceType.LDS.typeUrlV2(), "")));
-    assertThat(fakeClock.getPendingTasks(LISTENER_RESOURCE_FETCH_TIMEOUT_TASK_FILTER)).hasSize(1);
-
-    final FilterChain filterChainOutbound = buildFilterChain(buildFilterChainMatch(8000), null);
-    final FilterChain filterChainInbound = buildFilterChain(buildFilterChainMatch(PORT,
-        CidrRange.newBuilder().setAddressPrefix(LOCAL_IP)
-            .setPrefixLen(UInt32Value.of(32)).build()),
-        // Server is still speaking xds v2.
-        CommonTlsContextTestsUtil.buildTestDownstreamTlsContextV2("google-sds-config-default",
-            "ROOTCA"),
-        buildTestFilter("envoy.http_connection_manager"));
-    List<Any> listeners = ImmutableList.of(
-        Any.pack(buildListenerV2("bar.googleapis.com",
-            Any.pack(HttpConnectionManager.newBuilder()
-                .setRouteConfig(
-                    buildRouteConfigurationV2("route-bar.googleapis.com",
-                        ImmutableList.of(
-                            buildVirtualHostV2(
-                                ImmutableList.of("bar.googleapis.com"),
-                                "cluster-bar.googleapis.com"))))
-                .build()))),
-        Any.pack(buildListenerWithFilterChain(LISTENER_NAME, 15001, "0.0.0.0",
-            filterChainOutbound,
-            filterChainInbound
-        )));
-    DiscoveryResponse response =
-        buildDiscoveryResponseV2("0", listeners, ResourceType.LDS.typeUrlV2(), "0000");
-    responseObserver.onNext(response);
-
-    // Client sends an ACK LDS request.
-    verify(requestObserver)
-        .onNext(eq(buildDiscoveryRequest(getNodeToVerify(), "0",
-            ResourceType.LDS.typeUrlV2(), "0000")));
-
-    ArgumentCaptor<ListenerUpdate> listenerUpdateCaptor = ArgumentCaptor.forClass(null);
-    verify(listenerWatcher, times(1)).onListenerChanged(listenerUpdateCaptor.capture());
-
-    // Management sends back another LDS response containing updates for the requested Listener.
-    final FilterChain filterChainNewInbound = buildFilterChain(buildFilterChainMatch(PORT,
-        CidrRange.newBuilder().setAddressPrefix(LOCAL_IP)
-            .setPrefixLen(UInt32Value.of(32)).build()),
-        CommonTlsContextTestsUtil.buildTestDownstreamTlsContextV2("google-sds-config-default1",
-            "ROOTCA2"),
-        buildTestFilter("envoy.http_connection_manager"));
-    List<Any> listeners1 = ImmutableList.of(
-        Any.pack(buildListenerWithFilterChain(LISTENER_NAME, 15001, "0.0.0.0",
-            filterChainNewInbound
-        )));
-    DiscoveryResponse response1 =
-        buildDiscoveryResponseV2("1", listeners1, ResourceType.LDS.typeUrlV2(), "0001");
-    responseObserver.onNext(response1);
-
-    // Client sends an ACK LDS request.
-    verify(requestObserver)
-        .onNext(eq(buildDiscoveryRequest(getNodeToVerify(), "1",
-            ResourceType.LDS.typeUrlV2(), "0001")));
-
-    // Updated listener is notified to config watcher.
-    listenerUpdateCaptor = ArgumentCaptor.forClass(null);
-    verify(listenerWatcher, times(2)).onListenerChanged(listenerUpdateCaptor.capture());
-    ListenerUpdate configUpdate = listenerUpdateCaptor.getValue();
-    EnvoyServerProtoData.Listener listener = configUpdate.getListener();
-    assertThat(listener.getName()).isEqualTo(LISTENER_NAME);
-    assertThat(listener.getFilterChains()).hasSize(1);
-    EnvoyServerProtoData.FilterChain filterChain =
-        Iterables.getOnlyElement(listener.getFilterChains());
-    EnvoyServerProtoData.FilterChainMatch filterChainMatch = filterChain.getFilterChainMatch();
-    assertThat(filterChainMatch.getDestinationPort()).isEqualTo(PORT);
-    assertThat(filterChainMatch.getPrefixRanges()).containsExactly(
-        new EnvoyServerProtoData.CidrRange(LOCAL_IP, 32));
-    CommonTlsContext downstreamCommonTlsContext =
-        filterChain.getDownstreamTlsContext().getCommonTlsContext();
-    assertThat(downstreamCommonTlsContext.getTlsCertificateSdsSecretConfigs(0).getName())
-        .isEqualTo("google-sds-config-default1");
-    assertThat(
-        downstreamCommonTlsContext
-            .getCombinedValidationContext()
-            .getValidationContextSdsSecretConfig()
-            .getName())
-        .isEqualTo("ROOTCA2");
-  }
-
-  /**
-   * Client receives LDS response containing matching name but non-matching IP address. Test
-   * disabled until IP matching logic implemented.
-   */
-  @Ignore
-  @Test
-  public void ldsResponse_nonMatchingIpAddress() {
-    xdsClient.watchListenerData(PORT, listenerWatcher);
-    StreamObserver<DiscoveryResponse> responseObserver = responseObservers.poll();
-    StreamObserver<DiscoveryRequest> requestObserver = requestObservers.poll();
-
-    // Client sends an LDS request with null in lds resource name
-    verify(requestObserver)
-        .onNext(eq(buildDiscoveryRequest(getNodeToVerify(), "",
-            ResourceType.LDS.typeUrlV2(), "")));
-    assertThat(fakeClock.getPendingTasks(LISTENER_RESOURCE_FETCH_TIMEOUT_TASK_FILTER)).hasSize(1);
-
-    final FilterChain filterChainInbound = buildFilterChain(buildFilterChainMatch(8000), null);
-    final FilterChain filterChainOutbound = buildFilterChain(buildFilterChainMatch(PORT,
-        CidrRange.newBuilder().setAddressPrefix(DIFFERENT_IP)
-            .setPrefixLen(UInt32Value.of(32)).build()),
-        // Server is still speaking xds v2.
-        CommonTlsContextTestsUtil.buildTestDownstreamTlsContextV2("google-sds-config-default",
-            "ROOTCA"),
-        buildTestFilter("envoy.http_connection_manager"));
-    List<Any> listeners = ImmutableList.of(
-        Any.pack(buildListenerV2("bar.googleapis.com",
-            Any.pack(HttpConnectionManager.newBuilder()
-                .setRouteConfig(
-                    buildRouteConfigurationV2("route-bar.googleapis.com",
-                        ImmutableList.of(
-                            buildVirtualHostV2(
-                                ImmutableList.of("bar.googleapis.com"),
-                                "cluster-bar.googleapis.com"))))
-                .build()))),
-        Any.pack(buildListenerWithFilterChain(LISTENER_NAME, 15001, "0.0.0.0",
-            filterChainInbound,
-            filterChainOutbound
-        )));
-    DiscoveryResponse response =
-        buildDiscoveryResponseV2("0", listeners, ResourceType.LDS.typeUrlV2(), "0000");
-    responseObserver.onNext(response);
-
-    // Client sends an ACK LDS request.
-    verify(requestObserver)
-        .onNext(eq(buildDiscoveryRequest(getNodeToVerify(), "0",
-            ResourceType.LDS.typeUrlV2(), "0000")));
-
-    verify(listenerWatcher, never()).onError(any(Status.class));
-    verify(listenerWatcher, never()).onListenerChanged(any(ListenerUpdate.class));
-  }
-
-  /** Client receives LDS response containing non-matching port in the filterMatch. */
-  @Test
-  public void ldsResponse_nonMatchingPort() {
-    xdsClient.watchListenerData(PORT, listenerWatcher);
-    StreamObserver<DiscoveryResponse> responseObserver = responseObservers.poll();
-    StreamObserver<DiscoveryRequest> requestObserver = requestObservers.poll();
-
-    // Client sends an LDS request with null in lds resource name
-    verify(requestObserver)
-        .onNext(eq(buildDiscoveryRequest(getNodeToVerify(), "",
-            ResourceType.LDS.typeUrlV2(), "")));
-    assertThat(fakeClock.getPendingTasks(LISTENER_RESOURCE_FETCH_TIMEOUT_TASK_FILTER)).hasSize(1);
-
-    final FilterChain filterChainInbound = buildFilterChain(buildFilterChainMatch(8000), null);
-    final FilterChain filterChainOutbound = buildFilterChain(buildFilterChainMatch(
-        PORT + 1,  // add 1 to mismatch
-        CidrRange.newBuilder().setAddressPrefix(LOCAL_IP)
-            .setPrefixLen(UInt32Value.of(32)).build()),
-        // Server is still speaking xds v2.
-        CommonTlsContextTestsUtil.buildTestDownstreamTlsContextV2("google-sds-config-default",
-            "ROOTCA"),
-        buildTestFilter("envoy.http_connection_manager"));
-    List<Any> listeners = ImmutableList.of(
-        Any.pack(buildListenerV2("bar.googleapis.com",
-            Any.pack(HttpConnectionManager.newBuilder()
-                .setRouteConfig(
-                    buildRouteConfigurationV2("route-bar.googleapis.com",
-                        ImmutableList.of(
-                            buildVirtualHostV2(
-                                ImmutableList.of("bar.googleapis.com"),
-                                "cluster-bar.googleapis.com"))))
-                .build()))),
-        Any.pack(buildListenerWithFilterChain(LISTENER_NAME, PORT, "0.0.0.0",
-            filterChainInbound,
-            filterChainOutbound
-        )));
-    DiscoveryResponse response =
-        buildDiscoveryResponseV2("0", listeners, ResourceType.LDS.typeUrlV2(), "0000");
-    responseObserver.onNext(response);
-
-    // Client sends an ACK LDS request.
-    verify(requestObserver)
-        .onNext(eq(buildDiscoveryRequest(getNodeToVerify(), "0",
-            ResourceType.LDS.typeUrlV2(), "0000")));
-
-    verify(listenerWatcher, never()).onListenerChanged(any(ListenerUpdate.class));
-    verify(listenerWatcher, never()).onResourceDoesNotExist(":" + PORT);
-    verify(listenerWatcher, never()).onError(any(Status.class));
-    fakeClock.forwardTime(ServerXdsClient.INITIAL_RESOURCE_FETCH_TIMEOUT_SEC, TimeUnit.SECONDS);
-    verify(listenerWatcher).onResourceDoesNotExist(":" + PORT);
-    assertThat(fakeClock.getPendingTasks(LISTENER_RESOURCE_FETCH_TIMEOUT_TASK_FILTER)).isEmpty();
-  }
-
-  /**
-   * RPC stream close and retry while there is listener watcher registered.
-   */
-  @Test
-  public void streamClosedAndRetry() {
-    InOrder inOrder =
-        Mockito.inOrder(mockedDiscoveryService, backoffPolicyProvider, backoffPolicy1,
-            backoffPolicy2);
-    xdsClient.watchListenerData(PORT, listenerWatcher);
-
-    ArgumentCaptor<StreamObserver<DiscoveryResponse>> responseObserverCaptor =
-        ArgumentCaptor.forClass(null);
-    inOrder.verify(mockedDiscoveryService)
-        .streamAggregatedResources(responseObserverCaptor.capture());
-    StreamObserver<DiscoveryResponse> responseObserver =
-        responseObserverCaptor.getValue();  // same as responseObservers.poll()
-    StreamObserver<DiscoveryRequest> requestObserver = requestObservers.poll();
-    verify(requestObserver)
-        .onNext(eq(buildDiscoveryRequest(getNodeToVerify(), "",
-            ResourceType.LDS.typeUrlV2(), "")));
-    verifyNoMoreInteractions(requestObserver);
-
-    final FilterChain filterChainOutbound = buildFilterChain(buildFilterChainMatch(8000), null);
-    final FilterChain filterChainInbound = buildFilterChain(buildFilterChainMatch(PORT,
-        CidrRange.newBuilder().setAddressPrefix(LOCAL_IP)
-            .setPrefixLen(UInt32Value.of(32)).build()),
-        // Server is still speaking xds v2.
-        CommonTlsContextTestsUtil.buildTestDownstreamTlsContextV2("google-sds-config-default",
-            "ROOTCA"),
-        buildTestFilter("envoy.http_connection_manager"));
-    List<Any> listeners = ImmutableList.of(
-        Any.pack(buildListenerWithFilterChain(LISTENER_NAME, 15001, "0.0.0.0",
-            filterChainOutbound,
-            filterChainInbound
-        )));
-    DiscoveryResponse response =
-        buildDiscoveryResponseV2("0", listeners, ResourceType.LDS.typeUrlV2(), "0000");
-    responseObserver.onNext(response);
-
-    // Client sent an ACK CDS request (Omitted).
-
-    ArgumentCaptor<Status> statusCaptor = ArgumentCaptor.forClass(null);
-
-    // Management server closes the RPC stream with an error.
-    responseObserver.onError(Status.UNKNOWN.asException());
-    verify(listenerWatcher).onError(statusCaptor.capture());
-    assertThat(statusCaptor.getValue().getCode()).isEqualTo(Code.UNKNOWN);
-
-    // Resets backoff and retry immediately.
-    inOrder.verify(backoffPolicyProvider).get();
-    fakeClock.runDueTasks();
-    inOrder.verify(mockedDiscoveryService)
-        .streamAggregatedResources(responseObserverCaptor.capture());
-    responseObserver = responseObserverCaptor.getValue();
-    requestObserver = requestObservers.poll();
-
-    // Retry resumes requests for all wanted resources.
-    verify(requestObserver)
-        .onNext(eq(buildDiscoveryRequest(getNodeToVerify(), "0",
-            ResourceType.LDS.typeUrlV2(), "")));
-    verifyNoMoreInteractions(requestObserver);
-
-    // Management server becomes unreachable.
-    responseObserver.onError(Status.UNAVAILABLE.asException());
-    verify(listenerWatcher, times(2)).onError(statusCaptor.capture());
-    assertThat(statusCaptor.getValue().getCode()).isEqualTo(Code.UNAVAILABLE);
-    inOrder.verify(backoffPolicy1).nextBackoffNanos();
-    assertThat(fakeClock.getPendingTasks(RPC_RETRY_TASK_FILTER)).hasSize(1);
-
-    // Retry after backoff.
-    fakeClock.forwardNanos(9L);
-    assertThat(requestObservers).isEmpty();
-    fakeClock.forwardNanos(1L);
-    inOrder.verify(mockedDiscoveryService)
-        .streamAggregatedResources(responseObserverCaptor.capture());
-    responseObserver = responseObserverCaptor.getValue();
-    requestObserver = requestObservers.poll();
-    verify(requestObserver)
-        .onNext(eq(buildDiscoveryRequest(getNodeToVerify(), "0",
-            ResourceType.LDS.typeUrlV2(), "")));
-    verifyNoMoreInteractions(requestObserver);
-
-    // Management server is still not reachable.
-    responseObserver.onError(Status.UNAVAILABLE.asException());
-    verify(listenerWatcher, times(3)).onError(statusCaptor.capture());
-    assertThat(statusCaptor.getValue().getCode()).isEqualTo(Code.UNAVAILABLE);
-    inOrder.verify(backoffPolicy1).nextBackoffNanos();
-    assertThat(fakeClock.getPendingTasks(RPC_RETRY_TASK_FILTER)).hasSize(1);
-
-    // Retry after backoff.
-    fakeClock.forwardNanos(99L);
-    assertThat(requestObservers).isEmpty();
-    fakeClock.forwardNanos(1L);
-    inOrder.verify(mockedDiscoveryService)
-        .streamAggregatedResources(responseObserverCaptor.capture());
-    responseObserver = responseObserverCaptor.getValue();
-    requestObserver = requestObservers.poll();
-    verify(requestObserver)
-        .onNext(eq(buildDiscoveryRequest(getNodeToVerify(), "0",
-            ResourceType.LDS.typeUrlV2(), "")));
-    verifyNoMoreInteractions(requestObserver);
-
-    // Management server sends back a LDS response.
-    response = buildDiscoveryResponseV2("1", listeners,
-        ResourceType.LDS.typeUrlV2(), "0001");
-    responseObserver.onNext(response);
-
-    // Client sent an LDS ACK request (Omitted).
-
-    // Management server closes the RPC stream.
-    responseObserver.onCompleted();
-    verify(listenerWatcher, times(4)).onError(any(Status.class));
-
-    // Resets backoff and retry immediately
-    inOrder.verify(backoffPolicyProvider).get();
-    fakeClock.runDueTasks();
-    inOrder.verify(mockedDiscoveryService)
-        .streamAggregatedResources(responseObserverCaptor.capture());
-    responseObserver = responseObserverCaptor.getValue();
-    requestObserver = requestObservers.poll();
-
-    verify(requestObserver)
-        .onNext(eq(buildDiscoveryRequest(getNodeToVerify(), "1",
-            ResourceType.LDS.typeUrlV2(), "")));
-    verifyNoMoreInteractions(requestObserver);
-
-    // Management server becomes unreachable again.
-    responseObserver.onError(Status.UNAVAILABLE.asException());
-    verify(listenerWatcher, times(5)).onError(statusCaptor.capture());
-    assertThat(statusCaptor.getValue().getCode()).isEqualTo(Code.UNAVAILABLE);
-    inOrder.verify(backoffPolicy2).nextBackoffNanos();
-    assertThat(fakeClock.getPendingTasks(RPC_RETRY_TASK_FILTER)).hasSize(1);
-
-    // Retry after backoff.
-    fakeClock.forwardNanos(19L);
-    assertThat(requestObservers).isEmpty();
-    fakeClock.forwardNanos(1L);
-    inOrder.verify(mockedDiscoveryService)
-        .streamAggregatedResources(responseObserverCaptor.capture());
-    requestObserver = requestObservers.poll();
-    verify(requestObserver)
-        .onNext(eq(buildDiscoveryRequest(getNodeToVerify(), "1",
-            ResourceType.LDS.typeUrlV2(), "")));
-
-    verifyNoMoreInteractions(mockedDiscoveryService, backoffPolicyProvider, backoffPolicy1,
-        backoffPolicy2, requestObserver);
-  }
-
-  static Listener buildListenerWithFilterChain(String name, int portValue, String address,
-      FilterChain... filterChains) {
-    io.envoyproxy.envoy.api.v2.core.Address listenerAddress =
-        io.envoyproxy.envoy.api.v2.core.Address.newBuilder()
-            .setSocketAddress(
-                SocketAddress.newBuilder().setPortValue(portValue).setAddress(address))
-            .build();
-    return
-        Listener.newBuilder()
-            .setName(name)
-            .setAddress(listenerAddress)
-            .addAllFilterChains(Arrays.asList(filterChains))
-            .build();
-  }
-
-  @SuppressWarnings("deprecation")
-  static FilterChain buildFilterChain(FilterChainMatch filterChainMatch,
-      DownstreamTlsContext tlsContext, Filter...filters) {
-    return FilterChain.newBuilder()
-        .setFilterChainMatch(filterChainMatch)
-        .setTransportSocket(
-            tlsContext == null
-                ? TransportSocket.getDefaultInstance()
-                : TransportSocket.newBuilder()
-                    .setName("envoy.transport_sockets.tls")
-                    .setTypedConfig(Any.pack(tlsContext))
-                    .build())
-        .addAllFilters(Arrays.asList(filters))
-        .build();
-  }
-
-  static FilterChainMatch buildFilterChainMatch(int destPort, CidrRange...prefixRanges) {
-    return
-        FilterChainMatch.newBuilder()
-            .setDestinationPort(UInt32Value.of(destPort))
-            .addAllPrefixRanges(Arrays.asList(prefixRanges))
-            .build();
-  }
-
-  static Filter buildTestFilter(String name) {
-    return
-        Filter.newBuilder()
-            .setName(name)
-            .setTypedConfig(
-                Any.newBuilder()
-                    .setTypeUrl(TYPE_URL_HCM))
-            .build();
-  }
-}
diff --git a/xds/src/test/java/io/grpc/xds/SharedCallCounterMapTest.java b/xds/src/test/java/io/grpc/xds/SharedCallCounterMapTest.java
index 9f2293d3c53..3b10c0c0e31 100644
--- a/xds/src/test/java/io/grpc/xds/SharedCallCounterMapTest.java
+++ b/xds/src/test/java/io/grpc/xds/SharedCallCounterMapTest.java
@@ -54,6 +54,7 @@ public void autoCleanUp() {
     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();
@@ -62,4 +63,23 @@ public boolean isDone() {
     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
index 53ad28f3040..29b149f166f 100644
--- a/xds/src/test/java/io/grpc/xds/SharedXdsClientPoolProviderTest.java
+++ b/xds/src/test/java/io/grpc/xds/SharedXdsClientPoolProviderTest.java
@@ -18,21 +18,39 @@
 
 
 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.ManagedChannel;
+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.Bootstrapper.BootstrapInfo;
-import io.grpc.xds.Bootstrapper.ServerInfo;
-import io.grpc.xds.EnvoyProtoData.Node;
 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.rules.ExpectedException;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 import org.mockito.Mock;
@@ -46,45 +64,63 @@ public class SharedXdsClientPoolProviderTest {
   private static final String SERVER_URI = "trafficdirector.googleapis.com";
   @Rule
   public final MockitoRule mocks = MockitoJUnit.rule();
-  @SuppressWarnings("deprecation") // https://github.com/grpc/grpc-java/issues/7467
-  @Rule
-  public final ExpectedException thrown = ExpectedException.none();
   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 Bootstrapper bootstrapper;
+  private GrpcBootstrapperImpl bootstrapper;
+  @Mock private ResourceWatcher<LdsUpdate> ldsResourceWatcher;
 
+  @Deprecated
   @Test
-  public void noServer() throws XdsInitializationException {
+  public void sharedXdsClientObjectPool_deprecated() throws XdsInitializationException {
+    ServerInfo server = ServerInfo.create(SERVER_URI, InsecureChannelCredentials.create());
     BootstrapInfo bootstrapInfo =
-        new BootstrapInfo(Collections.<ServerInfo>emptyList(), node, null, null);
+        BootstrapInfo.builder().servers(Collections.singletonList(server)).node(node).build();
     when(bootstrapper.bootstrap()).thenReturn(bootstrapInfo);
+
     SharedXdsClientPoolProvider provider = new SharedXdsClientPoolProvider(bootstrapper);
-    thrown.expect(XdsInitializationException.class);
-    thrown.expectMessage("No xDS server provided");
-    provider.getXdsClientPool();
+    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 = new ServerInfo(SERVER_URI, InsecureChannelCredentials.create(), false);
+    ServerInfo server = ServerInfo.create(SERVER_URI, InsecureChannelCredentials.create());
     BootstrapInfo bootstrapInfo =
-        new BootstrapInfo(Collections.singletonList(server), node, null, null);
-    when(bootstrapper.bootstrap()).thenReturn(bootstrapInfo);
+        BootstrapInfo.builder().servers(Collections.singletonList(server)).node(node).build();
 
     SharedXdsClientPoolProvider provider = new SharedXdsClientPoolProvider(bootstrapper);
-    ObjectPool<XdsClient> xdsClientPool = provider.getXdsClientPool();
-    verify(bootstrapper).bootstrap();
-    assertThat(provider.getXdsClientPool()).isSameInstanceAs(xdsClientPool);
+    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() {
-    RefCountedXdsClientObjectPool xdsClientPool = new RefCountedXdsClientObjectPool(
-        SERVER_URI, InsecureChannelCredentials.create(), false, node);
+    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();
-    assertThat(xdsClientPool.getChannelForTest()).isNull();
     XdsClient xdsClient = xdsClientPool.getObject();
     assertThat(xdsClientPool.getXdsClientForTest()).isNotNull();
     xdsClientPool.returnObject(xdsClient);
@@ -92,8 +128,12 @@ public void refCountedXdsClientObjectPool_delayedCreation() {
 
   @Test
   public void refCountedXdsClientObjectPool_refCounted() {
-    RefCountedXdsClientObjectPool xdsClientPool = new RefCountedXdsClientObjectPool(
-        SERVER_URI, InsecureChannelCredentials.create(), false, node);
+    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();
@@ -105,22 +145,79 @@ public void refCountedXdsClientObjectPool_refCounted() {
     // returnObject twice
     assertThat(xdsClientPool.returnObject(xdsClient)).isNull();
     assertThat(xdsClient.isShutDown()).isTrue();
-    assertThat(xdsClientPool.getChannelForTest().isShutdown()).isTrue();
   }
 
   @Test
   public void refCountedXdsClientObjectPool_getObjectCreatesNewInstanceIfAlreadyShutdown() {
-    RefCountedXdsClientObjectPool xdsClientPool = new RefCountedXdsClientObjectPool(
-        SERVER_URI, InsecureChannelCredentials.create(), false, node);
+    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();
-    ManagedChannel channel1 = xdsClientPool.getChannelForTest();
     assertThat(xdsClientPool.returnObject(xdsClient1)).isNull();
     assertThat(xdsClient1.isShutDown()).isTrue();
-    assertThat(channel1.isShutdown()).isTrue();
 
     XdsClient xdsClient2 = xdsClientPool.getObject();
     assertThat(xdsClient2).isNotSameInstanceAs(xdsClient1);
-    assertThat(xdsClientPool.getChannelForTest()).isNotSameInstanceAs(channel1);
     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..a43ef14f8d4
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/StatefulFilter.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.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,
+        FilterConfigParseContext context) {
+      return ConfigOrError.fromConfig(Config.fromProto(rawProtoMessage, typeUrl));
+    }
+
+    @Override
+    public ConfigOrError<Config> parseFilterConfigOverride(
+        Message rawProtoMessage, FilterConfigParseContext context) {
+      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
index 8418e80bf2b..691615762bf 100644
--- a/xds/src/test/java/io/grpc/xds/WeightedRandomPickerTest.java
+++ b/xds/src/test/java/io/grpc/xds/WeightedRandomPickerTest.java
@@ -17,6 +17,7 @@
 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;
@@ -30,7 +31,6 @@
 import java.util.List;
 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.Mock;
@@ -42,9 +42,6 @@
  */
 @RunWith(JUnit4.class)
 public class WeightedRandomPickerTest {
-  @SuppressWarnings("deprecation") // https://github.com/grpc/grpc-java/issues/7467
-  @Rule
-  public final ExpectedException thrown = ExpectedException.none();
 
   @Rule
   public final MockitoRule mockitoRule = MockitoJUnit.rule();
@@ -87,7 +84,8 @@ public PickResult pickSubchannel(PickSubchannelArgs args) {
 
   private static final class FakeRandom implements ThreadSafeRandom {
     int nextInt;
-    int bound;
+    long bound;
+    Long nextLong;
 
     @Override
     public int nextInt(int bound) {
@@ -97,6 +95,28 @@ public int nextInt(int bound) {
       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();
@@ -105,14 +125,30 @@ public int nextInt(int bound) {
   public void emptyList() {
     List<WeightedChildPicker> emptyList = new ArrayList<>();
 
-    thrown.expect(IllegalArgumentException.class);
-    new WeightedRandomPicker(emptyList);
+    assertThrows(IllegalArgumentException.class, () -> new WeightedRandomPicker(emptyList));
   }
 
   @Test
   public void negativeWeight() {
-    thrown.expect(IllegalArgumentException.class);
-    new WeightedChildPicker(-1, childPicker0);
+    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
@@ -151,6 +187,36 @@ public void pickWithFakeRandom() {
     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);
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..0bd3283cb79
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/WeightedRoundRobinLoadBalancerProviderTest.java
@@ -0,0 +1,139 @@
+/*
+ * 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 io.grpc.xds.internal.MetricReportUtils.ParsedMetricName;
+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);
+  }
+
+  @Test
+  public void parseLoadBalancingConfigCustomMetricsIgnoresInvalid() throws IOException {
+    System.setProperty("GRPC_EXPERIMENTAL_WRR_CUSTOM_METRICS", "true");
+    try {
+      String lbConfig =
+          "{\"metricNamesForComputingUtilization\" : "
+          + "[\"utilization.foo\", \"invalid_name\", \"named_metrics.bar\"]}";
+      ConfigOrError configOrError = provider.parseLoadBalancingPolicyConfig(
+          parseJsonObject(lbConfig));
+      assertThat(configOrError.getConfig()).isNotNull();
+      WeightedRoundRobinLoadBalancerConfig config =
+          (WeightedRoundRobinLoadBalancerConfig) configOrError.getConfig();
+      assertThat(config.parsedMetricNamesForComputingUtilization).containsExactly(
+          ParsedMetricName.parse("utilization.foo"), ParsedMetricName.parse("named_metrics.bar"));
+    } finally {
+      System.clearProperty("GRPC_EXPERIMENTAL_WRR_CUSTOM_METRICS");
+    }
+  }
+
+
+  @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..bac62d1a103
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/WeightedRoundRobinLoadBalancerTest.java
@@ -0,0 +1,1722 @@
+/*
+ * 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.any;
+import static org.mockito.ArgumentMatchers.argThat;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.atLeast;
+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.ImmutableList;
+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 io.grpc.xds.orca.OrcaOobUtilAccessor;
+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));
+  }
+
+  private static WeightedRoundRobinPicker getWrrPicker(SubchannelPicker picker) {
+    return (WeightedRoundRobinPicker) OrcaOobUtilAccessor.getDelegate(picker);
+  }
+
+  @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 SubchannelPicker picker = pickerCaptor.getValue();
+    picker.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 =
+        getWrrPicker(pickerCaptor.getAllValues().get(0));
+    assertThat(weightedPicker.getChildren().size()).isEqualTo(1);
+    weightedPicker = getWrrPicker(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,
+        weightedConfig.parsedMetricNamesForComputingUtilization).onLoadReport(
+        InternalCallMetricRecorder.createMetricReport(
+            0.1, 0, 0.1, 1, 0, new HashMap<>(), new HashMap<>(), new HashMap<>()));
+    weightedChild2.new OrcaReportListener(weightedConfig.errorUtilizationPenalty,
+        weightedConfig.parsedMetricNamesForComputingUtilization).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 =
+        getWrrPicker(pickerCaptor.getAllValues().get(1));
+    WeightedChildLbState weightedChild1 = (WeightedChildLbState) getChild(weightedPicker, 0);
+    WeightedChildLbState weightedChild2 = (WeightedChildLbState) getChild(weightedPicker, 1);
+    weightedChild1.new OrcaReportListener(weightedConfig.errorUtilizationPenalty,
+        weightedConfig.parsedMetricNamesForComputingUtilization).onLoadReport(
+        InternalCallMetricRecorder.createMetricReport(
+            0.1, 0, 0.1, 1, 0, new HashMap<>(), new HashMap<>(), new HashMap<>()));
+    weightedChild2.new OrcaReportListener(weightedConfig.errorUtilizationPenalty,
+        weightedConfig.parsedMetricNamesForComputingUtilization).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());
+    SubchannelPicker rawPicker = pickerCaptor2.getAllValues().get(2);
+    pickResult = rawPicker.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 =
+        getWrrPicker(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,
+        weightedConfig.parsedMetricNamesForComputingUtilization).onLoadReport(r1);
+    weightedChild2.new OrcaReportListener(weightedConfig.errorUtilizationPenalty,
+        weightedConfig.parsedMetricNamesForComputingUtilization).onLoadReport(r2);
+    weightedChild3.new OrcaReportListener(weightedConfig.errorUtilizationPenalty,
+        weightedConfig.parsedMetricNamesForComputingUtilization).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 =
+        getWrrPicker(pickerCaptor.getAllValues().get(1));
+    WeightedChildLbState weightedChild1 = (WeightedChildLbState) getChild(weightedPicker, 0);
+    WeightedChildLbState weightedChild2 = (WeightedChildLbState) getChild(weightedPicker, 1);
+    weightedChild1.new OrcaReportListener(weightedConfig.errorUtilizationPenalty,
+        weightedConfig.parsedMetricNamesForComputingUtilization).onLoadReport(
+        InternalCallMetricRecorder.createMetricReport(
+            0.1, 0, 0.1, 1, 0, new HashMap<>(), new HashMap<>(), new HashMap<>()));
+    weightedChild2.new OrcaReportListener(weightedConfig.errorUtilizationPenalty,
+        weightedConfig.parsedMetricNamesForComputingUtilization).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 =
+        getWrrPicker(pickerCaptor.getAllValues().get(0));
+    assertThat(weightedPicker.getChildren().size()).isEqualTo(1);
+    weightedPicker = getWrrPicker(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,
+        weightedConfig.parsedMetricNamesForComputingUtilization).onLoadReport(
+        InternalCallMetricRecorder.createMetricReport(
+            0.1, 0, 0.1, 1, 0, new HashMap<>(), new HashMap<>(), new HashMap<>()));
+    weightedChild2.new OrcaReportListener(weightedConfig.errorUtilizationPenalty,
+        weightedConfig.parsedMetricNamesForComputingUtilization).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,
+        weightedConfig.parsedMetricNamesForComputingUtilization).onLoadReport(
+        InternalCallMetricRecorder.createMetricReport(
+            0.2, 0, 0.1, 1, 0, new HashMap<>(), new HashMap<>(), new HashMap<>()));
+    weightedChild2.new OrcaReportListener(weightedConfig.errorUtilizationPenalty,
+        weightedConfig.parsedMetricNamesForComputingUtilization).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 =
+        getWrrPicker(pickerCaptor.getAllValues().get(1));
+    WeightedChildLbState weightedChild1 = (WeightedChildLbState) getChild(weightedPicker, 0);
+    WeightedChildLbState weightedChild2 = (WeightedChildLbState) getChild(weightedPicker, 1);
+    weightedChild1.new OrcaReportListener(weightedConfig.errorUtilizationPenalty,
+        weightedConfig.parsedMetricNamesForComputingUtilization).onLoadReport(
+        InternalCallMetricRecorder.createMetricReport(
+            0.1, 0, 0.1, 1, 0, new HashMap<>(), new HashMap<>(), new HashMap<>()));
+    weightedChild2.new OrcaReportListener(weightedConfig.errorUtilizationPenalty,
+        weightedConfig.parsedMetricNamesForComputingUtilization).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 =
+        getWrrPicker(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 =
+        getWrrPicker(pickerCaptor.getAllValues().get(2));
+    WeightedChildLbState weightedChild1 = (WeightedChildLbState) getChild(weightedPicker, 0);
+    WeightedChildLbState weightedChild2 = (WeightedChildLbState) getChild(weightedPicker, 1);
+    weightedChild1.new OrcaReportListener(weightedConfig.errorUtilizationPenalty,
+        weightedConfig.parsedMetricNamesForComputingUtilization).onLoadReport(
+        InternalCallMetricRecorder.createMetricReport(
+            0.1, 0, 0.1, 1, 0, new HashMap<>(), new HashMap<>(), new HashMap<>()));
+    weightedChild2.new OrcaReportListener(weightedConfig.errorUtilizationPenalty,
+        weightedConfig.parsedMetricNamesForComputingUtilization).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 =
+        getWrrPicker(pickerCaptor.getAllValues().get(1));
+    WeightedChildLbState weightedChild1 = (WeightedChildLbState) getChild(weightedPicker, 0);
+    WeightedChildLbState weightedChild2 = (WeightedChildLbState) getChild(weightedPicker, 1);
+    weightedChild1.new OrcaReportListener(weightedConfig.errorUtilizationPenalty,
+        weightedConfig.parsedMetricNamesForComputingUtilization).onLoadReport(
+        InternalCallMetricRecorder.createMetricReport(
+            0.1, 0, 0.1, 1, 0, new HashMap<>(), new HashMap<>(), new HashMap<>()));
+    weightedChild2.new OrcaReportListener(weightedConfig.errorUtilizationPenalty,
+        weightedConfig.parsedMetricNamesForComputingUtilization).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,
+        weightedConfig.parsedMetricNamesForComputingUtilization)
+            .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,
+        weightedConfig.parsedMetricNamesForComputingUtilization)
+            .onLoadReport(InternalCallMetricRecorder.createMetricReport(0.1, 0, 0.1, 1, 0,
+                new HashMap<>(), new HashMap<>(), new HashMap<>()));
+    ((WeightedChildLbState) childLbStates.next()).new OrcaReportListener(
+        weightedConfig.errorUtilizationPenalty,
+        weightedConfig.parsedMetricNamesForComputingUtilization)
+            .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("", "")));
+  }
+
+
+  @Test
+  public void customMetric_priority_overAppUtil() {
+    weightedConfig = WeightedRoundRobinLoadBalancerConfig.newBuilder().setBlackoutPeriodNanos(0)
+        .setMetricNamesForComputingUtilization(ImmutableList.of("named_metrics.cost")).build();
+    wrr = new WeightedRoundRobinLoadBalancer(helper, fakeClock.getDeadlineTicker());
+
+    syncContext.execute(
+        () -> wrr.acceptResolvedAddresses(ResolvedAddresses.newBuilder().setAddresses(servers)
+            .setLoadBalancingPolicyConfig(weightedConfig).setAttributes(affinity).build()));
+
+    Iterator<Subchannel> it = subchannels.values().iterator();
+    Subchannel readySubchannel = it.next();
+    getSubchannelStateListener(readySubchannel)
+        .onSubchannelState(ConnectivityStateInfo.forNonError(ConnectivityState.READY));
+
+    WeightedChildLbState weightedChild =
+        (WeightedChildLbState) wrr.getChildLbStates().iterator().next();
+    WeightedChildLbState.OrcaReportListener listener = weightedChild.getOrCreateOrcaListener(
+        weightedConfig.errorUtilizationPenalty,
+        weightedConfig.parsedMetricNamesForComputingUtilization);
+
+    Map<String, Double> namedMetrics = new HashMap<>();
+    namedMetrics.put("cost", 0.5);
+    // App util = 0.8
+    MetricReport report = InternalCallMetricRecorder.createMetricReport(0.1, 0.8, 0.1, 1, 0,
+        new HashMap<>(), new HashMap<>(), namedMetrics);
+    listener.onLoadReport(report);
+    // Custom metrics now take priority over app_util
+    // qps=1, util=0.5 -> weight=2.0
+    fakeClock.forwardTime(1100, TimeUnit.MILLISECONDS);
+    verify(mockMetricRecorder).recordDoubleHistogram(
+        argThat(instr -> instr.getName().equals("grpc.lb.wrr.endpoint_weights")), eq(2.0), any(),
+        any());
+  }
+
+  @Test
+  public void customMetric_invalid_fallbackToAppUtil() {
+    weightedConfig = WeightedRoundRobinLoadBalancerConfig.newBuilder().setBlackoutPeriodNanos(0)
+        .setMetricNamesForComputingUtilization(ImmutableList.of("named_metrics.cost")).build();
+    wrr = new WeightedRoundRobinLoadBalancer(helper, fakeClock.getDeadlineTicker());
+
+    syncContext.execute(
+        () -> wrr.acceptResolvedAddresses(ResolvedAddresses.newBuilder().setAddresses(servers)
+            .setLoadBalancingPolicyConfig(weightedConfig).setAttributes(affinity).build()));
+
+    Iterator<Subchannel> it = subchannels.values().iterator();
+    Subchannel readySubchannel = it.next();
+    getSubchannelStateListener(readySubchannel)
+        .onSubchannelState(ConnectivityStateInfo.forNonError(ConnectivityState.READY));
+
+    WeightedChildLbState weightedChild =
+        (WeightedChildLbState) wrr.getChildLbStates().iterator().next();
+    WeightedChildLbState.OrcaReportListener listener = weightedChild.getOrCreateOrcaListener(
+        weightedConfig.errorUtilizationPenalty,
+        weightedConfig.parsedMetricNamesForComputingUtilization);
+
+    // custom metric is NaN, App util = 0.8
+    Map<String, Double> namedMetrics = new HashMap<>();
+    namedMetrics.put("cost", Double.NaN);
+    MetricReport report = InternalCallMetricRecorder.createMetricReport(0.1, 0.8, 0.1, 1, 0,
+        new HashMap<>(), new HashMap<>(), namedMetrics);
+    listener.onLoadReport(report);
+
+    // Should fallback to App Util (0.8)
+    // qps=1, util=0.8 -> weight=1.25
+    fakeClock.forwardTime(1100, TimeUnit.MILLISECONDS);
+    verify(mockMetricRecorder).recordDoubleHistogram(
+        argThat(instr -> instr.getName().equals("grpc.lb.wrr.endpoint_weights")), eq(1.25), any(),
+        any());
+  }
+
+  @Test
+  public void customMetric_mapLookup_used() {
+    weightedConfig = WeightedRoundRobinLoadBalancerConfig.newBuilder().setBlackoutPeriodNanos(0)
+        .setMetricNamesForComputingUtilization(ImmutableList.of("named_metrics.cost")).build();
+    wrr = new WeightedRoundRobinLoadBalancer(helper, fakeClock.getDeadlineTicker());
+
+    syncContext.execute(
+        () -> wrr.acceptResolvedAddresses(ResolvedAddresses.newBuilder().setAddresses(servers)
+            .setLoadBalancingPolicyConfig(weightedConfig).setAttributes(affinity).build()));
+
+    Iterator<Subchannel> it = subchannels.values().iterator();
+    Subchannel readySubchannel = it.next();
+    getSubchannelStateListener(readySubchannel)
+        .onSubchannelState(ConnectivityStateInfo.forNonError(ConnectivityState.READY));
+
+    WeightedChildLbState weightedChild =
+        (WeightedChildLbState) wrr.getChildLbStates().iterator().next();
+    WeightedChildLbState.OrcaReportListener listener = weightedChild.getOrCreateOrcaListener(
+        weightedConfig.errorUtilizationPenalty,
+        weightedConfig.parsedMetricNamesForComputingUtilization);
+
+    Map<String, Double> namedMetrics = new HashMap<>();
+    namedMetrics.put("cost", 0.5);
+    MetricReport report = InternalCallMetricRecorder.createMetricReport(0.1, 0, 0.1, 1, 0,
+        new HashMap<>(), new HashMap<>(), namedMetrics);
+    listener.onLoadReport(report);
+    // qps=1, util=0.5 -> weight=2.0
+    fakeClock.forwardTime(1100, TimeUnit.MILLISECONDS);
+    verify(mockMetricRecorder).recordDoubleHistogram(
+        argThat(instr -> instr.getName().equals("grpc.lb.wrr.endpoint_weights")), eq(2.0), any(),
+        any());
+  }
+
+  @Test
+  public void customMetric_shouldFilterOutAndFallbackToCpu() {
+    weightedConfig = WeightedRoundRobinLoadBalancerConfig.newBuilder().setBlackoutPeriodNanos(0)
+        .setMetricNamesForComputingUtilization(ImmutableList.of("named_metrics.cost")).build();
+    wrr = new WeightedRoundRobinLoadBalancer(helper, fakeClock.getDeadlineTicker());
+
+    syncContext.execute(
+        () -> wrr.acceptResolvedAddresses(ResolvedAddresses.newBuilder().setAddresses(servers)
+            .setLoadBalancingPolicyConfig(weightedConfig).setAttributes(affinity).build()));
+
+    Iterator<Subchannel> it = subchannels.values().iterator();
+    Subchannel readySubchannel = it.next();
+    getSubchannelStateListener(readySubchannel)
+        .onSubchannelState(ConnectivityStateInfo.forNonError(ConnectivityState.READY));
+
+    WeightedChildLbState weightedChild =
+        (WeightedChildLbState) wrr.getChildLbStates().iterator().next();
+    WeightedChildLbState.OrcaReportListener listener = weightedChild.getOrCreateOrcaListener(
+        weightedConfig.errorUtilizationPenalty,
+        weightedConfig.parsedMetricNamesForComputingUtilization);
+
+    // custom metric is NaN, but CPU is 0.1
+    Map<String, Double> namedMetrics = new HashMap<>();
+    namedMetrics.put("cost", Double.NaN);
+    MetricReport report = InternalCallMetricRecorder.createMetricReport(0.1, 0, 0.1, 1, 0,
+        new HashMap<>(), new HashMap<>(), namedMetrics);
+    listener.onLoadReport(report);
+
+    // Should fallback to CPU (0.1)
+    // fallback to cpu: qps=1, util=0.1 -> weight=10.0
+    fakeClock.forwardTime(1100, TimeUnit.MILLISECONDS);
+    verify(mockMetricRecorder).recordDoubleHistogram(
+        argThat(instr -> instr.getName().equals("grpc.lb.wrr.endpoint_weights")), eq(10.0), any(),
+        any());
+  }
+
+  @Test
+  public void customMetric_multipleMetrics_maxUsed() {
+    weightedConfig = WeightedRoundRobinLoadBalancerConfig.newBuilder().setBlackoutPeriodNanos(0)
+        .setMetricNamesForComputingUtilization(
+            ImmutableList.of("named_metrics.cost", "named_metrics.score"))
+        .build();
+    wrr = new WeightedRoundRobinLoadBalancer(helper, fakeClock.getDeadlineTicker());
+
+    syncContext.execute(
+        () -> wrr.acceptResolvedAddresses(ResolvedAddresses.newBuilder().setAddresses(servers)
+            .setLoadBalancingPolicyConfig(weightedConfig).setAttributes(affinity).build()));
+
+    Iterator<Subchannel> it = subchannels.values().iterator();
+    Subchannel readySubchannel = it.next();
+    getSubchannelStateListener(readySubchannel)
+        .onSubchannelState(ConnectivityStateInfo.forNonError(ConnectivityState.READY));
+
+    WeightedChildLbState weightedChild =
+        (WeightedChildLbState) wrr.getChildLbStates().iterator().next();
+    WeightedChildLbState.OrcaReportListener listener = weightedChild.getOrCreateOrcaListener(
+        weightedConfig.errorUtilizationPenalty,
+        weightedConfig.parsedMetricNamesForComputingUtilization);
+
+    Map<String, Double> namedMetrics = new HashMap<>();
+    namedMetrics.put("cost", 0.5);
+    namedMetrics.put("score", 0.8);
+    MetricReport report = InternalCallMetricRecorder.createMetricReport(0.1, 0, 0.1, 1, 0,
+        new HashMap<>(), new HashMap<>(), namedMetrics);
+    listener.onLoadReport(report);
+    // qps=1, util=0.8 (max of 0.5 and 0.8) -> weight=1.25
+    fakeClock.forwardTime(1100, TimeUnit.MILLISECONDS);
+    verify(mockMetricRecorder).recordDoubleHistogram(
+        argThat(instr -> instr.getName().equals("grpc.lb.wrr.endpoint_weights")), eq(1.25), any(),
+        any());
+  }
+
+  @Test
+  public void customMetric_allInvalid_fallbackToCpu() {
+    weightedConfig = WeightedRoundRobinLoadBalancerConfig.newBuilder().setBlackoutPeriodNanos(0)
+        .setMetricNamesForComputingUtilization(
+            ImmutableList.of("named_metrics.cost", "named_metrics.score", "named_metrics.other"))
+        .build();
+    wrr = new WeightedRoundRobinLoadBalancer(helper, fakeClock.getDeadlineTicker());
+
+    syncContext.execute(
+        () -> wrr.acceptResolvedAddresses(ResolvedAddresses.newBuilder().setAddresses(servers)
+            .setLoadBalancingPolicyConfig(weightedConfig).setAttributes(affinity).build()));
+
+    Iterator<Subchannel> it = subchannels.values().iterator();
+    Subchannel readySubchannel = it.next();
+    getSubchannelStateListener(readySubchannel)
+        .onSubchannelState(ConnectivityStateInfo.forNonError(ConnectivityState.READY));
+
+    WeightedChildLbState weightedChild =
+        (WeightedChildLbState) wrr.getChildLbStates().iterator().next();
+    WeightedChildLbState.OrcaReportListener listener = weightedChild.getOrCreateOrcaListener(
+        weightedConfig.errorUtilizationPenalty,
+        weightedConfig.parsedMetricNamesForComputingUtilization);
+
+    Map<String, Double> namedMetrics = new HashMap<>();
+    namedMetrics.put("cost", Double.NaN);
+    namedMetrics.put("score", 0.0);
+    namedMetrics.put("other", -1.0);
+    MetricReport report = InternalCallMetricRecorder.createMetricReport(0.1, 0, 0.1, 1, 0,
+        new HashMap<>(), new HashMap<>(), namedMetrics);
+    listener.onLoadReport(report);
+    // qps=1, util=0.1 (fallback to cpu) -> weight=10.0
+    fakeClock.forwardTime(1100, TimeUnit.MILLISECONDS);
+    verify(mockMetricRecorder).recordDoubleHistogram(
+        argThat(instr -> instr.getName().equals("grpc.lb.wrr.endpoint_weights")), eq(10.0), any(),
+        any());
+  }
+
+  @Test
+  public void customMetric_mixInvalidAndValid_validUsed() {
+    weightedConfig = WeightedRoundRobinLoadBalancerConfig.newBuilder().setBlackoutPeriodNanos(0)
+        .setMetricNamesForComputingUtilization(ImmutableList.of("named_metrics.cost",
+            "named_metrics.score", "named_metrics.other1", "named_metrics.other2"))
+        .build();
+    wrr = new WeightedRoundRobinLoadBalancer(helper, fakeClock.getDeadlineTicker());
+
+    syncContext.execute(
+        () -> wrr.acceptResolvedAddresses(ResolvedAddresses.newBuilder().setAddresses(servers)
+            .setLoadBalancingPolicyConfig(weightedConfig).setAttributes(affinity).build()));
+
+    Iterator<Subchannel> it = subchannels.values().iterator();
+    Subchannel readySubchannel = it.next();
+    getSubchannelStateListener(readySubchannel)
+        .onSubchannelState(ConnectivityStateInfo.forNonError(ConnectivityState.READY));
+
+    WeightedChildLbState weightedChild =
+        (WeightedChildLbState) wrr.getChildLbStates().iterator().next();
+    WeightedChildLbState.OrcaReportListener listener = weightedChild.getOrCreateOrcaListener(
+        weightedConfig.errorUtilizationPenalty,
+        weightedConfig.parsedMetricNamesForComputingUtilization);
+
+    Map<String, Double> namedMetrics = new HashMap<>();
+    namedMetrics.put("cost", Double.NaN);
+    namedMetrics.put("score", 0.5);
+    namedMetrics.put("other1", 0.0);
+    namedMetrics.put("other2", -123.0);
+    MetricReport report = InternalCallMetricRecorder.createMetricReport(0.1, 0, 0.1, 1, 0,
+        new HashMap<>(), new HashMap<>(), namedMetrics);
+    listener.onLoadReport(report);
+    // qps=1, util=0.5 -> weight=2.0
+    fakeClock.forwardTime(1100, TimeUnit.MILLISECONDS);
+    verify(mockMetricRecorder).recordDoubleHistogram(
+        argThat(instr -> instr.getName().equals("grpc.lb.wrr.endpoint_weights")), eq(2.0), any(),
+        any());
+  }
+
+  // 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
index 7a54036b73a..c8eab309f38 100644
--- a/xds/src/test/java/io/grpc/xds/WeightedTargetLoadBalancerProviderTest.java
+++ b/xds/src/test/java/io/grpc/xds/WeightedTargetLoadBalancerProviderTest.java
@@ -26,7 +26,7 @@
 import io.grpc.LoadBalancerRegistry;
 import io.grpc.NameResolver.ConfigOrError;
 import io.grpc.internal.JsonParser;
-import io.grpc.internal.ServiceConfigUtil.PolicySelection;
+import io.grpc.util.GracefulSwitchLoadBalancer;
 import io.grpc.xds.WeightedTargetLoadBalancerProvider.WeightedPolicySelection;
 import io.grpc.xds.WeightedTargetLoadBalancerProvider.WeightedTargetConfig;
 import java.util.Map;
@@ -128,11 +128,13 @@ public ConfigOrError parseLoadBalancingPolicyConfig(Map<String, ?> rawConfig) {
             "target_1",
             new WeightedPolicySelection(
                 10,
-                new PolicySelection(lbProviderFoo, fooConfig)),
+                GracefulSwitchLoadBalancer.createLoadBalancingPolicyConfig(
+                    lbProviderFoo, fooConfig)),
             "target_2",
             new WeightedPolicySelection(
                 20,
-                new PolicySelection(lbProviderBar, barConfig)))));
+                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
index f7f3d6c77b1..55ff0cd8078 100644
--- a/xds/src/test/java/io/grpc/xds/WeightedTargetLoadBalancerTest.java
+++ b/xds/src/test/java/io/grpc/xds/WeightedTargetLoadBalancerTest.java
@@ -20,15 +20,17 @@
 import static io.grpc.ConnectivityState.CONNECTING;
 import static io.grpc.ConnectivityState.READY;
 import static io.grpc.ConnectivityState.TRANSIENT_FAILURE;
-import static io.grpc.xds.XdsSubchannelPickers.BUFFER_PICKER;
+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;
@@ -37,6 +39,7 @@
 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;
@@ -46,11 +49,10 @@
 import io.grpc.LoadBalancerRegistry;
 import io.grpc.Status;
 import io.grpc.SynchronizationContext;
-import io.grpc.internal.ServiceConfigUtil.PolicySelection;
+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.XdsSubchannelPickers.ErrorPicker;
 import java.net.InetSocketAddress;
 import java.net.SocketAddress;
 import java.util.ArrayList;
@@ -58,16 +60,19 @@
 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.MockitoAnnotations;
+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() {
@@ -108,6 +113,7 @@ public String getPolicyName() {
     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;
@@ -134,6 +140,7 @@ public String getPolicyName() {
     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;
@@ -141,13 +148,13 @@ public LoadBalancer newLoadBalancer(Helper helper) {
   };
 
   private final WeightedPolicySelection weightedLbConfig0 = new WeightedPolicySelection(
-      weights[0], new PolicySelection(fooLbProvider, configs[0]));
+      weights[0], newChildConfig(fooLbProvider, configs[0]));
   private final WeightedPolicySelection weightedLbConfig1 = new WeightedPolicySelection(
-      weights[1], new PolicySelection(barLbProvider, configs[1]));
+      weights[1], newChildConfig(barLbProvider, configs[1]));
   private final WeightedPolicySelection weightedLbConfig2 = new WeightedPolicySelection(
-      weights[2],  new PolicySelection(barLbProvider, configs[2]));
+      weights[2],  newChildConfig(barLbProvider, configs[2]));
   private final WeightedPolicySelection weightedLbConfig3 = new WeightedPolicySelection(
-      weights[3], new PolicySelection(fooLbProvider, configs[3]));
+      weights[3], newChildConfig(fooLbProvider, configs[3]));
 
   @Mock
   private Helper helper;
@@ -158,12 +165,12 @@ public LoadBalancer newLoadBalancer(Helper helper) {
 
   @Before
   public void setUp() {
-    MockitoAnnotations.initMocks(this);
     when(helper.getSynchronizationContext()).thenReturn(syncContext);
     lbRegistry.register(fooLbProvider);
     lbRegistry.register(barLbProvider);
 
     weightedTargetLb = new WeightedTargetLoadBalancer(helper);
+    clearInvocations(helper);
   }
 
   @After
@@ -175,8 +182,9 @@ public void tearDown() {
   }
 
   @Test
-  public void handleResolvedAddresses() {
-    ArgumentCaptor<ResolvedAddresses> resolvedAddressesCaptor = ArgumentCaptor.forClass(null);
+  public void acceptResolvedAddresses() {
+    ArgumentCaptor<ResolvedAddresses> resolvedAddressesCaptor =
+        ArgumentCaptor.forClass(ResolvedAddresses.class);
     Attributes.Key<Object> fakeKey = Attributes.Key.create("fake_key");
     Object fakeValue = new Object();
 
@@ -197,27 +205,35 @@ public void handleResolvedAddresses() {
     eag2 = AddressFilter.setPathFilter(eag2, ImmutableList.of("target2"));
     EquivalentAddressGroup eag3 = new EquivalentAddressGroup(socketAddresses[3]);
     eag3 = AddressFilter.setPathFilter(eag3, ImmutableList.of("target3"));
-    weightedTargetLb.handleResolvedAddresses(
+    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());
-    verify(helper).updateBalancingState(eq(CONNECTING), eq(BUFFER_PICKER));
+    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)).handleResolvedAddresses(resolvedAddressesCaptor.capture());
+      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};
@@ -225,22 +241,24 @@ public void handleResolvedAddresses() {
     Map<String, WeightedPolicySelection> newTargets = ImmutableMap.of(
         "target1",
         new WeightedPolicySelection(
-            newWeights[0], new PolicySelection(barLbProvider, newConfigs[0])),
+            newWeights[0], newChildConfig(barLbProvider, newConfigs[0])),
         "target2",
         new WeightedPolicySelection(
-            newWeights[1], new PolicySelection(barLbProvider, newConfigs[1])),
+            newWeights[1], newChildConfig(barLbProvider, newConfigs[1])),
         "target3",
         new WeightedPolicySelection(
-            newWeights[2], new PolicySelection(fooLbProvider, newConfigs[2])),
+            newWeights[2], newChildConfig(fooLbProvider, newConfigs[2])),
         "target4",
         new WeightedPolicySelection(
-            newWeights[3], new PolicySelection(fooLbProvider, newConfigs[3])));
-    weightedTargetLb.handleResolvedAddresses(
+            newWeights[3], newChildConfig(fooLbProvider, newConfigs[3])));
+    status = weightedTargetLb.acceptResolvedAddresses(
         ResolvedAddresses.newBuilder()
             .setAddresses(ImmutableList.<EquivalentAddressGroup>of())
             .setLoadBalancingPolicyConfig(new WeightedTargetConfig(newTargets))
             .build());
-    verify(helper, atLeast(2)).updateBalancingState(eq(CONNECTING), eq(BUFFER_PICKER));
+    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
@@ -249,7 +267,7 @@ public void handleResolvedAddresses() {
     verify(childBalancers.get(0)).shutdown();
     for (int i = 1; i < childBalancers.size(); i++) {
       verify(childBalancers.get(i), atLeastOnce())
-          .handleResolvedAddresses(resolvedAddressesCaptor.capture());
+          .acceptResolvedAddresses(resolvedAddressesCaptor.capture());
       assertThat(resolvedAddressesCaptor.getValue().getLoadBalancingPolicyConfig())
           .isEqualTo(newConfigs[i - 1]);
     }
@@ -257,8 +275,8 @@ public void handleResolvedAddresses() {
 
   @Test
   public void handleNameResolutionError() {
-    ArgumentCaptor<SubchannelPicker> pickerCaptor = ArgumentCaptor.forClass(null);
-    ArgumentCaptor<Status> statusCaptor = ArgumentCaptor.forClass(null);
+    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);
@@ -277,12 +295,12 @@ public void handleNameResolutionError() {
         "target2", weightedLbConfig2,
         // {foo, 40, config3}
         "target3", weightedLbConfig3);
-    weightedTargetLb.handleResolvedAddresses(
+    weightedTargetLb.acceptResolvedAddresses(
         ResolvedAddresses.newBuilder()
             .setAddresses(ImmutableList.<EquivalentAddressGroup>of())
             .setLoadBalancingPolicyConfig(new WeightedTargetConfig(targets))
             .build());
-    verify(helper).updateBalancingState(eq(CONNECTING), eq(BUFFER_PICKER));
+    verify(helper).updateBalancingState(eq(CONNECTING), pickerReturns(PickResult.withNoResult()));
 
     // Error after child balancers created.
     weightedTargetLb.handleNameResolutionError(Status.ABORTED);
@@ -304,12 +322,12 @@ public void balancingStateUpdatedFromChildBalancers() {
         "target2", weightedLbConfig2,
         // {foo, 40, config3}
         "target3", weightedLbConfig3);
-    weightedTargetLb.handleResolvedAddresses(
+    weightedTargetLb.acceptResolvedAddresses(
         ResolvedAddresses.newBuilder()
             .setAddresses(ImmutableList.<EquivalentAddressGroup>of())
             .setLoadBalancingPolicyConfig(new WeightedTargetConfig(targets))
             .build());
-    verify(helper).updateBalancingState(eq(CONNECTING), eq(BUFFER_PICKER));
+    verify(helper).updateBalancingState(eq(CONNECTING), pickerReturns(PickResult.withNoResult()));
 
     // Subchannels to be created for each child balancer.
     final SubchannelPicker[] subchannelPickers = new SubchannelPicker[]{
@@ -317,13 +335,20 @@ public void balancingStateUpdatedFromChildBalancers() {
         mock(SubchannelPicker.class),
         mock(SubchannelPicker.class),
         mock(SubchannelPicker.class)};
-    ArgumentCaptor<SubchannelPicker> pickerCaptor = ArgumentCaptor.forClass(null);
+    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, new ErrorPicker(Status.ABORTED));
+    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), eq(BUFFER_PICKER));
+    verify(helper, times(2))
+        .updateBalancingState(eq(CONNECTING), pickerReturns(PickResult.withNoResult()));
 
     // Another child balancer goes to READY.
     childHelpers.get(2).updateBalancingState(READY, subchannelPickers[2]);
@@ -353,7 +378,7 @@ public void balancingStateUpdatedFromChildBalancers() {
             new WeightedChildPicker(weights[3], subchannelPickers[3]));
 
     // One of READY child balancers goes to TRANSIENT_FAILURE.
-    childHelpers.get(2).updateBalancingState(TRANSIENT_FAILURE, new ErrorPicker(Status.DATA_LOSS));
+    childHelpers.get(2).updateBalancingState(TRANSIENT_FAILURE, failurePickers[2]);
     verify(helper, times(4)).updateBalancingState(eq(READY), pickerCaptor.capture());
     overallPicker = (WeightedRandomPicker) pickerCaptor.getValue();
     assertThat(overallPicker.weightedChildPickers)
@@ -362,8 +387,110 @@ public void balancingStateUpdatedFromChildBalancers() {
             new WeightedChildPicker(weights[3], subchannelPickers[3]));
 
     // All child balancers go to TRANSIENT_FAILURE.
-    childHelpers.get(3).updateBalancingState(TRANSIENT_FAILURE, new ErrorPicker(Status.DATA_LOSS));
-    childHelpers.get(0).updateBalancingState(TRANSIENT_FAILURE, new ErrorPicker(Status.CANCELLED));
-    verify(helper).updateBalancingState(eq(TRANSIENT_FAILURE), any(SubchannelPicker.class));
+    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/XdsClientTestHelper.java b/xds/src/test/java/io/grpc/xds/XdsClientTestHelper.java
deleted file mode 100644
index 9ea9b1f8dc2..00000000000
--- a/xds/src/test/java/io/grpc/xds/XdsClientTestHelper.java
+++ /dev/null
@@ -1,137 +0,0 @@
-/*
- * 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 com.google.protobuf.Any;
-import io.envoyproxy.envoy.config.core.v3.Address;
-import io.envoyproxy.envoy.config.listener.v3.ApiListener;
-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.service.discovery.v3.DiscoveryRequest;
-import io.envoyproxy.envoy.service.discovery.v3.DiscoveryResponse;
-import io.grpc.xds.EnvoyProtoData.Node;
-import java.util.List;
-
-/**
- * Helper methods for building protobuf messages with custom data for xDS protocols.
- */
-// TODO(chengyuanzhang, sanjaypujare): delete this class, should not dump everything here.
-class XdsClientTestHelper {
-  static DiscoveryResponse buildDiscoveryResponse(String versionInfo,
-      List<Any> resources, String typeUrl, String nonce) {
-    return
-        DiscoveryResponse.newBuilder()
-            .setVersionInfo(versionInfo)
-            .setTypeUrl(typeUrl)
-            .addAllResources(resources)
-            .setNonce(nonce)
-            .build();
-  }
-
-  static io.envoyproxy.envoy.api.v2.DiscoveryResponse buildDiscoveryResponseV2(String versionInfo,
-      List<Any> resources, String typeUrl, String nonce) {
-    return
-        io.envoyproxy.envoy.api.v2.DiscoveryResponse.newBuilder()
-            .setVersionInfo(versionInfo)
-            .setTypeUrl(typeUrl)
-            .addAllResources(resources)
-            .setNonce(nonce)
-            .build();
-  }
-
-  static DiscoveryRequest buildDiscoveryRequest(Node node, String versionInfo,
-      List<String> resourceNames, String typeUrl, String nonce) {
-    return
-        DiscoveryRequest.newBuilder()
-            .setVersionInfo(versionInfo)
-            .setNode(node.toEnvoyProtoNode())
-            .setTypeUrl(typeUrl)
-            .addAllResourceNames(resourceNames)
-            .setResponseNonce(nonce)
-            .build();
-  }
-
-  static Listener buildListener(String name, com.google.protobuf.Any apiListener) {
-    return
-        Listener.newBuilder()
-            .setName(name)
-            .setAddress(Address.getDefaultInstance())
-            .addFilterChains(FilterChain.getDefaultInstance())
-            .setApiListener(ApiListener.newBuilder().setApiListener(apiListener))
-            .build();
-  }
-
-  static io.envoyproxy.envoy.api.v2.Listener buildListenerV2(
-      String name, com.google.protobuf.Any apiListener) {
-    return
-        io.envoyproxy.envoy.api.v2.Listener.newBuilder()
-            .setName(name)
-            .setAddress(io.envoyproxy.envoy.api.v2.core.Address.getDefaultInstance())
-            .addFilterChains(io.envoyproxy.envoy.api.v2.listener.FilterChain.getDefaultInstance())
-            .setApiListener(io.envoyproxy.envoy.config.listener.v2.ApiListener.newBuilder()
-                .setApiListener(apiListener))
-            .build();
-  }
-
-  static RouteConfiguration buildRouteConfiguration(String name,
-      List<VirtualHost> virtualHosts) {
-    return
-        RouteConfiguration.newBuilder()
-            .setName(name)
-            .addAllVirtualHosts(virtualHosts)
-            .build();
-  }
-
-  static io.envoyproxy.envoy.api.v2.RouteConfiguration buildRouteConfigurationV2(String name,
-      List<io.envoyproxy.envoy.api.v2.route.VirtualHost> virtualHosts) {
-    return
-        io.envoyproxy.envoy.api.v2.RouteConfiguration.newBuilder()
-            .setName(name)
-            .addAllVirtualHosts(virtualHosts)
-            .build();
-  }
-
-  static VirtualHost buildVirtualHost(List<String> domains, String clusterName) {
-    return VirtualHost.newBuilder()
-        .setName("virtualhost00.googleapis.com") // don't care
-        .addAllDomains(domains)
-        .addRoutes(
-            Route.newBuilder()
-                .setRoute(RouteAction.newBuilder().setCluster(clusterName))
-                .setMatch(RouteMatch.newBuilder().setPrefix("")))
-        .build();
-  }
-
-  static io.envoyproxy.envoy.api.v2.route.VirtualHost buildVirtualHostV2(
-      List<String> domains, String clusterName) {
-    return io.envoyproxy.envoy.api.v2.route.VirtualHost.newBuilder()
-        .setName("virtualhost00.googleapis.com") // don't care
-        .addAllDomains(domains)
-        .addRoutes(
-            io.envoyproxy.envoy.api.v2.route.Route.newBuilder()
-                .setRoute(
-                    io.envoyproxy.envoy.api.v2.route.RouteAction.newBuilder()
-                        .setCluster(clusterName))
-                .setMatch(io.envoyproxy.envoy.api.v2.route.RouteMatch.newBuilder().setPrefix("")))
-        .build();
-  }
-}
diff --git a/xds/src/test/java/io/grpc/xds/XdsClientWrapperForServerSdsTestMisc.java b/xds/src/test/java/io/grpc/xds/XdsClientWrapperForServerSdsTestMisc.java
index fc9b1eb4a0b..81186d0639c 100644
--- a/xds/src/test/java/io/grpc/xds/XdsClientWrapperForServerSdsTestMisc.java
+++ b/xds/src/test/java/io/grpc/xds/XdsClientWrapperForServerSdsTestMisc.java
@@ -17,216 +17,385 @@
 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.any;
 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.StatusException;
+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.internal.sds.CommonTlsContextTestsUtil;
-import io.netty.channel.Channel;
-import java.io.IOException;
+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.net.UnknownHostException;
-import java.util.Collections;
-import org.junit.After;
+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.ArgumentCaptor;
 import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
 
-/** Tests for {@link XdsClientWrapperForServerSds}. */
+/** 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;
 
-  @Mock private XdsClient xdsClient;
-  @Mock private Channel channel;
+  @Rule public final MockitoRule mocks = MockitoJUnit.rule();
 
-  private XdsClientWrapperForServerSds xdsClientWrapperForServerSds;
-  private XdsClient.ListenerWatcher registeredWatcher;
+  private EmbeddedChannel channel;
+  private ChannelPipeline pipeline;
+  @Mock private TlsContextManager tlsContextManager;
+  private InetSocketAddress localAddress;
+  private DownstreamTlsContext tlsContext1;
+  private DownstreamTlsContext tlsContext2;
+  private DownstreamTlsContext tlsContext3;
 
-  @Before
-  public void setUp() throws IOException {
-    MockitoAnnotations.initMocks(this);
-    xdsClientWrapperForServerSds = new XdsClientWrapperForServerSds(PORT);
-  }
+  @Mock
+  private ServerBuilder<?> mockBuilder;
+  @Mock
+  Server mockServer;
+  @Mock
+  private XdsServingStatusListener listener;
+  private FakeXdsClient xdsClient = new FakeXdsClient();
+  private FilterChainSelectorManager selectorManager = new FilterChainSelectorManager();
+  private XdsServerWrapper xdsServerWrapper;
 
-  @After
-  public void tearDown() {
-    xdsClientWrapperForServerSds.shutdown();
+
+  @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 verifyListenerWatcherRegistered() {
-    registeredWatcher =
-            XdsServerTestHelper.startAndGetWatcher(xdsClientWrapperForServerSds, xdsClient, PORT);
-    verify(xdsClient).watchListenerData(eq(PORT), any(XdsClient.ListenerWatcher.class));
+  public void nonInetSocketAddress_expectNull() throws Exception {
+    sendListenerUpdate(new InProcessSocketAddress("test1"), null, null, tlsContextManager);
+    assertThat(getSslContextProviderSupplier(selectorManager.getSelectorToUpdateSelector()))
+        .isNull();
   }
 
   @Test
-  public void nonInetSocketAddress_expectNull() throws UnknownHostException {
-    registeredWatcher =
-        XdsServerTestHelper.startAndGetWatcher(xdsClientWrapperForServerSds, xdsClient, PORT);
-    assertThat(sendListenerUpdate(new InProcessSocketAddress("test1"), null)).isNull();
+  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 nonMatchingPort_expectException() throws UnknownHostException {
-    registeredWatcher =
-        XdsServerTestHelper.startAndGetWatcher(xdsClientWrapperForServerSds, xdsClient, PORT);
+  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 {
-      InetAddress ipLocalAddress = InetAddress.getByName("10.1.2.3");
-      InetSocketAddress localAddress = new InetSocketAddress(ipLocalAddress, PORT + 1);
-      DownstreamTlsContext unused = sendListenerUpdate(localAddress, null);
-      fail("exception expected");
-    } catch (IllegalStateException expected) {
-      assertThat(expected)
-          .hasMessageThat()
-          .isEqualTo("Channel localAddress port does not match requested listener port");
+      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 emptyFilterChain_expectNull() throws UnknownHostException {
-    registeredWatcher =
-            XdsServerTestHelper.startAndGetWatcher(xdsClientWrapperForServerSds, xdsClient, PORT);
+  public void releaseOldSupplierOnChanged_noCloseDueToLazyLoading() throws Exception {
     InetAddress ipLocalAddress = InetAddress.getByName("10.1.2.3");
-    InetSocketAddress localAddress = new InetSocketAddress(ipLocalAddress, PORT);
-    ArgumentCaptor<XdsClient.ListenerWatcher> listenerWatcherCaptor = ArgumentCaptor.forClass(null);
-    verify(xdsClient).watchListenerData(eq(PORT), listenerWatcherCaptor.capture());
-    XdsClient.ListenerWatcher registeredWatcher = listenerWatcherCaptor.getValue();
-    when(channel.localAddress()).thenReturn(localAddress);
-    EnvoyServerProtoData.Listener listener =
-        new EnvoyServerProtoData.Listener(
-            "listener1",
-            "10.1.2.3",
-            Collections.<EnvoyServerProtoData.FilterChain>emptyList(),
-            null);
-    XdsClient.ListenerUpdate listenerUpdate =
-        XdsClient.ListenerUpdate.newBuilder().setListener(listener).build();
-    registeredWatcher.onListenerChanged(listenerUpdate);
-    DownstreamTlsContext tlsContext = xdsClientWrapperForServerSds.getDownstreamTlsContext(channel);
-    assertThat(tlsContext).isNull();
+    localAddress = new InetSocketAddress(ipLocalAddress, PORT);
+    sendListenerUpdate(localAddress, tlsContext2, null,
+            tlsContextManager);
+    verify(tlsContextManager, never())
+        .findOrCreateServerSslContextProvider(any(DownstreamTlsContext.class));
   }
 
   @Test
-  public void registerServerWatcher() throws UnknownHostException {
-    registeredWatcher =
-            XdsServerTestHelper.startAndGetWatcher(xdsClientWrapperForServerSds, xdsClient, PORT);
-    XdsClientWrapperForServerSds.ServerWatcher mockServerWatcher =
-        mock(XdsClientWrapperForServerSds.ServerWatcher.class);
-    xdsClientWrapperForServerSds.addServerWatcher(mockServerWatcher);
+  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");
-    InetSocketAddress localAddress = new InetSocketAddress(ipLocalAddress, PORT);
-    EnvoyServerProtoData.DownstreamTlsContext tlsContext =
-        CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT1", "VA1");
-    verify(mockServerWatcher, never())
-        .onSuccess();
-    DownstreamTlsContext returnedTlsContext = sendListenerUpdate(localAddress, tlsContext);
-    assertThat(returnedTlsContext).isSameInstanceAs(tlsContext);
-    verify(mockServerWatcher).onSuccess();
-    xdsClientWrapperForServerSds.removeServerWatcher(mockServerWatcher);
+    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 registerServerWatcher_afterListenerUpdate() throws UnknownHostException {
-    registeredWatcher =
-            XdsServerTestHelper.startAndGetWatcher(xdsClientWrapperForServerSds, xdsClient, PORT);
+  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");
-    InetSocketAddress localAddress = new InetSocketAddress(ipLocalAddress, PORT);
-    EnvoyServerProtoData.DownstreamTlsContext tlsContext =
-            CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT1", "VA1");
-    DownstreamTlsContext returnedTlsContext = sendListenerUpdate(localAddress, tlsContext);
-    assertThat(returnedTlsContext).isSameInstanceAs(tlsContext);
-    XdsClientWrapperForServerSds.ServerWatcher mockServerWatcher =
-            mock(XdsClientWrapperForServerSds.ServerWatcher.class);
-    xdsClientWrapperForServerSds.addServerWatcher(mockServerWatcher);
-    verify(mockServerWatcher).onSuccess();
+    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 registerServerWatcher_notifyError() throws UnknownHostException {
-    registeredWatcher =
-            XdsServerTestHelper.startAndGetWatcher(xdsClientWrapperForServerSds, xdsClient, PORT);
-    XdsClientWrapperForServerSds.ServerWatcher mockServerWatcher =
-        mock(XdsClientWrapperForServerSds.ServerWatcher.class);
-    xdsClientWrapperForServerSds.addServerWatcher(mockServerWatcher);
-    registeredWatcher.onError(Status.INTERNAL);
-    ArgumentCaptor<Throwable> argCaptor = ArgumentCaptor.forClass(null);
-    verify(mockServerWatcher).onError(argCaptor.capture());
-    Throwable throwable = argCaptor.getValue();
-    assertThat(throwable).isInstanceOf(StatusException.class);
-    Status captured = ((StatusException)throwable).getStatus();
-    assertThat(captured.getCode()).isEqualTo(Status.Code.INTERNAL);
-    reset(mockServerWatcher);
-    registeredWatcher.onResourceDoesNotExist("not-found Error");
-    ArgumentCaptor<Throwable> argCaptor1 = ArgumentCaptor.forClass(null);
-    verify(mockServerWatcher).onError(argCaptor1.capture());
-    throwable = argCaptor1.getValue();
-    assertThat(throwable).isInstanceOf(StatusException.class);
-    captured = ((StatusException)throwable).getStatus();
-    assertThat(captured.getCode()).isEqualTo(Status.Code.NOT_FOUND);
-    assertThat(captured.getDescription()).isEqualTo("not-found Error");
+  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");
-    InetSocketAddress localAddress = new InetSocketAddress(ipLocalAddress, PORT);
-    EnvoyServerProtoData.DownstreamTlsContext tlsContext =
-        CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT1", "VA1");
-    verify(mockServerWatcher, never())
-        .onSuccess();
-    DownstreamTlsContext returnedTlsContext = sendListenerUpdate(localAddress, tlsContext);
-    assertThat(returnedTlsContext).isSameInstanceAs(tlsContext);
-    verify(mockServerWatcher).onSuccess();
+    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));
   }
 
-  @Test
-  public void startXdsClient_expectException() {
-    XdsClientWrapperForServerSds.ServerWatcher mockServerWatcher =
-            mock(XdsClientWrapperForServerSds.ServerWatcher.class);
-    xdsClientWrapperForServerSds.addServerWatcher(mockServerWatcher);
-    try {
-      xdsClientWrapperForServerSds.createXdsClientAndStart();
-      fail("exception expected");
-    } catch (IOException expected) {
-      assertThat(expected)
-              .hasMessageThat()
-              .contains("Cannot find bootstrap configuration");
-    }
-    verify(mockServerWatcher, never()).onError(any(Throwable.class));
+  private void callUpdateSslContext(SslContextProviderSupplier sslContextProviderSupplier) {
+    assertThat(sslContextProviderSupplier).isNotNull();
+    SslContextProvider.Callback callback = mock(SslContextProvider.Callback.class);
+    sslContextProviderSupplier.updateSslContext(callback, false);
   }
 
-  private DownstreamTlsContext sendListenerUpdate(
-      SocketAddress localAddress, DownstreamTlsContext tlsContext) throws UnknownHostException {
-    when(channel.localAddress()).thenReturn(localAddress);
+  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");
-    InetSocketAddress remoteAddress = new InetSocketAddress(ipRemoteAddress, 1234);
-    when(channel.remoteAddress()).thenReturn(remoteAddress);
-    XdsServerTestHelper.generateListenerUpdate(registeredWatcher, tlsContext);
-    return xdsClientWrapperForServerSds.getDownstreamTlsContext(channel);
+    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();
   }
 
-  /** Creates XdsClientWrapperForServerSds: also used by other classes. */
-  public static XdsClientWrapperForServerSds createXdsClientWrapperForServerSds(
-      int port, DownstreamTlsContext downstreamTlsContext) {
-    XdsClient mockXdsClient = mock(XdsClient.class);
-    XdsClientWrapperForServerSds xdsClientWrapperForServerSds =
-        new XdsClientWrapperForServerSds(port);
-    xdsClientWrapperForServerSds.start(mockXdsClient);
-    XdsSdsClientServerTest.generateListenerUpdateToWatcher(
-        downstreamTlsContext, xdsClientWrapperForServerSds.getListenerWatcher());
-    return xdsClientWrapperForServerSds;
+  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..522eb29c001
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/XdsDependencyManagerTest.java
@@ -0,0 +1,1059 @@
+/*
+ * 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 testControlPlaneError() {
+    Status forcedStatus = Status.NOT_FOUND
+        .withDescription("expected")
+        .withCause(new IllegalArgumentException("a random exception"));
+    xdsClient.shutdown();
+    xdsClient = XdsTestUtils.createXdsClient(
+      Collections.singletonList("control-plane"),
+      serverInfo -> new GrpcXdsTransportFactory.GrpcXdsTransport(
+          InProcessChannelBuilder.forName(serverInfo.target())
+            .directExecutor()
+            .intercept(new FailingClientInterceptor(forcedStatus))
+            .build()),
+      fakeClock);
+    xdsDependencyManager = new XdsDependencyManager(
+        xdsClient, syncContext, serverName, serverName, nameResolverArgs);
+    xdsDependencyManager.start(xdsConfigWatcher);
+
+    verify(xdsConfigWatcher).onUpdate(
+        argThat(StatusOrMatcher.hasStatus(
+            statusHasCode(Status.Code.UNAVAILABLE)
+              .andDescriptionContains(forcedStatus.getDescription())
+              .andCause(forcedStatus.getCause()))));
+    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
index ba1e561410f..8998a2bae99 100644
--- a/xds/src/test/java/io/grpc/xds/XdsNameResolverProviderTest.java
+++ b/xds/src/test/java/io/grpc/xds/XdsNameResolverProviderTest.java
@@ -20,21 +20,31 @@
 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.Uri;
 import io.grpc.internal.FakeClock;
 import io.grpc.internal.GrpcUtil;
 import java.net.URI;
+import java.util.Arrays;
+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;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
 
 /** Unit tests for {@link XdsNameResolverProvider}. */
-@RunWith(JUnit4.class)
+@RunWith(Parameterized.class)
 public class XdsNameResolverProviderTest {
   private final SynchronizationContext syncContext = new SynchronizationContext(
       new Thread.UncaughtExceptionHandler() {
@@ -52,10 +62,18 @@ public void uncaughtException(Thread t, Throwable e) {
       .setServiceConfigParser(mock(ServiceConfigParser.class))
       .setScheduledExecutorService(fakeClock.getScheduledExecutorService())
       .setChannelLogger(mock(ChannelLogger.class))
+      .setMetricRecorder(mock(MetricRecorder.class))
       .build();
 
   private XdsNameResolverProvider provider = new XdsNameResolverProvider();
 
+  @Parameters(name = "enableRfc3986UrisParam={0}")
+  public static Iterable<Object[]> data() {
+    return Arrays.asList(new Object[][] {{true}, {false}});
+  }
+
+  @Parameter public boolean enableRfc3986UrisParam;
+
   @Test
   public void provided() {
     for (NameResolverProvider current
@@ -74,44 +92,100 @@ public void isAvailable() {
   }
 
   @Test
-  public void newNameResolver() {
-    assertThat(
-        provider.newNameResolver(URI.create("xds://1.1.1.1/foo.googleapis.com"), args))
+  public void newNameResolver_returnsExpectedType() {
+    assertThat(newNameResolver(provider, "xds://1.1.1.1/foo.googleapis.com", args))
         .isInstanceOf(XdsNameResolver.class);
-    assertThat(
-        provider.newNameResolver(URI.create("xds:///foo.googleapis.com"), args))
+    assertThat(newNameResolver(provider, "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 newNameResolver_matchesExpectedScheme() {
+    assertThat(newNameResolver(provider, "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);
+    NameResolver resolver =
+        newNameResolver(provider, "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);
+    NameResolver resolver = newNameResolver(provider, "xds:///foo.googleapis.com", args);
     assertThat(resolver).isNotNull();
     assertThat(resolver.getServiceAuthority()).isEqualTo("foo.googleapis.com");
   }
 
   @Test
-  public void invalidName_hostnameContainsUnderscore() {
-    URI uri = URI.create("xds:///foo_bar.googleapis.com");
-    try {
-      provider.newNameResolver(uri, args);
-      fail("Expected IllegalArgumentException");
-    } catch (IllegalArgumentException e) {
-      // Expected
-    }
+  public void validName_urlExtractedAuthorityInvalidWithoutEncoding() {
+    NameResolver resolver =
+        newNameResolver(provider, "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() {
+    NameResolver resolver =
+        newNameResolver(
+            provider, "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(newNameResolver(registry.asFactory(), "xds:///localhost", args)).isNotNull();
+    assertThat(newNameResolver(registry.asFactory(), "new-xds-scheme:///localhost", args))
+        .isNotNull();
+    assertThat(newNameResolver(registry.asFactory(), "no-scheme:///localhost", args)).isNotNull();
+    registry.deregister(provider1);
+    assertThat(newNameResolver(registry.asFactory(), "new-xds-scheme:///localhost", args)).isNull();
+    registry.deregister(provider0);
+    assertThat(newNameResolver(registry.asFactory(), "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);
+  }
+
+  private NameResolver newNameResolver(
+      NameResolver.Factory factory, String uriString, NameResolver.Args args) {
+    return enableRfc3986UrisParam
+        ? factory.newNameResolver(Uri.create(uriString), args)
+        : factory.newNameResolver(URI.create(uriString), args);
   }
 }
diff --git a/xds/src/test/java/io/grpc/xds/XdsNameResolverTest.java b/xds/src/test/java/io/grpc/xds/XdsNameResolverTest.java
index 2ece3ba9c9b..e78f97635ed 100644
--- a/xds/src/test/java/io/grpc/xds/XdsNameResolverTest.java
+++ b/xds/src/test/java/io/grpc/xds/XdsNameResolverTest.java
@@ -17,16 +17,21 @@
 package io.grpc.xds;
 
 import static com.google.common.truth.Truth.assertThat;
-import static io.grpc.xds.XdsNameResolver.DOWNSTREAM_NODE_KEY;
-import static io.grpc.xds.XdsNameResolver.HEADER_ABORT_GRPC_STATUS_KEY;
-import static io.grpc.xds.XdsNameResolver.HEADER_ABORT_HTTP_STATUS_KEY;
-import static io.grpc.xds.XdsNameResolver.HEADER_ABORT_PERCENTAGE_KEY;
-import static io.grpc.xds.XdsNameResolver.HEADER_DELAY_KEY;
-import static io.grpc.xds.XdsNameResolver.HEADER_DELAY_PERCENTAGE_KEY;
+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;
@@ -34,50 +39,80 @@
 import static org.mockito.Mockito.verifyNoMoreInteractions;
 import static org.mockito.Mockito.when;
 
-import com.google.common.base.Preconditions;
+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.NoopClientCall;
-import io.grpc.internal.NoopClientCall.NoopClientCallListener;
 import io.grpc.internal.ObjectPool;
 import io.grpc.internal.PickSubchannelArgsImpl;
+import io.grpc.internal.ScParser;
 import io.grpc.testing.TestMethodDescriptors;
-import io.grpc.xds.HttpFault.FaultAbort;
-import io.grpc.xds.HttpFault.FaultDelay;
-import io.grpc.xds.Matchers.HeaderMatcher;
-import io.grpc.xds.Matchers.PathMatcher;
+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.XdsClient.RdsResourceWatcher;
-import io.grpc.xds.XdsNameResolverProvider.XdsClientPoolFactory;
+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.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;
@@ -99,6 +134,20 @@
 @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(
@@ -122,6 +171,22 @@ public ConfigOrError parseServiceConfig(Map<String, ?> rawServiceConfig) {
   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;
@@ -133,89 +198,374 @@ public ConfigOrError parseServiceConfig(Map<String, ?> rawServiceConfig) {
   ArgumentCaptor<Status> errorCaptor;
   private XdsNameResolver resolver;
   private TestCall<?, ?> testCall;
-  private boolean originalEnableTimeout = XdsNameResolver.enableTimeout;
-  private AtomicLong originalFaultCounter = XdsNameResolver.activeFaultInjectedStreamCounter;
+  private boolean originalEnableTimeout;
+  private String targetUri = AUTHORITY;
+  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());
+
+    originalEnableTimeout = XdsNameResolver.enableTimeout;
     XdsNameResolver.enableTimeout = true;
-    XdsNameResolver.activeFaultInjectedStreamCounter = new AtomicLong();
-    resolver = new XdsNameResolver(AUTHORITY, serviceConfigParser, syncContext, scheduler,
-        xdsClientPoolFactory, mockRandom);
+
+    // 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;
-    XdsNameResolver.activeFaultInjectedStreamCounter = originalFaultCounter;
+    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.rdsWatcher).isNull();
+      assertThat(xdsClient.rdsWatchers).isEmpty();
     }
   }
 
   @Test
   public void resolving_failToCreateXdsClientPool() {
-    XdsClientPoolFactory xdsClientPoolFactory = new XdsClientPoolFactory() {
-      @Override
-      public void setBootstrapOverride(Map<String, ?> bootstrap) {
-        throw new UnsupportedOperationException("Should not be called");
-      }
-
-      @Override
-      public ObjectPool<XdsClient> getXdsClientPool() throws XdsInitializationException {
-        throw new XdsInitializationException("Fail to read bootstrap file");
-      }
-    };
-    resolver = new XdsNameResolver(AUTHORITY, serviceConfigParser, syncContext, scheduler,
-        xdsClientPoolFactory, mockRandom);
+    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().isEqualTo("Fail to read bootstrap file");
+    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_ldsResourceNotFound() {
+  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_emptyTargetAuthority_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(
+            "xds:///foo.googleapis.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_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();
-    assertThat(xdsClient.ldsResource).isEqualTo(AUTHORITY);
-    assertThat(xdsClient.ldsWatcher).isNotNull();
-    xdsClient.deliverLdsResourceNotFound(AUTHORITY);
-    assertEmptyResolutionResult();
+    xdsClient.deliverLdsResourceNotFound();
+    assertEmptyResolutionResult(expectedLdsResourceName);
   }
 
+  @SuppressWarnings("unchecked")
   @Test
   public void resolving_ldsResourceUpdateRdsName() {
-    String rdsResource = "route-configuration-foo.googleapis.com";
+    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.deliverRdsName(AUTHORITY, rdsResource);
-    RdsResourceWatcher rdsWatcher = xdsClient.rdsWatcher;
-    assertThat(rdsWatcher).isNotNull();
-    assertThat(xdsClient.rdsResource).isEqualTo(rdsResource);
-    rdsResource = "route-configuration-bar.googleapis.com";
-    xdsClient.deliverRdsName(AUTHORITY, rdsResource);
-    assertThat(xdsClient.rdsResource).isEqualTo(rdsResource);
-    assertThat(xdsClient.rdsWatcher).isNotSameInstanceAs(rdsWatcher);
+    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() {
-    String rdsResource = "route-configuration.googleapis.com";
     resolver.start(mockListener);
     FakeXdsClient xdsClient = (FakeXdsClient) resolver.getXdsClient();
-    assertThat(xdsClient.ldsResource).isEqualTo(AUTHORITY);
-    assertThat(xdsClient.ldsWatcher).isNotNull();
-    xdsClient.deliverRdsName(AUTHORITY, rdsResource);
-    assertThat(xdsClient.rdsResource).isEqualTo(rdsResource);
-    assertThat(xdsClient.rdsWatcher).isNotNull();
-    xdsClient.deliverRdsResourceNotFound(rdsResource);
-    assertEmptyResolutionResult();
+    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
@@ -223,107 +573,244 @@ public void resolving_encounterErrorLdsWatcherOnly() {
     resolver.start(mockListener);
     FakeXdsClient xdsClient = (FakeXdsClient) resolver.getXdsClient();
     xdsClient.deliverError(Status.UNAVAILABLE.withDescription("server unreachable"));
-    verify(mockListener).onError(errorCaptor.capture());
-    Status error = errorCaptor.getValue();
+    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()).isEqualTo("server unreachable");
+    assertThat(error.getDescription()).contains(AUTHORITY);
+    assertThat(error.getDescription()).contains("server unreachable");
+    assertThat(error.getCause()).isNull();
   }
 
   @Test
   public void resolving_encounterErrorLdsAndRdsWatchers() {
-    String rdsResource = "route-configuration.googleapis.com";
     resolver.start(mockListener);
     FakeXdsClient xdsClient = (FakeXdsClient) resolver.getXdsClient();
-    xdsClient.deliverRdsName(AUTHORITY, rdsResource);
-    assertThat(xdsClient.rdsWatcher).isNotNull();
+    xdsClient.deliverLdsUpdateForRdsName(RDS_RESOURCE_NAME);
     xdsClient.deliverError(Status.UNAVAILABLE.withDescription("server unreachable"));
-    verify(mockListener, times(2)).onError(errorCaptor.capture());
-    for (Status error : errorCaptor.getAllValues()) {
-      assertThat(error.getCode()).isEqualTo(Code.UNAVAILABLE);
-      assertThat(error.getDescription()).isEqualTo("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(AUTHORITY, 0L, buildUnmatchedVirtualHosts());
-    assertEmptyResolutionResult();
+    xdsClient.deliverLdsUpdate(0L, buildUnmatchedVirtualHosts());
+    assertEmptyResolutionResult(expectedLdsResourceName);
   }
 
   @Test
   public void resolving_matchingVirtualHostNotFoundInRdsResource() {
-    String rdsResource = "route-configuration.googleapis.com";
     resolver.start(mockListener);
     FakeXdsClient xdsClient = (FakeXdsClient) resolver.getXdsClient();
-    xdsClient.deliverRdsName(AUTHORITY, rdsResource);
-    assertThat(xdsClient.rdsWatcher).isNotNull();
-    xdsClient.deliverRdsUpdate(rdsResource, buildUnmatchedVirtualHosts());
-    assertEmptyResolutionResult();
+    xdsClient.deliverLdsUpdateForRdsName(RDS_RESOURCE_NAME);
+    xdsClient.deliverRdsUpdate(RDS_RESOURCE_NAME, buildUnmatchedVirtualHosts());
+    assertEmptyResolutionResult(expectedLdsResourceName);
   }
 
   private List<VirtualHost> buildUnmatchedVirtualHosts() {
-    Route route1 = Route.create(RouteMatch.withPathExactOnly(call2.getFullMethodNameForPath()),
+    Route route1 = Route.forAction(RouteMatch.withPathExactOnly(call2.getFullMethodNameForPath()),
         RouteAction.forCluster(
-            cluster2, Collections.<HashPolicy>emptyList(), TimeUnit.SECONDS.toNanos(15L)), null);
-    Route route2 = Route.create(RouteMatch.withPathExactOnly(call1.getFullMethodNameForPath()),
+            cluster2, Collections.emptyList(), TimeUnit.SECONDS.toNanos(15L), null, false),
+        ImmutableMap.of());
+    Route route2 = Route.forAction(RouteMatch.withPathExactOnly(call1.getFullMethodNameForPath()),
         RouteAction.forCluster(
-            cluster1, Collections.<HashPolicy>emptyList(), TimeUnit.SECONDS.toNanos(15L)), null);
+            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), null),
+            Collections.singletonList(route1),
+            ImmutableMap.of()),
         VirtualHost.create("virtualhost-bar", Collections.singletonList("hi.googleapis.com"),
-            Collections.singletonList(route2), null));
+            Collections.singletonList(route2),
+            ImmutableMap.of()));
   }
 
   @Test
   public void resolved_noTimeout() {
     resolver.start(mockListener);
     FakeXdsClient xdsClient = (FakeXdsClient) resolver.getXdsClient();
-    Route route = Route.create(RouteMatch.withPathExactOnly(call1.getFullMethodNameForPath()),
+    Route route = Route.forAction(RouteMatch.withPathExactOnly(call1.getFullMethodNameForPath()),
         RouteAction.forCluster(
-            cluster1, Collections.<HashPolicy>emptyList(), null), null); // per-route timeout unset
+            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), null);
-    xdsClient.deliverLdsUpdate(AUTHORITY, 0L, Collections.singletonList(virtualHost));
-    verify(mockListener).onResult(resolutionResultCaptor.capture());
+        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);
-    assertCallSelectResult(call1, configSelector, cluster1, null);
+    assertCallSelectClusterResult(call1, configSelector, cluster1, null);
   }
 
   @Test
   public void resolved_fallbackToHttpMaxStreamDurationAsTimeout() {
     resolver.start(mockListener);
     FakeXdsClient xdsClient = (FakeXdsClient) resolver.getXdsClient();
-    Route route = Route.create(RouteMatch.withPathExactOnly(call1.getFullMethodNameForPath()),
+    Route route = Route.forAction(RouteMatch.withPathExactOnly(call1.getFullMethodNameForPath()),
         RouteAction.forCluster(
-            cluster1, Collections.<HashPolicy>emptyList(), null), null); // per-route timeout unset
+            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), null);
-    xdsClient.deliverLdsUpdate(AUTHORITY, TimeUnit.SECONDS.toNanos(5L),
+        Collections.singletonList(AUTHORITY), Collections.singletonList(route),
+        ImmutableMap.of());
+    xdsClient.deliverLdsUpdate(TimeUnit.SECONDS.toNanos(5L),
         Collections.singletonList(virtualHost));
-    verify(mockListener).onResult(resolutionResultCaptor.capture());
+    verify(mockListener).onResult2(resolutionResultCaptor.capture());
     ResolutionResult result = resolutionResultCaptor.getValue();
     InternalConfigSelector configSelector = result.getAttributes().get(InternalConfigSelector.KEY);
-    assertCallSelectResult(call1, configSelector, cluster1, 5.0);
+    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();
-    assertCallSelectResult(call1, configSelector, cluster1, 15.0);
+    assertCallSelectClusterResult(call1, configSelector, cluster1, 15.0);
     testCall.deliverResponseHeaders();
     verifyNoMoreInteractions(mockListener);
   }
 
   @Test
-  public void resolved_simpleCallFailedToRoute() {
+  public void resolved_simpleCallFailedToRoute_noMatchingRoute() {
     InternalConfigSelector configSelector = resolveToClusters();
     CallInfo call = new CallInfo("FooService", "barMethod");
     Result selectResult = configSelector.selectConfig(
-        new PickSubchannelArgsImpl(call.methodDescriptor, new Metadata(), CallOptions.DEFAULT));
+        newPickSubchannelArgs(call.methodDescriptor, new Metadata(), CallOptions.DEFAULT));
     Status status = selectResult.getStatus();
     assertThat(status.isOk()).isFalse();
     assertThat(status.getCode()).isEqualTo(Code.UNAVAILABLE);
@@ -331,29 +818,274 @@ public void resolved_simpleCallFailedToRoute() {
     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();
-    assertCallSelectResult(call1, configSelector, cluster1, 15.0);
+    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(
-        AUTHORITY,
         Arrays.asList(
-            Route.create(
+            Route.forAction(
                 RouteMatch.withPathExactOnly(call1.getFullMethodNameForPath()),
                 RouteAction.forCluster(
-                    "another-cluster", Collections.<HashPolicy>emptyList(),
-                    TimeUnit.SECONDS.toNanos(20L)), null),
-            Route.create(
+                    "another-cluster", Collections.emptyList(),
+                    TimeUnit.SECONDS.toNanos(20L), null, false),
+                ImmutableMap.of()),
+            Route.forAction(
                 RouteMatch.withPathExactOnly(call2.getFullMethodNameForPath()),
                 RouteAction.forCluster(
-                    cluster2, Collections.<HashPolicy>emptyList(), TimeUnit.SECONDS.toNanos(15L)),
-                null)));
-    verify(mockListener).onResult(resolutionResultCaptor.capture());
+                    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.
@@ -362,10 +1094,12 @@ public void resolved_resourceUpdateAfterCallStarted() {
         (Map<String, ?>) result.getServiceConfig().getConfig());
     assertThat(result.getAttributes().get(InternalConfigSelector.KEY))
         .isSameInstanceAs(configSelector);
-    assertCallSelectResult(call1, configSelector, "another-cluster", 20.0);
+    assertCallSelectClusterResult(call1, configSelector, "another-cluster", 20.0);
 
     firstCall.deliverErrorStatus();  // completes previous call
-    verify(mockListener, times(2)).onResult(resolutionResultCaptor.capture());
+    // 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"),
@@ -378,29 +1112,32 @@ public void resolved_resourceUpdateAfterCallStarted() {
   public void resolved_resourceUpdatedBeforeCallStarted() {
     InternalConfigSelector configSelector = resolveToClusters();
     reset(mockListener);
+    when(mockListener.onResult2(any())).thenReturn(Status.OK);
     FakeXdsClient xdsClient = (FakeXdsClient) resolver.getXdsClient();
     xdsClient.deliverLdsUpdate(
-        AUTHORITY,
         Arrays.asList(
-            Route.create(
+            Route.forAction(
                 RouteMatch.withPathExactOnly(call1.getFullMethodNameForPath()),
                 RouteAction.forCluster(
-                    "another-cluster", Collections.<HashPolicy>emptyList(),
-                    TimeUnit.SECONDS.toNanos(20L)), null),
-            Route.create(
+                    "another-cluster", Collections.emptyList(),
+                    TimeUnit.SECONDS.toNanos(20L), null, false),
+                ImmutableMap.of()),
+            Route.forAction(
                 RouteMatch.withPathExactOnly(call2.getFullMethodNameForPath()),
-                RouteAction.forCluster(cluster2, Collections.<HashPolicy>emptyList(),
-                    TimeUnit.SECONDS.toNanos(15L)), null)));
+                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(2)).onResult(resolutionResultCaptor.capture());
+    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);
-    assertCallSelectResult(call1, configSelector, "another-cluster", 20.0);
+    assertCallSelectClusterResult(call1, configSelector, "another-cluster", 20.0);
 
     verifyNoMoreInteractions(mockListener);
   }
@@ -409,118 +1146,633 @@ public void resolved_resourceUpdatedBeforeCallStarted() {
   @Test
   public void resolved_raceBetweenCallAndRepeatedResourceUpdate() {
     InternalConfigSelector configSelector = resolveToClusters();
-    assertCallSelectResult(call1, configSelector, cluster1, 15.0);
+    assertCallSelectClusterResult(call1, configSelector, cluster1, 15.0);
 
     reset(mockListener);
+    when(mockListener.onResult2(any())).thenReturn(Status.OK);
     FakeXdsClient xdsClient = (FakeXdsClient) resolver.getXdsClient();
     xdsClient.deliverLdsUpdate(
-        AUTHORITY,
         Arrays.asList(
-            Route.create(
+            Route.forAction(
                 RouteMatch.withPathExactOnly(call1.getFullMethodNameForPath()),
-                RouteAction.forCluster("another-cluster", Collections.<HashPolicy>emptyList(),
-                    TimeUnit.SECONDS.toNanos(20L)), null),
-            Route.create(
+                RouteAction.forCluster(
+                    "another-cluster", Collections.emptyList(),
+                    TimeUnit.SECONDS.toNanos(20L), null, false),
+                ImmutableMap.of()),
+            Route.forAction(
                 RouteMatch.withPathExactOnly(call2.getFullMethodNameForPath()),
-                RouteAction.forCluster(cluster2, Collections.<HashPolicy>emptyList(),
-                    TimeUnit.SECONDS.toNanos(15L)), null)));
+                RouteAction.forCluster(
+                    cluster2, Collections.emptyList(),
+                    TimeUnit.SECONDS.toNanos(15L), null, false),
+                ImmutableMap.of())));
 
-    verify(mockListener).onResult(resolutionResultCaptor.capture());
+    verify(mockListener).onResult2(resolutionResultCaptor.capture());
     ResolutionResult result = resolutionResultCaptor.getValue();
     assertServiceConfigForLoadBalancingConfig(
         Arrays.asList(cluster1, cluster2, "another-cluster"),
         (Map<String, ?>) result.getServiceConfig().getConfig());
 
     xdsClient.deliverLdsUpdate(
-        AUTHORITY,
         Arrays.asList(
-            Route.create(
+            Route.forAction(
                 RouteMatch.withPathExactOnly(call1.getFullMethodNameForPath()),
-                RouteAction.forCluster("another-cluster", Collections.<HashPolicy>emptyList(),
-                    TimeUnit.SECONDS.toNanos(15L)), null),
-            Route.create(
+                RouteAction.forCluster(
+                    "another-cluster", Collections.emptyList(),
+                    TimeUnit.SECONDS.toNanos(15L), null, false),
+                ImmutableMap.of()),
+            Route.forAction(
                 RouteMatch.withPathExactOnly(call2.getFullMethodNameForPath()),
-                RouteAction.forCluster(cluster2, Collections.<HashPolicy>emptyList(),
-                    TimeUnit.SECONDS.toNanos(15L)), null)));
-    verifyNoMoreInteractions(mockListener);  // no cluster added/deleted
-    assertCallSelectResult(call1, configSelector, "another-cluster", 15.0);
+                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();
-    assertCallSelectResult(call1, configSelector, cluster1, 15.0);
+    assertCallSelectClusterResult(call1, configSelector, cluster1, 15.0);
     FakeXdsClient xdsClient = (FakeXdsClient) resolver.getXdsClient();
     xdsClient.deliverLdsUpdate(
-        AUTHORITY,
         Collections.singletonList(
-            Route.create(
+            Route.forAction(
                 RouteMatch.withPathExactOnly(call2.getFullMethodNameForPath()),
-                RouteAction.forCluster(cluster2, Collections.<HashPolicy>emptyList(),
-                    TimeUnit.SECONDS.toNanos(15L)), null)));
+                RouteAction.forCluster(
+                    cluster2, Collections.emptyList(), TimeUnit.SECONDS.toNanos(15L),
+                    null, false),
+                ImmutableMap.of())));
     xdsClient.deliverLdsUpdate(
-        AUTHORITY,
         Arrays.asList(
-            Route.create(
+            Route.forAction(
                 RouteMatch.withPathExactOnly(call1.getFullMethodNameForPath()),
-                RouteAction.forCluster(cluster1, Collections.<HashPolicy>emptyList(),
-                    TimeUnit.SECONDS.toNanos(15L)), null),
-            Route.create(
+                RouteAction.forCluster(
+                    cluster1, Collections.emptyList(), TimeUnit.SECONDS.toNanos(15L),
+                    null, false),
+                ImmutableMap.of()),
+            Route.forAction(
                 RouteMatch.withPathExactOnly(call2.getFullMethodNameForPath()),
-                RouteAction.forCluster(cluster2, Collections.<HashPolicy>emptyList(),
-                    TimeUnit.SECONDS.toNanos(15L)), null)));
+                RouteAction.forCluster(
+                    cluster2, Collections.emptyList(), TimeUnit.SECONDS.toNanos(15L),
+                    null, false),
+                ImmutableMap.of())));
     testCall.deliverErrorStatus();
-    verifyNoMoreInteractions(mockListener);
+    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(
-        AUTHORITY,
         Collections.singletonList(
-            Route.create(
+            Route.forAction(
                 RouteMatch.withPathExactOnly(call1.getFullMethodNameForPath()),
                 RouteAction.forWeightedClusters(
                     Arrays.asList(
-                        ClusterWeight.create(cluster1, 20, null),
-                        ClusterWeight.create(cluster2, 80, null)),
-                    Collections.<HashPolicy>emptyList(),
-                    TimeUnit.SECONDS.toNanos(20L)), null)));
-    verify(mockListener).onResult(resolutionResultCaptor.capture());
+                        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.getAddresses()).isEmpty();
+    assertThat(result.getAddressesOrError().getValue()).isEmpty();
     assertServiceConfigForLoadBalancingConfig(
         Arrays.asList(cluster1, cluster2), (Map<String, ?>) result.getServiceConfig().getConfig());
-    assertThat(result.getAttributes().get(InternalXdsAttributes.XDS_CLIENT_POOL)).isNotNull();
+    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);
-    assertCallSelectResult(call1, configSelector, cluster2, 20.0);
-    assertCallSelectResult(call1, configSelector, cluster1, 20.0);
+    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() {
-    verify(mockListener).onResult(resolutionResultCaptor.capture());
+  private void assertEmptyResolutionResult(String resource) {
+    verify(mockListener).onResult2(resolutionResultCaptor.capture());
     ResolutionResult result = resolutionResultCaptor.getValue();
-    assertThat(result.getAddresses()).isEmpty();
+    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 assertCallSelectResult(
+  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(
-        new PickSubchannelArgsImpl(call.methodDescriptor, new Metadata(), CallOptions.DEFAULT));
+        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<Void>(), new Metadata());
+    clientCall.start(new NoopClientCallListener<>(), new Metadata());
     assertThat(testCall.callOptions.getOption(XdsNameResolver.CLUSTER_SELECTION_KEY))
-        .isEqualTo(expectedCluster);
+        .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) {
@@ -537,31 +1789,63 @@ private void assertCallSelectResult(
     }
   }
 
+  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(
-        AUTHORITY,
         Arrays.asList(
-            Route.create(
+            Route.forAction(
                 RouteMatch.withPathExactOnly(call1.getFullMethodNameForPath()),
-                RouteAction.forCluster(cluster1, Collections.<HashPolicy>emptyList(),
-                    TimeUnit.SECONDS.toNanos(15L)), null),
-            Route.create(
+                RouteAction.forCluster(
+                    cluster1, Collections.emptyList(), TimeUnit.SECONDS.toNanos(15L),
+                    null, false),
+                ImmutableMap.of()),
+            Route.forAction(
                 RouteMatch.withPathExactOnly(call2.getFullMethodNameForPath()),
-                RouteAction.forCluster(cluster2, Collections.<HashPolicy>emptyList(),
-                    TimeUnit.SECONDS.toNanos(15L)), null)));
-    verify(mockListener).onResult(resolutionResultCaptor.capture());
+                RouteAction.forCluster(
+                    cluster2, Collections.emptyList(), TimeUnit.SECONDS.toNanos(15L),
+                    null, false),
+                ImmutableMap.of())));
+    verify(mockListener).onResult2(resolutionResultCaptor.capture());
     ResolutionResult result = resolutionResultCaptor.getValue();
-    assertThat(result.getAddresses()).isEmpty();
+    assertThat(result.getAddressesOrError().getValue()).isEmpty();
     assertServiceConfigForLoadBalancingConfig(
         Arrays.asList(cluster1, cluster2), (Map<String, ?>) result.getServiceConfig().getConfig());
-    assertThat(result.getAttributes().get(InternalXdsAttributes.XDS_CLIENT_POOL)).isNotNull();
-    assertThat(result.getAttributes().get(InternalXdsAttributes.CALL_COUNTER_PROVIDER)).isNotNull();
+    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.
    */
@@ -575,71 +1859,190 @@ private static void assertServiceConfigForLoadBalancingConfig(
         JsonUtil.getObject(lbConfig, "cluster_manager_experimental");
     Map<String, ?> clusterManagerChildLbPolicies =
         JsonUtil.getObject(clusterManagerLbConfig, "childPolicy");
-    assertThat(clusterManagerChildLbPolicies.keySet()).containsExactlyElementsIn(clusters);
+    List<String> expectedChildLbClusterNames = new ArrayList<>(clusters.size());
     for (String cluster : clusters) {
-      Map<String, ?> childLbConfig = JsonUtil.getObject(clusterManagerChildLbPolicies, cluster);
+      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", cluster);
+          .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_forLoadBalancingConfig() throws IOException {
-    List<String> clusters = Arrays.asList("cluster-foo", "cluster-bar", "cluster-baz");
+  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"
-        + "  \"loadBalancingConfig\": [{\n"
-        + "    \"cluster_manager_experimental\": {\n"
-        + "      \"childPolicy\": {\n"
-        + "        \"cluster-foo\": {\n"
-        + "          \"lbPolicy\": [{\n"
-        + "            \"cds_experimental\": {\n"
-        + "              \"cluster\": \"cluster-foo\"\n"
-        + "            }\n"
-        + "          }]\n"
-        + "        },\n"
-        + "        \"cluster-bar\": {\n"
-        + "          \"lbPolicy\": [{\n"
-        + "            \"cds_experimental\": {\n"
-        + "              \"cluster\": \"cluster-bar\"\n"
-        + "            }\n"
-        + "          }]\n"
-        + "        },\n"
-        + "        \"cluster-baz\": {\n"
-        + "          \"lbPolicy\": [{\n"
-        + "            \"cds_experimental\": {\n"
-        + "              \"cluster\": \"cluster-baz\"\n"
-        + "            }\n"
-        + "          }]\n"
-        + "        }\n"
-        + "      }\n"
-        + "    }\n"
+        + "  \"methodConfig\": [{\n"
+        + "    \"name\": [ {} ],\n"
+        + "    \"timeout\": \"1.000000001s\"\n"
         + "  }]\n"
         + "}";
     Map<String, ?> expectedServiceConfig =
         (Map<String, ?>) JsonParser.parse(expectedServiceConfigJson);
-    assertThat(XdsNameResolver.generateServiceConfigWithLoadBalancingConfig(clusters))
+    assertThat(XdsNameResolver.generateServiceConfigWithMethodConfig(timeoutNano, null))
         .isEqualTo(expectedServiceConfig);
-  }
 
-  @SuppressWarnings("unchecked")
-  @Test
-  public void generateServiceConfig_forMethodTimeoutConfig() throws IOException {
-    long timeoutNano = TimeUnit.SECONDS.toNanos(1L) + 1L; // 1.0000000001s
-    String expectedServiceConfigJson = "{\n"
+    // 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"
         + "}";
-    Map<String, ?> expectedServiceConfig =
+    expectedServiceConfig =
         (Map<String, ?>) JsonParser.parse(expectedServiceConfigJson);
-    assertThat(XdsNameResolver.generateServiceConfigWithMethodTimeoutConfig(timeoutNano))
+    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);
   }
 
@@ -685,49 +2088,6 @@ public void matchHostName_postfixWildCard() {
     assertThat(XdsNameResolver.matchHostName("foo-bar", pattern)).isTrue();
   }
 
-  @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, null);
-    VirtualHost vHost2 = VirtualHost.create("virtualhost02.googleapis.com",
-        Collections.singletonList("*.googleapis.com"), routes, null);
-    VirtualHost vHost3 = VirtualHost.create("virtualhost03.googleapis.com",
-        Collections.singletonList("*"), routes, null);
-    List<VirtualHost> virtualHosts = Arrays.asList(vHost1, vHost2, vHost3);
-    assertThat(XdsNameResolver.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, null);
-    VirtualHost vHost2 = VirtualHost.create("virtualhost02.googleapis.com",
-        Collections.singletonList("a.googleapis.*"), routes, null);
-    VirtualHost vHost3 = VirtualHost.create("virtualhost03.googleapis.com",
-        Collections.singletonList("*"), routes, null);
-    List<VirtualHost> virtualHosts = Arrays.asList(vHost1, vHost2, vHost3);
-    assertThat(XdsNameResolver.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, null);
-    VirtualHost vHost2 = VirtualHost.create("virtualhost02.googleapis.com",
-            Collections.singletonList("b.googleapis.com"), routes, null);
-    List<VirtualHost> virtualHosts = Arrays.asList(vHost1, vHost2);
-    assertThat(XdsNameResolver.findVirtualHostForHostName(virtualHosts, hostname))
-        .isEqualTo(vHost1);;
-  }
-
   @Test
   public void resolved_faultAbortInLdsUpdate() {
     resolver.start(mockListener);
@@ -735,109 +2095,104 @@ public void resolved_faultAbortInLdsUpdate() {
     when(mockRandom.nextInt(1000_000)).thenReturn(500_000); // 50%
 
     // header abort, header abort rate = 60 %
-    HttpFault httpFilterFaultConfig = HttpFault.create(
+    FaultConfig httpFilterFaultConfig = FaultConfig.create(
         null,
-        FaultAbort.forHeader(HttpFault.FractionalPercent.perHundred(70)),
-        cluster1,
-        Collections.<String>emptyList(),
-        Collections.<HeaderMatcher>emptyList(),
+        FaultAbort.forHeader(FaultConfig.FractionalPercent.perHundred(70)),
         null);
     xdsClient.deliverLdsUpdateWithFaultInjection(cluster1, httpFilterFaultConfig, null, null, null);
-    verify(mockListener).onResult(resolutionResultCaptor.capture());
+    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
-    Metadata metadata = new Metadata();
-    ClientCall.Listener<Void> observer = startCall(configSelector, metadata);
+    ClientCall.Listener<Void> observer = startNewCall(TestMethodDescriptors.voidMethod(),
+        configSelector, Collections.emptyMap(), CallOptions.DEFAULT);
     verifyRpcSucceeded(observer);
     // header abort http status key provided, rpc should fail
-    metadata = new Metadata();
-    metadata.put(HEADER_ABORT_HTTP_STATUS_KEY, "404");
-    metadata.put(HEADER_ABORT_PERCENTAGE_KEY, "60");
-    observer = startCall(configSelector, metadata);
-    verifyRpcFailed(observer, Status.UNIMPLEMENTED.withDescription("HTTP status code 404"));
+    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
-    metadata = new Metadata();
-    metadata.put(HEADER_ABORT_GRPC_STATUS_KEY, String.valueOf(
-        Status.UNAUTHENTICATED.getCode().value()));
-    metadata.put(HEADER_ABORT_PERCENTAGE_KEY, "60");
-    observer = startCall(configSelector, metadata);
-    verifyRpcFailed(observer, Status.UNAUTHENTICATED);
+    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
-    metadata = new Metadata();
-    metadata.put(HEADER_ABORT_HTTP_STATUS_KEY, "404");
-    metadata.put(HEADER_ABORT_GRPC_STATUS_KEY, String.valueOf(
-        Status.UNAUTHENTICATED.getCode().value()));
-    metadata.put(HEADER_ABORT_PERCENTAGE_KEY, "60");
-    observer = startCall(configSelector, metadata);
-    verifyRpcFailed(observer, Status.UNIMPLEMENTED.withDescription("HTTP status code 404"));
+    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 = HttpFault.create(
+    httpFilterFaultConfig = FaultConfig.create(
         null,
-        FaultAbort.forHeader(HttpFault.FractionalPercent.perMillion(600_000)),
-        cluster1,
-        Collections.<String>emptyList(),
-        Collections.<HeaderMatcher>emptyList(),
+        FaultAbort.forHeader(FaultConfig.FractionalPercent.perMillion(600_000)),
         null);
     xdsClient.deliverLdsUpdateWithFaultInjection(cluster1, httpFilterFaultConfig, null, null, null);
-    verify(mockListener).onResult(resolutionResultCaptor.capture());
+    verify(mockListener, times(2)).onResult2(resolutionResultCaptor.capture());
     result = resolutionResultCaptor.getValue();
     configSelector = result.getAttributes().get(InternalConfigSelector.KEY);
-    metadata = new Metadata();
-    metadata.put(HEADER_ABORT_HTTP_STATUS_KEY, "404");
-    observer = startCall(configSelector, metadata);
-    verifyRpcFailed(observer, Status.UNIMPLEMENTED.withDescription("HTTP status code 404"));
+    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 = HttpFault.create(
+    httpFilterFaultConfig = FaultConfig.create(
         null,
-        FaultAbort.forHeader(HttpFault.FractionalPercent.perMillion(0)),
-        cluster1,
-        Collections.<String>emptyList(),
-        Collections.<HeaderMatcher>emptyList(),
+        FaultAbort.forHeader(FaultConfig.FractionalPercent.perMillion(0)),
         null);
     xdsClient.deliverLdsUpdateWithFaultInjection(cluster1, httpFilterFaultConfig, null, null, null);
-    verify(mockListener).onResult(resolutionResultCaptor.capture());
+    verify(mockListener, times(3)).onResult2(resolutionResultCaptor.capture());
     result = resolutionResultCaptor.getValue();
     configSelector = result.getAttributes().get(InternalConfigSelector.KEY);
-    metadata = new Metadata();
-    metadata.put(HEADER_ABORT_HTTP_STATUS_KEY, "404");
-    observer = startCall(configSelector, metadata);
+    observer = startNewCall(TestMethodDescriptors.voidMethod(), configSelector,
+        ImmutableMap.of(HEADER_ABORT_HTTP_STATUS_KEY.name(), "404"), CallOptions.DEFAULT);
     verifyRpcSucceeded(observer);
 
     // fixed abort, fix rate = 60%
-    httpFilterFaultConfig = HttpFault.create(
+    httpFilterFaultConfig = FaultConfig.create(
         null,
         FaultAbort.forStatus(
             Status.UNAUTHENTICATED.withDescription("unauthenticated"),
-            HttpFault.FractionalPercent.perMillion(600_000)),
-        cluster1,
-        Collections.<String>emptyList(),
-        Collections.<HeaderMatcher>emptyList(),
+            FaultConfig.FractionalPercent.perMillion(600_000)),
         null);
     xdsClient.deliverLdsUpdateWithFaultInjection(cluster1, httpFilterFaultConfig, null, null, null);
-    verify(mockListener).onResult(resolutionResultCaptor.capture());
+    verify(mockListener, times(4)).onResult2(resolutionResultCaptor.capture());
     result = resolutionResultCaptor.getValue();
     configSelector = result.getAttributes().get(InternalConfigSelector.KEY);
-    observer = startCall(configSelector, new Metadata());
-    verifyRpcFailed(observer, Status.UNAUTHENTICATED.withDescription("unauthenticated"));
+    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 = HttpFault.create(
+    httpFilterFaultConfig = FaultConfig.create(
         null,
         FaultAbort.forStatus(
             Status.UNAUTHENTICATED.withDescription("unauthenticated"),
-            HttpFault.FractionalPercent.perMillion(400_000)),
-        cluster1,
-        Collections.<String>emptyList(),
-        Collections.<HeaderMatcher>emptyList(),
+            FaultConfig.FractionalPercent.perMillion(400_000)),
         null);
     xdsClient.deliverLdsUpdateWithFaultInjection(cluster1, httpFilterFaultConfig, null, null, null);
-    verify(mockListener).onResult(resolutionResultCaptor.capture());
+    verify(mockListener, times(5)).onResult2(resolutionResultCaptor.capture());
     result = resolutionResultCaptor.getValue();
     configSelector = result.getAttributes().get(InternalConfigSelector.KEY);
-    observer = startCall(configSelector, new Metadata());
+    observer = startNewCall(TestMethodDescriptors.voidMethod(), configSelector,
+        Collections.emptyMap(), CallOptions.DEFAULT);
     verifyRpcSucceeded(observer);
   }
 
@@ -848,269 +2203,129 @@ public void resolved_faultDelayInLdsUpdate() {
     when(mockRandom.nextInt(1000_000)).thenReturn(500_000); // 50%
 
     // header delay, header delay rate = 60 %
-    HttpFault httpFilterFaultConfig = HttpFault.create(
-        FaultDelay.forHeader(HttpFault.FractionalPercent.perHundred(70)),
-        null,
-        cluster1,
-        Collections.<String>emptyList(),
-        Collections.<HeaderMatcher>emptyList(),
-        null);
+    FaultConfig httpFilterFaultConfig = FaultConfig.create(
+        FaultDelay.forHeader(FaultConfig.FractionalPercent.perHundred(70)), null, null);
     xdsClient.deliverLdsUpdateWithFaultInjection(cluster1, httpFilterFaultConfig, null, null, null);
-    verify(mockListener).onResult(resolutionResultCaptor.capture());
+    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
-    Metadata metadata = new Metadata();
-    ClientCall.Listener<Void> observer = startCall(configSelector, metadata);
+    ClientCall.Listener<Void> observer = startNewCall(TestMethodDescriptors.voidMethod(),
+        configSelector, Collections.emptyMap(), CallOptions.DEFAULT);
     verifyRpcSucceeded(observer);
     // header delay key provided, rpc should be delayed
-    metadata = new Metadata();
-    metadata.put(HEADER_DELAY_KEY, "1000");
-    metadata.put(HEADER_DELAY_PERCENTAGE_KEY, "60");
-    observer = startCall(configSelector, metadata);
+    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 = HttpFault.create(
-        FaultDelay.forHeader(HttpFault.FractionalPercent.perMillion(600_000)),
-        null,
-        cluster1,
-        Collections.<String>emptyList(),
-        Collections.<HeaderMatcher>emptyList(),
-        null);
+    httpFilterFaultConfig = FaultConfig.create(
+        FaultDelay.forHeader(FaultConfig.FractionalPercent.perMillion(600_000)), null, null);
     xdsClient.deliverLdsUpdateWithFaultInjection(cluster1, httpFilterFaultConfig, null, null, null);
-    verify(mockListener).onResult(resolutionResultCaptor.capture());
+    verify(mockListener, times(2)).onResult2(resolutionResultCaptor.capture());
     result = resolutionResultCaptor.getValue();
     configSelector = result.getAttributes().get(InternalConfigSelector.KEY);
-    metadata = new Metadata();
-    metadata.put(HEADER_DELAY_KEY, "1000");
-    observer = startCall(configSelector, metadata);
+    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 = HttpFault.create(
-        FaultDelay.forHeader(HttpFault.FractionalPercent.perMillion(0)),
-        null,
-        cluster1,
-        Collections.<String>emptyList(),
-        Collections.<HeaderMatcher>emptyList(),
-        null);
+    httpFilterFaultConfig = FaultConfig.create(
+        FaultDelay.forHeader(FaultConfig.FractionalPercent.perMillion(0)), null, null);
     xdsClient.deliverLdsUpdateWithFaultInjection(cluster1, httpFilterFaultConfig, null, null, null);
-    verify(mockListener).onResult(resolutionResultCaptor.capture());
+    verify(mockListener, times(3)).onResult2(resolutionResultCaptor.capture());
     result = resolutionResultCaptor.getValue();
     configSelector = result.getAttributes().get(InternalConfigSelector.KEY);
-    metadata = new Metadata();
-    metadata.put(HEADER_DELAY_KEY, "1000");
-    observer = startCall(configSelector, metadata);
+    observer = startNewCall(TestMethodDescriptors.voidMethod(), configSelector,
+        ImmutableMap.of(HEADER_DELAY_KEY.name(), "1000"), CallOptions.DEFAULT);
     verifyRpcSucceeded(observer);
 
     // fixed delay, fix rate = 60%
-    httpFilterFaultConfig = HttpFault.create(
-        FaultDelay.forFixedDelay(5000L, HttpFault.FractionalPercent.perMillion(600_000)),
+    httpFilterFaultConfig = FaultConfig.create(
+        FaultDelay.forFixedDelay(5000L, FaultConfig.FractionalPercent.perMillion(600_000)),
         null,
-        cluster1,
-        Collections.<String>emptyList(),
-        Collections.<HeaderMatcher>emptyList(),
         null);
     xdsClient.deliverLdsUpdateWithFaultInjection(cluster1, httpFilterFaultConfig, null, null, null);
-    verify(mockListener).onResult(resolutionResultCaptor.capture());
+    verify(mockListener, times(4)).onResult2(resolutionResultCaptor.capture());
     result = resolutionResultCaptor.getValue();
     configSelector = result.getAttributes().get(InternalConfigSelector.KEY);
-    observer = startCall(configSelector, new Metadata());
+    observer = startNewCall(TestMethodDescriptors.voidMethod(), configSelector,
+        Collections.emptyMap(), CallOptions.DEFAULT);
     verifyRpcDelayed(observer, 5000L);
 
     // fixed delay, fix rate = 40%
-    httpFilterFaultConfig = HttpFault.create(
-        FaultDelay.forFixedDelay(5000L, HttpFault.FractionalPercent.perMillion(400_000)),
+    httpFilterFaultConfig = FaultConfig.create(
+        FaultDelay.forFixedDelay(5000L, FaultConfig.FractionalPercent.perMillion(400_000)),
         null,
-        cluster1,
-        Collections.<String>emptyList(),
-        Collections.<HeaderMatcher>emptyList(),
         null);
     xdsClient.deliverLdsUpdateWithFaultInjection(cluster1, httpFilterFaultConfig, null, null, null);
-    verify(mockListener).onResult(resolutionResultCaptor.capture());
+    verify(mockListener, times(5)).onResult2(resolutionResultCaptor.capture());
     result = resolutionResultCaptor.getValue();
     configSelector = result.getAttributes().get(InternalConfigSelector.KEY);
-    observer = startCall(configSelector, new Metadata());
-    verifyRpcSucceeded(observer);
-  }
-
-  @Test
-  public void resolved_faultAbortWithUpstreamClusterMismatchInLdsUpdate() {
-    resolver.start(mockListener);
-    FakeXdsClient xdsClient = (FakeXdsClient) resolver.getXdsClient();
-    when(mockRandom.nextInt(1000_000)).thenReturn(500_000); // 50%
-
-    HttpFault httpFilterFaultConfig = HttpFault.create(
-        null,
-        FaultAbort.forStatus(
-            Status.UNAUTHENTICATED.withDescription("unauthenticated"),
-            HttpFault.FractionalPercent.perMillion(1000_000)),
-        cluster1,
-        Collections.<String>emptyList(),
-        Collections.<HeaderMatcher>emptyList(),
-        null);
-    // cluster mismatch with fault config
-    xdsClient.deliverLdsUpdateWithFaultInjection(cluster2, httpFilterFaultConfig, null, null, null);
-    verify(mockListener).onResult(resolutionResultCaptor.capture());
-    ResolutionResult result = resolutionResultCaptor.getValue();
-    InternalConfigSelector configSelector = result.getAttributes().get(InternalConfigSelector.KEY);
-    ClientCall.Listener<Void> observer = startCall(configSelector, new Metadata());
+    observer = startNewCall(TestMethodDescriptors.voidMethod(), configSelector,
+        Collections.emptyMap(), CallOptions.DEFAULT);
     verifyRpcSucceeded(observer);
   }
 
   @Test
-  public void resolved_faultAbortWithDownstreamNodesInLdsUpdate() {
+  public void resolved_faultDelayWithMaxActiveStreamsInLdsUpdate() {
     resolver.start(mockListener);
     FakeXdsClient xdsClient = (FakeXdsClient) resolver.getXdsClient();
     when(mockRandom.nextInt(1000_000)).thenReturn(500_000); // 50%
 
-    // downstream node match
-    HttpFault httpFilterFaultConfig = HttpFault.create(
+    FaultConfig httpFilterFaultConfig = FaultConfig.create(
+        FaultDelay.forFixedDelay(5000L, FaultConfig.FractionalPercent.perMillion(1000_000)),
         null,
-        FaultAbort.forStatus(
-            Status.UNAUTHENTICATED.withDescription("unauthenticated"),
-            HttpFault.FractionalPercent.perMillion(1000_000)),
-        cluster1,
-        Collections.singletonList("node1.example.com"),
-        Collections.<HeaderMatcher>emptyList(),
-        null);
+        /* maxActiveFaults= */ 1);
     xdsClient.deliverLdsUpdateWithFaultInjection(cluster1, httpFilterFaultConfig, null, null, null);
-    verify(mockListener).onResult(resolutionResultCaptor.capture());
+    verify(mockListener).onResult2(resolutionResultCaptor.capture());
     ResolutionResult result = resolutionResultCaptor.getValue();
     InternalConfigSelector configSelector = result.getAttributes().get(InternalConfigSelector.KEY);
-    Metadata metadata = new Metadata();
-    metadata.put(DOWNSTREAM_NODE_KEY, "node1.example.com");
-    ClientCall.Listener<Void> observer = startCall(configSelector, metadata);
-    verifyRpcFailed(observer, Status.UNAUTHENTICATED.withDescription("unauthenticated"));
-
-    // downstream node mismatch
-    httpFilterFaultConfig = HttpFault.create(
-        null,
-        FaultAbort.forStatus(
-            Status.UNAUTHENTICATED.withDescription("unauthenticated"),
-            HttpFault.FractionalPercent.perMillion(1000_000)),
-        cluster1,
-        Collections.singletonList("node1.example.com"),
-        Collections.<HeaderMatcher>emptyList(),
-        null);
-    xdsClient.deliverLdsUpdateWithFaultInjection(cluster1, httpFilterFaultConfig, null, null, null);
-    verify(mockListener).onResult(resolutionResultCaptor.capture());
-    result = resolutionResultCaptor.getValue();
-    configSelector = result.getAttributes().get(InternalConfigSelector.KEY);
-    metadata = new Metadata();
-    metadata.put(DOWNSTREAM_NODE_KEY, "node2.example.com");
-    observer = startCall(configSelector, metadata);
-    verifyRpcSucceeded(observer);
 
-    // downstream node absent in headers
-    httpFilterFaultConfig = HttpFault.create(
-        null,
-        FaultAbort.forStatus(
-            Status.UNAUTHENTICATED.withDescription("unauthenticated"),
-            HttpFault.FractionalPercent.perMillion(1000_000)),
-        cluster1,
-        Collections.singletonList("node1.example.com"),
-        Collections.<HeaderMatcher>emptyList(),
-        null);
-    xdsClient.deliverLdsUpdateWithFaultInjection(cluster1, httpFilterFaultConfig, null, null, null);
-    verify(mockListener).onResult(resolutionResultCaptor.capture());
-    result = resolutionResultCaptor.getValue();
-    configSelector = result.getAttributes().get(InternalConfigSelector.KEY);
-    observer = startCall(configSelector, new Metadata());
-    verifyRpcSucceeded(observer);
+    // 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_faultAbortWithHeaderMatcherInLdsUpdate() {
+  public void resolved_faultDelayInLdsUpdate_callWithEarlyDeadline() {
     resolver.start(mockListener);
     FakeXdsClient xdsClient = (FakeXdsClient) resolver.getXdsClient();
     when(mockRandom.nextInt(1000_000)).thenReturn(500_000); // 50%
-    Metadata.Key<String> faultKey = Metadata.Key.of("fault_key", Metadata.ASCII_STRING_MARSHALLER);
-
-    // headers match
-    HttpFault httpFilterFaultConfig = HttpFault.create(
-        null,
-        FaultAbort.forStatus(
-            Status.UNAUTHENTICATED, HttpFault.FractionalPercent.perMillion(1000_000)),
-        cluster1,
-        Collections.<String>emptyList(),
-        Collections.singletonList(HeaderMatcher.forExactValue("fault_key", "fault_value", false)),
-        null);
-    xdsClient.deliverLdsUpdateWithFaultInjection(cluster1, httpFilterFaultConfig, null, null, null);
-    verify(mockListener).onResult(resolutionResultCaptor.capture());
-    ResolutionResult result = resolutionResultCaptor.getValue();
-    InternalConfigSelector configSelector = result.getAttributes().get(InternalConfigSelector.KEY);
-    Metadata metadata = new Metadata();
-    metadata.put(faultKey, "fault_value");
-    ClientCall.Listener<Void> observer = startCall(configSelector, metadata);
-    verifyRpcFailed(observer, Status.UNAUTHENTICATED);
-
-    // headers mismatch
-    httpFilterFaultConfig = HttpFault.create(
-        null,
-        FaultAbort.forStatus(
-            Status.UNAUTHENTICATED.withDescription("unauthenticated"),
-            HttpFault.FractionalPercent.perMillion(1000_000)),
-        cluster1,
-        Collections.<String>emptyList(),
-        Collections.singletonList(HeaderMatcher.forExactValue("fault_key", "fault_value", false)),
-        null);
-    xdsClient.deliverLdsUpdateWithFaultInjection(cluster1, httpFilterFaultConfig, null, null, null);
-    verify(mockListener).onResult(resolutionResultCaptor.capture());
-    result = resolutionResultCaptor.getValue();
-    configSelector = result.getAttributes().get(InternalConfigSelector.KEY);
-    metadata = new Metadata();
-    metadata.put(faultKey, "value_not_match");
-    observer = startCall(configSelector, metadata);
-    verifyRpcSucceeded(observer);
 
-    // headers absent
-    httpFilterFaultConfig = HttpFault.create(
+    FaultConfig httpFilterFaultConfig = FaultConfig.create(
+        FaultDelay.forFixedDelay(5000L, FaultConfig.FractionalPercent.perMillion(1000_000)),
         null,
-        FaultAbort.forStatus(
-            Status.UNAUTHENTICATED.withDescription("unauthenticated"),
-            HttpFault.FractionalPercent.perMillion(1000_000)),
-        cluster1,
-        Collections.<String>emptyList(),
-        Collections.singletonList(HeaderMatcher.forExactValue("fault_key", "fault_value", false)),
         null);
     xdsClient.deliverLdsUpdateWithFaultInjection(cluster1, httpFilterFaultConfig, null, null, null);
-    verify(mockListener).onResult(resolutionResultCaptor.capture());
-    result = resolutionResultCaptor.getValue();
-    configSelector = result.getAttributes().get(InternalConfigSelector.KEY);
-    observer = startCall(configSelector, new Metadata());
-    verifyRpcSucceeded(observer);
-  }
-
-  @Test
-  public void resolved_faultDelayWithMaxActiveStreamsInLdsUpdate() {
-    resolver.start(mockListener);
-    FakeXdsClient xdsClient = (FakeXdsClient) resolver.getXdsClient();
-    when(mockRandom.nextInt(1000_000)).thenReturn(500_000); // 50%
-
-    HttpFault httpFilterFaultConfig = HttpFault.create(
-        FaultDelay.forFixedDelay(5000L, HttpFault.FractionalPercent.perMillion(1000_000)),
-        null,
-        cluster1,
-        Collections.<String>emptyList(),
-        Collections.<HeaderMatcher>emptyList(),
-        /* maxActiveFaults= */ 1);
-    xdsClient.deliverLdsUpdateWithFaultInjection(cluster1, httpFilterFaultConfig, null, null, null);
-    verify(mockListener).onResult(resolutionResultCaptor.capture());
+    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 = startCall(configSelector, new Metadata());
+    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();
-    ClientCall.Listener<Void> observer2 = startCall(configSelector, new Metadata());
-    verifyRpcSucceeded(observer2);
-    verifyRpcDelayed(observer1, 5000L);
-    // Once all calls are finished, new call should be delayed.
-    ClientCall.Listener<Void> observer3 = startCall(configSelector, new Metadata());
-    verifyRpcDelayed(observer3, 5000L);
+    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
@@ -1119,22 +2334,22 @@ public void resolved_faultAbortAndDelayInLdsUpdateInLdsUpdate() {
     FakeXdsClient xdsClient = (FakeXdsClient) resolver.getXdsClient();
     when(mockRandom.nextInt(1000_000)).thenReturn(500_000); // 50%
 
-    HttpFault httpFilterFaultConfig = HttpFault.create(
-        FaultDelay.forFixedDelay(5000L, HttpFault.FractionalPercent.perMillion(1000_000)),
+    FaultConfig httpFilterFaultConfig = FaultConfig.create(
+        FaultDelay.forFixedDelay(5000L, FaultConfig.FractionalPercent.perMillion(1000_000)),
         FaultAbort.forStatus(
             Status.UNAUTHENTICATED.withDescription("unauthenticated"),
-            HttpFault.FractionalPercent.perMillion(1000_000)),
-        cluster1,
-        Collections.<String>emptyList(),
-        Collections.<HeaderMatcher>emptyList(),
+            FaultConfig.FractionalPercent.perMillion(1000_000)),
         null);
     xdsClient.deliverLdsUpdateWithFaultInjection(cluster1, httpFilterFaultConfig, null, null, null);
-    verify(mockListener).onResult(resolutionResultCaptor.capture());
+    verify(mockListener).onResult2(resolutionResultCaptor.capture());
     ResolutionResult result = resolutionResultCaptor.getValue();
     InternalConfigSelector configSelector = result.getAttributes().get(InternalConfigSelector.KEY);
-    ClientCall.Listener<Void> observer = startCall(configSelector, new Metadata());
+    ClientCall.Listener<Void> observer = startNewCall(TestMethodDescriptors.voidMethod(),
+        configSelector, Collections.emptyMap(), CallOptions.DEFAULT);
     verifyRpcDelayedThenAborted(
-        observer, 5000L, Status.UNAUTHENTICATED.withDescription("unauthenticated"));
+        observer, 5000L,
+        Status.UNAUTHENTICATED.withDescription(
+            "RPC terminated due to fault injection: unauthenticated"));
   }
 
   @Test
@@ -1143,62 +2358,57 @@ public void resolved_faultConfigOverrideInLdsUpdate() {
     FakeXdsClient xdsClient = (FakeXdsClient) resolver.getXdsClient();
     when(mockRandom.nextInt(1000_000)).thenReturn(500_000); // 50%
 
-    HttpFault httpFilterFaultConfig = HttpFault.create(
+    FaultConfig httpFilterFaultConfig = FaultConfig.create(
         null,
         FaultAbort.forStatus(
-            Status.UNAUTHENTICATED, HttpFault.FractionalPercent.perMillion(1000_000)),
-        cluster1,
-        Collections.<String>emptyList(),
-        Collections.<HeaderMatcher>emptyList(),
+            Status.UNAUTHENTICATED, FaultConfig.FractionalPercent.perMillion(1000_000)),
         null);
     // VirtualHost fault config override
-    HttpFault virtualHostFaultConfig = HttpFault.create(
+    FaultConfig virtualHostFaultConfig = FaultConfig.create(
         null,
-        FaultAbort.forStatus(Status.INTERNAL, HttpFault.FractionalPercent.perMillion(1000_000)),
-        cluster1,
-        Collections.<String>emptyList(),
-        Collections.<HeaderMatcher>emptyList(),
+        FaultAbort.forStatus(Status.INTERNAL, FaultConfig.FractionalPercent.perMillion(1000_000)),
         null);
     xdsClient.deliverLdsUpdateWithFaultInjection(
         cluster1, httpFilterFaultConfig, virtualHostFaultConfig, null, null);
-    verify(mockListener).onResult(resolutionResultCaptor.capture());
+    verify(mockListener).onResult2(resolutionResultCaptor.capture());
     ResolutionResult result = resolutionResultCaptor.getValue();
     InternalConfigSelector configSelector = result.getAttributes().get(InternalConfigSelector.KEY);
-    ClientCall.Listener<Void> observer = startCall(configSelector, new Metadata());
-    verifyRpcFailed(observer, Status.INTERNAL);
+    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
-    HttpFault routeFaultConfig = HttpFault.create(
+    FaultConfig routeFaultConfig = FaultConfig.create(
         null,
-        FaultAbort.forStatus(Status.UNKNOWN, HttpFault.FractionalPercent.perMillion(1000_000)),
-        cluster1,
-        Collections.<String>emptyList(),
-        Collections.<HeaderMatcher>emptyList(),
+        FaultAbort.forStatus(Status.UNKNOWN, FaultConfig.FractionalPercent.perMillion(1000_000)),
         null);
     xdsClient.deliverLdsUpdateWithFaultInjection(
         cluster1, httpFilterFaultConfig, virtualHostFaultConfig, routeFaultConfig, null);
-    verify(mockListener).onResult(resolutionResultCaptor.capture());
+    verify(mockListener, times(2)).onResult2(resolutionResultCaptor.capture());
     result = resolutionResultCaptor.getValue();
     configSelector = result.getAttributes().get(InternalConfigSelector.KEY);
-    observer = startCall(configSelector, new Metadata());
-    verifyRpcFailed(observer, Status.UNKNOWN);
+    observer = startNewCall(TestMethodDescriptors.voidMethod(), configSelector,
+        Collections.emptyMap(), CallOptions.DEFAULT);
+    verifyRpcFailed(
+        observer, Status.UNKNOWN.withDescription("RPC terminated due to fault injection"));
 
     // WeightedCluster fault config override
-    HttpFault weightedClusterFaultConfig = HttpFault.create(
+    FaultConfig weightedClusterFaultConfig = FaultConfig.create(
         null,
-        FaultAbort.forStatus(Status.UNAVAILABLE, HttpFault.FractionalPercent.perMillion(1000_000)),
-        cluster1,
-        Collections.<String>emptyList(),
-        Collections.<HeaderMatcher>emptyList(),
+        FaultAbort.forStatus(
+            Status.UNAVAILABLE, FaultConfig.FractionalPercent.perMillion(1000_000)),
         null);
     xdsClient.deliverLdsUpdateWithFaultInjection(
         cluster1, httpFilterFaultConfig, virtualHostFaultConfig, routeFaultConfig,
         weightedClusterFaultConfig);
-    verify(mockListener).onResult(resolutionResultCaptor.capture());
+    verify(mockListener, times(3)).onResult2(resolutionResultCaptor.capture());
     result = resolutionResultCaptor.getValue();
     configSelector = result.getAttributes().get(InternalConfigSelector.KEY);
-    observer = startCall(configSelector, new Metadata());
-    verifyRpcFailed(observer, Status.UNAVAILABLE);
+    observer = startNewCall(TestMethodDescriptors.voidMethod(), configSelector,
+        Collections.emptyMap(), CallOptions.DEFAULT);
+    verifyRpcFailed(
+        observer, Status.UNAVAILABLE.withDescription("RPC terminated due to fault injection"));
   }
 
   @Test
@@ -1207,51 +2417,43 @@ public void resolved_faultConfigOverrideInLdsAndInRdsUpdate() {
     FakeXdsClient xdsClient = (FakeXdsClient) resolver.getXdsClient();
     when(mockRandom.nextInt(1000_000)).thenReturn(500_000); // 50%
 
-    HttpFault httpFilterFaultConfig = HttpFault.create(
+    FaultConfig httpFilterFaultConfig = FaultConfig.create(
         null,
         FaultAbort.forStatus(
-            Status.UNAUTHENTICATED, HttpFault.FractionalPercent.perMillion(1000_000)),
-        cluster1,
-        Collections.<String>emptyList(),
-        Collections.<HeaderMatcher>emptyList(),
+            Status.UNAUTHENTICATED, FaultConfig.FractionalPercent.perMillion(1000_000)),
         null);
-    xdsClient.deliverRdsNameWithFaultInjection(AUTHORITY, httpFilterFaultConfig);
-
+    xdsClient.deliverLdsUpdateForRdsNameWithFaultInjection(
+        RDS_RESOURCE_NAME, httpFilterFaultConfig);
 
     // Route fault config override
-    HttpFault routeFaultConfig = HttpFault.create(
+    FaultConfig routeFaultConfig = FaultConfig.create(
         null,
-        FaultAbort.forStatus(Status.UNKNOWN, HttpFault.FractionalPercent.perMillion(1000_000)),
-        cluster1,
-        Collections.<String>emptyList(),
-        Collections.<HeaderMatcher>emptyList(),
+        FaultAbort.forStatus(Status.UNKNOWN, FaultConfig.FractionalPercent.perMillion(1000_000)),
         null);
-    xdsClient.deliverRdsUpdateWithFaultInjection(null, routeFaultConfig, null);
-    verify(mockListener).onResult(resolutionResultCaptor.capture());
+    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 = startCall(configSelector, new Metadata());
-    verifyRpcFailed(observer, Status.UNKNOWN);
+    ClientCall.Listener<Void> observer = startNewCall(TestMethodDescriptors.voidMethod(),
+        configSelector, Collections.emptyMap(), CallOptions.DEFAULT);
+    verifyRpcFailed(
+        observer, Status.UNKNOWN.withDescription("RPC terminated due to fault injection"));
   }
 
-  private ClientCall.Listener<Void> startCall(
-      InternalConfigSelector configSelector,
-      Metadata metadata) {
-    testCall = null;
-    MethodDescriptor<Void, Void> method = TestMethodDescriptors.voidMethod();
-    Result result = configSelector.selectConfig(
-        new PickSubchannelArgsImpl(method, metadata, CallOptions.DEFAULT));
-    assertThat(result.getStatus().isOk()).isTrue();
-    ClientInterceptor interceptor = result.getInterceptor();
-    ClientCall<Void, Void> clientCall = interceptor.interceptCall(
-        method, CallOptions.DEFAULT, channel);
+  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<Void> observer =
-        (ClientCall.Listener<Void>) mock(ClientCall.Listener.class);
-    clientCall.start(observer, metadata);
-    clientCall.sendMessage(null);
-    clientCall.halfClose();
-    return observer;
+    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) {
@@ -1285,131 +2487,29 @@ private void verifyRpcDelayedThenAborted(
     verifyRpcFailed(listener, expectedStatus);
   }
 
-  @Test
-  public void routeMatching_pathOnly() {
-    Map<String, Iterable<String>> headers = Collections.emptyMap();
-    ThreadSafeRandom random = mock(ThreadSafeRandom.class);
-
-    RouteMatch routeMatch1 =
-        RouteMatch.create(
-            PathMatcher.fromPath("/FooService/barMethod", true),
-            Collections.<HeaderMatcher>emptyList(), null);
-    assertThat(XdsNameResolver.matchRoute(routeMatch1, "/FooService/barMethod", headers, random))
-        .isTrue();
-    assertThat(XdsNameResolver.matchRoute(routeMatch1, "/FooService/bazMethod", headers, random))
-        .isFalse();
-
-    RouteMatch routeMatch2 =
-        RouteMatch.create(
-            PathMatcher.fromPrefix("/FooService/", true),
-            Collections.<HeaderMatcher>emptyList(), null);
-    assertThat(XdsNameResolver.matchRoute(routeMatch2, "/FooService/barMethod", headers, random))
-        .isTrue();
-    assertThat(XdsNameResolver.matchRoute(routeMatch2, "/FooService/bazMethod", headers, random))
-        .isTrue();
-    assertThat(XdsNameResolver.matchRoute(routeMatch2, "/BarService/bazMethod", headers, random))
-        .isFalse();
-
-    RouteMatch routeMatch3 =
-        RouteMatch.create(
-            PathMatcher.fromRegEx(Pattern.compile(".*Foo.*")),
-            Collections.<HeaderMatcher>emptyList(), null);
-    assertThat(XdsNameResolver.matchRoute(routeMatch3, "/FooService/barMethod", headers, random))
-        .isTrue();
-  }
-
-  @Test
-  public void routeMatching_withHeaders() {
-    Map<String, Iterable<String>> headers = new HashMap<>();
-    headers.put("authority", Collections.singletonList("foo.googleapis.com"));
-    headers.put("grpc-encoding", Collections.singletonList("gzip"));
-    headers.put("user-agent", Collections.singletonList("gRPC-Java"));
-    headers.put("content-length", Collections.singletonList("1000"));
-    headers.put("custom-key", Arrays.asList("custom-value1", "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(XdsNameResolver.matchRoute(routeMatch1, "/FooService/barMethod", headers, random))
-        .isTrue();
-
-    RouteMatch routeMatch2 = RouteMatch.create(
-        pathMatcher,
-        Collections.singletonList(
-            HeaderMatcher.forSafeRegEx("authority", Pattern.compile(".*googleapis.*"), true)),
-        null);
-    assertThat(XdsNameResolver.matchRoute(routeMatch2, "/FooService/barMethod", headers, random))
-        .isFalse();
-
-    RouteMatch routeMatch3 = RouteMatch.create(
-        pathMatcher,
-        Collections.singletonList(
-            HeaderMatcher.forExactValue("user-agent", "gRPC-Go", false)), null);
-    assertThat(XdsNameResolver.matchRoute(routeMatch3, "/FooService/barMethod", headers, random))
-        .isFalse();
-
-    RouteMatch routeMatch4 = RouteMatch.create(
-        pathMatcher,
-        Collections.singletonList(HeaderMatcher.forPresent("user-agent", false, false)),
-        null);
-    assertThat(XdsNameResolver.matchRoute(routeMatch4, "/FooService/barMethod", headers, random))
-        .isFalse();
-
-    RouteMatch routeMatch5 = RouteMatch.create(
-        pathMatcher,
-        Collections.singletonList(HeaderMatcher.forPresent("user-agent", false, true)), // inverted
-        null);
-    assertThat(XdsNameResolver.matchRoute(routeMatch5, "/FooService/barMethod", headers, random))
-        .isTrue();
-
-    RouteMatch routeMatch6 = RouteMatch.create(
-        pathMatcher,
-        Collections.singletonList(HeaderMatcher.forPresent("user-agent", true, true)),
-        null);
-    assertThat(XdsNameResolver.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(XdsNameResolver.matchRoute(routeMatch7, "/FooService/barMethod", headers, random))
-        .isTrue();
-  }
-
-  @Test
-  public void pathMatching_caseInsensitive() {
-    PathMatcher pathMatcher1 = PathMatcher.fromPath("/FooService/barMethod", false);
-    assertThat(XdsNameResolver.matchPath(pathMatcher1, "/fooservice/barmethod")).isTrue();
-
-    PathMatcher pathMatcher2 = PathMatcher.fromPrefix("/FooService", false);
-    assertThat(XdsNameResolver.matchPath(pathMatcher2, "/fooservice/barmethod")).isTrue();
+  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
-    public void setBootstrapOverride(Map<String, ?> bootstrap) {
+    @Nullable
+    public ObjectPool<XdsClient> get(String target) {
       throw new UnsupportedOperationException("Should not be called");
     }
 
     @Override
-    public ObjectPool<XdsClient> getXdsClientPool() throws XdsInitializationException {
+    public ObjectPool<XdsClient> getOrCreate(
+        String target, BootstrapInfo bootstrapInfo, MetricRecorder metricRecorder) {
+      targets.add(target);
       return new ObjectPool<XdsClient>() {
         @Override
         public XdsClient getObject() {
-          return new FakeXdsClient();
+          return xdsClient;
         }
 
         @Override
@@ -1418,198 +2518,378 @@ public XdsClient returnObject(Object object) {
         }
       };
     }
+
+    @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 {
-    private String ldsResource;
-    private String rdsResource;
-    private LdsResourceWatcher ldsWatcher;
-    private RdsResourceWatcher rdsWatcher;
+    // 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
-    void watchLdsResource(String resourceName, LdsResourceWatcher watcher) {
-      Preconditions.checkArgument(ldsResource == null && ldsWatcher == null, "already watched");
-      ldsResource = resourceName;
-      ldsWatcher = watcher;
+    public BootstrapInfo getBootstrapInfo() {
+      return bootstrapInfo;
     }
 
     @Override
-    void cancelLdsResourceWatch(String resourceName, LdsResourceWatcher watcher) {
-      Preconditions.checkArgument(resourceName.equals(ldsResource), "unknown resource");
-      Preconditions.checkArgument(watcher.equals(ldsWatcher), "unknown watcher");
-      ldsResource = null;
-      ldsWatcher = null;
+    @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
-    void watchRdsResource(String resourceName, RdsResourceWatcher watcher) {
-      Preconditions.checkArgument(rdsResource == null && rdsWatcher == null, "already watched");
-      rdsResource = resourceName;
-      rdsWatcher = watcher;
+    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:
+      }
     }
 
-    @Override
-    void cancelRdsResourceWatch(String resourceName, RdsResourceWatcher watcher) {
-      Preconditions.checkArgument(resourceName.equals(rdsResource), "unknown resource");
-      Preconditions.checkArgument(watcher.equals(rdsWatcher), "unknown watcher");
-      rdsResource = null;
-      rdsWatcher = null;
+    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));
+      });
     }
 
-    @Override
-    void shutdown() {
-      // no-op
+    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(final String resourceName, final long httpMaxStreamDurationNano,
-        final List<VirtualHost> virtualHosts) {
-      syncContext.execute(new Runnable() {
-        @Override
-        public void run() {
-          if (!resourceName.equals(ldsResource)) {
-            return;
-          }
-          ldsWatcher.onChanged(new LdsUpdate(httpMaxStreamDurationNano, virtualHosts, false, null));
-        }
+    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 String resourceName, final List<Route> routes) {
-      syncContext.execute(new Runnable() {
-        @Override
-        public void run() {
-          if (!resourceName.equals(ldsResource)) {
-            return;
-          }
-          VirtualHost virtualHost = VirtualHost.create("virtual-host",
-              Collections.singletonList(AUTHORITY), routes, null);
-          ldsWatcher.onChanged(
-              new LdsUpdate(0, Collections.singletonList(virtualHost), false, null));
+    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,
-        final HttpFault httpFilterFaultConfig,
-        final HttpFault virtualHostFaultConfig,
-        final HttpFault routeFaultConfig,
-        final HttpFault weightedClusterFaultConfig) {
-      syncContext.execute(new Runnable() {
-        @Override
-        public void run() {
-          ClusterWeight clusterWeight =
-              ClusterWeight.create(cluster, 100, weightedClusterFaultConfig);
-          Route route = Route.create(
-              RouteMatch.create(
-                  PathMatcher.fromPrefix("/", false), Collections.<HeaderMatcher>emptyList(), null),
-              RouteAction.forWeightedClusters(
-                  Collections.singletonList(clusterWeight),
-                  Collections.<HashPolicy>emptyList(),
-                  null),
-              routeFaultConfig);
-          VirtualHost virtualHost = VirtualHost.create(
-              "virtual-host",
-              Collections.singletonList(AUTHORITY),
-              Collections.singletonList(route), virtualHostFaultConfig);
-          ldsWatcher.onChanged(
-              new LdsUpdate(
-                  0, Collections.singletonList(virtualHost), true, httpFilterFaultConfig));
-        }
+        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 deliverRdsNameWithFaultInjection(
-        final String rdsName, final HttpFault httpFilterFaultConfig) {
-      syncContext.execute(new Runnable() {
-        @Override
-        public void run() {
-          ldsWatcher.onChanged(new LdsUpdate(0, rdsName, true, httpFilterFaultConfig));
-        }
+    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 deliverRdsName(final String resourceName, final String rdsName) {
-      syncContext.execute(new Runnable() {
-        @Override
-        public void run() {
-          if (!resourceName.equals(ldsResource)) {
-            return;
-          }
-          ldsWatcher.onChanged(new LdsUpdate(0, rdsName, false, null));
+    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));
         }
       });
     }
 
-    void deliverLdsResourceNotFound(final String resourceName) {
-      syncContext.execute(new Runnable() {
-        @Override
-        public void run() {
-          if (!resourceName.equals(ldsResource)) {
-            return;
+    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());
           }
-          ldsWatcher.onResourceDoesNotExist(ldsResource);
         }
-      });
+      }
+
+      return clusterNames;
     }
 
     void deliverRdsUpdateWithFaultInjection(
-        final HttpFault virtualHostFaultConfig, final HttpFault routFaultConfig,
-        final HttpFault weightedClusterFaultConfig) {
-      syncContext.execute(new Runnable() {
-        @Override
-        public void run() {
-          ClusterWeight clusterWeight =
-              ClusterWeight.create(cluster1, 100, weightedClusterFaultConfig);
-          Route route = Route.create(
-              RouteMatch.create(
-                  PathMatcher.fromPrefix("/", false), Collections.<HeaderMatcher>emptyList(), null),
-              RouteAction.forWeightedClusters(
-                  Collections.singletonList(clusterWeight),
-                  Collections.<HashPolicy>emptyList(),
-                  null),
-              routFaultConfig);
-          VirtualHost virtualHost = VirtualHost.create(
-              "virtual-host",
-              Collections.singletonList(AUTHORITY),
-              Collections.singletonList(route), virtualHostFaultConfig);
-          rdsWatcher.onChanged(new RdsUpdate(Collections.singletonList(virtualHost)));
-        }
+        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(final String resourceName, final List<VirtualHost> virtualHosts) {
-      syncContext.execute(new Runnable() {
-        @Override
-        public void run() {
-          rdsWatcher.onChanged(new RdsUpdate(virtualHosts));
-        }
+    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)));
       });
     }
 
-    void deliverRdsResourceNotFound(final String resourceName) {
-      syncContext.execute(new Runnable() {
-        @Override
-        public void run() {
-          if (!resourceName.equals(rdsResource)) {
-            return;
-          }
-          rdsWatcher.onResourceDoesNotExist(rdsResource);
+    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) {
-      syncContext.execute(new Runnable() {
-        @Override
-        public void run() {
-          if (ldsWatcher != null) {
-            ldsWatcher.onError(error);
-          }
-          if (rdsWatcher != null) {
-            rdsWatcher.onError(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)));
       });
     }
   }
diff --git a/xds/src/test/java/io/grpc/xds/XdsSdsClientServerTest.java b/xds/src/test/java/io/grpc/xds/XdsSdsClientServerTest.java
deleted file mode 100644
index 2a91e2de96e..00000000000
--- a/xds/src/test/java/io/grpc/xds/XdsSdsClientServerTest.java
+++ /dev/null
@@ -1,561 +0,0 @@
-/*
- * 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.sds.CommonTlsContextTestsUtil.BAD_CLIENT_KEY_FILE;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.BAD_CLIENT_PEM_FILE;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.BAD_SERVER_KEY_FILE;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.BAD_SERVER_PEM_FILE;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.CA_PEM_FILE;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.CLIENT_KEY_FILE;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.CLIENT_PEM_FILE;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.SERVER_1_KEY_FILE;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.SERVER_1_PEM_FILE;
-import static org.junit.Assert.fail;
-import static org.mockito.Mockito.mock;
-
-import com.google.common.collect.ImmutableList;
-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.ServerCredentials;
-import io.grpc.Status;
-import io.grpc.StatusRuntimeException;
-import io.grpc.netty.InternalProtocolNegotiators;
-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.DownstreamTlsContext;
-import io.grpc.xds.EnvoyServerProtoData.UpstreamTlsContext;
-import io.grpc.xds.internal.sds.CommonTlsContextTestsUtil;
-import io.grpc.xds.internal.sds.SslContextProviderSupplier;
-import io.grpc.xds.internal.sds.TlsContextManagerImpl;
-import io.grpc.xds.internal.sds.XdsChannelBuilder;
-import io.netty.handler.ssl.NotSslRecordException;
-import java.io.IOException;
-import java.net.Inet4Address;
-import java.net.InetSocketAddress;
-import java.net.URI;
-import java.net.URISyntaxException;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-import javax.net.ssl.SSLException;
-import javax.net.ssl.SSLHandshakeException;
-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;
-
-/**
- * Unit tests for {@link XdsChannelBuilder} and {@link XdsServerBuilder} for plaintext/TLS/mTLS
- * modes.
- */
-@RunWith(JUnit4.class)
-public class XdsSdsClientServerTest {
-
-  @Rule public final GrpcCleanupRule cleanupRule = new GrpcCleanupRule();
-  private int port;
-  private FakeNameResolverFactory fakeNameResolverFactory;
-  private Bootstrapper mockBootstrapper;
-
-  @Before
-  public void setUp() throws IOException {
-    port = XdsServerTestHelper.findFreePort();
-    mockBootstrapper = mock(Bootstrapper.class);
-  }
-
-  @After
-  public void tearDown() {
-    if (fakeNameResolverFactory != null) {
-      NameResolverRegistry.getDefaultRegistry().deregister(fakeNameResolverFactory);
-    }
-  }
-
-  @Test
-  public void plaintextClientServer() throws IOException, URISyntaxException {
-    buildServerWithTlsContext(/* downstreamTlsContext= */ null);
-
-    SimpleServiceGrpc.SimpleServiceBlockingStub blockingStub =
-        getBlockingStub(/* upstreamTlsContext= */ null, /* overrideAuthority= */ null);
-    assertThat(unaryRpc("buddy", blockingStub)).isEqualTo("Hello buddy");
-  }
-
-  @Test
-  public void plaintextClientServer_withXdsChannelCreds() throws IOException, URISyntaxException {
-    buildServerWithTlsContext(/* downstreamTlsContext= */ null);
-
-    SimpleServiceGrpc.SimpleServiceBlockingStub blockingStub =
-            getBlockingStubNewApi(/* upstreamTlsContext= */ null, /* overrideAuthority= */ null);
-    assertThat(unaryRpc("buddy", blockingStub)).isEqualTo("Hello buddy");
-  }
-
-  @Test
-  public void plaintextClientServer_withDefaultTlsContext() throws IOException, URISyntaxException {
-    DownstreamTlsContext defaultTlsContext =
-        EnvoyServerProtoData.DownstreamTlsContext.fromEnvoyProtoDownstreamTlsContext(
-            io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.DownstreamTlsContext
-                .getDefaultInstance());
-    buildServerWithTlsContext(/* downstreamTlsContext= */ defaultTlsContext);
-
-    SimpleServiceGrpc.SimpleServiceBlockingStub blockingStub =
-            getBlockingStub(/* upstreamTlsContext= */ null, /* overrideAuthority= */ null);
-    assertThat(unaryRpc("buddy", blockingStub)).isEqualTo("Hello buddy");
-  }
-
-  @Test
-  public void nullFallbackCredentials_expectException() throws IOException, URISyntaxException {
-    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 IOException, URISyntaxException {
-    DownstreamTlsContext downstreamTlsContext =
-        CommonTlsContextTestsUtil.buildDownstreamTlsContextFromFilenames(
-            SERVER_1_KEY_FILE, SERVER_1_PEM_FILE, null);
-    buildServerWithTlsContext(downstreamTlsContext);
-
-    // for TLS, client only needs trustCa
-    UpstreamTlsContext upstreamTlsContext =
-        CommonTlsContextTestsUtil.buildUpstreamTlsContextFromFilenames(
-            /* privateKey= */ null, /* certChain= */ null, CA_PEM_FILE);
-
-    SimpleServiceGrpc.SimpleServiceBlockingStub blockingStub =
-        getBlockingStub(upstreamTlsContext, /* overrideAuthority= */ "foo.test.google.fr");
-    assertThat(unaryRpc(/* requestMessage= */ "buddy", blockingStub)).isEqualTo("Hello buddy");
-  }
-
-  @Test
-  public void requireClientAuth_noClientCert_expectException()
-      throws IOException, URISyntaxException {
-    DownstreamTlsContext downstreamTlsContext =
-        CommonTlsContextTestsUtil.buildDownstreamTlsContextFromFilenamesWithClientCertRequired(
-            SERVER_1_KEY_FILE, SERVER_1_PEM_FILE, CA_PEM_FILE);
-    buildServerWithTlsContext(downstreamTlsContext);
-
-    // for TLS, client only uses trustCa
-    UpstreamTlsContext upstreamTlsContext =
-        CommonTlsContextTestsUtil.buildUpstreamTlsContextFromFilenames(
-            /* privateKey= */ null, /* certChain= */ null, CA_PEM_FILE);
-
-    SimpleServiceGrpc.SimpleServiceBlockingStub blockingStub =
-        getBlockingStub(upstreamTlsContext, /* overrideAuthority= */ "foo.test.google.fr");
-    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 IOException, URISyntaxException {
-    DownstreamTlsContext downstreamTlsContext =
-        CommonTlsContextTestsUtil.buildDownstreamTlsContextFromFilenames(
-            SERVER_1_KEY_FILE, SERVER_1_PEM_FILE, /* trustCa= */ null);
-    buildServerWithTlsContext(downstreamTlsContext);
-
-    UpstreamTlsContext upstreamTlsContext =
-        CommonTlsContextTestsUtil.buildUpstreamTlsContextFromFilenames(
-            BAD_CLIENT_KEY_FILE, BAD_CLIENT_PEM_FILE, CA_PEM_FILE);
-
-    SimpleServiceGrpc.SimpleServiceBlockingStub blockingStub =
-        getBlockingStub(upstreamTlsContext, /* overrideAuthority= */ "foo.test.google.fr");
-    assertThat(unaryRpc("buddy", blockingStub)).isEqualTo("Hello buddy");
-  }
-
-  @Test
-  public void mtls_badClientCert_expectException() throws IOException, URISyntaxException {
-    UpstreamTlsContext upstreamTlsContext =
-        CommonTlsContextTestsUtil.buildUpstreamTlsContextFromFilenames(
-            BAD_CLIENT_KEY_FILE, BAD_CLIENT_PEM_FILE, CA_PEM_FILE);
-    try {
-      XdsClient.ListenerWatcher unused = performMtlsTestAndGetListenerWatcher(upstreamTlsContext,
-          false);
-      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 - client auth enabled. */
-  @Test
-  public void mtlsClientServer_withClientAuthentication() throws IOException, URISyntaxException {
-    UpstreamTlsContext upstreamTlsContext =
-        CommonTlsContextTestsUtil.buildUpstreamTlsContextFromFilenames(
-            CLIENT_KEY_FILE, CLIENT_PEM_FILE, CA_PEM_FILE);
-    performMtlsTestAndGetListenerWatcher(upstreamTlsContext, false);
-  }
-
-  /** mTLS - client auth enabled - using {@link XdsChannelCredentials} API. */
-  @Test
-  public void mtlsClientServer_withClientAuthentication_withXdsChannelCreds()
-      throws IOException, URISyntaxException {
-    UpstreamTlsContext upstreamTlsContext =
-        CommonTlsContextTestsUtil.buildUpstreamTlsContextFromFilenames(
-            CLIENT_KEY_FILE, CLIENT_PEM_FILE, CA_PEM_FILE);
-    performMtlsTestAndGetListenerWatcher(upstreamTlsContext, true);
-  }
-
-  @Test
-  public void tlsServer_plaintextClient_expectException() throws IOException, URISyntaxException {
-    DownstreamTlsContext downstreamTlsContext =
-        CommonTlsContextTestsUtil.buildDownstreamTlsContextFromFilenames(
-            SERVER_1_KEY_FILE, SERVER_1_PEM_FILE, null);
-    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 IOException, URISyntaxException {
-    buildServerWithTlsContext(/* downstreamTlsContext= */ null);
-
-    // for TLS, client only needs trustCa
-    UpstreamTlsContext upstreamTlsContext =
-        CommonTlsContextTestsUtil.buildUpstreamTlsContextFromFilenames(
-            /* privateKey= */ null, /* certChain= */ null, CA_PEM_FILE);
-
-    SimpleServiceGrpc.SimpleServiceBlockingStub blockingStub =
-        getBlockingStub(upstreamTlsContext, /* overrideAuthority= */ "foo.test.google.fr");
-    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 IOException, URISyntaxException {
-    UpstreamTlsContext upstreamTlsContext =
-        CommonTlsContextTestsUtil.buildUpstreamTlsContextFromFilenames(
-            CLIENT_KEY_FILE, CLIENT_PEM_FILE, CA_PEM_FILE);
-    XdsClient.ListenerWatcher listenerWatcher =
-        performMtlsTestAndGetListenerWatcher(upstreamTlsContext, false);
-    DownstreamTlsContext downstreamTlsContext =
-        CommonTlsContextTestsUtil.buildDownstreamTlsContextFromFilenames(
-            BAD_SERVER_KEY_FILE, BAD_SERVER_PEM_FILE, CA_PEM_FILE);
-    generateListenerUpdateToWatcher(downstreamTlsContext, listenerWatcher);
-    try {
-      SimpleServiceGrpc.SimpleServiceBlockingStub blockingStub =
-          getBlockingStub(upstreamTlsContext, "foo.test.google.fr");
-      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 XdsClient.ListenerWatcher performMtlsTestAndGetListenerWatcher(
-      UpstreamTlsContext upstreamTlsContext, boolean newApi)
-      throws IOException, URISyntaxException {
-    DownstreamTlsContext downstreamTlsContext =
-        CommonTlsContextTestsUtil.buildDownstreamTlsContextFromFilenamesWithClientCertRequired(
-            SERVER_1_KEY_FILE, SERVER_1_PEM_FILE, CA_PEM_FILE);
-
-    final XdsClientWrapperForServerSds xdsClientWrapperForServerSds =
-        createXdsClientWrapperForServerSds(port);
-    buildServerWithFallbackServerCredentials(
-        xdsClientWrapperForServerSds, InsecureServerCredentials.create(), downstreamTlsContext);
-
-    XdsClient.ListenerWatcher listenerWatcher = xdsClientWrapperForServerSds.getListenerWatcher();
-
-    SimpleServiceGrpc.SimpleServiceBlockingStub blockingStub = newApi
-        ? getBlockingStubNewApi(upstreamTlsContext, "foo.test.google.fr") :
-        getBlockingStub(upstreamTlsContext, "foo.test.google.fr");
-    assertThat(unaryRpc("buddy", blockingStub)).isEqualTo("Hello buddy");
-    return listenerWatcher;
-  }
-
-  private void buildServerWithTlsContext(DownstreamTlsContext downstreamTlsContext)
-      throws IOException {
-    buildServerWithTlsContext(downstreamTlsContext, InsecureServerCredentials.create());
-  }
-
-  private void buildServerWithTlsContext(
-      DownstreamTlsContext downstreamTlsContext, ServerCredentials fallbackCredentials)
-      throws IOException {
-    XdsClient mockXdsClient = mock(XdsClient.class);
-    XdsClientWrapperForServerSds xdsClientWrapperForServerSds =
-        new XdsClientWrapperForServerSds(port);
-    xdsClientWrapperForServerSds.start(mockXdsClient);
-    buildServerWithFallbackServerCredentials(
-        xdsClientWrapperForServerSds, fallbackCredentials, downstreamTlsContext);
-  }
-
-  private void buildServerWithFallbackServerCredentials(
-      XdsClientWrapperForServerSds xdsClientWrapperForServerSds,
-      ServerCredentials fallbackCredentials,
-      DownstreamTlsContext downstreamTlsContext)
-      throws IOException {
-    ServerCredentials xdsCredentials = XdsServerCredentials.create(fallbackCredentials);
-    buildServer(port, xdsCredentials, xdsClientWrapperForServerSds, downstreamTlsContext);
-  }
-
-  /** Creates XdsClientWrapperForServerSds. */
-  private static XdsClientWrapperForServerSds createXdsClientWrapperForServerSds(int port) {
-    XdsClient mockXdsClient = mock(XdsClient.class);
-    XdsClientWrapperForServerSds xdsClientWrapperForServerSds =
-        new XdsClientWrapperForServerSds(port);
-    xdsClientWrapperForServerSds.start(mockXdsClient);
-    return xdsClientWrapperForServerSds;
-  }
-
-  static void generateListenerUpdateToWatcher(
-      DownstreamTlsContext tlsContext, XdsClient.ListenerWatcher registeredWatcher) {
-    EnvoyServerProtoData.Listener listener = buildListener("listener1", "0.0.0.0", tlsContext);
-    XdsClient.ListenerUpdate listenerUpdate =
-        XdsClient.ListenerUpdate.newBuilder().setListener(listener).build();
-    registeredWatcher.onListenerChanged(listenerUpdate);
-  }
-
-  private void buildServer(
-      int port,
-      ServerCredentials serverCredentials,
-      XdsClientWrapperForServerSds xdsClientWrapperForServerSds,
-      DownstreamTlsContext downstreamTlsContext)
-      throws IOException {
-    XdsServerBuilder builder = XdsServerBuilder.forPort(port, serverCredentials)
-        .addService(new SimpleServiceImpl());
-    XdsServerTestHelper.generateListenerUpdate(
-        xdsClientWrapperForServerSds.getListenerWatcher(), downstreamTlsContext);
-    cleanupRule.register(builder.buildServer(xdsClientWrapperForServerSds)).start();
-  }
-
-  static EnvoyServerProtoData.Listener buildListener(
-      String name, String address, DownstreamTlsContext tlsContext) {
-    EnvoyServerProtoData.FilterChainMatch filterChainMatch =
-        new EnvoyServerProtoData.FilterChainMatch(
-            0,
-            Arrays.<EnvoyServerProtoData.CidrRange>asList(),
-            Arrays.<String>asList(),
-            Arrays.<EnvoyServerProtoData.CidrRange>asList(),
-            null,
-            Arrays.<Integer>asList());
-    EnvoyServerProtoData.FilterChain defaultFilterChain =
-        new EnvoyServerProtoData.FilterChain(filterChainMatch, tlsContext);
-    EnvoyServerProtoData.Listener listener =
-        new EnvoyServerProtoData.Listener(name, address, Arrays.asList(defaultFilterChain), null);
-    return listener;
-  }
-
-  private SimpleServiceGrpc.SimpleServiceBlockingStub getBlockingStub(
-      final UpstreamTlsContext upstreamTlsContext, String overrideAuthority)
-      throws URISyntaxException {
-    URI expectedUri = new URI("sdstest://localhost:" + port);
-    fakeNameResolverFactory = new FakeNameResolverFactory.Builder(expectedUri).build();
-    NameResolverRegistry.getDefaultRegistry().register(fakeNameResolverFactory);
-    XdsChannelBuilder channelBuilder =
-        XdsChannelBuilder.forTarget("sdstest://localhost:" + port)
-            .fallbackProtocolNegotiator(InternalProtocolNegotiators.plaintext());
-    if (overrideAuthority != null) {
-      channelBuilder = channelBuilder.overrideAuthority(overrideAuthority);
-    }
-    InetSocketAddress socketAddress =
-        new InetSocketAddress(Inet4Address.getLoopbackAddress(), port);
-    Attributes attrs =
-        (upstreamTlsContext != null)
-            ? Attributes.newBuilder()
-                .set(InternalXdsAttributes.ATTR_SSL_CONTEXT_PROVIDER_SUPPLIER,
-                    new SslContextProviderSupplier(
-                        upstreamTlsContext, new TlsContextManagerImpl(mockBootstrapper)))
-                .build()
-            : Attributes.EMPTY;
-    fakeNameResolverFactory.setServers(
-        ImmutableList.of(new EquivalentAddressGroup(socketAddress, attrs)));
-    return SimpleServiceGrpc.newBlockingStub(cleanupRule.register(channelBuilder.build()));
-  }
-
-  private SimpleServiceGrpc.SimpleServiceBlockingStub getBlockingStubNewApi(
-          final UpstreamTlsContext upstreamTlsContext, String overrideAuthority)
-          throws URISyntaxException {
-    URI expectedUri = new URI("sdstest://localhost:" + port);
-    fakeNameResolverFactory = new FakeNameResolverFactory.Builder(expectedUri).build();
-    NameResolverRegistry.getDefaultRegistry().register(fakeNameResolverFactory);
-    ManagedChannelBuilder<?> channelBuilder =
-        Grpc.newChannelBuilder(
-            "sdstest://localhost:" + port,
-            XdsChannelCredentials.create(InsecureChannelCredentials.create()));
-
-    if (overrideAuthority != null) {
-      channelBuilder = channelBuilder.overrideAuthority(overrideAuthority);
-    }
-    InetSocketAddress socketAddress =
-        new InetSocketAddress(Inet4Address.getLoopbackAddress(), port);
-    Attributes attrs =
-        (upstreamTlsContext != null)
-            ? Attributes.newBuilder()
-                .set(InternalXdsAttributes.ATTR_SSL_CONTEXT_PROVIDER_SUPPLIER,
-                    new SslContextProviderSupplier(
-                        upstreamTlsContext, new TlsContextManagerImpl(mockBootstrapper)))
-                .build()
-            : Attributes.EMPTY;
-    fakeNameResolverFactory.setServers(
-        ImmutableList.of(new EquivalentAddressGroup(socketAddress, attrs)));
-    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 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 "sdstest";
-    }
-
-    @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().setAddresses(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/XdsSecurityClientServerTest.java b/xds/src/test/java/io/grpc/xds/XdsSecurityClientServerTest.java
new file mode 100644
index 00000000000..6b39106f18c
--- /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 {
+    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();
+    }
+  }
+
+  @Test
+  public void tlsClientServer_autoSniValidation_sniFromHostname()
+      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,
+              // 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();
+    }
+  }
+
+  @Test
+  public void tlsClientServer_autoSniValidation_noSniApplicable_usesMatcherFromCmnVdnCtx()
+      throws Exception {
+    Path trustStoreFilePath = getCacertFilePathForTestCa();
+    boolean originalUseChannelAuthorityIfNoSniApplicable =
+            CertificateUtils.useChannelAuthorityIfNoSniApplicable;
+    try {
+      CertificateUtils.useChannelAuthorityIfNoSniApplicable =
+              true;
+      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 {
+      CertificateUtils.useChannelAuthorityIfNoSniApplicable =
+              originalUseChannelAuthorityIfNoSniApplicable;
+      Files.deleteIfExists(trustStoreFilePath);
+      clearTrustStoreSystemProperties();
+    }
+  }
+
+  /**
+   * 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
index e9f3beedeca..ac990226259 100644
--- a/xds/src/test/java/io/grpc/xds/XdsServerBuilderTest.java
+++ b/xds/src/test/java/io/grpc/xds/XdsServerBuilderTest.java
@@ -17,6 +17,7 @@
 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;
@@ -24,31 +25,39 @@
 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.internal.sds.CommonTlsContextTestsUtil;
-import io.grpc.xds.internal.sds.ServerWrapperForXds;
+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}.
  */
@@ -56,31 +65,30 @@
 public class XdsServerBuilderTest {
 
   @Rule public final GrpcCleanupRule cleanupRule = new GrpcCleanupRule();
-  private XdsClient mockXdsClient;
-  private ServerWrapperForXds xdsServer;
-  private XdsClient.ListenerWatcher listenerWatcher;
+  private XdsServerBuilder builder;
+  private XdsServerWrapper xdsServer;
   private int port;
-  private XdsClientWrapperForServerSds xdsClientWrapperForServerSds;
+  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 XdsServerBuilder buildServer(
-      XdsServerBuilder.XdsServingStatusListener xdsServingStatusListener,
-      boolean injectMockXdsClient)
+  private void buildBuilder(XdsServerBuilder.XdsServingStatusListener xdsServingStatusListener)
       throws IOException {
-    port = XdsServerTestHelper.findFreePort();
-    XdsServerBuilder builder =
+    builder =
         XdsServerBuilder.forPort(
             port, XdsServerCredentials.create(InsecureServerCredentials.create()));
+    builder.xdsClientPoolFactory(xdsClientPoolFactory);
+    builder.overrideBootstrapForTest(XdsServerTestHelper.RAW_BOOTSTRAP);
     if (xdsServingStatusListener != null) {
-      builder = builder.xdsServingStatusListener(xdsServingStatusListener);
+      builder.xdsServingStatusListener(xdsServingStatusListener);
     }
-    xdsClientWrapperForServerSds = new XdsClientWrapperForServerSds(port);
-    if (injectMockXdsClient) {
-      mockXdsClient = mock(XdsClient.class);
-      listenerWatcher =
-          XdsServerTestHelper.startAndGetWatcher(xdsClientWrapperForServerSds, mockXdsClient, port);
-    }
-    xdsServer = cleanupRule.register(builder.buildServer(xdsClientWrapperForServerSds));
-    return builder;
+    tlsContextManager = mock(TlsContextManager.class);
   }
 
   private void verifyServer(
@@ -96,10 +104,10 @@ private void verifyServer(
     assertThat(list).hasSize(1);
     InetSocketAddress socketAddress = (InetSocketAddress) list.get(0);
     assertThat(socketAddress.getAddress().isAnyLocalAddress()).isTrue();
-    assertThat(socketAddress.getPort()).isEqualTo(port);
+    assertThat(socketAddress.getPort()).isGreaterThan(-1);
     if (mockXdsServingStatusListener != null) {
       if (notServingStatus != null) {
-        ArgumentCaptor<Throwable> argCaptor = ArgumentCaptor.forClass(null);
+        ArgumentCaptor<Throwable> argCaptor = ArgumentCaptor.forClass(Throwable.class);
         verify(mockXdsServingStatusListener, times(1)).onNotServing(argCaptor.capture());
         Throwable throwable = argCaptor.getValue();
         assertThat(throwable).isInstanceOf(StatusException.class);
@@ -114,10 +122,11 @@ private void verifyServer(
   private void verifyShutdown() throws InterruptedException {
     xdsServer.shutdown();
     xdsServer.awaitTermination(500L, TimeUnit.MILLISECONDS);
-    verify(mockXdsClient, times(1)).shutdown();
+    assertThat(xdsClient.isShutDown()).isTrue();
   }
 
-  private Future<Throwable> startServerAsync() throws InterruptedException {
+  private Future<Throwable> startServerAsync() throws
+          InterruptedException, TimeoutException, ExecutionException {
     final SettableFuture<Throwable> settableFuture = SettableFuture.create();
     Executors.newSingleThreadExecutor().execute(new Runnable() {
       @Override
@@ -130,9 +139,17 @@ public void run() {
         }
       }
     });
-    // wait until xdsClientWrapperForServerSds.serverWatchers populated
-    for (int i = 0; i < 10 && xdsClientWrapperForServerSds.serverWatchers.isEmpty(); i++) {
-      Thread.sleep(100L);
+    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;
   }
@@ -140,33 +157,32 @@ public void run() {
   @Test
   public void xdsServerStartAndShutdown()
       throws IOException, InterruptedException, TimeoutException, ExecutionException {
-    buildServer(null, true);
+    buildServer(null);
     Future<Throwable> future = startServerAsync();
     XdsServerTestHelper.generateListenerUpdate(
-        listenerWatcher,
-        CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT1", "VA1")
-    );
+        xdsClient,
+        CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT1", "VA1"),
+        tlsContextManager);
     verifyServer(future, null, null);
     verifyShutdown();
   }
 
   @Test
-  public void xdsServerStartAfterListenerUpdate()
+  public void xdsServerRestartAfterListenerUpdate()
           throws IOException, InterruptedException, TimeoutException, ExecutionException {
-    buildServer(null, true);
+    buildServer(null);
+    Future<Throwable> future = startServerAsync();
     XdsServerTestHelper.generateListenerUpdate(
-            listenerWatcher,
-            CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT1", "VA1")
-    );
-    xdsServer.start();
+            xdsClient,
+            CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT1", "VA1"),
+            tlsContextManager);
     try {
       xdsServer.start();
       fail("expected exception");
     } catch (IllegalStateException expected) {
       assertThat(expected).hasMessageThat().contains("Already started");
     }
-    verifyServer(null,null, null);
-    verifyShutdown();
+    verifyServer(future,null, null);
   }
 
   @Test
@@ -174,50 +190,41 @@ public void xdsServerStartAndShutdownWithXdsServingStatusListener()
       throws IOException, InterruptedException, TimeoutException, ExecutionException {
     XdsServerBuilder.XdsServingStatusListener mockXdsServingStatusListener =
         mock(XdsServerBuilder.XdsServingStatusListener.class);
-    buildServer(mockXdsServingStatusListener, true);
+    buildServer(mockXdsServingStatusListener);
     Future<Throwable> future = startServerAsync();
     XdsServerTestHelper.generateListenerUpdate(
-        listenerWatcher,
-        CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT1", "VA1")
-    );
+        xdsClient,
+        CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT1", "VA1"),
+            tlsContextManager);
     verifyServer(future, mockXdsServingStatusListener, null);
-    verifyShutdown();
   }
 
   @Test
-  public void xdsServer_serverWatcher()
-      throws IOException, InterruptedException, TimeoutException, ExecutionException {
+  public void xdsServer_discoverState() throws Exception {
     XdsServerBuilder.XdsServingStatusListener mockXdsServingStatusListener =
         mock(XdsServerBuilder.XdsServingStatusListener.class);
-    buildServer(mockXdsServingStatusListener, true);
+    buildServer(mockXdsServingStatusListener);
     Future<Throwable> future = startServerAsync();
-    listenerWatcher.onError(Status.ABORTED);
-    ArgumentCaptor<Throwable> argCaptor = ArgumentCaptor.forClass(null);
-    verify(mockXdsServingStatusListener).onNotServing(argCaptor.capture());
-    Throwable throwable = argCaptor.getValue();
-    assertThat(throwable).isInstanceOf(StatusException.class);
-    Status captured = ((StatusException) throwable).getStatus();
-    assertThat(captured.getCode()).isEqualTo(Status.Code.ABORTED);
-    assertThat(xdsClientWrapperForServerSds.serverWatchers).hasSize(1);
-    assertThat(future.isDone()).isFalse();
+    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);
-    listenerWatcher.onResourceDoesNotExist("not found error");
-    argCaptor = ArgumentCaptor.forClass(null);
-    verify(mockXdsServingStatusListener).onNotServing(argCaptor.capture());
-    throwable = argCaptor.getValue();
-    assertThat(throwable).isInstanceOf(StatusException.class);
-    captured = ((StatusException) throwable).getStatus();
-    assertThat(captured.getCode()).isEqualTo(Status.Code.NOT_FOUND);
-    assertThat(captured.getDescription()).isEqualTo("not found error");
-    assertThat(xdsClientWrapperForServerSds.serverWatchers).hasSize(1);
-    assertThat(future.isDone()).isFalse();
+    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(
-        listenerWatcher,
-        CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT1", "VA1")
-    );
-    verifyServer(future, mockXdsServingStatusListener, null);
-    verifyShutdown();
+        xdsClient,
+        CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT1", "VA1"),
+            tlsContextManager);
+    verifyServer(null, mockXdsServingStatusListener, null);
   }
 
   @Test
@@ -225,14 +232,18 @@ public void xdsServer_startError()
       throws IOException, InterruptedException, TimeoutException, ExecutionException {
     XdsServerBuilder.XdsServingStatusListener mockXdsServingStatusListener =
         mock(XdsServerBuilder.XdsServingStatusListener.class);
-    buildServer(mockXdsServingStatusListener, true);
+    ServerSocket serverSocket = new ServerSocket(0);
+    port = serverSocket.getLocalPort();
+    buildServer(mockXdsServingStatusListener);
     Future<Throwable> future = startServerAsync();
     // create port conflict for start to fail
-    ServerSocket serverSocket = new ServerSocket(port);
-    XdsServerTestHelper.generateListenerUpdate(
-        listenerWatcher,
-        CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT1", "VA1")
-    );
+    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");
@@ -240,48 +251,32 @@ public void xdsServer_startError()
     serverSocket.close();
   }
 
-  @Test
-  public void xdsServerWithoutMockXdsClient_startError()
-      throws IOException, InterruptedException, TimeoutException, ExecutionException {
-    XdsServerBuilder.XdsServingStatusListener mockXdsServingStatusListener =
-        mock(XdsServerBuilder.XdsServingStatusListener.class);
-    buildServer(mockXdsServingStatusListener, false);
-    try {
-      xdsServer.start();
-      fail("exception expected");
-    } catch (IOException expected) {
-      assertThat(expected).hasMessageThat().contains("Cannot find bootstrap configuration");
-    }
-    verify(mockXdsServingStatusListener, never()).onNotServing(any(Throwable.class));
-  }
-
   @Test
   public void xdsServerStartSecondUpdateAndError()
       throws IOException, InterruptedException, TimeoutException, ExecutionException {
     XdsServerBuilder.XdsServingStatusListener mockXdsServingStatusListener =
         mock(XdsServerBuilder.XdsServingStatusListener.class);
-    buildServer(mockXdsServingStatusListener, true);
+    buildServer(mockXdsServingStatusListener);
     Future<Throwable> future = startServerAsync();
     XdsServerTestHelper.generateListenerUpdate(
-        listenerWatcher,
-        CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT1", "VA1")
-    );
+        xdsClient,
+        CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT1", "VA1"),
+            tlsContextManager);
     XdsServerTestHelper.generateListenerUpdate(
-        listenerWatcher,
-        CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT1", "VA1")
-    );
+        xdsClient,
+        CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT1", "VA1"),
+            tlsContextManager);
     verify(mockXdsServingStatusListener, never()).onNotServing(any(Throwable.class));
     verifyServer(future, mockXdsServingStatusListener, null);
-    listenerWatcher.onError(Status.ABORTED);
-    verifyServer(null, mockXdsServingStatusListener, Status.ABORTED);
-    verifyShutdown();
+    xdsClient.ldsWatcher.onAmbientError(Status.ABORTED);
+    verifyServer(null, mockXdsServingStatusListener, null);
   }
 
   @Test
   public void xdsServer_2ndBuild_expectException() throws IOException {
     XdsServerBuilder.XdsServingStatusListener mockXdsServingStatusListener =
         mock(XdsServerBuilder.XdsServingStatusListener.class);
-    XdsServerBuilder builder = buildServer(mockXdsServingStatusListener, true);
+    buildServer(mockXdsServingStatusListener);
     try {
       builder.build();
       fail("exception expected");
@@ -289,4 +284,45 @@ public void xdsServer_2ndBuild_expectException() throws IOException {
       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
index 972340ecfcb..386793299d8 100644
--- a/xds/src/test/java/io/grpc/xds/XdsServerTestHelper.java
+++ b/xds/src/test/java/io/grpc/xds/XdsServerTestHelper.java
@@ -16,70 +16,332 @@
 
 package io.grpc.xds;
 
-import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.Mockito.verify;
+import static com.google.common.truth.Truth.assertThat;
 
-import java.io.IOException;
-import java.net.ServerSocket;
+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 org.mockito.ArgumentCaptor;
+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.
  */
-class XdsServerTestHelper {
-
-  static XdsClient.ListenerWatcher startAndGetWatcher(
-      XdsClientWrapperForServerSds xdsClientWrapperForServerSds,
-      XdsClient mockXdsClient,
-      int port) {
-    xdsClientWrapperForServerSds.start(mockXdsClient);
-    ArgumentCaptor<XdsClient.ListenerWatcher> listenerWatcherCaptor = ArgumentCaptor.forClass(null);
-    verify(mockXdsClient).watchListenerData(eq(port), listenerWatcherCaptor.capture());
-    return listenerWatcherCaptor.getValue();
-  }
+public class XdsServerTestHelper {
 
-  /**
-   * Creates a {@link XdsClient.ListenerUpdate} with {@link
-   * io.grpc.xds.EnvoyServerProtoData.FilterChain} with a destination port and an optional {@link
-   * EnvoyServerProtoData.DownstreamTlsContext}.
-   *
-   * @param registeredWatcher the watcher on which to generate the update
-   * @param tlsContext if non-null, used to populate filterChain
-   */
-  static void generateListenerUpdate(
-      XdsClient.ListenerWatcher registeredWatcher,
-      EnvoyServerProtoData.DownstreamTlsContext tlsContext) {
-    EnvoyServerProtoData.Listener listener = buildTestListener("listener1", "10.1.2.3", tlsContext);
-    XdsClient.ListenerUpdate listenerUpdate =
-        XdsClient.ListenerUpdate.newBuilder().setListener(listener).build();
-    registeredWatcher.onListenerChanged(listenerUpdate);
+  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 int findFreePort() throws IOException {
-    try (ServerSocket socket = new ServerSocket(0)) {
-      socket.setReuseAddress(true);
-      return socket.getLocalPort();
-    }
+  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, EnvoyServerProtoData.DownstreamTlsContext tlsContext) {
+      String name, String address, ImmutableList<Integer> sourcePorts,
+      EnvoyServerProtoData.DownstreamTlsContext tlsContext,
+      EnvoyServerProtoData.DownstreamTlsContext tlsContextForDefaultFilterChain,
+      TlsContextManager tlsContextManager) {
     EnvoyServerProtoData.FilterChainMatch filterChainMatch1 =
-        new EnvoyServerProtoData.FilterChainMatch(
+        EnvoyServerProtoData.FilterChainMatch.create(
+            0,
+            ImmutableList.of(),
+            ImmutableList.of(),
+            ImmutableList.of(),
+            ConnectionSourceType.ANY,
+            sourcePorts,
+            ImmutableList.of(),
+            "");
+    EnvoyServerProtoData.FilterChainMatch defaultFilterChainMatch =
+        EnvoyServerProtoData.FilterChainMatch.create(
             0,
-            Arrays.<EnvoyServerProtoData.CidrRange>asList(),
-            Arrays.<String>asList(),
-            Arrays.<EnvoyServerProtoData.CidrRange>asList(),
-            null,
-            Arrays.<Integer>asList());
-    EnvoyServerProtoData.FilterChain filterChain1 =
-        new EnvoyServerProtoData.FilterChain(filterChainMatch1, tlsContext);
-    EnvoyServerProtoData.FilterChain defaultFilterChain =
-        new EnvoyServerProtoData.FilterChain(null, null);
+            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 =
-        new EnvoyServerProtoData.Listener(
-            name, address, Arrays.asList(filterChain1), defaultFilterChain);
+        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..93113411b5e
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/XdsTestUtils.java
@@ -0,0 +1,442 @@
+/*
+ * 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);
+  static final Bootstrapper.BootstrapInfo EMPTY_BOOTSTRAP =
+      Bootstrapper.BootstrapInfo.builder()
+          .servers(com.google.common.collect.ImmutableList.of(EMPTY_BOOTSTRAPPER_SERVER_INFO))
+          .node(io.grpc.xds.client.EnvoyProtoData.Node.newBuilder().setId("node-id").build())
+          .build();
+  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", EMPTY_BOOTSTRAP, 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/ControlPlaneClientTest.java b/xds/src/test/java/io/grpc/xds/client/ControlPlaneClientTest.java
new file mode 100644
index 00000000000..64786c4fb3b
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/client/ControlPlaneClientTest.java
@@ -0,0 +1,279 @@
+/*
+ * 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.xds.client;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.argThat;
+import static org.mockito.Mockito.atLeastOnce;
+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.base.Stopwatch;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import io.envoyproxy.envoy.service.discovery.v3.DiscoveryRequest;
+import io.envoyproxy.envoy.service.discovery.v3.DiscoveryResponse;
+import io.grpc.InsecureChannelCredentials;
+import io.grpc.MethodDescriptor;
+import io.grpc.SynchronizationContext;
+import io.grpc.internal.BackoffPolicy;
+import io.grpc.internal.FakeClock;
+import io.grpc.xds.client.Bootstrapper.ServerInfo;
+import io.grpc.xds.client.EnvoyProtoData.Node;
+import io.grpc.xds.client.XdsClient.ResourceStore;
+import io.grpc.xds.client.XdsClient.XdsResponseHandler;
+import io.grpc.xds.client.XdsTransportFactory.EventHandler;
+import io.grpc.xds.client.XdsTransportFactory.StreamingCall;
+import io.grpc.xds.client.XdsTransportFactory.XdsTransport;
+import java.util.Collections;
+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.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+/** Unit tests for {@link ControlPlaneClient}. */
+@RunWith(JUnit4.class)
+public class ControlPlaneClientTest {
+
+  private static final String CDS_TYPE_URL = "type.googleapis.com/envoy.config.cluster.v3.Cluster";
+  private static final String EDS_TYPE_URL =
+      "type.googleapis.com/envoy.config.endpoint.v3.ClusterLoadAssignment";
+
+  private final SynchronizationContext syncContext =
+      new SynchronizationContext((t, e) -> {
+        throw new AssertionError("Uncaught exception in sync context", e);
+      });
+  private final FakeClock fakeClock = new FakeClock();
+  private final ServerInfo serverInfo =
+      ServerInfo.create("eds-control-plane:8443", InsecureChannelCredentials.create());
+  private final Node bootstrapNode = Node.newBuilder().setId("test-node").build();
+
+  @Mock private XdsTransport xdsTransport;
+  @Mock private StreamingCall<DiscoveryRequest, DiscoveryResponse> streamingCall;
+  @Mock private XdsResponseHandler responseHandler;
+  @Mock private ResourceStore resourceStore;
+  @Mock private BackoffPolicy.Provider backoffPolicyProvider;
+  @Mock private MessagePrettyPrinter messagePrinter;
+  @Mock private XdsResourceType<?> cdsType;
+  @Mock private XdsResourceType<?> edsType;
+
+  @Rule public final MockitoRule mocks = MockitoJUnit.rule();
+
+  private ControlPlaneClient cpc;
+  private ArgumentCaptor<EventHandler<DiscoveryResponse>> handlerCaptor;
+
+  @Before
+  @SuppressWarnings("unchecked")
+  public void setUp() {
+    when(cdsType.typeUrl()).thenReturn(CDS_TYPE_URL);
+    when(cdsType.typeName()).thenReturn("CDS");
+    when(edsType.typeUrl()).thenReturn(EDS_TYPE_URL);
+    when(edsType.typeName()).thenReturn("EDS");
+
+    when(xdsTransport.<DiscoveryRequest, DiscoveryResponse>createStreamingCall(
+            anyString(),
+            any(MethodDescriptor.Marshaller.class),
+            any(MethodDescriptor.Marshaller.class)))
+        .thenReturn(streamingCall);
+    when(streamingCall.isReady()).thenReturn(true);
+
+    handlerCaptor = ArgumentCaptor.forClass(EventHandler.class);
+
+    cpc = new ControlPlaneClient(
+        xdsTransport,
+        serverInfo,
+        bootstrapNode,
+        responseHandler,
+        resourceStore,
+        fakeClock.getScheduledExecutorService(),
+        syncContext,
+        backoffPolicyProvider,
+        () -> Stopwatch.createUnstarted(fakeClock.getTicker()),
+        messagePrinter);
+  }
+
+  /**
+   * Reproduces the bug where, when an ADS stream is opened to an authority-specific server (e.g.
+   * an EDS-only control plane), {@code sendDiscoveryRequests} previously emitted an empty
+   * DiscoveryRequest for every globally-subscribed resource type — including types this server
+   * does not handle. Authority-specific servers may reject those requests with UNIMPLEMENTED and
+   * tear down the stream, blocking the legitimate request that follows.
+   *
+   * <p>Asserts that the empty CDS request is suppressed and only the EDS request (which has
+   * resources for this server) goes on the wire.
+   */
+  @Test
+  public void streamReady_skipsEmptyDiscoveryRequestForUnsubscribedType() {
+    // CDS is globally subscribed (e.g. against a different authority) but has no resources on
+    // this server. EDS has one resource on this server.
+    Map<String, XdsResourceType<?>> subscribedTypes =
+        ImmutableMap.of(CDS_TYPE_URL, cdsType, EDS_TYPE_URL, edsType);
+    when(resourceStore.getSubscribedResourceTypesWithTypeUrl()).thenReturn(subscribedTypes);
+    when(resourceStore.getSubscribedResources(serverInfo, cdsType)).thenReturn(null);
+    when(resourceStore.getSubscribedResources(serverInfo, edsType))
+        .thenReturn(ImmutableList.of("foo-endpoint"));
+
+    // Triggers stream creation and registers the EventHandler.
+    syncContext.execute(cpc::sendDiscoveryRequests);
+    verify(streamingCall).start(handlerCaptor.capture());
+
+    // Drive the stream into the connected state. onReady() flips sentInitialRequest=true and
+    // re-invokes sendDiscoveryRequests, which iterates the globally-subscribed types.
+    handlerCaptor.getValue().onReady();
+
+    // EDS request was sent with the one resource for this server.
+    ArgumentCaptor<DiscoveryRequest> sent = ArgumentCaptor.forClass(DiscoveryRequest.class);
+    verify(streamingCall, atLeastOnce()).sendMessage(sent.capture());
+    ImmutableSet<String> sentTypes = sent.getAllValues().stream()
+        .map(DiscoveryRequest::getTypeUrl)
+        .collect(ImmutableSet.toImmutableSet());
+    assertThat(sentTypes).contains(EDS_TYPE_URL);
+    assertThat(sentTypes).doesNotContain(CDS_TYPE_URL);
+
+    // Confirm the EDS request actually carried the resource name.
+    DiscoveryRequest edsReq = sent.getAllValues().stream()
+        .filter(r -> r.getTypeUrl().equals(EDS_TYPE_URL))
+        .findFirst()
+        .orElseThrow(() -> new AssertionError("EDS request not sent"));
+    assertThat(edsReq.getResourceNamesList()).containsExactly("foo-endpoint");
+  }
+
+  /**
+   * If a server has resources for every globally-subscribed type, the empty-skip guard is a
+   * no-op: a DiscoveryRequest is sent for every type. This guards against the skip becoming
+   * over-eager and dropping legitimate subscriptions.
+   */
+  @Test
+  public void streamReady_sendsRequestForAllTypesWhenAllHaveResources() {
+    Map<String, XdsResourceType<?>> subscribedTypes =
+        ImmutableMap.of(CDS_TYPE_URL, cdsType, EDS_TYPE_URL, edsType);
+    when(resourceStore.getSubscribedResourceTypesWithTypeUrl()).thenReturn(subscribedTypes);
+    when(resourceStore.getSubscribedResources(serverInfo, cdsType))
+        .thenReturn(ImmutableList.of("foo-cluster"));
+    when(resourceStore.getSubscribedResources(serverInfo, edsType))
+        .thenReturn(ImmutableList.of("foo-endpoint"));
+
+    syncContext.execute(cpc::sendDiscoveryRequests);
+    verify(streamingCall).start(handlerCaptor.capture());
+    handlerCaptor.getValue().onReady();
+
+    ArgumentCaptor<DiscoveryRequest> sent = ArgumentCaptor.forClass(DiscoveryRequest.class);
+    verify(streamingCall, times(2)).sendMessage(sent.capture());
+    ImmutableSet<String> sentTypes = sent.getAllValues().stream()
+        .map(DiscoveryRequest::getTypeUrl)
+        .collect(ImmutableSet.toImmutableSet());
+    assertThat(sentTypes).containsExactly(CDS_TYPE_URL, EDS_TYPE_URL);
+  }
+
+  /**
+   * If only one type has a subscription on this server, no request is sent for the unsubscribed
+   * type. This is the canonical multi-authority federation case (e.g. fabric authority owns CDS,
+   * eds-control-plane owns EDS — the eds-control-plane stream should only see EDS).
+   */
+  @Test
+  public void streamReady_skipsTypeWithNoSubscription() {
+    Map<String, XdsResourceType<?>> subscribedTypes =
+        ImmutableMap.of(CDS_TYPE_URL, cdsType, EDS_TYPE_URL, edsType);
+    when(resourceStore.getSubscribedResourceTypesWithTypeUrl()).thenReturn(subscribedTypes);
+    when(resourceStore.getSubscribedResources(serverInfo, cdsType)).thenReturn(null);
+    when(resourceStore.getSubscribedResources(serverInfo, edsType))
+        .thenReturn(ImmutableList.of("foo-endpoint"));
+
+    syncContext.execute(cpc::sendDiscoveryRequests);
+    verify(streamingCall).start(handlerCaptor.capture());
+    handlerCaptor.getValue().onReady();
+
+    verify(streamingCall, never()).sendMessage(
+        argThatTypeUrlIs(CDS_TYPE_URL));
+    verify(streamingCall).sendMessage(argThatTypeUrlIs(EDS_TYPE_URL));
+  }
+
+  /**
+   * Per the ResourceStore contract in XdsClient.java, an empty collection from
+   * getSubscribedResources indicates a wildcard subscription. The skip-on-empty guard must not
+   * suppress wildcard requests on initial stream ready — the server needs the empty-resource-list
+   * DiscoveryRequest to start streaming, and the watcher's missing-resource timers must start.
+   */
+  @Test
+  public void streamReady_sendsWildcardRequestAndStartsTimers() {
+    Map<String, XdsResourceType<?>> subscribedTypes = ImmutableMap.of(CDS_TYPE_URL, cdsType);
+    when(resourceStore.getSubscribedResourceTypesWithTypeUrl()).thenReturn(subscribedTypes);
+    // Empty collection == wildcard subscription per the ResourceStore contract.
+    when(resourceStore.getSubscribedResources(serverInfo, cdsType))
+        .thenReturn(Collections.emptyList());
+
+    syncContext.execute(cpc::sendDiscoveryRequests);
+    verify(streamingCall).start(handlerCaptor.capture());
+    handlerCaptor.getValue().onReady();
+
+    ArgumentCaptor<DiscoveryRequest> sent = ArgumentCaptor.forClass(DiscoveryRequest.class);
+    verify(streamingCall, atLeastOnce()).sendMessage(sent.capture());
+    DiscoveryRequest cdsReq = sent.getAllValues().stream()
+        .filter(r -> r.getTypeUrl().equals(CDS_TYPE_URL))
+        .findFirst()
+        .orElseThrow(() -> new AssertionError("CDS wildcard request not sent"));
+    assertThat(cdsReq.getResourceNamesList()).isEmpty();
+
+    verify(resourceStore).startMissingResourceTimers(Collections.emptyList(), cdsType);
+  }
+
+  /**
+   * If a watch is canceled after the initial DiscoveryRequest goes out but before any response
+   * is ACKed, the empty unsubscribe must still be sent — otherwise the server keeps the stale
+   * subscription until the stream resets. The skip guard must gate on per-stream send history,
+   * not on the {@code versions} map (which is only populated on ACK).
+   */
+  @Test
+  public void cancelBeforeAck_sendsEmptyUnsubscribe() {
+    Map<String, XdsResourceType<?>> subscribedTypes = ImmutableMap.of(CDS_TYPE_URL, cdsType);
+    when(resourceStore.getSubscribedResourceTypesWithTypeUrl()).thenReturn(subscribedTypes);
+    when(resourceStore.getSubscribedResources(serverInfo, cdsType))
+        .thenReturn(ImmutableList.of("foo-cluster"));
+
+    syncContext.execute(cpc::sendDiscoveryRequests);
+    verify(streamingCall).start(handlerCaptor.capture());
+    handlerCaptor.getValue().onReady();
+
+    // Initial DiscoveryRequest with the resource went out. No DiscoveryResponse has been ACKed.
+    verify(streamingCall).sendMessage(argThatTypeUrlIs(CDS_TYPE_URL));
+
+    // Cancel the watch before any response arrives: store now reports no subscription.
+    when(resourceStore.getSubscribedResources(serverInfo, cdsType)).thenReturn(null);
+    syncContext.execute(() -> cpc.adjustResourceSubscription(cdsType));
+
+    ArgumentCaptor<DiscoveryRequest> sent = ArgumentCaptor.forClass(DiscoveryRequest.class);
+    verify(streamingCall, times(2)).sendMessage(sent.capture());
+    DiscoveryRequest unsub = sent.getAllValues().get(1);
+    assertThat(unsub.getTypeUrl()).isEqualTo(CDS_TYPE_URL);
+    assertThat(unsub.getResourceNamesList()).isEmpty();
+  }
+
+  private static DiscoveryRequest argThatTypeUrlIs(String typeUrl) {
+    return argThat(req -> req != null && typeUrl.equals(req.getTypeUrl()));
+  }
+}
\ No newline at end of file
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/MatcherParserTest.java b/xds/src/test/java/io/grpc/xds/internal/MatcherParserTest.java
new file mode 100644
index 00000000000..86a6a95fd4b
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/internal/MatcherParserTest.java
@@ -0,0 +1,85 @@
+/*
+ * 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 static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertThrows;
+
+import io.envoyproxy.envoy.type.matcher.v3.RegexMatcher;
+import io.envoyproxy.envoy.type.matcher.v3.StringMatcher;
+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;
+
+@RunWith(JUnit4.class)
+public class MatcherParserTest {
+
+  @Test
+  public void parseStringMatcher_exact() {
+    StringMatcher proto =
+        StringMatcher.newBuilder().setExact("exact-match").setIgnoreCase(true).build();
+    Matchers.StringMatcher matcher = MatcherParser.parseStringMatcher(proto);
+    assertThat(matcher).isNotNull();
+  }
+
+  @Test
+  public void parseStringMatcher_allTypes() {
+    MatcherParser.parseStringMatcher(StringMatcher.newBuilder().setExact("test").build());
+    MatcherParser.parseStringMatcher(StringMatcher.newBuilder().setPrefix("test").build());
+    MatcherParser.parseStringMatcher(StringMatcher.newBuilder().setSuffix("test").build());
+    MatcherParser.parseStringMatcher(StringMatcher.newBuilder().setContains("test").build());
+    MatcherParser.parseStringMatcher(StringMatcher.newBuilder()
+        .setSafeRegex(RegexMatcher.newBuilder().setRegex(".*").build()).build());
+  }
+
+  @Test
+  public void parseStringMatcher_unknownTypeThrows() {
+    StringMatcher unknownProto = StringMatcher.getDefaultInstance();
+    IllegalArgumentException exception = assertThrows(IllegalArgumentException.class,
+        () -> MatcherParser.parseStringMatcher(unknownProto));
+    assertThat(exception).hasMessageThat().contains("Unknown StringMatcher match pattern");
+  }
+
+  @Test
+  public void parseFractionMatcher_denominators() {
+    Matchers.FractionMatcher hundred = MatcherParser.parseFractionMatcher(FractionalPercent
+        .newBuilder().setNumerator(1).setDenominator(DenominatorType.HUNDRED).build());
+    assertThat(hundred.numerator()).isEqualTo(1);
+    assertThat(hundred.denominator()).isEqualTo(100);
+
+    Matchers.FractionMatcher tenThousand = MatcherParser.parseFractionMatcher(FractionalPercent
+        .newBuilder().setNumerator(2).setDenominator(DenominatorType.TEN_THOUSAND).build());
+    assertThat(tenThousand.numerator()).isEqualTo(2);
+    assertThat(tenThousand.denominator()).isEqualTo(10_000);
+
+    Matchers.FractionMatcher million = MatcherParser.parseFractionMatcher(FractionalPercent
+        .newBuilder().setNumerator(3).setDenominator(DenominatorType.MILLION).build());
+    assertThat(million.numerator()).isEqualTo(3);
+    assertThat(million.denominator()).isEqualTo(1_000_000);
+  }
+
+  @Test
+  public void parseFractionMatcher_unknownDenominatorThrows() {
+    FractionalPercent unknownProto =
+        FractionalPercent.newBuilder().setDenominatorValue(999).build();
+    IllegalArgumentException exception = assertThrows(IllegalArgumentException.class,
+        () -> MatcherParser.parseFractionMatcher(unknownProto));
+    assertThat(exception).hasMessageThat().contains("Unknown denominator type");
+  }
+}
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/MetricReportUtilsTest.java b/xds/src/test/java/io/grpc/xds/internal/MetricReportUtilsTest.java
new file mode 100644
index 00000000000..9d7a3910216
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/internal/MetricReportUtilsTest.java
@@ -0,0 +1,115 @@
+/*
+ * 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.xds.internal;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import io.grpc.services.InternalCallMetricRecorder;
+import io.grpc.services.MetricReport;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.OptionalDouble;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Tests for {@link MetricReportUtils}. */
+@RunWith(JUnit4.class)
+public class MetricReportUtilsTest {
+
+  @Test
+  public void getMetricValue_cpuUtilization() {
+    MetricReport report = createMetricReport(0.5, 0.1, 0.2, 10.0, 5.0, Collections.emptyMap());
+    MetricReportUtils.ParsedMetricName parsed =
+        MetricReportUtils.ParsedMetricName.parse("cpu_utilization");
+    OptionalDouble result = MetricReportUtils.getMetricValue(report, parsed);
+    assertTrue(result.isPresent());
+    assertEquals(0.5, result.getAsDouble(), 0.0001);
+  }
+
+  @Test
+  public void getMetricValue_applicationUtilization() {
+    MetricReport report = createMetricReport(0.5, 0.1, 0.2, 10.0, 5.0, Collections.emptyMap());
+    MetricReportUtils.ParsedMetricName parsed =
+        MetricReportUtils.ParsedMetricName.parse("application_utilization");
+    OptionalDouble result = MetricReportUtils.getMetricValue(report, parsed);
+    assertTrue(result.isPresent());
+    assertEquals(0.1, result.getAsDouble(), 0.0001);
+  }
+
+  @Test
+  public void getMetricValue_memUtilization() {
+    MetricReport report = createMetricReport(0.5, 0.1, 0.2, 10.0, 5.0, Collections.emptyMap());
+    MetricReportUtils.ParsedMetricName parsed =
+        MetricReportUtils.ParsedMetricName.parse("mem_utilization");
+    OptionalDouble result = MetricReportUtils.getMetricValue(report, parsed);
+    assertTrue(result.isPresent());
+    assertEquals(0.2, result.getAsDouble(), 0.0001);
+  }
+
+  @Test
+  public void getMetricValue_utilizationMetric() {
+    Map<String, Double> utilizationMetrics = new HashMap<>();
+    utilizationMetrics.put("foo", 1.23);
+    MetricReport report = InternalCallMetricRecorder.createMetricReport(
+         0, 0, 0, 0, 0, Collections.emptyMap(), utilizationMetrics, Collections.emptyMap());
+
+    MetricReportUtils.ParsedMetricName parsed =
+        MetricReportUtils.ParsedMetricName.parse("utilization.foo");
+    OptionalDouble result = MetricReportUtils.getMetricValue(report, parsed);
+    assertTrue(result.isPresent());
+    assertEquals(1.23, result.getAsDouble(), 0.0001);
+
+    MetricReportUtils.ParsedMetricName bad =
+        MetricReportUtils.ParsedMetricName.parse("utilization.bar");
+    assertFalse(MetricReportUtils.getMetricValue(report, bad).isPresent());
+  }
+
+  @Test
+  public void getMetricValue_namedMetric() {
+    Map<String, Double> namedMetrics = new HashMap<>();
+    namedMetrics.put("foo", 7.89);
+    MetricReport report = createMetricReport(0, 0, 0, 0, 0, namedMetrics);
+
+    MetricReportUtils.ParsedMetricName parsed =
+        MetricReportUtils.ParsedMetricName.parse("named_metrics.foo");
+    OptionalDouble result = MetricReportUtils.getMetricValue(report, parsed);
+    assertTrue(result.isPresent());
+    assertEquals(7.89, result.getAsDouble(), 0.0001);
+
+    MetricReportUtils.ParsedMetricName bad =
+        MetricReportUtils.ParsedMetricName.parse("named_metrics.bar");
+    assertFalse(MetricReportUtils.getMetricValue(report, bad).isPresent());
+  }
+
+  @Test
+  public void getMetricValue_invalidMetric() {
+    MetricReport report = createMetricReport(0.5, 0.1, 0.2, 10.0, 5.0, Collections.emptyMap());
+    MetricReportUtils.ParsedMetricName invalid =
+        MetricReportUtils.ParsedMetricName.parse("invalid_metric");
+    assertFalse(MetricReportUtils.getMetricValue(report, invalid).isPresent());
+  }
+
+  private MetricReport createMetricReport(double cpu, double app, double mem, double qps,
+      double eps, Map<String, Double> namedMetrics) {
+    return InternalCallMetricRecorder.createMetricReport(
+        cpu, app, mem, qps, eps, Collections.emptyMap(), Collections.emptyMap(), namedMetrics);
+  }
+}
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/certprovider/CertProviderClientSslContextProviderTest.java b/xds/src/test/java/io/grpc/xds/internal/certprovider/CertProviderClientSslContextProviderTest.java
deleted file mode 100644
index 00b29014648..00000000000
--- a/xds/src/test/java/io/grpc/xds/internal/certprovider/CertProviderClientSslContextProviderTest.java
+++ /dev/null
@@ -1,295 +0,0 @@
-/*
- * 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.certprovider;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-import static com.google.common.truth.Truth.assertThat;
-import static io.grpc.xds.internal.certprovider.CommonCertProviderTestUtils.getCertFromResourceName;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.CA_PEM_FILE;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.CLIENT_KEY_FILE;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.CLIENT_PEM_FILE;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.SERVER_0_PEM_FILE;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.SERVER_1_KEY_FILE;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.SERVER_1_PEM_FILE;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.doChecksOnSslContext;
-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.Bootstrapper;
-import io.grpc.xds.CommonBootstrapperTestUtils;
-import io.grpc.xds.EnvoyServerProtoData;
-import io.grpc.xds.internal.sds.CommonTlsContextTestsUtil;
-import io.grpc.xds.internal.sds.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 CertProviderClientSslContextProvider.Factory certProviderClientSslContextProviderFactory;
-
-  @Before
-  public void setUp() throws Exception {
-    certificateProviderRegistry = new CertificateProviderRegistry();
-    certificateProviderStore = new CertificateProviderStore(certificateProviderRegistry);
-    certProviderClientSslContextProviderFactory =
-        new CertProviderClientSslContextProvider.Factory(certificateProviderStore);
-  }
-
-  /** Helper method to build CertProviderClientSslContextProvider. */
-  private CertProviderClientSslContextProvider getSslContextProvider(
-      String certInstanceName,
-      String rootInstanceName,
-      Bootstrapper.BootstrapInfo bootstrapInfo,
-      Iterable<String> alpnProtocols,
-      CertificateValidationContext staticCertValidationContext) {
-    EnvoyServerProtoData.UpstreamTlsContext upstreamTlsContext =
-        CommonTlsContextTestsUtil.buildUpstreamTlsContextForCertProviderInstance(
-            certInstanceName,
-            "cert-default",
-            rootInstanceName,
-            "root-default",
-            alpnProtocols,
-            staticCertValidationContext);
-    return certProviderClientSslContextProviderFactory.getProvider(
-        upstreamTlsContext,
-        bootstrapInfo.getNode().toEnvoyProtoNode(),
-        bootstrapInfo.getCertProviders());
-  }
-
-  @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);
-
-    assertThat(provider.savedKey).isNull();
-    assertThat(provider.savedCertChain).isNull();
-    assertThat(provider.savedTrustedRoots).isNull();
-    assertThat(provider.getSslContext()).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.getSslContext()).isNull();
-
-    // now generate root cert update
-    watcherCaptor[0].updateTrustedRoots(ImmutableList.of(getCertFromResourceName(CA_PEM_FILE)));
-    assertThat(provider.getSslContext()).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.getSslContext()).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);
-    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);
-
-    assertThat(provider.savedKey).isNull();
-    assertThat(provider.savedCertChain).isNull();
-    assertThat(provider.savedTrustedRoots).isNull();
-    assertThat(provider.getSslContext()).isNull();
-
-    // now generate root cert update
-    watcherCaptor[0].updateTrustedRoots(ImmutableList.of(getCertFromResourceName(CA_PEM_FILE)));
-    assertThat(provider.getSslContext()).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);
-
-    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_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);
-      fail("exception expected");
-    } catch (NullPointerException expected) {
-      assertThat(expected).hasMessageThat().contains("Client SSL requires rootCertInstance");
-    }
-  }
-
-  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/certprovider/CertProviderServerSslContextProviderTest.java b/xds/src/test/java/io/grpc/xds/internal/certprovider/CertProviderServerSslContextProviderTest.java
deleted file mode 100644
index ef801ccc2c1..00000000000
--- a/xds/src/test/java/io/grpc/xds/internal/certprovider/CertProviderServerSslContextProviderTest.java
+++ /dev/null
@@ -1,279 +0,0 @@
-/*
- * 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.certprovider;
-
-import static com.google.common.truth.Truth.assertThat;
-import static io.grpc.xds.internal.certprovider.CommonCertProviderTestUtils.getCertFromResourceName;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.CA_PEM_FILE;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.CLIENT_PEM_FILE;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.SERVER_0_KEY_FILE;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.SERVER_0_PEM_FILE;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.SERVER_1_KEY_FILE;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.SERVER_1_PEM_FILE;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.doChecksOnSslContext;
-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.grpc.xds.Bootstrapper;
-import io.grpc.xds.CommonBootstrapperTestUtils;
-import io.grpc.xds.EnvoyServerProtoData;
-import io.grpc.xds.internal.certprovider.CertProviderClientSslContextProviderTest.QueuedExecutor;
-import io.grpc.xds.internal.sds.CommonTlsContextTestsUtil;
-import io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.TestCallback;
-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 CertProviderServerSslContextProvider.Factory certProviderServerSslContextProviderFactory;
-
-  @Before
-  public void setUp() throws Exception {
-    certificateProviderRegistry = new CertificateProviderRegistry();
-    certificateProviderStore = new CertificateProviderStore(certificateProviderRegistry);
-    certProviderServerSslContextProviderFactory =
-        new CertProviderServerSslContextProvider.Factory(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 certProviderServerSslContextProviderFactory.getProvider(
-        downstreamTlsContext,
-        bootstrapInfo.getNode().toEnvoyProtoNode(),
-        bootstrapInfo.getCertProviders());
-  }
-
-  @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.getSslContext()).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.getSslContext()).isNull();
-
-    // now generate root cert update
-    watcherCaptor[0].updateTrustedRoots(ImmutableList.of(getCertFromResourceName(CA_PEM_FILE)));
-    assertThat(provider.getSslContext()).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.getSslContext()).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.getSslContext()).isNull();
-
-    // now generate cert update
-    watcherCaptor[0].updateCertificate(
-            CommonCertProviderTestUtils.getPrivateKey(SERVER_0_KEY_FILE),
-            ImmutableList.of(getCertFromResourceName(SERVER_0_PEM_FILE)));
-
-    assertThat(provider.getSslContext()).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/certprovider/CommonCertProviderTestUtils.java b/xds/src/test/java/io/grpc/xds/internal/certprovider/CommonCertProviderTestUtils.java
deleted file mode 100644
index 2933d630068..00000000000
--- a/xds/src/test/java/io/grpc/xds/internal/certprovider/CommonCertProviderTestUtils.java
+++ /dev/null
@@ -1,55 +0,0 @@
-/*
- * 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.certprovider;
-
-import static java.nio.charset.StandardCharsets.UTF_8;
-
-import com.google.common.io.CharStreams;
-import io.grpc.internal.testing.TestUtils;
-import io.grpc.xds.internal.sds.trust.CertificateUtils;
-import java.io.ByteArrayInputStream;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.InputStreamReader;
-import java.io.Reader;
-import java.security.PrivateKey;
-import java.security.cert.CertificateException;
-import java.security.cert.X509Certificate;
-
-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 {
-    return CertificateUtils.toX509Certificate(
-            new ByteArrayInputStream(getResourceContents(resourceName).getBytes(UTF_8)));
-  }
-
-  private static String getResourceContents(String resourceName) throws IOException {
-    InputStream inputStream = TestUtils.class.getResourceAsStream("/certs/" + resourceName);
-    String text = null;
-    try (Reader reader = new InputStreamReader(inputStream, UTF_8)) {
-      text = CharStreams.toString(reader);
-    }
-    return text;
-  }
-}
diff --git a/xds/src/test/java/io/grpc/xds/internal/certprovider/DynamicReloadingCertificateProviderProviderTest.java b/xds/src/test/java/io/grpc/xds/internal/certprovider/DynamicReloadingCertificateProviderProviderTest.java
deleted file mode 100644
index 2ee5fb39640..00000000000
--- a/xds/src/test/java/io/grpc/xds/internal/certprovider/DynamicReloadingCertificateProviderProviderTest.java
+++ /dev/null
@@ -1,219 +0,0 @@
-/*
- * 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.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 io.grpc.internal.JsonParser;
-import io.grpc.internal.TimeProvider;
-import java.io.IOException;
-import java.util.Map;
-import java.util.concurrent.ScheduledExecutorService;
-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 DynamicReloadingCertificateProviderProvider}. */
-@RunWith(JUnit4.class)
-public class DynamicReloadingCertificateProviderProviderTest {
-
-  @Mock DynamicReloadingCertificateProvider.Factory dynamicReloadingCertificateProviderFactory;
-  @Mock private DynamicReloadingCertificateProviderProvider.ScheduledExecutorServiceFactory
-      scheduledExecutorServiceFactory;
-  @Mock private TimeProvider timeProvider;
-
-  private DynamicReloadingCertificateProviderProvider provider;
-
-  @Before
-  public void setUp() throws IOException {
-    MockitoAnnotations.initMocks(this);
-    provider =
-        new DynamicReloadingCertificateProviderProvider(
-            dynamicReloadingCertificateProviderFactory,
-            scheduledExecutorServiceFactory,
-            timeProvider);
-  }
-
-  @Test
-  public void providerRegisteredName() {
-    CertificateProviderProvider certProviderProvider =
-        CertificateProviderRegistry.getInstance()
-            .getProvider(
-                DynamicReloadingCertificateProviderProvider.DYNAMIC_RELOADING_PROVIDER_NAME);
-    assertThat(certProviderProvider)
-        .isInstanceOf(DynamicReloadingCertificateProviderProvider.class);
-    DynamicReloadingCertificateProviderProvider dynamicReloadingCertificateProviderProvider =
-        (DynamicReloadingCertificateProviderProvider) certProviderProvider;
-    assertThat(
-            dynamicReloadingCertificateProviderProvider.dynamicReloadingCertificateProviderFactory)
-        .isSameInstanceAs(DynamicReloadingCertificateProvider.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_DYNAMIC_RELOADING_CONFIG);
-    ScheduledExecutorService mockService = mock(ScheduledExecutorService.class);
-    when(scheduledExecutorServiceFactory.create()).thenReturn(mockService);
-    provider.createCertificateProvider(map, distWatcher, true);
-    verify(dynamicReloadingCertificateProviderFactory, times(1))
-        .create(
-            eq(distWatcher),
-            eq(true),
-            eq("/var/run/gke-spiffe/certs/..data"),
-            eq("certificates.pem"),
-            eq("private_key.pem"),
-            eq("ca_certificates.pem"),
-            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_DYNAMIC_RELOADING_CONFIG);
-    ScheduledExecutorService mockService = mock(ScheduledExecutorService.class);
-    when(scheduledExecutorServiceFactory.create()).thenReturn(mockService);
-    provider.createCertificateProvider(map, distWatcher, true);
-    verify(dynamicReloadingCertificateProviderFactory, times(1))
-        .create(
-            eq(distWatcher),
-            eq(true),
-            eq("/var/run/gke-spiffe/certs/..data1"),
-            eq("certificates2.pem"),
-            eq("private_key3.pem"),
-            eq("ca_certificates4.pem"),
-            eq(7890L),
-            eq(mockService),
-            eq(timeProvider));
-  }
-
-  @Test
-  public void createProvider_missingDir_expectException() throws IOException {
-    CertificateProvider.DistributorWatcher distWatcher =
-        new CertificateProvider.DistributorWatcher();
-    @SuppressWarnings("unchecked")
-    Map<String, ?> map = (Map<String, ?>) JsonParser.parse(MISSING_DIR_CONFIG);
-    try {
-      provider.createCertificateProvider(map, distWatcher, true);
-      fail("exception expected");
-    } catch (NullPointerException npe) {
-      assertThat(npe).hasMessageThat().isEqualTo("'directory' is required in the config");
-    }
-  }
-
-  @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 {
-    CertificateProvider.DistributorWatcher distWatcher =
-        new CertificateProvider.DistributorWatcher();
-    @SuppressWarnings("unchecked")
-    Map<String, ?> map = (Map<String, ?>) JsonParser.parse(MISSING_ROOT_CONFIG);
-    try {
-      provider.createCertificateProvider(map, distWatcher, true);
-      fail("exception expected");
-    } catch (NullPointerException npe) {
-      assertThat(npe).hasMessageThat().isEqualTo("'ca-certificate-file' is required in the config");
-    }
-  }
-
-  private static final String MINIMAL_DYNAMIC_RELOADING_CONFIG =
-      "{\n"
-          + "        \"directory\": \"/var/run/gke-spiffe/certs/..data\","
-          + "        \"certificate-file\": \"certificates.pem\","
-          + "        \"private-key-file\": \"private_key.pem\","
-          + "        \"ca-certificate-file\": \"ca_certificates.pem\""
-          + "      }";
-
-  private static final String FULL_DYNAMIC_RELOADING_CONFIG =
-      "{\n"
-          + "        \"directory\": \"/var/run/gke-spiffe/certs/..data1\","
-          + "        \"certificate-file\": \"certificates2.pem\","
-          + "        \"private-key-file\": \"private_key3.pem\","
-          + "        \"ca-certificate-file\": \"ca_certificates4.pem\","
-          + "        \"refresh-interval\": 7890"
-          + "      }";
-
-  private static final String MISSING_DIR_CONFIG =
-      "{\n"
-          + "        \"certificate-file\": \"certificates.pem\","
-          + "        \"private-key-file\": \"private_key.pem\","
-          + "        \"ca-certificate-file\": \"ca_certificates.pem\""
-          + "      }";
-
-  private static final String MISSING_CERT_CONFIG =
-      "{\n"
-          + "        \"directory\": \"/var/run/gke-spiffe/certs/..data\","
-          + "        \"private-key-file\": \"private_key.pem\","
-          + "        \"ca-certificate-file\": \"ca_certificates.pem\""
-          + "      }";
-
-  private static final String MISSING_KEY_CONFIG =
-      "{\n"
-          + "        \"directory\": \"/var/run/gke-spiffe/certs/..data\","
-          + "        \"certificate-file\": \"certificates.pem\","
-          + "        \"ca-certificate-file\": \"ca_certificates.pem\""
-          + "      }";
-
-  private static final String MISSING_ROOT_CONFIG =
-      "{\n"
-          + "        \"directory\": \"/var/run/gke-spiffe/certs/..data\","
-          + "        \"certificate-file\": \"certificates.pem\","
-          + "        \"private-key-file\": \"private_key.pem\""
-          + "      }";
-}
diff --git a/xds/src/test/java/io/grpc/xds/internal/certprovider/DynamicReloadingCertificateProviderTest.java b/xds/src/test/java/io/grpc/xds/internal/certprovider/DynamicReloadingCertificateProviderTest.java
deleted file mode 100644
index a2f7cb7e32f..00000000000
--- a/xds/src/test/java/io/grpc/xds/internal/certprovider/DynamicReloadingCertificateProviderTest.java
+++ /dev/null
@@ -1,303 +0,0 @@
-/*
- * 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.certprovider;
-
-import static com.google.common.truth.Truth.assertThat;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.CA_PEM_FILE;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.CLIENT_KEY_FILE;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.CLIENT_PEM_FILE;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.SERVER_0_KEY_FILE;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.SERVER_0_PEM_FILE;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.SERVER_1_PEM_FILE;
-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 static org.mockito.Mockito.when;
-
-import io.grpc.Status;
-import io.grpc.internal.TimeProvider;
-import io.grpc.xds.internal.certprovider.CertificateProvider.DistributorWatcher;
-import io.grpc.xds.internal.sds.CommonTlsContextTestsUtil;
-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.security.PrivateKey;
-import java.security.cert.CertificateException;
-import java.security.cert.X509Certificate;
-import java.util.List;
-import java.util.concurrent.ScheduledExecutorService;
-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.MockitoAnnotations;
-
-/** Unit tests for {@link DynamicReloadingCertificateProvider}. */
-@RunWith(JUnit4.class)
-public class DynamicReloadingCertificateProviderTest {
-  private static final String CERT_FILE = "cert.pem";
-  private static final String KEY_FILE = "key.pem";
-  private static final String ROOT_FILE = "root.pem";
-
-  @Mock private CertificateProvider.Watcher mockWatcher;
-  @Mock private ScheduledExecutorService timeService;
-  @Mock private TimeProvider timeProvider;
-
-  @Rule public TemporaryFolder tempFolder = new TemporaryFolder();
-  private String symlink;
-
-  private DynamicReloadingCertificateProvider provider;
-
-  @Before
-  public void setUp() throws IOException {
-    MockitoAnnotations.initMocks(this);
-
-    DistributorWatcher watcher = new DistributorWatcher();
-    watcher.addWatcher(mockWatcher);
-
-    symlink = new File(tempFolder.getRoot(), "..data").getAbsolutePath();
-    provider =
-        new DynamicReloadingCertificateProvider(
-            watcher,
-            true,
-            symlink,
-            CERT_FILE,
-            KEY_FILE,
-            ROOT_FILE,
-            600L,
-            timeService,
-            timeProvider);
-  }
-
-  private void populateTarget(
-      String certFile, String keyFile, String rootFile, boolean deleteExisting, boolean createNew)
-      throws IOException {
-    String target = tempFolder.newFolder().getAbsolutePath();
-    if (certFile != null) {
-      certFile = CommonTlsContextTestsUtil.getTempFileNameForResourcesFile(certFile);
-      Files.copy(Paths.get(certFile), Paths.get(target, CERT_FILE));
-    }
-    if (keyFile != null) {
-      keyFile = CommonTlsContextTestsUtil.getTempFileNameForResourcesFile(keyFile);
-      Files.copy(Paths.get(keyFile), Paths.get(target, KEY_FILE));
-    }
-    if (rootFile != null) {
-      rootFile = CommonTlsContextTestsUtil.getTempFileNameForResourcesFile(rootFile);
-      Files.copy(Paths.get(rootFile), Paths.get(target, ROOT_FILE));
-    }
-    if (deleteExisting) {
-      Files.delete(Paths.get(symlink));
-    }
-    if (createNew) {
-      Files.createSymbolicLink(Paths.get(symlink), Paths.get(target));
-    }
-  }
-
-  @Test
-  public void getCertificateAndCheckUpdates() throws IOException, CertificateException {
-    MeshCaCertificateProviderTest.TestScheduledFuture<?> scheduledFuture =
-        new MeshCaCertificateProviderTest.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, false, true);
-    provider.checkAndReloadCertificates();
-    verifyWatcherUpdates(CLIENT_PEM_FILE, CA_PEM_FILE);
-    verifyTimeServiceAndScheduledHandle();
-
-    reset(mockWatcher, timeService);
-    doReturn(scheduledFuture)
-        .when(timeService)
-        .schedule(any(Runnable.class), any(Long.TYPE), eq(TimeUnit.SECONDS));
-    provider.scheduledHandle.cancel();
-    provider.checkAndReloadCertificates();
-    verifyWatcherErrorUpdates(null, null, (String[]) null);
-    verifyTimeServiceAndScheduledHandle();
-
-    reset(mockWatcher, timeService);
-    doReturn(scheduledFuture)
-        .when(timeService)
-        .schedule(any(Runnable.class), any(Long.TYPE), eq(TimeUnit.SECONDS));
-    provider.scheduledHandle.cancel();
-    populateTarget(SERVER_0_PEM_FILE, SERVER_0_KEY_FILE, SERVER_1_PEM_FILE, true, true);
-    provider.checkAndReloadCertificates();
-    verifyWatcherUpdates(SERVER_0_PEM_FILE, SERVER_1_PEM_FILE);
-    verifyTimeServiceAndScheduledHandle();
-  }
-
-  @Test
-  public void getCertificate_initialMissingCertFile() throws IOException {
-    MeshCaCertificateProviderTest.TestScheduledFuture<?> scheduledFuture =
-        new MeshCaCertificateProviderTest.TestScheduledFuture<>();
-    doReturn(scheduledFuture)
-        .when(timeService)
-        .schedule(any(Runnable.class), any(Long.TYPE), eq(TimeUnit.SECONDS));
-    populateTarget(null, CLIENT_KEY_FILE, CA_PEM_FILE, false, true);
-    when(timeProvider.currentTimeNanos())
-        .thenReturn(TimeProvider.SYSTEM_TIME_PROVIDER.currentTimeNanos());
-    provider.checkAndReloadCertificates();
-    verifyWatcherErrorUpdates(Status.Code.UNKNOWN, java.io.FileNotFoundException.class, "cert.pem");
-  }
-
-  @Test
-  public void getCertificate_missingSymlink() throws IOException {
-    commonErrorTest(null, null, null, true, false, NoSuchFileException.class, "..data");
-  }
-
-  @Test
-  public void getCertificate_missingCertFile() throws IOException {
-    commonErrorTest(
-        null,
-        CLIENT_KEY_FILE,
-        CA_PEM_FILE,
-        true,
-        true,
-        java.io.FileNotFoundException.class,
-        "cert.pem");
-  }
-
-  @Test
-  public void getCertificate_missingKeyFile() throws IOException {
-    commonErrorTest(
-        CLIENT_PEM_FILE,
-        null,
-        CA_PEM_FILE,
-        true,
-        true,
-        java.io.FileNotFoundException.class,
-        "key.pem");
-  }
-
-  @Test
-  public void getCertificate_badKeyFile() throws IOException {
-    commonErrorTest(
-        CLIENT_PEM_FILE,
-        SERVER_0_PEM_FILE,
-        CA_PEM_FILE,
-        true,
-        true,
-         java.security.KeyException.class,
-        "could not find a PKCS #8 private key in input stream");
-  }
-
-  @Test
-  public void getCertificate_missingRootFile() throws IOException {
-    commonErrorTest(
-        CLIENT_PEM_FILE,
-        CLIENT_KEY_FILE,
-        null,
-        true,
-        true,
-        java.io.FileNotFoundException.class,
-        "root.pem");
-  }
-
-  private void commonErrorTest(
-      String certFile,
-      String keyFile,
-      String rootFile,
-      boolean deleteExisting,
-      boolean createNew,
-      Class<?> throwableType,
-      String... causeMessages)
-      throws IOException {
-    MeshCaCertificateProviderTest.TestScheduledFuture<?> scheduledFuture =
-        new MeshCaCertificateProviderTest.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, false, true);
-    provider.checkAndReloadCertificates();
-
-    reset(mockWatcher);
-    populateTarget(certFile, keyFile, rootFile, deleteExisting, createNew);
-    when(timeProvider.currentTimeNanos())
-        .thenReturn(
-            TimeUnit.MILLISECONDS.toNanos(
-                MeshCaCertificateProviderTest.CERT0_EXPIRY_TIME_MILLIS - 610_000L));
-    provider.scheduledHandle.cancel();
-    provider.checkAndReloadCertificates();
-    verifyWatcherErrorUpdates(null, null, (String[]) null);
-
-    reset(mockWatcher, timeProvider);
-    when(timeProvider.currentTimeNanos())
-        .thenReturn(
-            TimeUnit.MILLISECONDS.toNanos(
-                MeshCaCertificateProviderTest.CERT0_EXPIRY_TIME_MILLIS - 590_000L));
-    provider.scheduledHandle.cancel();
-    provider.checkAndReloadCertificates();
-    verifyWatcherErrorUpdates(Status.Code.UNKNOWN, throwableType, causeMessages);
-  }
-
-  private void verifyWatcherErrorUpdates(
-      Status.Code code, Class<?> throwableType, String... causeMessages) {
-    verify(mockWatcher, never())
-        .updateCertificate(any(PrivateKey.class), ArgumentMatchers.<X509Certificate>anyList());
-    verify(mockWatcher, never()).updateTrustedRoots(ArgumentMatchers.<X509Certificate>anyList());
-    if (code == null && throwableType == null && causeMessages == null) {
-      verify(mockWatcher, never()).onError(any(Status.class));
-    } else {
-      ArgumentCaptor<Status> statusCaptor = ArgumentCaptor.forClass(null);
-      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 verifyTimeServiceAndScheduledHandle() {
-    verify(timeService, times(1)).schedule(any(Runnable.class), eq(600L), eq(TimeUnit.SECONDS));
-    assertThat(provider.scheduledHandle).isNotNull();
-    assertThat(provider.scheduledHandle.isPending()).isTrue();
-  }
-
-  private void verifyWatcherUpdates(String certPemFile, String rootPemFile)
-      throws IOException, CertificateException {
-    ArgumentCaptor<List<X509Certificate>> certChainCaptor = ArgumentCaptor.forClass(null);
-    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));
-
-    ArgumentCaptor<List<X509Certificate>> rootsCaptor = ArgumentCaptor.forClass(null);
-    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));
-  }
-}
diff --git a/xds/src/test/java/io/grpc/xds/internal/certprovider/FileWatcherCertificateProviderProviderTest.java b/xds/src/test/java/io/grpc/xds/internal/certprovider/FileWatcherCertificateProviderProviderTest.java
deleted file mode 100644
index b3ab5999528..00000000000
--- a/xds/src/test/java/io/grpc/xds/internal/certprovider/FileWatcherCertificateProviderProviderTest.java
+++ /dev/null
@@ -1,186 +0,0 @@
-/*
- * 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.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 io.grpc.internal.JsonParser;
-import io.grpc.internal.TimeProvider;
-import java.io.IOException;
-import java.util.Map;
-import java.util.concurrent.ScheduledExecutorService;
-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 FileWatcherCertificateProviderProvider}. */
-@RunWith(JUnit4.class)
-public class FileWatcherCertificateProviderProviderTest {
-
-  @Mock FileWatcherCertificateProvider.Factory fileWatcherCertificateProviderFactory;
-  @Mock private FileWatcherCertificateProviderProvider.ScheduledExecutorServiceFactory
-      scheduledExecutorServiceFactory;
-  @Mock private TimeProvider timeProvider;
-
-  private FileWatcherCertificateProviderProvider provider;
-
-  @Before
-  public void setUp() throws IOException {
-    MockitoAnnotations.initMocks(this);
-    provider =
-        new FileWatcherCertificateProviderProvider(
-            fileWatcherCertificateProviderFactory, scheduledExecutorServiceFactory, timeProvider);
-  }
-
-  @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(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(7890L),
-            eq(mockService),
-            eq(timeProvider));
-  }
-
-  @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 {
-    CertificateProvider.DistributorWatcher distWatcher =
-        new CertificateProvider.DistributorWatcher();
-    @SuppressWarnings("unchecked")
-    Map<String, ?> map = (Map<String, ?>) JsonParser.parse(MISSING_ROOT_CONFIG);
-    try {
-      provider.createCertificateProvider(map, distWatcher, true);
-      fail("exception expected");
-    } catch (NullPointerException npe) {
-      assertThat(npe).hasMessageThat().isEqualTo("'ca_certificate_file' is required in the config");
-    }
-  }
-
-  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 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 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_CONFIG =
-      "{\n"
-          + "        \"certificate_file\": \"/var/run/gke-spiffe/certs/certificates.pem\","
-          + "        \"private_key_file\": \"/var/run/gke-spiffe/certs/private_key.pem\""
-          + "      }";
-}
diff --git a/xds/src/test/java/io/grpc/xds/internal/certprovider/FileWatcherCertificateProviderTest.java b/xds/src/test/java/io/grpc/xds/internal/certprovider/FileWatcherCertificateProviderTest.java
deleted file mode 100644
index e2cb464734e..00000000000
--- a/xds/src/test/java/io/grpc/xds/internal/certprovider/FileWatcherCertificateProviderTest.java
+++ /dev/null
@@ -1,376 +0,0 @@
-/*
- * 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.certprovider;
-
-import static com.google.common.truth.Truth.assertThat;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.CA_PEM_FILE;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.CLIENT_KEY_FILE;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.CLIENT_PEM_FILE;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.SERVER_0_KEY_FILE;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.SERVER_0_PEM_FILE;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.SERVER_1_PEM_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 static org.mockito.Mockito.when;
-
-import io.grpc.Status;
-import io.grpc.internal.TimeProvider;
-import io.grpc.xds.internal.certprovider.CertificateProvider.DistributorWatcher;
-import io.grpc.xds.internal.sds.CommonTlsContextTestsUtil;
-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.security.PrivateKey;
-import java.security.cert.CertificateException;
-import java.security.cert.X509Certificate;
-import java.util.List;
-import java.util.concurrent.ScheduledExecutorService;
-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.MockitoAnnotations;
-
-/** Unit tests for {@link FileWatcherCertificateProvider}. */
-@RunWith(JUnit4.class)
-public class FileWatcherCertificateProviderTest {
-  private static final String CERT_FILE = "cert.pem";
-  private static final String KEY_FILE = "key.pem";
-  private static final String ROOT_FILE = "root.pem";
-
-  @Mock private CertificateProvider.Watcher mockWatcher;
-  @Mock private ScheduledExecutorService timeService;
-  @Mock private TimeProvider timeProvider;
-
-  @Rule public TemporaryFolder tempFolder = new TemporaryFolder();
-
-  private String certFile;
-  private String keyFile;
-  private String rootFile;
-
-  private FileWatcherCertificateProvider provider;
-
-  @Before
-  public void setUp() throws IOException {
-    MockitoAnnotations.initMocks(this);
-
-    DistributorWatcher 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();
-    provider =
-        new FileWatcherCertificateProvider(
-            watcher, true, certFile, keyFile, rootFile, 600L, timeService, timeProvider);
-  }
-
-  private void populateTarget(
-      String certFileSource,
-      String keyFileSource,
-      String rootFileSource,
-      boolean deleteCurCert,
-      boolean deleteCurKey,
-      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);
-    }
-    if (deleteCurKey) {
-      Files.delete(Paths.get(keyFile));
-    }
-    if (keyFileSource != null) {
-      keyFileSource = CommonTlsContextTestsUtil.getTempFileNameForResourcesFile(keyFileSource);
-      Files.copy(Paths.get(keyFileSource), Paths.get(keyFile), REPLACE_EXISTING);
-    }
-    if (deleteCurRoot) {
-      Files.delete(Paths.get(rootFile));
-    }
-    if (rootFileSource != null) {
-      rootFileSource = CommonTlsContextTestsUtil.getTempFileNameForResourcesFile(rootFileSource);
-      Files.copy(Paths.get(rootFileSource), Paths.get(rootFile), REPLACE_EXISTING);
-    }
-  }
-
-  @Test
-  public void getCertificateAndCheckUpdates() throws IOException, CertificateException {
-    MeshCaCertificateProviderTest.TestScheduledFuture<?> scheduledFuture =
-        new MeshCaCertificateProviderTest.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, false, false, false);
-    provider.checkAndReloadCertificates();
-    verifyWatcherUpdates(CLIENT_PEM_FILE, CA_PEM_FILE);
-    verifyTimeServiceAndScheduledHandle();
-
-    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);
-    verifyTimeServiceAndScheduledHandle();
-  }
-
-  @Test
-  public void allUpdateSecondTime() throws IOException, CertificateException, InterruptedException {
-    MeshCaCertificateProviderTest.TestScheduledFuture<?> scheduledFuture =
-        new MeshCaCertificateProviderTest.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, false, false, false);
-    provider.checkAndReloadCertificates();
-
-    reset(mockWatcher, timeService);
-    doReturn(scheduledFuture)
-        .when(timeService)
-        .schedule(any(Runnable.class), any(Long.TYPE), eq(TimeUnit.SECONDS));
-    Thread.sleep(1000L);
-    populateTarget(SERVER_0_PEM_FILE, SERVER_0_KEY_FILE, SERVER_1_PEM_FILE, false, false, false);
-    provider.checkAndReloadCertificates();
-    verifyWatcherUpdates(SERVER_0_PEM_FILE, SERVER_1_PEM_FILE);
-    verifyTimeServiceAndScheduledHandle();
-  }
-
-  @Test
-  public void rootFileUpdateOnly() throws IOException, CertificateException, InterruptedException {
-    MeshCaCertificateProviderTest.TestScheduledFuture<?> scheduledFuture =
-        new MeshCaCertificateProviderTest.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, false, false, false);
-    provider.checkAndReloadCertificates();
-
-    reset(mockWatcher, timeService);
-    doReturn(scheduledFuture)
-        .when(timeService)
-        .schedule(any(Runnable.class), any(Long.TYPE), eq(TimeUnit.SECONDS));
-    Thread.sleep(1000L);
-    populateTarget(null, null, SERVER_1_PEM_FILE, false, false, false);
-    provider.checkAndReloadCertificates();
-    verifyWatcherUpdates(null, SERVER_1_PEM_FILE);
-    verifyTimeServiceAndScheduledHandle();
-  }
-
-  @Test
-  public void certAndKeyFileUpdateOnly()
-      throws IOException, CertificateException, InterruptedException {
-    MeshCaCertificateProviderTest.TestScheduledFuture<?> scheduledFuture =
-        new MeshCaCertificateProviderTest.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, false, false, false);
-    provider.checkAndReloadCertificates();
-
-    reset(mockWatcher, timeService);
-    doReturn(scheduledFuture)
-        .when(timeService)
-        .schedule(any(Runnable.class), any(Long.TYPE), eq(TimeUnit.SECONDS));
-    Thread.sleep(1000L);
-    populateTarget(SERVER_0_PEM_FILE, SERVER_0_KEY_FILE, null, false, false, false);
-    provider.checkAndReloadCertificates();
-    verifyWatcherUpdates(SERVER_0_PEM_FILE, null);
-    verifyTimeServiceAndScheduledHandle();
-  }
-
-  @Test
-  public void getCertificate_initialMissingCertFile() throws IOException {
-    MeshCaCertificateProviderTest.TestScheduledFuture<?> scheduledFuture =
-        new MeshCaCertificateProviderTest.TestScheduledFuture<>();
-    doReturn(scheduledFuture)
-        .when(timeService)
-        .schedule(any(Runnable.class), any(Long.TYPE), eq(TimeUnit.SECONDS));
-    populateTarget(null, CLIENT_KEY_FILE, CA_PEM_FILE, false, false, false);
-    when(timeProvider.currentTimeNanos())
-        .thenReturn(TimeProvider.SYSTEM_TIME_PROVIDER.currentTimeNanos());
-    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, NoSuchFileException.class, 0, 1, 0, 0, "cert.pem");
-  }
-
-  @Test
-  public void getCertificate_missingKeyFile() throws IOException, InterruptedException {
-    commonErrorTest(
-        CLIENT_PEM_FILE, null, CA_PEM_FILE, 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,
-        java.security.KeyException.class,
-        0,
-        1,
-        0,
-        0,
-        "could not find a PKCS #8 private key in input stream");
-  }
-
-  @Test
-  public void getCertificate_missingRootFile() throws IOException, InterruptedException {
-    MeshCaCertificateProviderTest.TestScheduledFuture<?> scheduledFuture =
-        new MeshCaCertificateProviderTest.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, false, false, false);
-    provider.checkAndReloadCertificates();
-
-    reset(mockWatcher);
-    Thread.sleep(1000L);
-    populateTarget(CLIENT_PEM_FILE, CLIENT_KEY_FILE, null, false, false, true);
-    when(timeProvider.currentTimeNanos())
-        .thenReturn(
-            TimeUnit.MILLISECONDS.toNanos(
-                MeshCaCertificateProviderTest.CERT0_EXPIRY_TIME_MILLIS - 610_000L));
-    provider.checkAndReloadCertificates();
-    verifyWatcherErrorUpdates(Status.Code.UNKNOWN, NoSuchFileException.class, 1, 0, "root.pem");
-  }
-
-  private void commonErrorTest(
-      String certFile,
-      String keyFile,
-      String rootFile,
-      Class<?> throwableType,
-      int firstUpdateCertCount,
-      int firstUpdateRootCount,
-      int secondUpdateCertCount,
-      int secondUpdateRootCount,
-      String... causeMessages)
-      throws IOException, InterruptedException {
-    MeshCaCertificateProviderTest.TestScheduledFuture<?> scheduledFuture =
-        new MeshCaCertificateProviderTest.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, false, false, false);
-    provider.checkAndReloadCertificates();
-
-    reset(mockWatcher);
-    Thread.sleep(1000L);
-    populateTarget(
-        certFile, keyFile, rootFile, certFile == null, keyFile == null, rootFile == null);
-    when(timeProvider.currentTimeNanos())
-        .thenReturn(
-            TimeUnit.MILLISECONDS.toNanos(
-                MeshCaCertificateProviderTest.CERT0_EXPIRY_TIME_MILLIS - 610_000L));
-    provider.checkAndReloadCertificates();
-    verifyWatcherErrorUpdates(
-        null, null, firstUpdateCertCount, firstUpdateRootCount, (String[]) null);
-
-    reset(mockWatcher, timeProvider);
-    when(timeProvider.currentTimeNanos())
-        .thenReturn(
-            TimeUnit.MILLISECONDS.toNanos(
-                MeshCaCertificateProviderTest.CERT0_EXPIRY_TIME_MILLIS - 590_000L));
-    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(null);
-      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 verifyTimeServiceAndScheduledHandle() {
-    verify(timeService, times(1)).schedule(any(Runnable.class), eq(600L), eq(TimeUnit.SECONDS));
-    assertThat(provider.scheduledHandle).isNotNull();
-    assertThat(provider.scheduledHandle.isPending()).isTrue();
-  }
-
-  private void verifyWatcherUpdates(String certPemFile, String rootPemFile)
-      throws IOException, CertificateException {
-    if (certPemFile != null) {
-      ArgumentCaptor<List<X509Certificate>> certChainCaptor = ArgumentCaptor.forClass(null);
-      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) {
-      ArgumentCaptor<List<X509Certificate>> rootsCaptor = ArgumentCaptor.forClass(null);
-      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());
-    }
-  }
-}
diff --git a/xds/src/test/java/io/grpc/xds/internal/certprovider/MeshCaCertificateProviderProviderTest.java b/xds/src/test/java/io/grpc/xds/internal/certprovider/MeshCaCertificateProviderProviderTest.java
deleted file mode 100644
index 791d5a395c5..00000000000
--- a/xds/src/test/java/io/grpc/xds/internal/certprovider/MeshCaCertificateProviderProviderTest.java
+++ /dev/null
@@ -1,409 +0,0 @@
-/*
- * 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.certprovider;
-
-import static com.google.common.truth.Truth.assertThat;
-import static io.grpc.xds.internal.certprovider.MeshCaCertificateProviderProvider.RPC_TIMEOUT_SECONDS;
-import static org.junit.Assert.fail;
-import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.ArgumentMatchers.isNull;
-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.auth.oauth2.GoogleCredentials;
-import io.grpc.internal.BackoffPolicy;
-import io.grpc.internal.ExponentialBackoffPolicy;
-import io.grpc.internal.JsonParser;
-import io.grpc.internal.TimeProvider;
-import io.grpc.xds.internal.sts.StsCredentials;
-import java.io.IOException;
-import java.util.Map;
-import java.util.concurrent.ScheduledExecutorService;
-import java.util.concurrent.TimeUnit;
-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 MeshCaCertificateProviderProvider}. */
-@RunWith(JUnit4.class)
-public class MeshCaCertificateProviderProviderTest {
-
-  public static final String EXPECTED_AUDIENCE =
-      "identitynamespace:test-project1.svc.id.goog:https://container.googleapis.com/v1/projects/test-project1/locations/test-zone2/clusters/test-cluster3";
-  public static final String EXPECTED_AUDIENCE_V1BETA1_ZONE =
-          "identitynamespace:test-project1.svc.id.goog:https://container.googleapis.com/v1beta1/projects/test-project1/zones/test-zone2/clusters/test-cluster3";
-  public static final String TMP_PATH_4 = "/tmp/path4";
-  public static final String NON_DEFAULT_MESH_CA_URL = "nonDefaultMeshCaUrl";
-
-  @Mock
-  StsCredentials.Factory stsCredentialsFactory;
-
-  @Mock
-  MeshCaCertificateProvider.MeshCaChannelFactory meshCaChannelFactory;
-
-  @Mock
-  BackoffPolicy.Provider backoffPolicyProvider;
-
-  @Mock
-  MeshCaCertificateProvider.Factory meshCaCertificateProviderFactory;
-
-  @Mock
-  private MeshCaCertificateProviderProvider.ScheduledExecutorServiceFactory
-      scheduledExecutorServiceFactory;
-
-  @Mock
-  private TimeProvider timeProvider;
-
-  private MeshCaCertificateProviderProvider provider;
-
-  @Before
-  public void setUp() throws IOException {
-    MockitoAnnotations.initMocks(this);
-    provider =
-        new MeshCaCertificateProviderProvider(
-            stsCredentialsFactory,
-            meshCaChannelFactory,
-            backoffPolicyProvider,
-            meshCaCertificateProviderFactory,
-            scheduledExecutorServiceFactory,
-            timeProvider);
-  }
-
-  @Test
-  public void providerRegisteredName() {
-    CertificateProviderProvider certProviderProvider = CertificateProviderRegistry.getInstance()
-        .getProvider(MeshCaCertificateProviderProvider.MESH_CA_NAME);
-    assertThat(certProviderProvider).isInstanceOf(MeshCaCertificateProviderProvider.class);
-    MeshCaCertificateProviderProvider meshCaCertificateProviderProvider =
-        (MeshCaCertificateProviderProvider) certProviderProvider;
-    assertThat(meshCaCertificateProviderProvider.stsCredentialsFactory)
-        .isSameInstanceAs(StsCredentials.Factory.getInstance());
-    assertThat(meshCaCertificateProviderProvider.meshCaChannelFactory)
-        .isSameInstanceAs(MeshCaCertificateProvider.MeshCaChannelFactory.getInstance());
-    assertThat(meshCaCertificateProviderProvider.backoffPolicyProvider)
-        .isInstanceOf(ExponentialBackoffPolicy.Provider.class);
-    assertThat(meshCaCertificateProviderProvider.meshCaCertificateProviderFactory)
-        .isSameInstanceAs(MeshCaCertificateProvider.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_MESHCA_CONFIG);
-    ScheduledExecutorService mockService = mock(ScheduledExecutorService.class);
-    when(scheduledExecutorServiceFactory.create(
-            eq(MeshCaCertificateProviderProvider.MESHCA_URL_DEFAULT)))
-        .thenReturn(mockService);
-    provider.createCertificateProvider(map, distWatcher, true);
-    verify(stsCredentialsFactory, times(1))
-        .create(
-            eq(MeshCaCertificateProviderProvider.STS_URL_DEFAULT),
-            eq(EXPECTED_AUDIENCE),
-            eq("/tmp/path5"));
-    verify(meshCaCertificateProviderFactory, times(1))
-        .create(
-            eq(distWatcher),
-            eq(true),
-            eq(MeshCaCertificateProviderProvider.MESHCA_URL_DEFAULT),
-            eq("test-zone2"),
-            eq(MeshCaCertificateProviderProvider.CERT_VALIDITY_SECONDS_DEFAULT),
-            eq(MeshCaCertificateProviderProvider.KEY_SIZE_DEFAULT),
-            eq(MeshCaCertificateProviderProvider.KEY_ALGO_DEFAULT),
-            eq(MeshCaCertificateProviderProvider.SIGNATURE_ALGO_DEFAULT),
-            eq(meshCaChannelFactory),
-            eq(backoffPolicyProvider),
-            eq(MeshCaCertificateProviderProvider.RENEWAL_GRACE_PERIOD_SECONDS_DEFAULT),
-            eq(MeshCaCertificateProviderProvider.MAX_RETRY_ATTEMPTS_DEFAULT),
-            (GoogleCredentials) isNull(),
-            eq(mockService),
-            eq(timeProvider),
-            eq(TimeUnit.SECONDS.toMillis(RPC_TIMEOUT_SECONDS)));
-  }
-
-  @Test
-  public void createProvider_minimalConfig_v1beta1AndZone()
-      throws IOException {
-    CertificateProvider.DistributorWatcher distWatcher =
-        new CertificateProvider.DistributorWatcher();
-    @SuppressWarnings("unchecked")
-    Map<String, ?> map = (Map<String, ?>) JsonParser.parse(V1BETA1_ZONE_MESHCA_CONFIG);
-    ScheduledExecutorService mockService = mock(ScheduledExecutorService.class);
-    when(scheduledExecutorServiceFactory.create(
-            eq(MeshCaCertificateProviderProvider.MESHCA_URL_DEFAULT)))
-        .thenReturn(mockService);
-    provider.createCertificateProvider(map, distWatcher, true);
-    verify(stsCredentialsFactory, times(1))
-        .create(
-            eq(MeshCaCertificateProviderProvider.STS_URL_DEFAULT),
-            eq(EXPECTED_AUDIENCE_V1BETA1_ZONE),
-            eq("/tmp/path5"));
-    verify(meshCaCertificateProviderFactory, times(1))
-        .create(
-            eq(distWatcher),
-            eq(true),
-            eq(MeshCaCertificateProviderProvider.MESHCA_URL_DEFAULT),
-            eq("test-zone2"),
-            eq(MeshCaCertificateProviderProvider.CERT_VALIDITY_SECONDS_DEFAULT),
-            eq(MeshCaCertificateProviderProvider.KEY_SIZE_DEFAULT),
-            eq(MeshCaCertificateProviderProvider.KEY_ALGO_DEFAULT),
-            eq(MeshCaCertificateProviderProvider.SIGNATURE_ALGO_DEFAULT),
-            eq(meshCaChannelFactory),
-            eq(backoffPolicyProvider),
-            eq(MeshCaCertificateProviderProvider.RENEWAL_GRACE_PERIOD_SECONDS_DEFAULT),
-            eq(MeshCaCertificateProviderProvider.MAX_RETRY_ATTEMPTS_DEFAULT),
-            (GoogleCredentials) isNull(),
-            eq(mockService),
-            eq(timeProvider),
-            eq(TimeUnit.SECONDS.toMillis(RPC_TIMEOUT_SECONDS)));
-  }
-
-  @Test
-  public void createProvider_missingGkeUrl_expectException()
-      throws IOException {
-    CertificateProvider.DistributorWatcher distWatcher =
-            new CertificateProvider.DistributorWatcher();
-    @SuppressWarnings("unchecked")
-    Map<String, ?> map = (Map<String, ?>) JsonParser.parse(MISSING_GKE_CLUSTER_URL_MESHCA_CONFIG);
-    try {
-      provider.createCertificateProvider(map, distWatcher, true);
-      fail("exception expected");
-    } catch (NullPointerException npe) {
-      assertThat(npe).hasMessageThat().isEqualTo("'location' is required in the config");
-    }
-  }
-
-  @Test
-  public void createProvider_missingSaJwtLocation_expectException()
-      throws IOException {
-    CertificateProvider.DistributorWatcher distWatcher =
-            new CertificateProvider.DistributorWatcher();
-    @SuppressWarnings("unchecked")
-    Map<String, ?> map = (Map<String, ?>) JsonParser.parse(MISSING_SAJWT_MESHCA_CONFIG);
-    try {
-      provider.createCertificateProvider(map, distWatcher, true);
-      fail("exception expected");
-    } catch (NullPointerException npe) {
-      assertThat(npe).hasMessageThat().isEqualTo("'subject_token_path' is required in the config");
-    }
-  }
-
-  @Test
-  public void createProvider_missingProject_expectException()
-      throws IOException {
-    CertificateProvider.DistributorWatcher distWatcher =
-            new CertificateProvider.DistributorWatcher();
-    @SuppressWarnings("unchecked")
-    Map<String, ?> map = (Map<String, ?>) JsonParser.parse(MINIMAL_BAD_CLUSTER_URL_MESHCA_CONFIG);
-    try {
-      provider.createCertificateProvider(map, distWatcher, true);
-      fail("exception expected");
-    } catch (IllegalStateException ex) {
-      assertThat(ex).hasMessageThat().isEqualTo("gkeClusterUrl does not have correct format");
-    }
-  }
-
-  @Test
-  public void createProvider_badChannelCreds_expectException()
-      throws IOException {
-    CertificateProvider.DistributorWatcher distWatcher =
-            new CertificateProvider.DistributorWatcher();
-    @SuppressWarnings("unchecked")
-    Map<String, ?> map = (Map<String, ?>) JsonParser.parse(BAD_CHANNEL_CREDS_MESHCA_CONFIG);
-    try {
-      provider.createCertificateProvider(map, distWatcher, true);
-      fail("exception expected");
-    } catch (NullPointerException ex) {
-      assertThat(ex).hasMessageThat().isEqualTo("channel_credentials need to be google_default!");
-    }
-  }
-
-  @Test
-  public void createProvider_nonDefaultFullConfig() throws IOException {
-    CertificateProvider.DistributorWatcher distWatcher =
-            new CertificateProvider.DistributorWatcher();
-    @SuppressWarnings("unchecked")
-    Map<String, ?> map = (Map<String, ?>) JsonParser.parse(NONDEFAULT_MESHCA_CONFIG);
-    ScheduledExecutorService mockService = mock(ScheduledExecutorService.class);
-    when(scheduledExecutorServiceFactory.create(eq(NON_DEFAULT_MESH_CA_URL)))
-        .thenReturn(mockService);
-    provider.createCertificateProvider(map, distWatcher, true);
-    verify(stsCredentialsFactory, times(1))
-            .create(
-                    eq("test.sts.com"),
-                    eq(EXPECTED_AUDIENCE),
-                    eq(TMP_PATH_4));
-    verify(meshCaCertificateProviderFactory, times(1))
-            .create(
-                    eq(distWatcher),
-                    eq(true),
-                    eq(NON_DEFAULT_MESH_CA_URL),
-                    eq("test-zone2"),
-                    eq(234567L),
-                    eq(512),
-                    eq("RSA"),
-                    eq("SHA256withRSA"),
-                    eq(meshCaChannelFactory),
-                    eq(backoffPolicyProvider),
-                    eq(4321L),
-                    eq(3),
-                    (GoogleCredentials) isNull(),
-                    eq(mockService),
-                    eq(timeProvider),
-                    eq(TimeUnit.SECONDS.toMillis(RPC_TIMEOUT_SECONDS)));
-  }
-
-  private static final String NONDEFAULT_MESHCA_CONFIG =
-      "{\n"
-          + "        \"server\": {\n"
-          + "          \"api_type\": \"GRPC\",\n"
-          + "          \"grpc_services\": [{\n"
-          + "            \"google_grpc\": {\n"
-          + "              \"target_uri\": \"nonDefaultMeshCaUrl\",\n"
-          + "              \"channel_credentials\": {\"google_default\": {}},\n"
-          + "              \"call_credentials\": [{\n"
-          + "                \"sts_service\": {\n"
-          + "                  \"token_exchange_service\": \"test.sts.com\",\n"
-          + "                  \"subject_token_path\": \"/tmp/path4\"\n"
-          + "                }\n"
-          + "              }]\n" // end call_credentials
-          + "            },\n" // end google_grpc
-          + "            \"time_out\": {\"seconds\": 12}\n"
-          + "          }]\n" // end grpc_services
-          + "        },\n" // end server
-          + "        \"certificate_lifetime\": {\"seconds\": 234567},\n"
-          + "        \"renewal_grace_period\": {\"seconds\": 4321},\n"
-          + "        \"key_type\": \"RSA\",\n"
-          + "        \"key_size\": 512,\n"
-          + "        \"location\": \"https://container.googleapis.com/v1/projects/test-project1/locations/test-zone2/clusters/test-cluster3\"\n"
-          + "      }";
-
-  private static final String MINIMAL_MESHCA_CONFIG =
-      "{\n"
-          + "        \"server\": {\n"
-          + "          \"api_type\": \"GRPC\",\n"
-          + "          \"grpc_services\": [{\n"
-          + "            \"google_grpc\": {\n"
-          + "              \"call_credentials\": [{\n"
-          + "                \"sts_service\": {\n"
-          + "                  \"subject_token_path\": \"/tmp/path5\"\n"
-          + "                }\n"
-          + "              }]\n" // end call_credentials
-          + "            }\n" // end google_grpc
-          + "          }]\n" // end grpc_services
-          + "        },\n" // end server
-          + "        \"location\": \"https://container.googleapis.com/v1/projects/test-project1/locations/test-zone2/clusters/test-cluster3\"\n"
-          + "      }";
-
-  private static final String V1BETA1_ZONE_MESHCA_CONFIG =
-      "{\n"
-          + "        \"server\": {\n"
-          + "          \"api_type\": \"GRPC\",\n"
-          + "          \"grpc_services\": [{\n"
-          + "            \"google_grpc\": {\n"
-          + "              \"call_credentials\": [{\n"
-          + "                \"sts_service\": {\n"
-          + "                  \"subject_token_path\": \"/tmp/path5\"\n"
-          + "                }\n"
-          + "              }]\n" // end call_credentials
-          + "            }\n" // end google_grpc
-          + "          }]\n" // end grpc_services
-          + "        },\n" // end server
-          + "        \"location\": \"https://container.googleapis.com/v1beta1/projects/test-project1/zones/test-zone2/clusters/test-cluster3\"\n"
-          + "      }";
-
-  private static final String MINIMAL_BAD_CLUSTER_URL_MESHCA_CONFIG =
-      "{\n"
-          + "        \"server\": {\n"
-          + "          \"api_type\": \"GRPC\",\n"
-          + "          \"grpc_services\": [{\n"
-          + "            \"google_grpc\": {\n"
-          + "              \"call_credentials\": [{\n"
-          + "                \"sts_service\": {\n"
-          + "                  \"subject_token_path\": \"/tmp/path5\"\n"
-          + "                }\n"
-          + "              }]\n" // end call_credentials
-          + "            }\n" // end google_grpc
-          + "          }]\n" // end grpc_services
-          + "        },\n" // end server
-          + "        \"location\": \"https://container.googleapis.com/v1/project/test-project1/locations/test-zone2/clusters/test-cluster3\"\n"
-          + "      }";
-
-  private static final String MISSING_SAJWT_MESHCA_CONFIG =
-      "{\n"
-          + "        \"server\": {\n"
-          + "          \"api_type\": \"GRPC\",\n"
-          + "          \"grpc_services\": [{\n"
-          + "            \"google_grpc\": {\n"
-          + "              \"call_credentials\": [{\n"
-          + "                \"sts_service\": {\n"
-          + "                }\n"
-          + "              }]\n" // end call_credentials
-          + "            }\n" // end google_grpc
-          + "          }]\n" // end grpc_services
-          + "        },\n" // end server
-          + "        \"location\": \"https://container.googleapis.com/v1/projects/test-project1/locations/test-zone2/clusters/test-cluster3\"\n"
-          + "      }";
-
-  private static final String MISSING_GKE_CLUSTER_URL_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"
-          + "      }";
-
-  private static final String BAD_CHANNEL_CREDS_MESHCA_CONFIG =
-      "{\n"
-          + "        \"server\": {\n"
-          + "          \"api_type\": \"GRPC\",\n"
-          + "          \"grpc_services\": [{\n"
-          + "            \"google_grpc\": {\n"
-          + "              \"channel_credentials\": {\"mtls\": \"true\"},\n"
-          + "              \"call_credentials\": [{\n"
-          + "                \"sts_service\": {\n"
-          + "                  \"subject_token_path\": \"/tmp/path5\"\n"
-          + "                }\n"
-          + "              }]\n" // end call_credentials
-          + "            }\n" // end google_grpc
-          + "          }]\n" // end grpc_services
-          + "        },\n" // end server
-          + "        \"location\": \"https://container.googleapis.com/v1/projects/test-project1/locations/test-zone2/clusters/test-cluster3\"\n"
-          + "      }";
-}
diff --git a/xds/src/test/java/io/grpc/xds/internal/certprovider/MeshCaCertificateProviderTest.java b/xds/src/test/java/io/grpc/xds/internal/certprovider/MeshCaCertificateProviderTest.java
deleted file mode 100644
index 4b4791dd0c6..00000000000
--- a/xds/src/test/java/io/grpc/xds/internal/certprovider/MeshCaCertificateProviderTest.java
+++ /dev/null
@@ -1,591 +0,0 @@
-/*
- * 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.certprovider;
-
-import static com.google.common.truth.Truth.assertThat;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.CA_PEM_FILE;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.SERVER_0_PEM_FILE;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.SERVER_1_PEM_FILE;
-import static org.mockito.AdditionalAnswers.delegatesTo;
-import static org.mockito.Mockito.any;
-import static org.mockito.Mockito.doAnswer;
-import static org.mockito.Mockito.doReturn;
-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.when;
-
-import com.google.auth.http.AuthHttpConstants;
-import com.google.auth.oauth2.AccessToken;
-import com.google.auth.oauth2.GoogleCredentials;
-import com.google.common.collect.ImmutableList;
-import com.google.common.util.concurrent.MoreExecutors;
-import com.google.security.meshca.v1.MeshCertificateRequest;
-import com.google.security.meshca.v1.MeshCertificateResponse;
-import com.google.security.meshca.v1.MeshCertificateServiceGrpc;
-import io.grpc.Context;
-import io.grpc.ManagedChannel;
-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.SynchronizationContext;
-import io.grpc.inprocess.InProcessChannelBuilder;
-import io.grpc.inprocess.InProcessServerBuilder;
-import io.grpc.internal.BackoffPolicy;
-import io.grpc.internal.TimeProvider;
-import io.grpc.stub.StreamObserver;
-import io.grpc.testing.GrpcCleanupRule;
-import io.grpc.xds.internal.certprovider.CertificateProvider.DistributorWatcher;
-import io.grpc.xds.internal.sds.CommonTlsContextTestsUtil;
-import java.io.IOException;
-import java.security.NoSuchAlgorithmException;
-import java.security.PrivateKey;
-import java.security.cert.CertificateException;
-import java.security.cert.X509Certificate;
-import java.util.ArrayDeque;
-import java.util.ArrayList;
-import java.util.Date;
-import java.util.List;
-import java.util.Queue;
-import java.util.concurrent.Delayed;
-import java.util.concurrent.ScheduledExecutorService;
-import java.util.concurrent.ScheduledFuture;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicBoolean;
-import org.bouncycastle.operator.OperatorCreationException;
-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.Spy;
-import org.mockito.invocation.InvocationOnMock;
-import org.mockito.stubbing.Answer;
-
-/** Unit tests for {@link MeshCaCertificateProvider}. */
-@RunWith(JUnit4.class)
-public class MeshCaCertificateProviderTest {
-
-  private static final String TEST_STS_TOKEN = "test-stsToken";
-  private static final long RENEWAL_GRACE_PERIOD_SECONDS = TimeUnit.HOURS.toSeconds(1L);
-  private static final Metadata.Key<String> KEY_FOR_AUTHORIZATION =
-      Metadata.Key.of(AuthHttpConstants.AUTHORIZATION, Metadata.ASCII_STRING_MARSHALLER);
-  private static final String ZONE = "us-west2-a";
-  private static final long START_DELAY = 200_000_000L;  // 0.2 seconds
-  private static final long[] DELAY_VALUES = {START_DELAY, START_DELAY * 2, START_DELAY * 4};
-  private static final long RPC_TIMEOUT_MILLIS = 1000L;
-  /**
-   * Expire time of cert SERVER_0_PEM_FILE.
-   */
-  static final long CERT0_EXPIRY_TIME_MILLIS = 1899853658000L;
-  /**
-   * Cert validity of 12 hours for the above cert.
-   */
-  private static final long CERT0_VALIDITY_MILLIS = TimeUnit.MILLISECONDS
-      .convert(12, TimeUnit.HOURS);
-  /**
-   * Compute current time based on cert expiry and cert validity.
-   */
-  private static final long CURRENT_TIME_NANOS =
-      TimeUnit.MILLISECONDS.toNanos(CERT0_EXPIRY_TIME_MILLIS - CERT0_VALIDITY_MILLIS);
-  @Rule
-  public final GrpcCleanupRule cleanupRule = new GrpcCleanupRule();
-
-  private static class ResponseToSend {
-    Throwable getThrowable() {
-      throw new UnsupportedOperationException("Called on " + getClass().getCanonicalName());
-    }
-
-    List<String> getList() {
-      throw new UnsupportedOperationException("Called on " + getClass().getCanonicalName());
-    }
-  }
-
-  private static class ResponseThrowable extends ResponseToSend {
-    final Throwable throwableToSend;
-
-    ResponseThrowable(Throwable throwable) {
-      throwableToSend = throwable;
-    }
-
-    @Override
-    Throwable getThrowable() {
-      return throwableToSend;
-    }
-  }
-
-  private static class ResponseList extends ResponseToSend {
-    final List<String> listToSend;
-
-    ResponseList(List<String> list) {
-      listToSend = list;
-    }
-
-    @Override
-    List<String> getList() {
-      return listToSend;
-    }
-  }
-
-  private final Queue<MeshCertificateRequest> receivedRequests = new ArrayDeque<>();
-  private final Queue<String> receivedStsCreds = new ArrayDeque<>();
-  private final Queue<String> receivedZoneValues = new ArrayDeque<>();
-  private final Queue<ResponseToSend> responsesToSend = new ArrayDeque<>();
-  private final Queue<String> oauth2Tokens = new ArrayDeque<>();
-  private final AtomicBoolean callEnded = new AtomicBoolean(true);
-
-  @Mock private MeshCertificateServiceGrpc.MeshCertificateServiceImplBase mockedMeshCaService;
-  @Mock private CertificateProvider.Watcher mockWatcher;
-  @Mock private BackoffPolicy.Provider backoffPolicyProvider;
-  @Mock private BackoffPolicy backoffPolicy;
-  @Spy private GoogleCredentials oauth2Creds;
-  @Mock private ScheduledExecutorService timeService;
-  @Mock private TimeProvider timeProvider;
-
-  private ManagedChannel channel;
-  private MeshCaCertificateProvider provider;
-
-  @Before
-  public void setUp() throws IOException {
-    MockitoAnnotations.initMocks(this);
-    when(backoffPolicyProvider.get()).thenReturn(backoffPolicy);
-    when(backoffPolicy.nextBackoffNanos())
-        .thenReturn(DELAY_VALUES[0], DELAY_VALUES[1], DELAY_VALUES[2]);
-    doAnswer(
-        new Answer<AccessToken>() {
-          @Override
-          public AccessToken answer(InvocationOnMock invocation) throws Throwable {
-            return new AccessToken(
-                oauth2Tokens.poll(), new Date(System.currentTimeMillis() + 1000L));
-          }
-        })
-        .when(oauth2Creds)
-        .refreshAccessToken();
-    final String meshCaUri = InProcessServerBuilder.generateName();
-    MeshCertificateServiceGrpc.MeshCertificateServiceImplBase meshCaServiceImpl =
-        new MeshCertificateServiceGrpc.MeshCertificateServiceImplBase() {
-
-          @Override
-          public void createCertificate(
-              MeshCertificateRequest request,
-              StreamObserver<MeshCertificateResponse> responseObserver) {
-            assertThat(callEnded.get()).isTrue(); // ensure previous call was ended
-            callEnded.set(false);
-            Context.current()
-                .addListener(
-                    new Context.CancellationListener() {
-                      @Override
-                      public void cancelled(Context context) {
-                        callEnded.set(true);
-                      }
-                    },
-                    MoreExecutors.directExecutor());
-            receivedRequests.offer(request);
-            ResponseToSend response = responsesToSend.poll();
-            if (response instanceof ResponseThrowable) {
-              responseObserver.onError(response.getThrowable());
-            } else if (response instanceof ResponseList) {
-              List<String> certChainInResponse = response.getList();
-              MeshCertificateResponse responseToSend =
-                  MeshCertificateResponse.newBuilder()
-                      .addAllCertChain(certChainInResponse)
-                      .build();
-              responseObserver.onNext(responseToSend);
-              responseObserver.onCompleted();
-            } else {
-              callEnded.set(true);
-            }
-          }
-        };
-    mockedMeshCaService =
-        mock(
-            MeshCertificateServiceGrpc.MeshCertificateServiceImplBase.class,
-            delegatesTo(meshCaServiceImpl));
-    ServerInterceptor interceptor =
-        new ServerInterceptor() {
-          @Override
-          public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(
-              ServerCall<ReqT, RespT> call, Metadata headers, ServerCallHandler<ReqT, RespT> next) {
-            receivedStsCreds.offer(headers.get(KEY_FOR_AUTHORIZATION));
-            receivedZoneValues.offer(headers.get(MeshCaCertificateProvider.KEY_FOR_ZONE_INFO));
-            return next.startCall(call, headers);
-          }
-        };
-    cleanupRule.register(
-        InProcessServerBuilder.forName(meshCaUri)
-            .addService(mockedMeshCaService)
-            .intercept(interceptor)
-            .directExecutor()
-            .build()
-            .start());
-    channel =
-        cleanupRule.register(InProcessChannelBuilder.forName(meshCaUri).directExecutor().build());
-    MeshCaCertificateProvider.MeshCaChannelFactory channelFactory =
-        new MeshCaCertificateProvider.MeshCaChannelFactory() {
-          @Override
-          ManagedChannel createChannel(String serverUri) {
-            assertThat(serverUri).isEqualTo(meshCaUri);
-            return channel;
-          }
-        };
-    CertificateProvider.DistributorWatcher watcher = new CertificateProvider.DistributorWatcher();
-    watcher.addWatcher(mockWatcher); //
-    provider =
-        new MeshCaCertificateProvider(
-            watcher,
-            true,
-            meshCaUri,
-            ZONE,
-            TimeUnit.HOURS.toSeconds(9L),
-            2048,
-            "RSA",
-            "SHA256withRSA",
-            channelFactory,
-            backoffPolicyProvider,
-            RENEWAL_GRACE_PERIOD_SECONDS,
-            MeshCaCertificateProviderProvider.MAX_RETRY_ATTEMPTS_DEFAULT,
-            oauth2Creds,
-            timeService,
-            timeProvider,
-            RPC_TIMEOUT_MILLIS);
-  }
-
-  @Test
-  public void startAndClose() {
-    TestScheduledFuture<?> scheduledFuture = new TestScheduledFuture<>();
-    doReturn(scheduledFuture)
-        .when(timeService)
-        .schedule(any(Runnable.class), any(Long.TYPE), eq(TimeUnit.SECONDS));
-    provider.start();
-    SynchronizationContext.ScheduledHandle savedScheduledHandle = provider.scheduledHandle;
-    assertThat(savedScheduledHandle).isNotNull();
-    assertThat(savedScheduledHandle.isPending()).isTrue();
-    verify(timeService, times(1))
-        .schedule(
-            any(Runnable.class),
-            eq(MeshCaCertificateProvider.INITIAL_DELAY_SECONDS),
-            eq(TimeUnit.SECONDS));
-    DistributorWatcher distWatcher = provider.getWatcher();
-    assertThat(distWatcher.downstreamWatchers).hasSize(1);
-    PrivateKey mockKey = mock(PrivateKey.class);
-    X509Certificate mockCert = mock(X509Certificate.class);
-    distWatcher.updateCertificate(mockKey, ImmutableList.of(mockCert));
-    distWatcher.updateTrustedRoots(ImmutableList.of(mockCert));
-    provider.close();
-    assertThat(provider.scheduledHandle).isNull();
-    assertThat(savedScheduledHandle.isPending()).isFalse();
-    assertThat(distWatcher.downstreamWatchers).isEmpty();
-    assertThat(distWatcher.getLastIdentityCert()).isNull();
-  }
-
-  @Test
-  public void startTwice_noException() {
-    TestScheduledFuture<?> scheduledFuture = new TestScheduledFuture<>();
-    doReturn(scheduledFuture)
-        .when(timeService)
-        .schedule(any(Runnable.class), any(Long.TYPE), eq(TimeUnit.SECONDS));
-    provider.start();
-    SynchronizationContext.ScheduledHandle savedScheduledHandle1 = provider.scheduledHandle;
-    provider.start();
-    SynchronizationContext.ScheduledHandle savedScheduledHandle2 = provider.scheduledHandle;
-    assertThat(savedScheduledHandle2).isNotSameInstanceAs(savedScheduledHandle1);
-    assertThat(savedScheduledHandle2.isPending()).isTrue();
-  }
-
-  @Test
-  public void getCertificate()
-      throws IOException, CertificateException, OperatorCreationException,
-      NoSuchAlgorithmException {
-    oauth2Tokens.offer(TEST_STS_TOKEN + "0");
-    responsesToSend.offer(
-        new ResponseList(ImmutableList.of(
-            CommonTlsContextTestsUtil.getResourceContents(SERVER_0_PEM_FILE),
-            CommonTlsContextTestsUtil.getResourceContents(SERVER_1_PEM_FILE),
-            CommonTlsContextTestsUtil.getResourceContents(CA_PEM_FILE))));
-    when(timeProvider.currentTimeNanos()).thenReturn(CURRENT_TIME_NANOS);
-    TestScheduledFuture<?> scheduledFuture = new TestScheduledFuture<>();
-    doReturn(scheduledFuture)
-        .when(timeService)
-        .schedule(any(Runnable.class), any(Long.TYPE), eq(TimeUnit.SECONDS));
-    provider.refreshCertificate();
-    MeshCertificateRequest receivedReq = receivedRequests.poll();
-    assertThat(receivedReq.getValidity().getSeconds()).isEqualTo(TimeUnit.HOURS.toSeconds(9L));
-    // cannot decode CSR: just check the PEM format delimiters
-    String csr = receivedReq.getCsr();
-    assertThat(csr).startsWith("-----BEGIN NEW CERTIFICATE REQUEST-----");
-    verifyReceivedMetadataValues(1);
-    verify(timeService, times(1))
-        .schedule(
-            any(Runnable.class),
-            eq(
-                TimeUnit.MILLISECONDS.toSeconds(
-                    CERT0_VALIDITY_MILLIS
-                        - TimeUnit.SECONDS.toMillis(RENEWAL_GRACE_PERIOD_SECONDS))),
-            eq(TimeUnit.SECONDS));
-    verifyMockWatcher();
-  }
-
-  @Test
-  public void getCertificate_withError()
-      throws IOException, OperatorCreationException, NoSuchAlgorithmException {
-    oauth2Tokens.offer(TEST_STS_TOKEN + "0");
-    responsesToSend
-        .offer(new ResponseThrowable(new StatusRuntimeException(Status.FAILED_PRECONDITION)));
-    TestScheduledFuture<?> scheduledFuture = new TestScheduledFuture<>();
-    doReturn(scheduledFuture).when(timeService)
-        .schedule(any(Runnable.class), any(Long.TYPE), eq(TimeUnit.SECONDS));
-    provider.refreshCertificate();
-    verify(mockWatcher, never())
-        .updateCertificate(any(PrivateKey.class), ArgumentMatchers.<X509Certificate>anyList());
-    verify(mockWatcher, never()).updateTrustedRoots(ArgumentMatchers.<X509Certificate>anyList());
-    verify(mockWatcher, times(1)).onError(Status.FAILED_PRECONDITION);
-    verify(timeService, times(1)).schedule(any(Runnable.class),
-        eq(MeshCaCertificateProvider.INITIAL_DELAY_SECONDS),
-        eq(TimeUnit.SECONDS));
-    verifyReceivedMetadataValues(1);
-  }
-
-  @Test
-  public void getCertificate_withError_withExistingCert()
-      throws IOException, OperatorCreationException, NoSuchAlgorithmException {
-    PrivateKey mockKey = mock(PrivateKey.class);
-    X509Certificate mockCert = mock(X509Certificate.class);
-    // have current cert expire in 3 hours from current time
-    long threeHoursFromNowMillis = TimeUnit.NANOSECONDS
-        .toMillis(CURRENT_TIME_NANOS + TimeUnit.HOURS.toNanos(3));
-    when(mockCert.getNotAfter()).thenReturn(new Date(threeHoursFromNowMillis));
-    provider.getWatcher().updateCertificate(mockKey, ImmutableList.of(mockCert));
-    reset(mockWatcher);
-    oauth2Tokens.offer(TEST_STS_TOKEN + "0");
-    responsesToSend
-        .offer(new ResponseThrowable(new StatusRuntimeException(Status.FAILED_PRECONDITION)));
-    when(timeProvider.currentTimeNanos()).thenReturn(CURRENT_TIME_NANOS);
-    TestScheduledFuture<?> scheduledFuture = new TestScheduledFuture<>();
-    doReturn(scheduledFuture).when(timeService)
-        .schedule(any(Runnable.class), any(Long.TYPE), eq(TimeUnit.SECONDS));
-    provider.refreshCertificate();
-    verify(mockWatcher, never())
-        .updateCertificate(any(PrivateKey.class), ArgumentMatchers.<X509Certificate>anyList());
-    verify(mockWatcher, never()).updateTrustedRoots(ArgumentMatchers.<X509Certificate>anyList());
-    verify(mockWatcher, never()).onError(any(Status.class));
-    verify(timeService, times(1)).schedule(any(Runnable.class),
-        eq(5400L),
-        eq(TimeUnit.SECONDS));
-    assertThat(provider.getWatcher().getLastIdentityCert()).isNotNull();
-    verifyReceivedMetadataValues(1);
-  }
-
-  @Test
-  public void getCertificate_withError_withExistingExpiredCert()
-      throws IOException, OperatorCreationException, NoSuchAlgorithmException {
-    PrivateKey mockKey = mock(PrivateKey.class);
-    X509Certificate mockCert = mock(X509Certificate.class);
-    // have current cert expire in 3 seconds from current time
-    long threeSecondsFromNowMillis = TimeUnit.NANOSECONDS
-        .toMillis(CURRENT_TIME_NANOS + TimeUnit.SECONDS.toNanos(3));
-    when(mockCert.getNotAfter()).thenReturn(new Date(threeSecondsFromNowMillis));
-    provider.getWatcher().updateCertificate(mockKey, ImmutableList.of(mockCert));
-    reset(mockWatcher);
-    oauth2Tokens.offer(TEST_STS_TOKEN + "0");
-    responsesToSend
-        .offer(new ResponseThrowable(new StatusRuntimeException(Status.FAILED_PRECONDITION)));
-    when(timeProvider.currentTimeNanos()).thenReturn(CURRENT_TIME_NANOS);
-    TestScheduledFuture<?> scheduledFuture = new TestScheduledFuture<>();
-    doReturn(scheduledFuture).when(timeService)
-        .schedule(any(Runnable.class), any(Long.TYPE), eq(TimeUnit.SECONDS));
-    provider.refreshCertificate();
-    verify(mockWatcher, never())
-        .updateCertificate(any(PrivateKey.class), ArgumentMatchers.<X509Certificate>anyList());
-    verify(mockWatcher, never()).updateTrustedRoots(ArgumentMatchers.<X509Certificate>anyList());
-    verify(mockWatcher, times(1)).onError(Status.FAILED_PRECONDITION);
-    verify(timeService, times(1)).schedule(any(Runnable.class),
-        eq(MeshCaCertificateProvider.INITIAL_DELAY_SECONDS),
-        eq(TimeUnit.SECONDS));
-    assertThat(provider.getWatcher().getLastIdentityCert()).isNull();
-    verifyReceivedMetadataValues(1);
-  }
-
-  @Test
-  public void getCertificate_retriesWithErrors()
-      throws IOException, CertificateException, OperatorCreationException,
-      NoSuchAlgorithmException {
-    oauth2Tokens.offer(TEST_STS_TOKEN + "0");
-    oauth2Tokens.offer(TEST_STS_TOKEN + "1");
-    oauth2Tokens.offer(TEST_STS_TOKEN + "2");
-    responsesToSend.offer(new ResponseThrowable(new StatusRuntimeException(Status.UNKNOWN)));
-    responsesToSend.offer(
-        new ResponseThrowable(
-            new Exception(new StatusRuntimeException(Status.RESOURCE_EXHAUSTED))));
-    responsesToSend.offer(new ResponseList(ImmutableList.of(
-        CommonTlsContextTestsUtil.getResourceContents(SERVER_0_PEM_FILE),
-        CommonTlsContextTestsUtil.getResourceContents(SERVER_1_PEM_FILE),
-        CommonTlsContextTestsUtil.getResourceContents(CA_PEM_FILE))));
-    when(timeProvider.currentTimeNanos()).thenReturn(CURRENT_TIME_NANOS);
-    TestScheduledFuture<?> scheduledFuture = new TestScheduledFuture<>();
-    doReturn(scheduledFuture).when(timeService)
-        .schedule(any(Runnable.class), any(Long.TYPE), eq(TimeUnit.SECONDS));
-    TestScheduledFuture<?> scheduledFutureSleep = new TestScheduledFuture<>();
-    doReturn(scheduledFutureSleep).when(timeService)
-        .schedule(any(Runnable.class), any(Long.TYPE), eq(TimeUnit.NANOSECONDS));
-    provider.refreshCertificate();
-    assertThat(receivedRequests.size()).isEqualTo(3);
-    verify(timeService, times(1)).schedule(any(Runnable.class),
-        eq(TimeUnit.MILLISECONDS.toSeconds(
-            CERT0_VALIDITY_MILLIS - TimeUnit.SECONDS.toMillis(RENEWAL_GRACE_PERIOD_SECONDS))),
-        eq(TimeUnit.SECONDS));
-    verifyRetriesWithBackoff(scheduledFutureSleep, 2);
-    verifyMockWatcher();
-    verifyReceivedMetadataValues(3);
-  }
-
-  @Test
-  public void getCertificate_retriesWithTimeouts()
-      throws IOException, CertificateException, OperatorCreationException,
-      NoSuchAlgorithmException {
-    oauth2Tokens.offer(TEST_STS_TOKEN + "0");
-    oauth2Tokens.offer(TEST_STS_TOKEN + "1");
-    oauth2Tokens.offer(TEST_STS_TOKEN + "2");
-    oauth2Tokens.offer(TEST_STS_TOKEN + "3");
-    responsesToSend.offer(new ResponseToSend());
-    responsesToSend.offer(new ResponseToSend());
-    responsesToSend.offer(new ResponseToSend());
-    responsesToSend.offer(new ResponseList(ImmutableList.of(
-        CommonTlsContextTestsUtil.getResourceContents(SERVER_0_PEM_FILE),
-        CommonTlsContextTestsUtil.getResourceContents(SERVER_1_PEM_FILE),
-        CommonTlsContextTestsUtil.getResourceContents(CA_PEM_FILE))));
-    when(timeProvider.currentTimeNanos()).thenReturn(CURRENT_TIME_NANOS);
-    TestScheduledFuture<?> scheduledFuture = new TestScheduledFuture<>();
-    doReturn(scheduledFuture).when(timeService)
-        .schedule(any(Runnable.class), any(Long.TYPE), eq(TimeUnit.SECONDS));
-    TestScheduledFuture<?> scheduledFutureSleep = new TestScheduledFuture<>();
-    doReturn(scheduledFutureSleep).when(timeService)
-        .schedule(any(Runnable.class), any(Long.TYPE), eq(TimeUnit.NANOSECONDS));
-    provider.refreshCertificate();
-    assertThat(receivedRequests.size()).isEqualTo(4);
-    verify(timeService, times(1)).schedule(any(Runnable.class),
-        eq(TimeUnit.MILLISECONDS.toSeconds(
-            CERT0_VALIDITY_MILLIS - TimeUnit.SECONDS.toMillis(RENEWAL_GRACE_PERIOD_SECONDS))),
-        eq(TimeUnit.SECONDS));
-    verifyRetriesWithBackoff(scheduledFutureSleep, 3);
-    verifyMockWatcher();
-    verifyReceivedMetadataValues(4);
-  }
-
-  private void verifyRetriesWithBackoff(
-      TestScheduledFuture<?> scheduledFutureSleep, int numOfRetries) {
-    for (int i = 0; i < numOfRetries; i++) {
-      long delayValue = DELAY_VALUES[i];
-      verify(timeService, times(1)).schedule(any(Runnable.class),
-          eq(delayValue),
-          eq(TimeUnit.NANOSECONDS));
-      assertThat(scheduledFutureSleep.calls.get(i).timeout).isEqualTo(delayValue);
-      assertThat(scheduledFutureSleep.calls.get(i).unit).isEqualTo(TimeUnit.NANOSECONDS);
-    }
-  }
-
-  private void verifyMockWatcher() throws IOException, CertificateException {
-    ArgumentCaptor<List<X509Certificate>> certChainCaptor = ArgumentCaptor.forClass(null);
-    verify(mockWatcher, times(1))
-        .updateCertificate(any(PrivateKey.class), certChainCaptor.capture());
-    List<X509Certificate> certChain = certChainCaptor.getValue();
-    assertThat(certChain).hasSize(3);
-    assertThat(certChain.get(0))
-        .isEqualTo(CommonTlsContextTestsUtil.getCertFromResourceName(SERVER_0_PEM_FILE));
-    assertThat(certChain.get(1))
-        .isEqualTo(CommonTlsContextTestsUtil.getCertFromResourceName(SERVER_1_PEM_FILE));
-    assertThat(certChain.get(2))
-        .isEqualTo(CommonTlsContextTestsUtil.getCertFromResourceName(CA_PEM_FILE));
-
-    ArgumentCaptor<List<X509Certificate>> rootsCaptor = ArgumentCaptor.forClass(null);
-    verify(mockWatcher, times(1)).updateTrustedRoots(rootsCaptor.capture());
-    List<X509Certificate> roots = rootsCaptor.getValue();
-    assertThat(roots).hasSize(1);
-    assertThat(roots.get(0))
-        .isEqualTo(CommonTlsContextTestsUtil.getCertFromResourceName(CA_PEM_FILE));
-    verify(mockWatcher, never()).onError(any(Status.class));
-  }
-
-  private void verifyReceivedMetadataValues(int count) {
-    assertThat(receivedStsCreds).hasSize(count);
-    assertThat(receivedZoneValues).hasSize(count);
-    for (int i = 0; i < count; i++) {
-      assertThat(receivedStsCreds.poll()).isEqualTo("Bearer " + TEST_STS_TOKEN + i);
-      assertThat(receivedZoneValues.poll()).isEqualTo("location=locations/us-west2-a");
-    }
-  }
-
-  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;
-    }
-  }
-}
diff --git a/xds/src/test/java/io/grpc/xds/internal/grpcservice/HeaderValueTest.java b/xds/src/test/java/io/grpc/xds/internal/grpcservice/HeaderValueTest.java
new file mode 100644
index 00000000000..b55e6ae76f7
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/internal/grpcservice/HeaderValueTest.java
@@ -0,0 +1,49 @@
+/*
+ * 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.grpcservice;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import com.google.protobuf.ByteString;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class HeaderValueTest {
+
+  @Test
+  public void create_withStringValue_success() {
+    HeaderValue headerValue = HeaderValue.create("key1", "value1");
+    assertThat(headerValue.key()).isEqualTo("key1");
+    assertThat(headerValue.value().isPresent()).isTrue();
+    assertThat(headerValue.value().get()).isEqualTo("value1");
+    assertThat(headerValue.rawValue().isPresent()).isFalse();
+  }
+
+  @Test
+  public void create_withByteStringValue_success() {
+    ByteString rawValue = ByteString.copyFromUtf8("raw_value");
+    HeaderValue headerValue = HeaderValue.create("key2", rawValue);
+    assertThat(headerValue.key()).isEqualTo("key2");
+    assertThat(headerValue.rawValue().isPresent()).isTrue();
+    assertThat(headerValue.rawValue().get()).isEqualTo(rawValue);
+    assertThat(headerValue.value().isPresent()).isFalse();
+  }
+
+
+}
diff --git a/xds/src/test/java/io/grpc/xds/internal/grpcservice/HeaderValueValidationUtilsTest.java b/xds/src/test/java/io/grpc/xds/internal/grpcservice/HeaderValueValidationUtilsTest.java
new file mode 100644
index 00000000000..c4658f3f305
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/internal/grpcservice/HeaderValueValidationUtilsTest.java
@@ -0,0 +1,87 @@
+/*
+ * 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.xds.internal.grpcservice;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import com.google.protobuf.ByteString;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Unit tests for {@link HeaderValueValidationUtils}.
+ */
+@RunWith(JUnit4.class)
+public class HeaderValueValidationUtilsTest {
+
+  @Test
+  public void isDisallowed_string_emptyKey() {
+    assertThat(HeaderValueValidationUtils.isDisallowed("")).isTrue();
+  }
+
+  @Test
+  public void isDisallowed_string_tooLongKey() {
+    String longKey = new String(new char[16385]).replace('\0', 'a');
+    assertThat(HeaderValueValidationUtils.isDisallowed(longKey)).isTrue();
+  }
+
+  @Test
+  public void isDisallowed_string_notLowercase() {
+    assertThat(HeaderValueValidationUtils.isDisallowed("Content-Type")).isTrue();
+  }
+
+  @Test
+  public void isDisallowed_string_grpcPrefix() {
+    assertThat(HeaderValueValidationUtils.isDisallowed("grpc-timeout")).isTrue();
+  }
+
+  @Test
+  public void isDisallowed_string_systemHeader_colon() {
+    assertThat(HeaderValueValidationUtils.isDisallowed(":authority")).isTrue();
+  }
+
+  @Test
+  public void isDisallowed_string_systemHeader_host() {
+    assertThat(HeaderValueValidationUtils.isDisallowed("host")).isTrue();
+  }
+
+  @Test
+  public void isDisallowed_string_valid() {
+    assertThat(HeaderValueValidationUtils.isDisallowed("content-type")).isFalse();
+  }
+
+  @Test
+  public void isDisallowed_headerValue_tooLongValue() {
+    String longValue = new String(new char[16385]).replace('\0', 'v');
+    HeaderValue header = HeaderValue.create("content-type", longValue);
+    assertThat(HeaderValueValidationUtils.isDisallowed(header)).isTrue();
+  }
+
+  @Test
+  public void isDisallowed_headerValue_tooLongRawValue() {
+    ByteString longRawValue = ByteString.copyFrom(new byte[16385]);
+    HeaderValue header = HeaderValue.create("content-type", longRawValue);
+    assertThat(HeaderValueValidationUtils.isDisallowed(header)).isTrue();
+  }
+
+  @Test
+  public void isDisallowed_headerValue_valid() {
+    HeaderValue header = HeaderValue.create("content-type", "application/grpc");
+    assertThat(HeaderValueValidationUtils.isDisallowed(header)).isFalse();
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/internal/headermutations/HeaderMutationFilterTest.java b/xds/src/test/java/io/grpc/xds/internal/headermutations/HeaderMutationFilterTest.java
new file mode 100644
index 00000000000..f07997a6244
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/internal/headermutations/HeaderMutationFilterTest.java
@@ -0,0 +1,244 @@
+/*
+ * 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.headermutations;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertThrows;
+
+import com.google.common.base.Strings;
+import com.google.common.collect.ImmutableList;
+import com.google.protobuf.ByteString;
+import com.google.re2j.Pattern;
+import io.grpc.xds.internal.headermutations.HeaderValueOption.HeaderAppendAction;
+import java.util.Optional;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class HeaderMutationFilterTest {
+
+  private static final int MAX_HEADER_LENGTH = 16384;
+
+  private static HeaderValueOption header(String key, ByteString value) {
+    return HeaderValueOption.create(io.grpc.xds.internal.grpcservice.HeaderValue.create(key, value),
+        HeaderAppendAction.APPEND_IF_EXISTS_OR_ADD, false);
+  }
+
+  private static HeaderValueOption header(String key, String value) {
+    return HeaderValueOption.create(io.grpc.xds.internal.grpcservice.HeaderValue.create(key, value),
+        HeaderAppendAction.APPEND_IF_EXISTS_OR_ADD, false);
+  }
+
+  @Test
+  public void filter_validationRules_dropsInvalidHeaders() throws Exception {
+    HeaderMutationFilter filter = new HeaderMutationFilter(Optional.empty());
+    @SuppressWarnings("InlineMeInliner")
+    String longString = Strings.repeat("a", MAX_HEADER_LENGTH + 1);
+    ByteString longBytes = ByteString.copyFrom(new byte[MAX_HEADER_LENGTH + 1]);
+
+    HeaderMutations mutations = HeaderMutations.create(
+        ImmutableList.of(
+            header("add-key", "add-value"), header(":authority", "new-authority"),
+            header("host", "new-host"), header(":scheme", "https"), header(":method", "PUT"),
+            header("resp-add-key", "resp-add-value"), header(":scheme", "https"),
+            header(":path", "/new-path"), header(":grpc-trace-bin", "binary-value"),
+            header(":alt-svc", "h3=:443"), header("user-agent", "new-agent"),
+            header("Valid-Key", "value"), header("", "value"), header(longString, "value"),
+            header("long-value-key", longString), header("long-bin-key-bin", longBytes),
+            header("grpc-timeout", "10S"), header("valid-key-lower", "value")),
+        ImmutableList.of("remove-key", "host", ":authority", ":scheme", ":method", ":foo", ":bar",
+            "Valid-Key", "", longString, "grpc-timeout", "UPPER-REMOVE", "lower-remove"));
+
+    HeaderMutations filtered = filter.filter(mutations);
+
+    assertThat(filtered.headersToRemove()).containsExactly("remove-key", "lower-remove");
+    assertThat(filtered.headers()).containsExactly(
+        header("add-key", "add-value"), header("resp-add-key", "resp-add-value"),
+        header("user-agent", "new-agent"), header("valid-key-lower", "value"));
+  }
+
+  @Test
+  public void filter_validationRules_throwsOnInvalidHeaders() throws Exception {
+    HeaderMutationRulesConfig rules =
+        HeaderMutationRulesConfig.builder().disallowIsError(true).build();
+    HeaderMutationFilter filter = new HeaderMutationFilter(Optional.of(rules));
+    @SuppressWarnings("InlineMeInliner")
+    String longString = Strings.repeat("a", MAX_HEADER_LENGTH + 1);
+
+    // Test system headers modification
+    assertThrows(HeaderMutationDisallowedException.class, () -> filter.filter(HeaderMutations
+        .create(
+            ImmutableList.of(header(":path", "/new-path")), ImmutableList.of())));
+
+    // Test system headers removal
+    assertThrows(HeaderMutationDisallowedException.class,
+        () -> filter.filter(HeaderMutations.create(
+            ImmutableList.of(), ImmutableList.of(":path"))));
+
+    // Test uppercase header modification
+    assertThrows(HeaderMutationDisallowedException.class, () -> filter.filter(HeaderMutations
+        .create(
+            ImmutableList.of(header("Valid-Key", "value")), ImmutableList.of())));
+
+    // Test uppercase header removal
+    assertThrows(HeaderMutationDisallowedException.class, () -> filter
+        .filter(HeaderMutations.create(
+            ImmutableList.of(), ImmutableList.of("UPPER-REMOVE"))));
+
+    // Test empty header
+    assertThrows(HeaderMutationDisallowedException.class, () -> filter
+        .filter(HeaderMutations.create(
+            ImmutableList.of(header("", "value")), ImmutableList.of())));
+
+    // Test long header key
+    assertThrows(HeaderMutationDisallowedException.class, () -> filter
+        .filter(HeaderMutations.create(
+            ImmutableList.of(), ImmutableList.of(longString))));
+  }
+
+
+  @Test
+  public void filter_mutationRules_disallowAll_dropsAll() throws Exception {
+    HeaderMutationRulesConfig rules = HeaderMutationRulesConfig.builder().disallowAll(true).build();
+    HeaderMutationFilter filter = new HeaderMutationFilter(Optional.of(rules));
+    HeaderMutations mutations = HeaderMutations.create(
+        ImmutableList.of(header("add-key", "add-value"), header("resp-add-key", "resp-add-value")),
+        ImmutableList.of("remove-key"));
+
+    HeaderMutations filtered = filter.filter(mutations);
+
+    assertThat(filtered.headers()).isEmpty();
+    assertThat(filtered.headersToRemove()).isEmpty();
+  }
+
+  @Test
+  public void filter_mutationRules_disallowAll_throws() throws Exception {
+    HeaderMutationRulesConfig rules =
+        HeaderMutationRulesConfig.builder().disallowAll(true).disallowIsError(true).build();
+    HeaderMutationFilter filter = new HeaderMutationFilter(Optional.of(rules));
+
+    // Test add header
+    assertThrows(HeaderMutationDisallowedException.class, () -> filter.filter(HeaderMutations
+        .create(
+            ImmutableList.of(header("add-key", "add-value")), ImmutableList.of())));
+
+    // Test remove header
+    assertThrows(HeaderMutationDisallowedException.class, () -> filter
+        .filter(HeaderMutations.create(
+            ImmutableList.of(), ImmutableList.of("remove-key"))));
+
+    // Test response header
+    assertThrows(HeaderMutationDisallowedException.class, () -> filter.filter(HeaderMutations
+        .create(
+            ImmutableList.of(header("resp-add-key", "resp-add-value")), ImmutableList.of())));
+  }
+
+
+  @Test
+  public void filter_mutationRules_disallowExpression_dropsMatching() throws Exception {
+    HeaderMutationRulesConfig rules = HeaderMutationRulesConfig.builder()
+        .disallowExpression(Pattern.compile("^x-private-.*")).build();
+    HeaderMutationFilter filter = new HeaderMutationFilter(Optional.of(rules));
+    HeaderMutations mutations = HeaderMutations.create(
+        ImmutableList.of(header("x-public", "value"), header("x-private-key", "value"),
+            header("x-public-resp", "value"), header("x-private-resp", "value")),
+        ImmutableList.of("x-public-remove", "x-private-remove"));
+
+    HeaderMutations filtered = filter.filter(mutations);
+
+    assertThat(filtered.headersToRemove()).containsExactly("x-public-remove");
+    assertThat(filtered.headers()).containsExactly(header("x-public", "value"),
+            header("x-public-resp", "value"));
+  }
+
+  @Test
+  public void filter_mutationRules_disallowExpression_throws() throws Exception {
+    HeaderMutationRulesConfig rules = HeaderMutationRulesConfig.builder()
+        .disallowExpression(Pattern.compile("^x-private-.*")).disallowIsError(true).build();
+    HeaderMutationFilter filter = new HeaderMutationFilter(Optional.of(rules));
+
+    // Test disallowed key modification
+    assertThrows(HeaderMutationDisallowedException.class, () -> filter.filter(HeaderMutations
+        .create(
+            ImmutableList.of(header("x-private-key", "value")), ImmutableList.of())));
+
+    // Test disallowed key removal
+    assertThrows(HeaderMutationDisallowedException.class, () -> filter
+        .filter(HeaderMutations.create(
+            ImmutableList.of(), ImmutableList.of("x-private-remove"))));
+  }
+
+
+  @Test
+  public void filter_mutationRules_precedence() throws Exception {
+    HeaderMutationRulesConfig rules = HeaderMutationRulesConfig.builder()
+        .disallowAll(true)
+        .allowExpression(Pattern.compile("^x-allowed-.*"))
+        .disallowExpression(Pattern.compile("^x-allowed-but-disallowed-.*"))
+        .build();
+    HeaderMutationFilter filter = new HeaderMutationFilter(Optional.of(rules));
+
+    // Case 1: allowExpression overrides disallowAll
+    HeaderMutations mutations1 = HeaderMutations.create(
+        ImmutableList.of(header("x-allowed-key", "value"), header("not-allowed", "value")),
+        ImmutableList.of("x-allowed-remove", "not-allowed-remove"));
+    HeaderMutations filtered1 = filter.filter(mutations1);
+    assertThat(filtered1.headersToRemove()).containsExactly("x-allowed-remove");
+    assertThat(filtered1.headers()).containsExactly(header("x-allowed-key", "value"));
+
+    // Case 2: disallowExpression overrides allowExpression
+    HeaderMutations mutations2 = HeaderMutations.create(
+        ImmutableList.of(header("x-allowed-but-disallowed-key", "value")),
+        ImmutableList.of("x-allowed-but-disallowed-remove"));
+    HeaderMutations filtered2 = filter.filter(mutations2);
+    assertThat(filtered2.headers()).isEmpty();
+    assertThat(filtered2.headersToRemove()).isEmpty();
+  }
+
+  @Test
+  public void filter_mutationRules_precedence_throws() throws Exception {
+    // Case 1: allowExpression overrides disallowAll (does not throw)
+    HeaderMutationRulesConfig rules1 = HeaderMutationRulesConfig.builder()
+        .disallowAll(true)
+        .allowExpression(Pattern.compile("^x-allowed-.*"))
+        .disallowIsError(true)
+        .build();
+    HeaderMutationFilter filter1 = new HeaderMutationFilter(Optional.of(rules1));
+    HeaderMutations mutations1 = HeaderMutations.create(
+        ImmutableList.of(header("x-allowed-key", "value")), ImmutableList.of("x-allowed-remove"));
+    HeaderMutations filtered1 = filter1.filter(mutations1);
+    assertThat(filtered1.headersToRemove()).containsExactly("x-allowed-remove");
+    assertThat(filtered1.headers()).containsExactly(header("x-allowed-key", "value"));
+
+    // Case 2: disallowExpression overrides allowExpression (throws)
+    HeaderMutationRulesConfig rules2 = HeaderMutationRulesConfig.builder()
+        .allowExpression(Pattern.compile("^x-allowed-.*"))
+        .disallowExpression(Pattern.compile("^x-allowed-but-disallowed-.*"))
+        .disallowIsError(true)
+        .build();
+    HeaderMutationFilter filter2 = new HeaderMutationFilter(Optional.of(rules2));
+    assertThrows(HeaderMutationDisallowedException.class,
+        () -> filter2.filter(HeaderMutations.create(
+            ImmutableList.of(header("x-allowed-but-disallowed-key", "value")),
+            ImmutableList.of())));
+
+    assertThrows(HeaderMutationDisallowedException.class, () -> filter2.filter(HeaderMutations
+        .create(
+            ImmutableList.of(), ImmutableList.of("x-allowed-but-disallowed-remove"))));
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/internal/headermutations/HeaderMutationRulesConfigTest.java b/xds/src/test/java/io/grpc/xds/internal/headermutations/HeaderMutationRulesConfigTest.java
new file mode 100644
index 00000000000..9f5cb75460f
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/internal/headermutations/HeaderMutationRulesConfigTest.java
@@ -0,0 +1,84 @@
+/*
+ * 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.headermutations;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import com.google.re2j.Pattern;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class HeaderMutationRulesConfigTest {
+  @Test
+  public void testBuilderDefaultValues() {
+    HeaderMutationRulesConfig config = HeaderMutationRulesConfig.builder().build();
+    assertFalse(config.disallowAll());
+    assertFalse(config.disallowIsError());
+    assertThat(config.allowExpression()).isEmpty();
+    assertThat(config.disallowExpression()).isEmpty();
+  }
+
+  @Test
+  public void testBuilder_setDisallowAll() {
+    HeaderMutationRulesConfig config =
+        HeaderMutationRulesConfig.builder().disallowAll(true).build();
+    assertTrue(config.disallowAll());
+  }
+
+  @Test
+  public void testBuilder_setDisallowIsError() {
+    HeaderMutationRulesConfig config =
+        HeaderMutationRulesConfig.builder().disallowIsError(true).build();
+    assertTrue(config.disallowIsError());
+  }
+
+  @Test
+  public void testBuilder_setAllowExpression() {
+    Pattern pattern = Pattern.compile("allow.*");
+    HeaderMutationRulesConfig config =
+        HeaderMutationRulesConfig.builder().allowExpression(pattern).build();
+    assertThat(config.allowExpression()).hasValue(pattern);
+  }
+
+  @Test
+  public void testBuilder_setDisallowExpression() {
+    Pattern pattern = Pattern.compile("disallow.*");
+    HeaderMutationRulesConfig config =
+        HeaderMutationRulesConfig.builder().disallowExpression(pattern).build();
+    assertThat(config.disallowExpression()).hasValue(pattern);
+  }
+
+  @Test
+  public void testBuilder_setAll() {
+    Pattern allowPattern = Pattern.compile("allow.*");
+    Pattern disallowPattern = Pattern.compile("disallow.*");
+    HeaderMutationRulesConfig config = HeaderMutationRulesConfig.builder()
+        .disallowAll(true)
+        .disallowIsError(true)
+        .allowExpression(allowPattern)
+        .disallowExpression(disallowPattern)
+        .build();
+    assertTrue(config.disallowAll());
+    assertTrue(config.disallowIsError());
+    assertThat(config.allowExpression()).hasValue(allowPattern);
+    assertThat(config.disallowExpression()).hasValue(disallowPattern);
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/internal/headermutations/HeaderMutationRulesParserTest.java b/xds/src/test/java/io/grpc/xds/internal/headermutations/HeaderMutationRulesParserTest.java
new file mode 100644
index 00000000000..e880c197450
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/internal/headermutations/HeaderMutationRulesParserTest.java
@@ -0,0 +1,90 @@
+/*
+ * 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.headermutations;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertThrows;
+
+import com.google.protobuf.BoolValue;
+import io.envoyproxy.envoy.config.common.mutation_rules.v3.HeaderMutationRules;
+import io.envoyproxy.envoy.type.matcher.v3.RegexMatcher;
+import io.grpc.xds.internal.headermutations.HeaderMutationRulesParseException;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class HeaderMutationRulesParserTest {
+
+  @Test
+  public void parse_protoWithAllFields_success() throws Exception {
+    HeaderMutationRules proto = HeaderMutationRules.newBuilder()
+        .setAllowExpression(RegexMatcher.newBuilder().setRegex("allow-.*"))
+        .setDisallowExpression(RegexMatcher.newBuilder().setRegex("disallow-.*"))
+        .setDisallowAll(BoolValue.newBuilder().setValue(true).build())
+        .setDisallowIsError(BoolValue.newBuilder().setValue(true).build())
+        .build();
+
+    HeaderMutationRulesConfig config = HeaderMutationRulesParser.parse(proto);
+
+    assertThat(config.allowExpression().isPresent()).isTrue();
+    assertThat(config.allowExpression().get().pattern()).isEqualTo("allow-.*");
+
+    assertThat(config.disallowExpression().isPresent()).isTrue();
+    assertThat(config.disallowExpression().get().pattern()).isEqualTo("disallow-.*");
+
+    assertThat(config.disallowAll()).isTrue();
+    assertThat(config.disallowIsError()).isTrue();
+  }
+
+  @Test
+  public void parse_protoWithNoExpressions_success() throws Exception {
+    HeaderMutationRules proto = HeaderMutationRules.newBuilder().build();
+
+    HeaderMutationRulesConfig config = HeaderMutationRulesParser.parse(proto);
+
+    assertThat(config.allowExpression().isPresent()).isFalse();
+    assertThat(config.disallowExpression().isPresent()).isFalse();
+    assertThat(config.disallowAll()).isFalse();
+    assertThat(config.disallowIsError()).isFalse();
+  }
+
+  @Test
+  public void parse_invalidRegexAllowExpression_throwsHeaderMutationRulesParseException() {
+    HeaderMutationRules proto = HeaderMutationRules.newBuilder()
+        .setAllowExpression(RegexMatcher.newBuilder().setRegex("allow-["))
+        .build();
+
+    HeaderMutationRulesParseException exception = assertThrows(
+        HeaderMutationRulesParseException.class, () -> HeaderMutationRulesParser.parse(proto));
+
+    assertThat(exception).hasMessageThat().contains("Invalid regex pattern for allow_expression");
+  }
+
+  @Test
+  public void parse_invalidRegexDisallowExpression_throwsHeaderMutationRulesParseException() {
+    HeaderMutationRules proto = HeaderMutationRules.newBuilder()
+        .setDisallowExpression(RegexMatcher.newBuilder().setRegex("disallow-["))
+        .build();
+
+    HeaderMutationRulesParseException exception = assertThrows(
+        HeaderMutationRulesParseException.class, () -> HeaderMutationRulesParser.parse(proto));
+
+    assertThat(exception).hasMessageThat()
+        .contains("Invalid regex pattern for disallow_expression");
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/internal/headermutations/HeaderMutationsTest.java b/xds/src/test/java/io/grpc/xds/internal/headermutations/HeaderMutationsTest.java
new file mode 100644
index 00000000000..ef7f22b7ac8
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/internal/headermutations/HeaderMutationsTest.java
@@ -0,0 +1,40 @@
+/*
+ * 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.headermutations;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import com.google.common.collect.ImmutableList;
+import io.grpc.xds.internal.grpcservice.HeaderValue;
+import io.grpc.xds.internal.headermutations.HeaderValueOption.HeaderAppendAction;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class HeaderMutationsTest {
+  @Test
+  public void testCreate() {
+    HeaderValueOption header = HeaderValueOption.create(
+        HeaderValue.create("key", "value"),
+        HeaderAppendAction.APPEND_IF_EXISTS_OR_ADD, false);
+    HeaderMutations mutations = HeaderMutations.create(
+        ImmutableList.of(header), ImmutableList.of("remove-key"));
+    assertThat(mutations.headers()).containsExactly(header);
+    assertThat(mutations.headersToRemove()).containsExactly("remove-key");
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/internal/headermutations/HeaderMutatorTest.java b/xds/src/test/java/io/grpc/xds/internal/headermutations/HeaderMutatorTest.java
new file mode 100644
index 00000000000..b6806760f9b
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/internal/headermutations/HeaderMutatorTest.java
@@ -0,0 +1,315 @@
+/*
+ * 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.headermutations;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.testing.TestLogHandler;
+import com.google.protobuf.ByteString;
+import io.grpc.Metadata;
+import io.grpc.xds.internal.grpcservice.HeaderValue;
+import io.grpc.xds.internal.headermutations.HeaderMutations;
+import io.grpc.xds.internal.headermutations.HeaderValueOption.HeaderAppendAction;
+import java.util.logging.Level;
+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 HeaderMutatorTest {
+
+  private static final Metadata.Key<byte[]> BINARY_KEY =
+      Metadata.Key.of("some-key-bin", Metadata.BINARY_BYTE_MARSHALLER);
+  private static final Metadata.Key<String> APPEND_KEY =
+      Metadata.Key.of("append-key", Metadata.ASCII_STRING_MARSHALLER);
+  private static final Metadata.Key<String> ADD_KEY =
+      Metadata.Key.of("add-key", Metadata.ASCII_STRING_MARSHALLER);
+  private static final Metadata.Key<String> OVERWRITE_KEY =
+      Metadata.Key.of("overwrite-key", Metadata.ASCII_STRING_MARSHALLER);
+  private static final Metadata.Key<String> REMOVE_KEY =
+      Metadata.Key.of("remove-key", Metadata.ASCII_STRING_MARSHALLER);
+  private static final Metadata.Key<String> NEW_ADD_KEY =
+      Metadata.Key.of("new-add-key", Metadata.ASCII_STRING_MARSHALLER);
+  private static final Metadata.Key<String> NEW_OVERWRITE_KEY =
+      Metadata.Key.of("new-overwrite-key", Metadata.ASCII_STRING_MARSHALLER);
+  private static final Metadata.Key<String> OVERWRITE_IF_EXISTS_KEY =
+      Metadata.Key.of("overwrite-if-exists-key", Metadata.ASCII_STRING_MARSHALLER);
+  private static final Metadata.Key<String> OVERWRITE_IF_EXISTS_ABSENT_KEY =
+      Metadata.Key.of("overwrite-if-exists-absent-key", Metadata.ASCII_STRING_MARSHALLER);
+
+  private final HeaderMutator headerMutator = HeaderMutator.create();
+
+  private static final TestLogHandler logHandler = new TestLogHandler();
+  private static final Logger logger = Logger.getLogger(HeaderMutator.class.getName());
+
+  @Before
+  public void setUp() {
+    logHandler.clear();
+    logger.addHandler(logHandler);
+    logger.setLevel(Level.WARNING);
+  }
+
+  @After
+  public void tearDown() {
+    logger.removeHandler(logHandler);
+  }
+
+  private static HeaderValueOption header(String key, String value, HeaderAppendAction action) {
+    return HeaderValueOption.create(HeaderValue.create(key, value), action, false);
+  }
+
+  @Test
+  public void applyMutations_asciiHeaders() {
+    Metadata headers = new Metadata();
+    headers.put(APPEND_KEY, "append-value-1");
+    headers.put(ADD_KEY, "add-value-original");
+    headers.put(OVERWRITE_KEY, "overwrite-value-original");
+    headers.put(REMOVE_KEY, "remove-value-original");
+    headers.put(OVERWRITE_IF_EXISTS_KEY, "original-value");
+
+    HeaderMutations mutations =
+        HeaderMutations.create(
+            ImmutableList.of(
+                header(
+                    APPEND_KEY.name(),
+                    "append-value-2",
+                    HeaderAppendAction.APPEND_IF_EXISTS_OR_ADD),
+                header(ADD_KEY.name(), "add-value-new", HeaderAppendAction.ADD_IF_ABSENT),
+                header(NEW_ADD_KEY.name(), "new-add-value", HeaderAppendAction.ADD_IF_ABSENT),
+                header(
+                    OVERWRITE_KEY.name(),
+                    "overwrite-value-new",
+                    HeaderAppendAction.OVERWRITE_IF_EXISTS_OR_ADD),
+                header(
+                    NEW_OVERWRITE_KEY.name(),
+                    "new-overwrite-value",
+                    HeaderAppendAction.OVERWRITE_IF_EXISTS_OR_ADD),
+                header(
+                    OVERWRITE_IF_EXISTS_KEY.name(),
+                    "new-value",
+                    HeaderAppendAction.OVERWRITE_IF_EXISTS),
+                header(
+                    OVERWRITE_IF_EXISTS_ABSENT_KEY.name(),
+                    "new-value",
+                    HeaderAppendAction.OVERWRITE_IF_EXISTS)),
+            ImmutableList.of(REMOVE_KEY.name()));
+
+    headerMutator.applyMutations(mutations, headers);
+
+    assertThat(headers.getAll(APPEND_KEY)).containsExactly("append-value-1", "append-value-2");
+    assertThat(headers.get(ADD_KEY)).isEqualTo("add-value-original");
+    assertThat(headers.get(NEW_ADD_KEY)).isEqualTo("new-add-value");
+    assertThat(headers.get(OVERWRITE_KEY)).isEqualTo("overwrite-value-new");
+    assertThat(headers.get(NEW_OVERWRITE_KEY)).isEqualTo("new-overwrite-value");
+    assertThat(headers.containsKey(REMOVE_KEY)).isFalse();
+    assertThat(headers.get(OVERWRITE_IF_EXISTS_KEY)).isEqualTo("new-value");
+    assertThat(headers.containsKey(OVERWRITE_IF_EXISTS_ABSENT_KEY)).isFalse();
+  }
+
+  @Test
+  public void applyMutations_removalHasPriority() {
+    Metadata headers = new Metadata();
+    headers.put(REMOVE_KEY, "value");
+    HeaderMutations mutations =
+        HeaderMutations.create(
+            ImmutableList.of(
+                header(
+                    REMOVE_KEY.name(), "new-value", HeaderAppendAction.OVERWRITE_IF_EXISTS_OR_ADD)),
+            ImmutableList.of(REMOVE_KEY.name()));
+
+    headerMutator.applyMutations(mutations, headers);
+
+    assertThat(headers.containsKey(REMOVE_KEY)).isFalse();
+  }
+
+  @Test
+  public void applyMutations_binary() {
+    Metadata headers = new Metadata();
+    byte[] value = new byte[] {1, 2, 3};
+    HeaderValueOption option =
+        HeaderValueOption.create(
+            HeaderValue.create(BINARY_KEY.name(), ByteString.copyFrom(value)),
+            HeaderAppendAction.APPEND_IF_EXISTS_OR_ADD,
+            false);
+    headerMutator.applyMutations(
+        HeaderMutations.create(ImmutableList.of(option), ImmutableList.of()), headers);
+    assertThat(headers.get(BINARY_KEY)).isEqualTo(value);
+  }
+
+  @Test
+  public void applyResponseMutations_asciiHeaders() {
+    Metadata headers = new Metadata();
+    headers.put(APPEND_KEY, "append-value-1");
+    headers.put(ADD_KEY, "add-value-original");
+    headers.put(OVERWRITE_KEY, "overwrite-value-original");
+
+    HeaderMutations mutations =
+        HeaderMutations.create(
+            ImmutableList.of(
+                header(
+                    APPEND_KEY.name(),
+                    "append-value-2",
+                    HeaderAppendAction.APPEND_IF_EXISTS_OR_ADD),
+                header(ADD_KEY.name(), "add-value-new", HeaderAppendAction.ADD_IF_ABSENT),
+                header(NEW_ADD_KEY.name(), "new-add-value", HeaderAppendAction.ADD_IF_ABSENT),
+                header(
+                    OVERWRITE_KEY.name(),
+                    "overwrite-value-new",
+                    HeaderAppendAction.OVERWRITE_IF_EXISTS_OR_ADD),
+                header(
+                    NEW_OVERWRITE_KEY.name(),
+                    "new-overwrite-value",
+                    HeaderAppendAction.OVERWRITE_IF_EXISTS_OR_ADD)), ImmutableList.of());
+
+    headerMutator.applyMutations(mutations, headers);
+
+    assertThat(headers.getAll(APPEND_KEY)).containsExactly("append-value-1", "append-value-2");
+    assertThat(headers.get(ADD_KEY)).isEqualTo("add-value-original");
+    assertThat(headers.get(NEW_ADD_KEY)).isEqualTo("new-add-value");
+    assertThat(headers.get(OVERWRITE_KEY)).isEqualTo("overwrite-value-new");
+    assertThat(headers.get(NEW_OVERWRITE_KEY)).isEqualTo("new-overwrite-value");
+  }
+
+  @Test
+  public void applyResponseMutations_binary() {
+    Metadata headers = new Metadata();
+    byte[] value = new byte[] {1, 2, 3};
+    HeaderValueOption option =
+        HeaderValueOption.create(
+            HeaderValue.create(BINARY_KEY.name(), ByteString.copyFrom(value)),
+            HeaderAppendAction.APPEND_IF_EXISTS_OR_ADD,
+            false);
+    headerMutator.applyMutations(
+        HeaderMutations.create(ImmutableList.of(option), ImmutableList.of()), headers);
+    assertThat(headers.get(BINARY_KEY)).isEqualTo(value);
+  }
+
+  @Test
+  public void applyMutations_keepEmptyValue() {
+    Metadata headers = new Metadata();
+    headers.put(APPEND_KEY, "existing-value");
+    headers.put(OVERWRITE_KEY, "existing-value");
+    headers.put(OVERWRITE_IF_EXISTS_KEY, "existing-value");
+
+    HeaderMutations mutations =
+        HeaderMutations.create(
+            ImmutableList.of(
+                header(NEW_ADD_KEY.name(), "", HeaderAppendAction.APPEND_IF_EXISTS_OR_ADD),
+                header(APPEND_KEY.name(), "", HeaderAppendAction.APPEND_IF_EXISTS_OR_ADD),
+                header(OVERWRITE_KEY.name(), "", HeaderAppendAction.OVERWRITE_IF_EXISTS_OR_ADD),
+                header(ADD_KEY.name(), "", HeaderAppendAction.ADD_IF_ABSENT),
+                header(OVERWRITE_IF_EXISTS_KEY.name(), "", HeaderAppendAction.OVERWRITE_IF_EXISTS),
+                    HeaderValueOption.create(
+                    HeaderValue.create("keep-empty-key", ""),
+                    HeaderAppendAction.APPEND_IF_EXISTS_OR_ADD,
+                    true),
+                HeaderValueOption.create(
+                    HeaderValue.create("keep-empty-overwrite-key", ""),
+                    HeaderAppendAction.OVERWRITE_IF_EXISTS_OR_ADD,
+                    true),
+                    HeaderValueOption.create(
+                    HeaderValue.create("keep-empty-bin-key-bin", ByteString.EMPTY),
+                    HeaderAppendAction.APPEND_IF_EXISTS_OR_ADD, true),
+                HeaderValueOption.create(
+                    HeaderValue.create("ignore-empty-bin-key-bin", ByteString.EMPTY),
+                    HeaderAppendAction.APPEND_IF_EXISTS_OR_ADD, false),
+                HeaderValueOption.create(
+                    HeaderValue.create("overwrite-empty-bin-key-bin", ByteString.EMPTY),
+                    HeaderAppendAction.OVERWRITE_IF_EXISTS_OR_ADD, false)),
+            ImmutableList.of());
+
+    headers.put(
+        Metadata.Key.of("keep-empty-overwrite-key", Metadata.ASCII_STRING_MARSHALLER), "old");
+
+    Metadata.Key<byte[]> overwriteEmptyBinKey =
+        Metadata.Key.of("overwrite-empty-bin-key-bin", Metadata.BINARY_BYTE_MARSHALLER);
+    byte[] originalBinValue = new byte[] {1, 2, 3};
+    headers.put(overwriteEmptyBinKey, originalBinValue);
+
+    headerMutator.applyMutations(mutations, headers);
+
+    assertThat(headers.containsKey(NEW_ADD_KEY)).isFalse();
+    assertThat(headers.getAll(APPEND_KEY)).containsExactly("existing-value");
+    assertThat(headers.get(OVERWRITE_KEY)).isEqualTo("existing-value");
+    assertThat(headers.containsKey(ADD_KEY)).isFalse();
+    assertThat(headers.get(OVERWRITE_IF_EXISTS_KEY)).isEqualTo("existing-value");
+
+    Metadata.Key<String> keepEmptyKey =
+        Metadata.Key.of("keep-empty-key", Metadata.ASCII_STRING_MARSHALLER);
+    Metadata.Key<String> keepEmptyOverwriteKey =
+        Metadata.Key.of("keep-empty-overwrite-key", Metadata.ASCII_STRING_MARSHALLER);
+
+    assertThat(headers.containsKey(keepEmptyKey)).isTrue();
+    assertThat(headers.get(keepEmptyKey)).isEqualTo("");
+    assertThat(headers.containsKey(keepEmptyOverwriteKey)).isTrue();
+    assertThat(headers.get(keepEmptyOverwriteKey)).isEqualTo("");
+
+    Metadata.Key<byte[]> keepEmptyBinKey =
+        Metadata.Key.of("keep-empty-bin-key-bin", Metadata.BINARY_BYTE_MARSHALLER);
+    Metadata.Key<byte[]> ignoreEmptyBinKey =
+        Metadata.Key.of("ignore-empty-bin-key-bin", Metadata.BINARY_BYTE_MARSHALLER);
+
+    assertThat(headers.containsKey(keepEmptyBinKey)).isTrue();
+    assertThat(headers.get(keepEmptyBinKey)).isEqualTo(new byte[0]);
+    assertThat(headers.containsKey(ignoreEmptyBinKey)).isFalse();
+    assertThat(headers.get(overwriteEmptyBinKey)).isEqualTo(originalBinValue);
+  }
+
+  @Test
+  public void applyMutations_binaryRemoval() {
+    Metadata headers = new Metadata();
+    byte[] value = new byte[] {1, 2, 3};
+    headers.put(BINARY_KEY, value);
+    HeaderMutations mutations =
+        HeaderMutations.create(ImmutableList.of(), ImmutableList.of(BINARY_KEY.name()));
+
+    headerMutator.applyMutations(mutations, headers);
+
+    assertThat(headers.containsKey(BINARY_KEY)).isFalse();
+  }
+
+  @Test
+  public void applyMutations_stringValueWithBinaryKey_ignored() {
+    Metadata headers = new Metadata();
+    HeaderValueOption option = HeaderValueOption.create(HeaderValue.create("some-key-bin", "value"),
+        HeaderAppendAction.APPEND_IF_EXISTS_OR_ADD, false);
+
+    headerMutator.applyMutations(
+        HeaderMutations.create(ImmutableList.of(option), ImmutableList.of()), headers);
+
+    Metadata.Key<byte[]> key = Metadata.Key.of("some-key-bin", Metadata.BINARY_BYTE_MARSHALLER);
+    assertThat(headers.containsKey(key)).isFalse();
+  }
+
+  @Test
+  public void applyMutations_binaryValueWithAsciiKey_ignored() {
+    Metadata headers = new Metadata();
+    HeaderValueOption option = HeaderValueOption.create(
+        HeaderValue.create("some-key", ByteString.copyFrom(new byte[] {1})),
+        HeaderAppendAction.APPEND_IF_EXISTS_OR_ADD, false);
+
+    headerMutator.applyMutations(
+        HeaderMutations.create(ImmutableList.of(option), ImmutableList.of()), headers);
+
+    Metadata.Key<String> key = Metadata.Key.of("some-key", Metadata.ASCII_STRING_MARSHALLER);
+    assertThat(headers.containsKey(key)).isFalse();
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/internal/headermutations/HeaderValueOptionTest.java b/xds/src/test/java/io/grpc/xds/internal/headermutations/HeaderValueOptionTest.java
new file mode 100644
index 00000000000..49c43749135
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/internal/headermutations/HeaderValueOptionTest.java
@@ -0,0 +1,40 @@
+/*
+ * 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.headermutations;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import io.grpc.xds.internal.grpcservice.HeaderValue;
+import io.grpc.xds.internal.headermutations.HeaderValueOption.HeaderAppendAction;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class HeaderValueOptionTest {
+
+  @Test
+  public void create_withAllFields_success() {
+    HeaderValue header = HeaderValue.create("key1", "value1");
+    HeaderValueOption option = HeaderValueOption.create(
+        header, HeaderAppendAction.APPEND_IF_EXISTS_OR_ADD, true);
+
+    assertThat(option.header()).isEqualTo(header);
+    assertThat(option.appendAction()).isEqualTo(HeaderAppendAction.APPEND_IF_EXISTS_OR_ADD);
+    assertThat(option.keepEmptyValue()).isTrue();
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/internal/rbac/engine/AuthzEngineEvaluationTest.java b/xds/src/test/java/io/grpc/xds/internal/rbac/engine/AuthzEngineEvaluationTest.java
deleted file mode 100644
index bd8d35744b6..00000000000
--- a/xds/src/test/java/io/grpc/xds/internal/rbac/engine/AuthzEngineEvaluationTest.java
+++ /dev/null
@@ -1,469 +0,0 @@
-/*
- * 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.rbac.engine;
-
-import static com.google.common.truth.Truth.assertThat;
-import static org.junit.Assert.assertEquals;
-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 com.google.api.expr.v1alpha1.Expr;
-import com.google.api.expr.v1alpha1.Expr.Ident;
-import com.google.common.collect.ImmutableMap;
-import io.envoyproxy.envoy.config.rbac.v2.Policy;
-import io.envoyproxy.envoy.config.rbac.v2.RBAC;
-import io.envoyproxy.envoy.config.rbac.v2.RBAC.Action;
-import io.grpc.xds.internal.rbac.engine.cel.Activation;
-import io.grpc.xds.internal.rbac.engine.cel.InterpreterException;
-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.Mock;
-import org.mockito.Mockito;
-import org.mockito.junit.MockitoJUnit;
-import org.mockito.junit.MockitoRule;
-
-/** Unit tests for evaluate function of CEL Evaluation Engine. */
-@RunWith(JUnit4.class)
-public class AuthzEngineEvaluationTest {
-  @Rule
-  public final MockitoRule mocks = MockitoJUnit.rule();
-  
-  @Mock
-  private EvaluateArgs args;
-  @Mock
-  private Map<String, Object> attributes;
-
-  private AuthorizationEngine spyEngine;
-  private AuthorizationDecision evaluateResult;
-
-  // Mock RBAC engine with ALLOW action.
-  private RBAC rbacAllow;
-  // Mock RBAC engine with DENY action.
-  private RBAC rbacDeny;
-
-  // Mock policies that will be used to construct RBAC Engine.
-  private Policy policy1;
-  private Policy policy2;
-  private Policy policy3;
-  private Policy policy4;
-  private Policy policy5;
-  private Policy policy6;
-
-  // Mock conditions that will be used to construct RBAC poilcies.
-  private Expr condition1;
-  private Expr condition2;
-  private Expr condition3;
-  private Expr condition4;
-  private Expr condition5;
-  private Expr condition6;
-  
-  @Before
-  public void buildRbac() {
-    // Set up RBAC conditions.
-    condition1 = Expr.newBuilder()
-        .setIdentExpr(Ident.newBuilder().setName("Condition 1").build())
-        .build();
-    condition2 = Expr.newBuilder()
-        .setIdentExpr(Ident.newBuilder().setName("Condition 2").build())
-        .build();
-    condition3 = Expr.newBuilder()
-        .setIdentExpr(Ident.newBuilder().setName("Condition 3").build())
-        .build();
-    condition4 = Expr.newBuilder()
-        .setIdentExpr(Ident.newBuilder().setName("Condition 4").build())
-        .build();
-    condition5 = Expr.newBuilder()
-        .setIdentExpr(Ident.newBuilder().setName("Condition 5").build())
-        .build();
-    condition6 = Expr.newBuilder()
-        .setIdentExpr(Ident.newBuilder().setName("Condition 6").build())
-        .build();
-    // Set up RBAC policies.
-    policy1 = Policy.newBuilder().setCondition(condition1).build();
-    policy2 = Policy.newBuilder().setCondition(condition2).build();
-    policy3 = Policy.newBuilder().setCondition(condition3).build();
-    policy4 = Policy.newBuilder().setCondition(condition4).build();
-    policy5 = Policy.newBuilder().setCondition(condition5).build();
-    policy6 = Policy.newBuilder().setCondition(condition6).build();
-    // Set up RBACs.
-    rbacAllow = RBAC.newBuilder()
-        .setAction(Action.ALLOW)
-        .putPolicies("Policy 1", policy1)
-        .putPolicies("Policy 2", policy2)
-        .putPolicies("Policy 3", policy3)
-        .build();
-    rbacDeny = RBAC.newBuilder()
-        .setAction(Action.DENY)
-        .putPolicies("Policy 4", policy4)
-        .putPolicies("Policy 5", policy5)
-        .putPolicies("Policy 6", policy6)
-        .build();
-  }
-
-  /** Build an ALLOW engine from Policy 1, 2, 3. */
-  @Before
-  public void setupEngineSingleRbacAllow() {
-    buildRbac();
-    AuthorizationEngine engine = new AuthorizationEngine(rbacAllow);
-    spyEngine = Mockito.spy(engine);
-    doReturn(ImmutableMap.copyOf(attributes)).when(args).generateEnvoyAttributes();
-  }
-
-  /** Build a DENY engine from Policy 4, 5, 6. */
-  @Before
-  public void setupEngineSingleRbacDeny() {
-    buildRbac();
-    AuthorizationEngine engine = new AuthorizationEngine(rbacDeny);
-    spyEngine = Mockito.spy(engine);
-    doReturn(ImmutableMap.copyOf(attributes)).when(args).generateEnvoyAttributes();
-  }
-
-  /** Build a pair of engines with a DENY engine followed by an ALLOW engine. */
-  @Before
-  public void setupEngineRbacPair() {
-    buildRbac();
-    AuthorizationEngine engine = new AuthorizationEngine(rbacDeny, rbacAllow);
-    spyEngine = Mockito.spy(engine);
-    doReturn(ImmutableMap.copyOf(attributes)).when(args).generateEnvoyAttributes();
-  }
-
-  /**
-   * Test on the ALLOW engine.
-   * The evaluation result of all the CEL expressions is set to true,
-   * so the gRPC authorization returns ALLOW.
-   */
-  @Test
-  public void testAllowEngineWithAllMatchedPolicies() throws InterpreterException {
-    setupEngineSingleRbacAllow();
-    // Policy 1 - matched; Policy 2 - matched; Policy 3 - matched
-    doReturn(true).when(spyEngine).matches(eq(condition1), any(Activation.class));
-    doReturn(true).when(spyEngine).matches(eq(condition2), any(Activation.class));
-    doReturn(true).when(spyEngine).matches(eq(condition3), any(Activation.class));
-    evaluateResult = spyEngine.evaluate(args);
-    assertThat(evaluateResult.getDecision()).isEqualTo(AuthorizationDecision.Output.ALLOW);
-    assertThat(evaluateResult.getPolicyNames()).hasSize(1);
-    assertThat(evaluateResult.getPolicyNames()).contains("Policy 1");
-  }
-
-  /**
-   * Test on the ALLOW engine.
-   * The evaluation result of all the CEL expressions is set to false,
-   * so the gRPC authorization returns DENY.
-   */
-  @Test
-  public void testAllowEngineWithAllUnmatchedPolicies() throws InterpreterException {
-    setupEngineSingleRbacAllow();
-    // Policy 1 - unmatched; Policy 2 - unmatched; Policy 3 - unmatched
-    doReturn(false).when(spyEngine).matches(eq(condition1), any(Activation.class));
-    doReturn(false).when(spyEngine).matches(eq(condition2), any(Activation.class));
-    doReturn(false).when(spyEngine).matches(eq(condition3), any(Activation.class));
-    evaluateResult = spyEngine.evaluate(args);
-    assertThat(evaluateResult.getDecision()).isEqualTo(AuthorizationDecision.Output.DENY);
-    assertThat(evaluateResult.getPolicyNames()).isEmpty();
-    assertThat(evaluateResult.toString()).isEqualTo(
-        new StringBuilder("Authorization Decision: DENY. \n").toString());
-  }
-
-  /**
-   * Test on the ALLOW engine.
-   * The evaluation result of two CEL expressions is set to true,
-   * and the evaluation result of one CEL expression is set to false,
-   * so the gRPC authorization returns ALLOW.
-   */
-  @Test
-  public void testAllowEngineWithMatchedAndUnmatchedPolicies() 
-      throws InterpreterException {
-    setupEngineSingleRbacAllow();
-    // Policy 1 - unmatched; Policy 2 - matched; Policy 3 - matched
-    doReturn(false).when(spyEngine).matches(eq(condition1), any(Activation.class));
-    doReturn(true).when(spyEngine).matches(eq(condition2), any(Activation.class));
-    doReturn(true).when(spyEngine).matches(eq(condition3), any(Activation.class));
-    evaluateResult = spyEngine.evaluate(args);
-    assertEquals(evaluateResult.getDecision(), AuthorizationDecision.Output.ALLOW);
-    assertEquals(evaluateResult.getPolicyNames().size(), 1);
-    assertThat(evaluateResult.getPolicyNames()).contains("Policy 2");
-  }
-
-  /**
-   * Test on the ALLOW engine.
-   * The evaluation result of one CEL expression is set to unknown,
-   * so the gRPC authorization returns UNKNOWN.
-   */
-  @Test
-  public void testAllowEngineWithUnknownAndUnmatchedPolicies() 
-      throws InterpreterException {
-    setupEngineSingleRbacAllow();
-    // Policy 1 - unmatched; Policy 2 - unknown; Policy 3 - unknown
-    doReturn(false).when(spyEngine).matches(eq(condition1), any(Activation.class));
-    doThrow(new InterpreterException.Builder("Unknown result").build())
-        .when(spyEngine).matches(eq(condition2), any(Activation.class));
-    doThrow(new InterpreterException.Builder("Unknown result").build())
-        .when(spyEngine).matches(eq(condition3), any(Activation.class));
-    evaluateResult = spyEngine.evaluate(args);
-    assertThat(evaluateResult.getDecision()).isEqualTo(AuthorizationDecision.Output.UNKNOWN);
-    assertThat(evaluateResult.getPolicyNames()).hasSize(2);
-    assertThat(evaluateResult.getPolicyNames()).contains("Policy 2");
-    assertThat(evaluateResult.getPolicyNames()).contains("Policy 3");
-    assertThat(evaluateResult.toString()).isEqualTo(
-        new StringBuilder("Authorization Decision: UNKNOWN. \n" 
-            + "Policy 2; \n" + "Policy 3; \n").toString());
-  }
-
-  /**
-   * Test on the ALLOW engine.
-   * The evaluation result of one CEL expression is set to unknown,
-   * so the gRPC authorization returns UNKNOWN.
-   */
-  @Test
-  public void testAllowEngineWithMatchedUnmatchedAndUnknownPolicies() 
-      throws InterpreterException {
-    setupEngineSingleRbacAllow();
-    // Policy 1 - unmatched; Policy 2 - matched; Policy 3 - unknown
-    doReturn(false).when(spyEngine).matches(eq(condition1), any(Activation.class));
-    doReturn(true).when(spyEngine).matches(eq(condition2), any(Activation.class));
-    doThrow(new InterpreterException.Builder("Unknown result").build())
-        .when(spyEngine).matches(eq(condition3), any(Activation.class));
-    evaluateResult = spyEngine.evaluate(args);
-    assertThat(evaluateResult.getDecision()).isEqualTo(AuthorizationDecision.Output.ALLOW);
-    assertThat(evaluateResult.getPolicyNames()).hasSize(1);
-    assertThat(evaluateResult.getPolicyNames()).contains("Policy 2");
-    assertThat(evaluateResult.toString()).isEqualTo(
-        new StringBuilder("Authorization Decision: ALLOW. \n" + "Policy 2; \n").toString());
-  }
-
-  /**
-   * Test on the DENY engine.
-   * The evaluation result of all the CEL expressions is set to true,
-   * so the gRPC authorization returns DENY.
-   */
-  @Test
-  public void testDenyEngineWithAllMatchedPolicies() throws InterpreterException {
-    setupEngineSingleRbacDeny();
-    // Policy 4 - matched; Policy 5 - matched; Policy 6 - matched
-    doReturn(true).when(spyEngine).matches(eq(condition4), any(Activation.class));
-    doReturn(true).when(spyEngine).matches(eq(condition5), any(Activation.class));
-    doReturn(true).when(spyEngine).matches(eq(condition6), any(Activation.class));
-    evaluateResult = spyEngine.evaluate(args);
-    assertThat(evaluateResult.getDecision()).isEqualTo(AuthorizationDecision.Output.DENY);
-    assertThat(evaluateResult.getPolicyNames()).hasSize(1);
-    assertThat(evaluateResult.getPolicyNames()).contains("Policy 4");
-  }
-
-  /**
-   * Test on the DENY engine.
-   * The evaluation result of all the CEL expressions is set to false,
-   * so the gRPC authorization returns ALLOW.
-   */
-  @Test
-  public void testDenyEngineWithAllUnmatchedPolicies() throws InterpreterException {
-    setupEngineSingleRbacDeny();
-    // Policy 4 - unmatched; Policy 5 - unmatched; Policy 6 - unmatched
-    doReturn(false).when(spyEngine).matches(eq(condition4), any(Activation.class));
-    doReturn(false).when(spyEngine).matches(eq(condition5), any(Activation.class));
-    doReturn(false).when(spyEngine).matches(eq(condition6), any(Activation.class));
-    evaluateResult = spyEngine.evaluate(args);
-    assertThat(evaluateResult.getDecision()).isEqualTo(AuthorizationDecision.Output.ALLOW);
-    assertThat(evaluateResult.getPolicyNames()).isEmpty();
-  }
-
-  /**
-   * Test on the DENY engine.
-   * The evaluation result of two CEL expressions is set to true,
-   * and the evaluation result of one CEL expression is set to false,
-   * so the gRPC authorization returns DENY.
-   */
-  @Test
-  public void testDenyEngineWithMatchedAndUnmatchedPolicies() 
-      throws InterpreterException {
-    setupEngineSingleRbacDeny();
-    // Policy 4 - unmatched; Policy 5 - matched; Policy 6 - matched
-    doReturn(false).when(spyEngine).matches(eq(condition4), any(Activation.class));
-    doReturn(true).when(spyEngine).matches(eq(condition5), any(Activation.class));
-    doReturn(true).when(spyEngine).matches(eq(condition6), any(Activation.class));
-    evaluateResult = spyEngine.evaluate(args);
-    assertThat(evaluateResult.getDecision()).isEqualTo(AuthorizationDecision.Output.DENY);
-    assertThat(evaluateResult.getPolicyNames()).hasSize(1);
-    assertThat(evaluateResult.getPolicyNames()).contains("Policy 5");
-  }
-
-  /**
-   * Test on the DENY engine.
-   * The evaluation result of one CEL expression is set to unknown,
-   * so the gRPC authorization returns UNKNOWN.
-   */
-  @Test
-  public void testDenyEngineWithUnknownAndUnmatchedPolicies() 
-      throws InterpreterException {
-    setupEngineSingleRbacDeny();
-    // Policy 4 - unmatched; Policy 5 - unknown; Policy 6 - unknown
-    doReturn(false).when(spyEngine).matches(eq(condition4), any(Activation.class));
-    doThrow(new InterpreterException.Builder("Unknown result").build())
-        .when(spyEngine).matches(eq(condition5), any(Activation.class));
-    doThrow(new InterpreterException.Builder("Unknown result").build())
-        .when(spyEngine).matches(eq(condition6), any(Activation.class));
-    evaluateResult = spyEngine.evaluate(args);
-    assertThat(evaluateResult.getDecision()).isEqualTo(AuthorizationDecision.Output.UNKNOWN);
-    assertThat(evaluateResult.getPolicyNames()).hasSize(2);
-    assertThat(evaluateResult.getPolicyNames()).contains("Policy 5");
-    assertThat(evaluateResult.getPolicyNames()).contains("Policy 6");
-  }
-
-  /**
-   * Test on the DENY engine.
-   * The evaluation result of one CEL expression is set to unknown,
-   * so the gRPC authorization returns UNKNOWN.
-   */
-  @Test
-  public void testDenyEngineWithMatchedUnmatchedAndUnknownPolicies() 
-      throws InterpreterException {
-    setupEngineSingleRbacDeny();
-    // Policy 4 - unmatched; Policy 5 - matched; Policy 6 - unknown
-    doReturn(false).when(spyEngine).matches(eq(condition4), any(Activation.class));
-    doReturn(true).when(spyEngine).matches(eq(condition5), any(Activation.class));
-    doThrow(new InterpreterException.Builder("Unknown result").build())
-        .when(spyEngine).matches(eq(condition6), any(Activation.class));
-    evaluateResult = spyEngine.evaluate(args);
-    assertThat(evaluateResult.getDecision()).isEqualTo(AuthorizationDecision.Output.DENY);
-    assertThat(evaluateResult.getPolicyNames()).hasSize(1);
-    assertThat(evaluateResult.getPolicyNames()).contains("Policy 5");
-  }
-
-  /**
-   * Test on the DENY engine and ALLOW engine pair.
-   * The evaluation result of all the CEL expressions is set to true in DENY engine,
-   * so the gRPC authorization returns DENY.
-   */
-  @Test
-  public void testEnginePairWithAllMatchedDenyEngine() throws InterpreterException {
-    setupEngineRbacPair();
-    // Policy 4 - matched; Policy 5 - matched; Policy 6 - matched
-    // Policy 1 - matched; Policy 2 - matched; Policy 3 - matched
-    doReturn(true).when(spyEngine).matches(eq(condition1), any(Activation.class));
-    doReturn(true).when(spyEngine).matches(eq(condition2), any(Activation.class));
-    doReturn(true).when(spyEngine).matches(eq(condition3), any(Activation.class));
-    doReturn(true).when(spyEngine).matches(eq(condition4), any(Activation.class));
-    doReturn(true).when(spyEngine).matches(eq(condition5), any(Activation.class));
-    doReturn(true).when(spyEngine).matches(eq(condition6), any(Activation.class));
-    evaluateResult = spyEngine.evaluate(args);
-    assertThat(evaluateResult.getDecision()).isEqualTo(AuthorizationDecision.Output.DENY);
-    assertThat(evaluateResult.getPolicyNames()).hasSize(1);
-    assertThat(evaluateResult.getPolicyNames()).contains("Policy 4");
-  }
-
-  /**
-   * Test on the DENY engine and ALLOW engine pair.
-   * The evaluation result of two CEL expressions is set to true,
-   * and the evaluation result of one CEL expression is set to false in DENY engine, 
-   * so the gRPC authorization returns DENY.
-   */
-  @Test
-  public void testEnginePairWithPartiallyMatchedDenyEngine() 
-      throws InterpreterException {
-    setupEngineRbacPair();
-    // Policy 4 - unmatched; Policy 5 - matched; Policy 6 - unknown
-    // Policy 1 - matched; Policy 2 - matched; Policy 3 - matched
-    doReturn(true).when(spyEngine).matches(eq(condition1), any(Activation.class));
-    doReturn(true).when(spyEngine).matches(eq(condition2), any(Activation.class));
-    doReturn(true).when(spyEngine).matches(eq(condition3), any(Activation.class));
-    doReturn(false).when(spyEngine).matches(eq(condition4), any(Activation.class));
-    doReturn(true).when(spyEngine).matches(eq(condition5), any(Activation.class));
-    doThrow(new InterpreterException.Builder("Unknown result").build())
-        .when(spyEngine).matches(eq(condition6), any(Activation.class));
-    evaluateResult = spyEngine.evaluate(args);
-    assertThat(evaluateResult.getDecision()).isEqualTo(AuthorizationDecision.Output.DENY);
-    assertThat(evaluateResult.getPolicyNames()).hasSize(1);
-    assertThat(evaluateResult.getPolicyNames()).contains("Policy 5");
-  }
-
-  /**
-   * Test on the DENY engine and ALLOW engine pair.
-   * The DENY engine has unknown policies, so the gRPC authorization returns UNKNOWN.
-   */
-  @Test
-  public void testEnginePairWithUnknownDenyEngine() throws InterpreterException {
-    setupEngineRbacPair();
-    // Policy 4 - unmatched; Policy 5 - unknown; Policy 6 - unknown
-    // Policy 1 - matched; Policy 2 - matched; Policy 3 - matched
-    doReturn(true).when(spyEngine).matches(eq(condition1), any(Activation.class));
-    doReturn(true).when(spyEngine).matches(eq(condition2), any(Activation.class));
-    doReturn(true).when(spyEngine).matches(eq(condition3), any(Activation.class));
-    doReturn(false).when(spyEngine).matches(eq(condition4), any(Activation.class));
-    doThrow(new InterpreterException.Builder("Unknown result").build())
-        .when(spyEngine).matches(eq(condition5), any(Activation.class));
-    doThrow(new InterpreterException.Builder("Unknown result").build())
-        .when(spyEngine).matches(eq(condition6), any(Activation.class));
-    evaluateResult = spyEngine.evaluate(args);
-    assertThat(evaluateResult.getDecision()).isEqualTo(AuthorizationDecision.Output.UNKNOWN);
-    assertThat(evaluateResult.getPolicyNames()).hasSize(2);
-    assertThat(evaluateResult.getPolicyNames()).contains("Policy 5");
-    assertThat(evaluateResult.getPolicyNames()).contains("Policy 6");
-  }
-
-  /**
-   * Test on the DENY engine and ALLOW engine pair.
-   * The evaluation result of all the CEL expressions is set to false in DENY engine,
-   * and the ALLOW engine has unknown policies, 
-   * so the gRPC authorization returns UNKNOWN.
-   */
-  @Test
-  public void testEnginePairWithUnmatchedDenyEngineAndUnknownAllowEngine() 
-      throws InterpreterException {
-    setupEngineRbacPair();
-    // Policy 4 - unmatched; Policy 5 - unmatched; Policy 6 - unmatched
-    // Policy 1 - unmatched; Policy 2 - unknown; Policy 3 - unknown
-    doReturn(false).when(spyEngine).matches(eq(condition1), any(Activation.class));
-    doThrow(new InterpreterException.Builder("Unknown result").build())
-        .when(spyEngine).matches(eq(condition2), any(Activation.class));
-    doThrow(new InterpreterException.Builder("Unknown result").build())
-        .when(spyEngine).matches(eq(condition3), any(Activation.class));
-    doReturn(false).when(spyEngine).matches(eq(condition4), any(Activation.class));
-    doReturn(false).when(spyEngine).matches(eq(condition5), any(Activation.class));
-    doReturn(false).when(spyEngine).matches(eq(condition6), any(Activation.class));
-    evaluateResult = spyEngine.evaluate(args);
-    assertThat(evaluateResult.getDecision()).isEqualTo(AuthorizationDecision.Output.UNKNOWN);
-    assertThat(evaluateResult.getPolicyNames()).hasSize(2);
-    assertThat(evaluateResult.getPolicyNames()).contains("Policy 2");
-    assertThat(evaluateResult.getPolicyNames()).contains("Policy 3");
-  }
-
-  /**
-   * Test on the DENY engine and ALLOW engine pair.
-   * The evaluation result of all the CEL expressions is set to false in both engines,
-   * so the gRPC authorization returns DENY.
-   */
-  @Test
-  public void testUnmatchedEnginePair() throws InterpreterException {
-    setupEngineRbacPair();
-    // Policy 4 - unmatched; Policy 5 - unmatched; Policy 6 - unmatched
-    // Policy 1 - unmatched; Policy 2 - unmatched; Policy 3 - unmatched
-    doReturn(false).when(spyEngine).matches(eq(condition1), any(Activation.class));
-    doReturn(false).when(spyEngine).matches(eq(condition2), any(Activation.class));
-    doReturn(false).when(spyEngine).matches(eq(condition3), any(Activation.class));
-    doReturn(false).when(spyEngine).matches(eq(condition4), any(Activation.class));
-    doReturn(false).when(spyEngine).matches(eq(condition5), any(Activation.class));
-    doReturn(false).when(spyEngine).matches(eq(condition6), any(Activation.class));
-    evaluateResult = spyEngine.evaluate(args);
-    assertThat(evaluateResult.getDecision()).isEqualTo(AuthorizationDecision.Output.DENY);
-    assertThat(evaluateResult.getPolicyNames()).isEmpty();
-  }
-}
diff --git a/xds/src/test/java/io/grpc/xds/internal/rbac/engine/AuthzEngineTest.java b/xds/src/test/java/io/grpc/xds/internal/rbac/engine/AuthzEngineTest.java
deleted file mode 100644
index 9d890430ba7..00000000000
--- a/xds/src/test/java/io/grpc/xds/internal/rbac/engine/AuthzEngineTest.java
+++ /dev/null
@@ -1,141 +0,0 @@
-/*
- * 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.rbac.engine;
-
-import static com.google.common.truth.Truth.assertThat;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.Mockito.when;
-
-import com.google.api.expr.v1alpha1.Expr;
-import io.envoyproxy.envoy.config.rbac.v2.RBAC;
-import io.envoyproxy.envoy.config.rbac.v2.RBAC.Action;
-import io.grpc.xds.internal.rbac.engine.cel.Activation;
-import io.grpc.xds.internal.rbac.engine.cel.Dispatcher;
-import io.grpc.xds.internal.rbac.engine.cel.Interpretable;
-import io.grpc.xds.internal.rbac.engine.cel.Interpreter;
-import io.grpc.xds.internal.rbac.engine.cel.InterpreterException;
-import io.grpc.xds.internal.rbac.engine.cel.RuntimeTypeProvider;
-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.Mock;
-import org.mockito.junit.MockitoJUnit;
-import org.mockito.junit.MockitoRule;
-
-/** Unit tests for constructor of CEL-based Authorization Engine. */
-@RunWith(JUnit4.class)
-public class AuthzEngineTest {
-  @SuppressWarnings("deprecation") // https://github.com/grpc/grpc-java/issues/7467
-  @Rule
-  public final ExpectedException thrown = ExpectedException.none();
-
-  @Rule
-  public final MockitoRule mocks = MockitoJUnit.rule();
-
-  @Mock
-  private Activation activation;
-
-  @Mock
-  private RuntimeTypeProvider messageProvider;
-
-  @Mock
-  private Dispatcher dispatcher;
-
-  @Mock
-  private Interpreter interpreter;
-
-  @Mock
-  private Interpretable interpretable;
-  
-  private AuthorizationEngine engine;  
-  private RBAC rbacDeny;
-  private RBAC rbacAllow;
-  private Object result;
-
-  @Before
-  public void setup() {
-    rbacAllow = RBAC.newBuilder()
-        .setAction(Action.ALLOW)
-        .build();
-    rbacDeny = RBAC.newBuilder()
-        .setAction(Action.DENY)
-        .build();
-  }
-
-  @Test
-  public void createEngineAllowPolicy() {
-    engine = new AuthorizationEngine(rbacAllow);
-    assertNotNull(engine);
-  }
-
-  @Test
-  public void createEngineDenyPolicy() {
-    engine = new AuthorizationEngine(rbacDeny);
-    assertNotNull(engine);
-  }
-
-  @Test
-  public void createEngineDenyAllowPolicies() {
-    engine = new AuthorizationEngine(rbacDeny, rbacAllow);
-    assertNotNull(engine);
-  }
-
-  @Test
-  public void failToCreateEngineIfRbacPairOfAllowAllow() {
-    thrown.expect(IllegalArgumentException.class);
-    thrown.expectMessage("Invalid RBAC list, " 
-        + "must provide a RBAC with DENY action followed by a RBAC with ALLOW action. ");
-    engine = new AuthorizationEngine(rbacAllow, rbacAllow);
-    assertNull(engine);
-  }
-
-  @Test
-  public void failToCreateEngineIfRbacPairOfAllowDeny() {
-    thrown.expect(IllegalArgumentException.class);
-    thrown.expectMessage("Invalid RBAC list, " 
-        + "must provide a RBAC with DENY action followed by a RBAC with ALLOW action. ");
-    engine = new AuthorizationEngine(rbacAllow, rbacDeny);
-    assertNull(engine);
-  }
-
-  @Test
-  public void failToCreateEngineIfRbacPairOfDenyDeny() {
-    thrown.expect(IllegalArgumentException.class);
-    thrown.expectMessage("Invalid RBAC list, " 
-        + "must provide a RBAC with DENY action followed by a RBAC with ALLOW action. ");
-    engine = new AuthorizationEngine(rbacDeny, rbacDeny);
-    assertNull(engine);
-  }
-
-  @Test
-  public void testCelInterface() throws InterpreterException {
-    engine = new AuthorizationEngine(rbacAllow);
-    when(interpretable.eval(any(Activation.class))).thenReturn(true);
-    Expr expr = Expr.getDefaultInstance();
-    result = engine.matches(expr, activation);
-    assertThat(messageProvider).isNotNull();
-    assertThat(dispatcher).isNotNull();
-    assertThat(interpreter).isNotNull();
-    assertThat(activation).isNotNull();
-    assertThat(result).isNotNull();
-  }
-}
diff --git a/xds/src/test/java/io/grpc/xds/internal/rbac/engine/EvaluateArgsTest.java b/xds/src/test/java/io/grpc/xds/internal/rbac/engine/EvaluateArgsTest.java
deleted file mode 100644
index 8f908f91888..00000000000
--- a/xds/src/test/java/io/grpc/xds/internal/rbac/engine/EvaluateArgsTest.java
+++ /dev/null
@@ -1,133 +0,0 @@
-/*
- * 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.rbac.engine;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-
-import com.google.common.collect.ImmutableMap;
-import io.grpc.Attributes;
-import io.grpc.Grpc;
-import io.grpc.Metadata;
-import io.grpc.SecurityLevel;
-import io.grpc.ServerCall;
-import io.grpc.internal.GrpcAttributes;
-import io.netty.channel.local.LocalAddress;
-import java.net.SocketAddress;
-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.junit.MockitoJUnit;
-import org.mockito.junit.MockitoRule;
-
-/** Unit tests for evaluate argument. */
-@RunWith(JUnit4.class)
-public class EvaluateArgsTest<ReqT,RespT> {
-  @Rule
-  public final MockitoRule mocks = MockitoJUnit.rule();
-
-  @Mock
-  private ServerCall<ReqT,RespT> call;
-
-  private EvaluateArgs args;
-  private EvaluateArgs spyArgs;
-
-  private Metadata metadata;
-  private ImmutableMap<String, Object> attributesMap;
-
-  @Before
-  public void setup() {
-    // Set up metadata.
-    metadata = new Metadata();
-    // Set up spyArgs.
-    args = new EvaluateArgs(metadata, call);
-    spyArgs = Mockito.spy(args);
-    // Set up attributes map.
-    attributesMap = ImmutableMap.<String, Object>builder()
-        .put("request.url_path", "package.service/method")
-        .put("request.host", "fooapi.googleapis.com")
-        .put("request.method", "GET")
-        .put("request.headers", metadata)
-        .put("source.address", "1.2.3.4")
-        .put("source.port", 5050)
-        .put("destination.address", "4.3.2.1")
-        .put("destination.port", 8080)
-        .put("connection.uri_san_peer_certificate", "foo")
-        .put("source.principal", "spiffe")
-        .build();
-    // Set up evaluate args.
-    doReturn("package.service/method").when(spyArgs).getRequestUrlPath();
-    doReturn("fooapi.googleapis.com").when(spyArgs).getRequestHost();
-    doReturn("GET").when(spyArgs).getRequestMethod();
-    doReturn(metadata).when(spyArgs).getRequestHeaders();
-    doReturn("1.2.3.4").when(spyArgs).getSourceAddress();
-    doReturn(5050).when(spyArgs).getSourcePort();
-    doReturn("4.3.2.1").when(spyArgs).getDestinationAddress();
-    doReturn(8080).when(spyArgs).getDestinationPort();
-    doReturn("foo").when(spyArgs).getConnectionUriSanPeerCertificate();
-    doReturn("spiffe").when(spyArgs).getSourcePrincipal();
-  }
-
-  @Test
-  public void testGenerateEnvoyAttributes() {
-    setup();
-    ImmutableMap<String, Object> attributes = spyArgs.generateEnvoyAttributes();
-    assertEquals(attributesMap, attributes);
-    verify(spyArgs, times(1)).getRequestUrlPath();
-    verify(spyArgs, times(1)).getRequestHost();
-    verify(spyArgs, times(1)).getRequestMethod();
-    verify(spyArgs, times(1)).getRequestHeaders();
-    verify(spyArgs, times(1)).getSourceAddress();
-    verify(spyArgs, times(1)).getSourcePort();
-    verify(spyArgs, times(1)).getDestinationAddress();
-    verify(spyArgs, times(1)).getDestinationPort();
-    verify(spyArgs, times(1)).getConnectionUriSanPeerCertificate();
-    verify(spyArgs, times(1)).getSourcePrincipal();
-  }
-
-  @Test
-  public void testEvaluateArgsAccessorFunctions() {
-    // Set up args and call.
-    args = new EvaluateArgs(new Metadata(), call);
-    SocketAddress localAddr = new LocalAddress("local_addr");
-    SocketAddress remoteAddr = new LocalAddress("remote_addr");
-    Attributes attrs = Attributes.newBuilder()
-        .set(Grpc.TRANSPORT_ATTR_LOCAL_ADDR, localAddr)
-        .set(Grpc.TRANSPORT_ATTR_REMOTE_ADDR, remoteAddr)
-        .set(GrpcAttributes.ATTR_SECURITY_LEVEL, SecurityLevel.NONE)
-        .build();
-    when(call.getAttributes()).thenReturn(attrs);
-    when(call.getAuthority()).thenReturn("fooapi.googleapis.com");
-    // Check the behavior of accessor functions.
-    assertEquals(args.getRequestHost(), "fooapi.googleapis.com");
-    assertNotNull(args.getRequestHeaders());
-    assertEquals(args.getSourcePort(), 0);
-    assertEquals(args.getDestinationPort(), 0);
-    assertEquals(args.getSourceAddress(), "local:remote_addr");
-    assertEquals(args.getDestinationAddress(), "local:local_addr");
-    assertEquals(args.getConnectionUriSanPeerCertificate(), "placeholder");
-    assertEquals(args.getSourcePrincipal(), "placeholder");
-  }
-}
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/rbac/engine/cel/CelInterfaceTest.java b/xds/src/test/java/io/grpc/xds/internal/rbac/engine/cel/CelInterfaceTest.java
deleted file mode 100644
index 194955d7140..00000000000
--- a/xds/src/test/java/io/grpc/xds/internal/rbac/engine/cel/CelInterfaceTest.java
+++ /dev/null
@@ -1,81 +0,0 @@
-/*
- * 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.rbac.engine.cel;
-
-import static com.google.common.truth.Truth.assertThat;
-
-import com.google.api.expr.v1alpha1.Expr;
-import com.google.common.collect.ImmutableMap;
-import com.google.protobuf.Descriptors.Descriptor;
-import java.lang.String;
-import java.util.ArrayList;
-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;
-
-/** Tests for CEL library stub. */
-@RunWith(JUnit4.class)
-public class CelInterfaceTest {
-  private RuntimeTypeProvider messageProvider;
-  private Dispatcher dispatcher;
-  private Interpreter interpreter;
-  private Activation activation;
-  private String activationString;
-  private Object activationResolution;
-  private Object result;
-  private InterpreterException interpreterException;
-  private InterpreterException.Builder interpreterExceptionBuilder;
-
-  @Test
-  public void testCelInterface() throws Exception {
-    // Set up interpreter used in Cel library's eval function.
-    List<Descriptor> descriptors = new ArrayList<>();
-    messageProvider = DescriptorMessageProvider.dynamicMessages(descriptors);
-    dispatcher = DefaultDispatcher.create();
-    interpreter = new DefaultInterpreter(messageProvider, dispatcher);
-    // Set up activation used in Cel library's eval function.
-    Map<String, Object> map = new HashMap<>();
-    map.put("requestUrlPath", new Object());
-    map.put("requestHost", new Object());
-    map.put("requestMethod", new Object());
-    ImmutableMap<String, Object> apiAttributes = ImmutableMap.copyOf(map);
-    activation = Activation.copyOf(apiAttributes);
-    activationString = activation.toString();
-    activationResolution = activation.resolve("");
-    // Add a fake condition Expr that are being evaluated.
-    Expr conditions = Expr.newBuilder().build();
-    result = interpreter.createInterpretable(conditions).eval(activation);
-    assertThat(messageProvider).isNotNull();
-    assertThat(dispatcher).isNotNull();
-    assertThat(interpreter).isNotNull();
-    assertThat(activation).isNotNull();
-    assertThat(activationString).isNotNull();
-    assertThat(activationResolution).isNull();
-    assertThat(result).isNotNull();
-  }
-
-  @Test
-  public void testInterpreterException() {
-    interpreterExceptionBuilder = new InterpreterException.Builder("");
-    interpreterException = interpreterExceptionBuilder.build();
-    assertThat(interpreterExceptionBuilder).isNotNull();
-    assertThat(interpreterException).isNotNull();
-  }
-}
diff --git a/xds/src/test/java/io/grpc/xds/internal/sds/ClientSslContextProviderFactoryTest.java b/xds/src/test/java/io/grpc/xds/internal/sds/ClientSslContextProviderFactoryTest.java
deleted file mode 100644
index 4a1b79c8dd4..00000000000
--- a/xds/src/test/java/io/grpc/xds/internal/sds/ClientSslContextProviderFactoryTest.java
+++ /dev/null
@@ -1,356 +0,0 @@
-/*
- * 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.sds;
-
-import static com.google.common.truth.Truth.assertThat;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.CA_PEM_FILE;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.CLIENT_KEY_FILE;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.CLIENT_PEM_FILE;
-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.Bootstrapper;
-import io.grpc.xds.CommonBootstrapperTestUtils;
-import io.grpc.xds.EnvoyServerProtoData.UpstreamTlsContext;
-import io.grpc.xds.XdsInitializationException;
-import io.grpc.xds.internal.certprovider.CertProviderClientSslContextProvider;
-import io.grpc.xds.internal.certprovider.CertificateProvider;
-import io.grpc.xds.internal.certprovider.CertificateProviderProvider;
-import io.grpc.xds.internal.certprovider.CertificateProviderRegistry;
-import io.grpc.xds.internal.certprovider.CertificateProviderStore;
-import io.grpc.xds.internal.certprovider.TestCertificateProvider;
-import java.io.IOException;
-import org.junit.Assert;
-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 {
-
-  Bootstrapper bootstrapper;
-  CertificateProviderRegistry certificateProviderRegistry;
-  CertificateProviderStore certificateProviderStore;
-  CertProviderClientSslContextProvider.Factory certProviderClientSslContextProviderFactory;
-  ClientSslContextProviderFactory clientSslContextProviderFactory;
-
-  @Before
-  public void setUp() {
-    bootstrapper = mock(Bootstrapper.class);
-    certificateProviderRegistry = new CertificateProviderRegistry();
-    certificateProviderStore = new CertificateProviderStore(certificateProviderRegistry);
-    certProviderClientSslContextProviderFactory =
-        new CertProviderClientSslContextProvider.Factory(certificateProviderStore);
-    clientSslContextProviderFactory =
-        new ClientSslContextProviderFactory(
-            bootstrapper, certProviderClientSslContextProviderFactory);
-  }
-
-  @Test
-  public void createSslContextProvider_allFilenames() {
-    UpstreamTlsContext upstreamTlsContext =
-        CommonTlsContextTestsUtil.buildUpstreamTlsContextFromFilenames(
-            CLIENT_KEY_FILE, CLIENT_PEM_FILE, CA_PEM_FILE);
-
-    SslContextProvider sslContextProvider =
-        clientSslContextProviderFactory.create(upstreamTlsContext);
-    assertThat(sslContextProvider).isNotNull();
-  }
-
-  @Test
-  public void createSslContextProvider_sdsConfigForTlsCert_expectException() {
-    CommonTlsContext commonTlsContext =
-        CommonTlsContextTestsUtil.buildCommonTlsContextFromSdsConfigForTlsCertificate(
-            /* name= */ "name", /* targetUri= */ "unix:/tmp/sds/path", CA_PEM_FILE);
-    UpstreamTlsContext upstreamTlsContext =
-        CommonTlsContextTestsUtil.buildUpstreamTlsContext(commonTlsContext);
-
-    try {
-      clientSslContextProviderFactory.create(upstreamTlsContext);
-      Assert.fail("no exception thrown");
-    } catch (IllegalArgumentException expected) {
-      assertThat(expected).hasMessageThat().isEqualTo("unexpected TlsCertificateSdsSecretConfigs");
-    }
-  }
-
-  @Test
-  public void createSslContextProvider_sdsConfigForCertValidationContext_expectException() {
-    CommonTlsContext commonTlsContext =
-        CommonTlsContextTestsUtil.buildCommonTlsContextFromSdsConfigForValidationContext(
-            /* name= */ "name",
-            /* targetUri= */ "unix:/tmp/sds/path",
-            CLIENT_KEY_FILE,
-            CLIENT_PEM_FILE);
-    UpstreamTlsContext upstreamTlsContext =
-        CommonTlsContextTestsUtil.buildUpstreamTlsContext(commonTlsContext);
-
-    try {
-      SslContextProvider unused =
-          clientSslContextProviderFactory.create(upstreamTlsContext);
-      Assert.fail("no exception thrown");
-    } catch (IllegalStateException expected) {
-      assertThat(expected).hasMessageThat().isEqualTo("incorrect ValidationContextTypeCase");
-    }
-  }
-
-  @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();
-    when(bootstrapper.bootstrap()).thenReturn(bootstrapInfo);
-    SslContextProvider sslContextProvider =
-        clientSslContextProviderFactory.create(upstreamTlsContext);
-    assertThat(sslContextProvider).isInstanceOf(CertProviderClientSslContextProvider.class);
-    verifyWatcher(sslContextProvider, watcherCaptor[0]);
-  }
-
-  @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();
-    when(bootstrapper.bootstrap()).thenReturn(bootstrapInfo);
-    SslContextProvider sslContextProvider =
-        clientSslContextProviderFactory.create(upstreamTlsContext);
-    assertThat(sslContextProvider).isInstanceOf(CertProviderClientSslContextProvider.class);
-    verifyWatcher(sslContextProvider, watcherCaptor[0]);
-  }
-
-  @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();
-    when(bootstrapper.bootstrap()).thenReturn(bootstrapInfo);
-    SslContextProvider sslContextProvider =
-            clientSslContextProviderFactory.create(upstreamTlsContext);
-    assertThat(sslContextProvider).isInstanceOf(CertProviderClientSslContextProvider.class);
-    verifyWatcher(sslContextProvider, watcherCaptor[0]);
-  }
-
-  @Test
-  public void createCertProviderClientSslContextProvider_withStaticContext()
-      throws XdsInitializationException {
-    final CertificateProvider.DistributorWatcher[] watcherCaptor =
-            new CertificateProvider.DistributorWatcher[1];
-    createAndRegisterProviderProvider(certificateProviderRegistry, watcherCaptor, "testca", 0);
-    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();
-    when(bootstrapper.bootstrap()).thenReturn(bootstrapInfo);
-    SslContextProvider sslContextProvider =
-            clientSslContextProviderFactory.create(upstreamTlsContext);
-    assertThat(sslContextProvider).isInstanceOf(CertProviderClientSslContextProvider.class);
-    verifyWatcher(sslContextProvider, watcherCaptor[0]);
-  }
-
-  @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();
-    when(bootstrapper.bootstrap()).thenReturn(bootstrapInfo);
-    SslContextProvider sslContextProvider =
-        clientSslContextProviderFactory.create(upstreamTlsContext);
-    assertThat(sslContextProvider).isInstanceOf(CertProviderClientSslContextProvider.class);
-    verifyWatcher(sslContextProvider, watcherCaptor[0]);
-    verifyWatcher(sslContextProvider, watcherCaptor[1]);
-  }
-
-  @Test
-  public void createCertProviderClientSslContextProvider_exception()
-      throws XdsInitializationException {
-    UpstreamTlsContext upstreamTlsContext =
-        CommonTlsContextTestsUtil.buildUpstreamTlsContextForCertProviderInstance(
-            "gcp_id",
-            "cert-default",
-            "gcp_id",
-            "root-default",
-            /* alpnProtocols= */ null,
-            /* staticCertValidationContext= */ null);
-    when(bootstrapper.bootstrap())
-        .thenThrow(new XdsInitializationException("test exception"));
-    try {
-      clientSslContextProviderFactory.create(upstreamTlsContext);
-      Assert.fail("no exception thrown");
-    } catch (RuntimeException expected) {
-      assertThat(expected).hasMessageThat().contains("test exception");
-    }
-  }
-
-  @Test
-  public void createEmptyCommonTlsContext_exception() throws IOException {
-    UpstreamTlsContext upstreamTlsContext =
-        CommonTlsContextTestsUtil.buildUpstreamTlsContextFromFilenames(null, null, null);
-    try {
-      clientSslContextProviderFactory.create(upstreamTlsContext);
-      Assert.fail("no exception thrown");
-    } catch (UnsupportedOperationException expected) {
-      assertThat(expected)
-          .hasMessageThat()
-          .isEqualTo("Unsupported configurations in UpstreamTlsContext!");
-    }
-  }
-
-  @Test
-  public void createNullCommonTlsContext_exception() throws IOException {
-    UpstreamTlsContext upstreamTlsContext = new UpstreamTlsContext(null);
-    try {
-      clientSslContextProviderFactory.create(upstreamTlsContext);
-      Assert.fail("no exception thrown");
-    } catch (NullPointerException expected) {
-      assertThat(expected)
-              .hasMessageThat()
-              .isEqualTo("upstreamTlsContext should have CommonTlsContext");
-    }
-  }
-
-  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) {
-    assertThat(watcherCaptor).isNotNull();
-    assertThat(watcherCaptor.getDownstreamWatchers()).hasSize(1);
-    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.CertificateProviderInstance certificateProviderInstance =
-        builder.getValidationContextCertificateProviderInstance();
-    CommonTlsContext.CombinedCertificateValidationContext.Builder combinedBuilder =
-        CommonTlsContext.CombinedCertificateValidationContext.newBuilder();
-    combinedBuilder
-        .setDefaultValidationContext(certContext)
-        .setValidationContextCertificateProviderInstance(certificateProviderInstance);
-    return builder
-        .addTlsCertificates(tlsCert)
-        .setCombinedValidationContext(combinedBuilder.build());
-  }
-}
diff --git a/xds/src/test/java/io/grpc/xds/internal/sds/CommonTlsContextTestsUtil.java b/xds/src/test/java/io/grpc/xds/internal/sds/CommonTlsContextTestsUtil.java
deleted file mode 100644
index 4b20c871641..00000000000
--- a/xds/src/test/java/io/grpc/xds/internal/sds/CommonTlsContextTestsUtil.java
+++ /dev/null
@@ -1,626 +0,0 @@
-/*
- * 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.sds;
-
-import static com.google.common.truth.Truth.assertThat;
-import static java.nio.charset.StandardCharsets.UTF_8;
-
-import com.google.common.base.Strings;
-import com.google.common.io.CharStreams;
-import com.google.common.util.concurrent.MoreExecutors;
-import com.google.protobuf.BoolValue;
-import com.google.protobuf.Struct;
-import com.google.protobuf.Value;
-import io.envoyproxy.envoy.api.v2.core.ApiConfigSource.ApiType;
-import io.envoyproxy.envoy.api.v2.core.GrpcService.GoogleGrpc;
-import io.envoyproxy.envoy.config.core.v3.ApiConfigSource;
-import io.envoyproxy.envoy.config.core.v3.ConfigSource;
-import io.envoyproxy.envoy.config.core.v3.DataSource;
-import io.envoyproxy.envoy.config.core.v3.GrpcService;
-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.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.UpstreamTlsContext;
-import io.envoyproxy.envoy.type.matcher.v3.StringMatcher;
-import io.grpc.internal.testing.TestUtils;
-import io.grpc.xds.EnvoyServerProtoData;
-import io.grpc.xds.internal.sds.trust.CertificateUtils;
-import io.netty.handler.ssl.SslContext;
-import java.io.ByteArrayInputStream;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.InputStreamReader;
-import java.io.Reader;
-import java.security.cert.CertificateException;
-import java.security.cert.X509Certificate;
-import java.util.Arrays;
-import java.util.List;
-import java.util.concurrent.Executor;
-import javax.annotation.Nullable;
-
-/** 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_KEY_FILE = "server1.key";
-  public static final String CLIENT_PEM_FILE = "client.pem";
-  public static final String CLIENT_KEY_FILE = "client.key";
-  public static final String CA_PEM_FILE = "ca.pem";
-  /** 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";
-
-  static io.envoyproxy.envoy.api.v2.auth.SdsSecretConfig buildSdsSecretConfigV2(
-      String name, String targetUri, String channelType) {
-    io.envoyproxy.envoy.api.v2.auth.SdsSecretConfig sdsSecretConfig = null;
-    if (!Strings.isNullOrEmpty(name) && !Strings.isNullOrEmpty(targetUri)) {
-      sdsSecretConfig =
-          io.envoyproxy.envoy.api.v2.auth.SdsSecretConfig.newBuilder()
-              .setName(name)
-              .setSdsConfig(buildConfigSourceV2(targetUri, channelType))
-              .build();
-    }
-    return sdsSecretConfig;
-  }
-
-  private static SdsSecretConfig
-      buildSdsSecretConfig(String name, String targetUri, String channelType) {
-    SdsSecretConfig sdsSecretConfig = null;
-    if (!Strings.isNullOrEmpty(name) && !Strings.isNullOrEmpty(targetUri)) {
-      sdsSecretConfig =
-          SdsSecretConfig.newBuilder()
-              .setName(name)
-              .setSdsConfig(buildConfigSource(targetUri, channelType))
-              .build();
-    }
-    return sdsSecretConfig;
-  }
-
-  /**
-   * Builds a {@link io.envoyproxy.envoy.api.v2.core.ConfigSource} for the given targetUri.
-   *
-   * @param channelType specifying "inproc" creates an Inprocess channel for testing.
-   */
-  private static io.envoyproxy.envoy.api.v2.core.ConfigSource buildConfigSourceV2(
-      String targetUri, String channelType) {
-    GoogleGrpc.Builder googleGrpcBuilder = GoogleGrpc.newBuilder().setTargetUri(targetUri);
-    if (channelType != null) {
-      Struct.Builder structBuilder = Struct.newBuilder()
-          .putFields("channelType", Value.newBuilder().setStringValue(channelType).build());
-      googleGrpcBuilder.setConfig(structBuilder.build());
-    }
-    return io.envoyproxy.envoy.api.v2.core.ConfigSource.newBuilder()
-        .setApiConfigSource(
-            io.envoyproxy.envoy.api.v2.core.ApiConfigSource.newBuilder()
-                .setApiType(ApiType.GRPC)
-                .addGrpcServices(
-                    io.envoyproxy.envoy.api.v2.core.GrpcService.newBuilder()
-                        .setGoogleGrpc(googleGrpcBuilder.build())
-                        .build())
-                .build())
-        .build();
-  }
-
-  /**
-   * Builds a {@link ConfigSource} for the given targetUri.
-   *
-   * @param channelType specifying "inproc" creates an Inprocess channel for testing.
-   */
-  private static ConfigSource buildConfigSource(String targetUri, String channelType) {
-    GrpcService.GoogleGrpc.Builder googleGrpcBuilder =
-        GrpcService.GoogleGrpc.newBuilder().setTargetUri(targetUri);
-    if (channelType != null) {
-      Struct.Builder structBuilder = Struct.newBuilder()
-          .putFields("channelType", Value.newBuilder().setStringValue(channelType).build());
-      googleGrpcBuilder.setConfig(structBuilder.build());
-    }
-    return ConfigSource.newBuilder()
-        .setApiConfigSource(
-            ApiConfigSource.newBuilder()
-                .setApiType(ApiConfigSource.ApiType.GRPC)
-                .addGrpcServices(GrpcService.newBuilder().setGoogleGrpc(googleGrpcBuilder))
-                .build())
-        .build();
-  }
-
-  static CommonTlsContext buildCommonTlsContextFromSdsConfigForValidationContext(
-      String name, String targetUri, String privateKey, String certChain) {
-    SdsSecretConfig sdsSecretConfig =
-        buildSdsSecretConfig(name, targetUri, /* channelType= */ null);
-
-    CommonTlsContext.Builder builder =
-        CommonTlsContext.newBuilder().setValidationContextSdsSecretConfig(sdsSecretConfig);
-
-    if (!Strings.isNullOrEmpty(privateKey) && !Strings.isNullOrEmpty(certChain)) {
-      builder.addTlsCertificates(
-          TlsCertificate.newBuilder()
-              .setCertificateChain(DataSource.newBuilder().setFilename(certChain))
-              .setPrivateKey(DataSource.newBuilder().setFilename(privateKey))
-              .build());
-    }
-    return builder.build();
-  }
-
-  static CommonTlsContext buildCommonTlsContextFromSdsConfigForTlsCertificate(
-      String name, String targetUri, String trustCa) {
-
-    SdsSecretConfig sdsSecretConfig =
-        buildSdsSecretConfig(name, targetUri, /* channelType= */ null);
-    CommonTlsContext.Builder builder =
-        CommonTlsContext.newBuilder().addTlsCertificateSdsSecretConfigs(sdsSecretConfig);
-
-    if (!Strings.isNullOrEmpty(trustCa)) {
-      builder.setValidationContext(
-          CertificateValidationContext.newBuilder()
-              .setTrustedCa(DataSource.newBuilder().setFilename(trustCa))
-              .build());
-    }
-    return builder.build();
-  }
-
-  /** takes additional values and creates CombinedCertificateValidationContext as needed. */
-  @SuppressWarnings("deprecation")
-  static io.envoyproxy.envoy.api.v2.auth.CommonTlsContext
-      buildCommonTlsContextWithAdditionalValuesV2(
-          String certName,
-          String certTargetUri,
-          String validationContextName,
-          String validationContextTargetUri,
-          Iterable<String> verifySubjectAltNames,
-          Iterable<String> alpnNames,
-          String channelType) {
-
-    io.envoyproxy.envoy.api.v2.auth.CommonTlsContext.Builder builder =
-        io.envoyproxy.envoy.api.v2.auth.CommonTlsContext.newBuilder();
-
-    io.envoyproxy.envoy.api.v2.auth.SdsSecretConfig sdsSecretConfig =
-        buildSdsSecretConfigV2(certName, certTargetUri, channelType);
-    if (sdsSecretConfig != null) {
-      builder.addTlsCertificateSdsSecretConfigs(sdsSecretConfig);
-    }
-    sdsSecretConfig =
-        buildSdsSecretConfigV2(validationContextName, validationContextTargetUri, channelType);
-    io.envoyproxy.envoy.api.v2.auth.CertificateValidationContext certValidationContext =
-        verifySubjectAltNames == null ? null
-            : io.envoyproxy.envoy.api.v2.auth.CertificateValidationContext.newBuilder()
-                .addAllVerifySubjectAltName(verifySubjectAltNames).build();
-
-    if (sdsSecretConfig != null && certValidationContext != null) {
-      io.envoyproxy.envoy.api.v2.auth.CommonTlsContext.CombinedCertificateValidationContext
-          combined =
-              io.envoyproxy.envoy.api.v2.auth.CommonTlsContext.CombinedCertificateValidationContext
-                  .newBuilder()
-                  .setDefaultValidationContext(certValidationContext)
-                  .setValidationContextSdsSecretConfig(sdsSecretConfig)
-                  .build();
-      builder.setCombinedValidationContext(combined);
-    } else if (sdsSecretConfig != null) {
-      builder.setValidationContextSdsSecretConfig(sdsSecretConfig);
-    } else if (certValidationContext != null) {
-      builder.setValidationContext(certValidationContext);
-    }
-    if (alpnNames != null) {
-      builder.addAllAlpnProtocols(alpnNames);
-    }
-    return builder.build();
-  }
-
-  /** takes additional values and creates CombinedCertificateValidationContext as needed. */
-  static CommonTlsContext buildCommonTlsContextWithAdditionalValues(
-      String certName,
-      String certTargetUri,
-      String validationContextName,
-      String validationContextTargetUri,
-      Iterable<StringMatcher> matchSubjectAltNames,
-      Iterable<String> alpnNames,
-      String channelType) {
-
-    CommonTlsContext.Builder builder = CommonTlsContext.newBuilder();
-
-    SdsSecretConfig sdsSecretConfig = buildSdsSecretConfig(certName, certTargetUri, channelType);
-    if (sdsSecretConfig != null) {
-      builder.addTlsCertificateSdsSecretConfigs(sdsSecretConfig);
-    }
-    sdsSecretConfig =
-        buildSdsSecretConfig(validationContextName, validationContextTargetUri, channelType);
-    CertificateValidationContext certValidationContext =
-        matchSubjectAltNames == null
-            ? null
-            : CertificateValidationContext.newBuilder()
-                .addAllMatchSubjectAltNames(matchSubjectAltNames)
-                .build();
-    if (sdsSecretConfig != null && certValidationContext != null) {
-      CombinedCertificateValidationContext.Builder combinedBuilder =
-          CombinedCertificateValidationContext.newBuilder()
-              .setDefaultValidationContext(certValidationContext)
-              .setValidationContextSdsSecretConfig(sdsSecretConfig);
-      builder.setCombinedValidationContext(combinedBuilder);
-    } else if (sdsSecretConfig != null) {
-      builder.setValidationContextSdsSecretConfig(sdsSecretConfig);
-    } else if (certValidationContext != null) {
-      builder.setValidationContext(certValidationContext);
-    }
-    if (alpnNames != null) {
-      builder.addAllAlpnProtocols(alpnNames);
-    }
-    return builder.build();
-  }
-
-  /** Helper method to build DownstreamTlsContext for multiple test classes. */
-  static io.envoyproxy.envoy.api.v2.auth.DownstreamTlsContext buildDownstreamTlsContextV2(
-      io.envoyproxy.envoy.api.v2.auth.CommonTlsContext commonTlsContext,
-      boolean requireClientCert) {
-    io.envoyproxy.envoy.api.v2.auth.DownstreamTlsContext downstreamTlsContext =
-        io.envoyproxy.envoy.api.v2.auth.DownstreamTlsContext.newBuilder()
-            .setCommonTlsContext(commonTlsContext)
-            .setRequireClientCertificate(BoolValue.of(requireClientCert))
-            .build();
-    return downstreamTlsContext;
-  }
-
-  /** Helper method to build DownstreamTlsContext for multiple test classes. */
-  static DownstreamTlsContext buildDownstreamTlsContext(
-      CommonTlsContext commonTlsContext, boolean requireClientCert) {
-    DownstreamTlsContext downstreamTlsContext =
-        DownstreamTlsContext.newBuilder()
-            .setCommonTlsContext(commonTlsContext)
-            .setRequireClientCertificate(BoolValue.of(requireClientCert))
-            .build();
-    return downstreamTlsContext;
-  }
-
-  /** 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 io.envoyproxy.envoy.api.v2.auth.DownstreamTlsContext
-      buildTestDownstreamTlsContextV2(String certName, String validationContextName) {
-    return buildDownstreamTlsContextV2(
-        buildCommonTlsContextWithAdditionalValuesV2(
-            certName,
-            "unix:/var/run/sds/uds_path",
-            validationContextName,
-            "unix:/var/run/sds/uds_path",
-            Arrays.asList("spiffe://grpc-sds-testing.svc.id.goog/ns/default/sa/bob"),
-            Arrays.asList("managed-tls"),
-            null),
-        /* requireClientCert= */ false);
-  }
-
-  /** Helper method for creating DownstreamTlsContext values with names. */
-  public static DownstreamTlsContext buildTestDownstreamTlsContext(
-      String certName, String validationContextName) {
-    return buildDownstreamTlsContext(
-        buildCommonTlsContextWithAdditionalValues(
-            certName,
-            "unix:/var/run/sds/uds_path",
-            validationContextName,
-            "unix:/var/run/sds/uds_path",
-            Arrays.asList(
-                StringMatcher.newBuilder()
-                    .setExact("spiffe://grpc-sds-testing.svc.id.goog/ns/default/sa/bob")
-                    .build()),
-            Arrays.asList("managed-tls"),
-            null),
-        /* requireClientCert= */ false);
-  }
-
-  public static EnvoyServerProtoData.DownstreamTlsContext buildTestInternalDownstreamTlsContext(
-      String certName, String validationContextName) {
-    return EnvoyServerProtoData.DownstreamTlsContext.fromEnvoyProtoDownstreamTlsContext(
-        buildTestDownstreamTlsContext(certName, validationContextName));
-  }
-
-  public static String getTempFileNameForResourcesFile(String resFile) throws IOException {
-    return TestUtils.loadCert(resFile).getAbsolutePath();
-  }
-
-  /**
-   * Helper method to build DownstreamTlsContext for above tests. Called from other classes as well.
-   */
-  public static EnvoyServerProtoData.DownstreamTlsContext buildDownstreamTlsContextFromFilenames(
-      @Nullable String privateKey, @Nullable String certChain, @Nullable String trustCa) {
-    return buildDownstreamTlsContextFromFilenamesWithClientAuth(privateKey, certChain, trustCa,
-        false);
-  }
-
-  /**
-   * Helper method to build DownstreamTlsContext for above tests. Called from other classes as well.
-   */
-  public static EnvoyServerProtoData.DownstreamTlsContext
-      buildDownstreamTlsContextFromFilenamesWithClientCertRequired(
-          @Nullable String privateKey, @Nullable String certChain, @Nullable String trustCa) {
-    return buildDownstreamTlsContextFromFilenamesWithClientAuth(privateKey, certChain, trustCa,
-        true);
-  }
-
-  private static EnvoyServerProtoData.DownstreamTlsContext
-      buildDownstreamTlsContextFromFilenamesWithClientAuth(
-          @Nullable String privateKey,
-          @Nullable String certChain,
-          @Nullable String trustCa,
-          boolean requireClientCert) {
-    // get temp file for each file
-    try {
-      if (certChain != null) {
-        certChain = getTempFileNameForResourcesFile(certChain);
-      }
-      if (privateKey != null) {
-        privateKey = getTempFileNameForResourcesFile(privateKey);
-      }
-      if (trustCa != null) {
-        trustCa = getTempFileNameForResourcesFile(trustCa);
-      }
-    } catch (IOException ioe) {
-      throw new RuntimeException(ioe);
-    }
-    return buildInternalDownstreamTlsContext(
-        buildCommonTlsContextFromFilenames(privateKey, certChain, trustCa), requireClientCert);
-  }
-
-  /**
-   * Helper method to build UpstreamTlsContext for above tests. Called from other classes as well.
-   */
-  public static EnvoyServerProtoData.UpstreamTlsContext buildUpstreamTlsContextFromFilenames(
-      @Nullable String privateKey, @Nullable String certChain, @Nullable String trustCa) {
-    try {
-      if (certChain != null) {
-        certChain = getTempFileNameForResourcesFile(certChain);
-      }
-      if (privateKey != null) {
-        privateKey = getTempFileNameForResourcesFile(privateKey);
-      }
-      if (trustCa != null) {
-        trustCa = getTempFileNameForResourcesFile(trustCa);
-      }
-    } catch (IOException ioe) {
-      throw new RuntimeException(ioe);
-    }
-    return buildUpstreamTlsContext(
-        buildCommonTlsContextFromFilenames(privateKey, certChain, trustCa));
-  }
-
-  private static CommonTlsContext buildCommonTlsContextFromFilenames(
-      String privateKey, String certChain, String trustCa) {
-    TlsCertificate tlsCert = null;
-    if (!Strings.isNullOrEmpty(privateKey) && !Strings.isNullOrEmpty(certChain)) {
-      tlsCert =
-          TlsCertificate.newBuilder()
-              .setCertificateChain(DataSource.newBuilder().setFilename(certChain))
-              .setPrivateKey(DataSource.newBuilder().setFilename(privateKey))
-              .build();
-    }
-    CertificateValidationContext certContext = null;
-    if (!Strings.isNullOrEmpty(trustCa)) {
-      certContext =
-          CertificateValidationContext.newBuilder()
-              .setTrustedCa(DataSource.newBuilder().setFilename(trustCa))
-              .build();
-    }
-    return getCommonTlsContext(tlsCert, certContext);
-  }
-
-  static CommonTlsContext getCommonTlsContext(
-      TlsCertificate tlsCertificate, CertificateValidationContext certContext) {
-    CommonTlsContext.Builder builder = CommonTlsContext.newBuilder();
-    if (tlsCertificate != null) {
-      builder = builder.addTlsCertificates(tlsCertificate);
-    }
-    if (certContext != null) {
-      builder = builder.setValidationContext(certContext);
-    }
-    return builder.build();
-  }
-
-  /**
-   * Helper method to build UpstreamTlsContext for above tests. Called from other classes as well.
-   */
-  static EnvoyServerProtoData.UpstreamTlsContext buildUpstreamTlsContext(
-      CommonTlsContext commonTlsContext) {
-    UpstreamTlsContext upstreamTlsContext =
-        UpstreamTlsContext.newBuilder().setCommonTlsContext(commonTlsContext).build();
-    return EnvoyServerProtoData.UpstreamTlsContext.fromEnvoyProtoUpstreamTlsContext(
-        upstreamTlsContext);
-  }
-
-  /** Gets a cert from contents of a resource. */
-  public static X509Certificate getCertFromResourceName(String resourceName)
-      throws IOException, CertificateException {
-    try (ByteArrayInputStream bais =
-        new ByteArrayInputStream(getResourceContents(resourceName).getBytes(UTF_8))) {
-      return CertificateUtils.toX509Certificate(bais);
-    }
-  }
-
-  /** Gets contents of a resource from TestUtils.class loader. */
-  public static String getResourceContents(String resourceName) throws IOException {
-    InputStream inputStream = TestUtils.class.getResourceAsStream("/certs/" + resourceName);
-    String text = null;
-    try (Reader reader = new InputStreamReader(inputStream, UTF_8)) {
-      text = CharStreams.toString(reader);
-    }
-    return text;
-  }
-
-  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.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.Builder addCertificateValidationContext(
-      CommonTlsContext.Builder builder,
-      String rootInstanceName,
-      String rootCertName,
-      CertificateValidationContext staticCertValidationContext) {
-    if (rootInstanceName != null) {
-      CertificateProviderInstance providerInstance =
-          CertificateProviderInstance.newBuilder()
-              .setInstanceName(rootInstanceName)
-              .setCertificateName(rootCertName)
-              .build();
-      if (staticCertValidationContext != null) {
-        CombinedCertificateValidationContext combined =
-            CombinedCertificateValidationContext.newBuilder()
-                .setDefaultValidationContext(staticCertValidationContext)
-                .setValidationContextCertificateProviderInstance(providerInstance)
-                .build();
-        return builder.setCombinedValidationContext(combined);
-      }
-      builder = builder.setValidationContextCertificateProviderInstance(providerInstance);
-    }
-    return builder;
-  }
-
-  static CommonTlsContext.Builder addCertificateValidationContext(
-      CommonTlsContext.Builder builder,
-      String name,
-      String targetUri,
-      String channelType,
-      CertificateValidationContext staticCertValidationContext) {
-    SdsSecretConfig sdsSecretConfig = buildSdsSecretConfig(name, targetUri, channelType);
-
-    CombinedCertificateValidationContext combined =
-        CombinedCertificateValidationContext.newBuilder()
-            .setDefaultValidationContext(staticCertValidationContext)
-            .setValidationContextSdsSecretConfig(sdsSecretConfig)
-            .build();
-    return builder.setCombinedValidationContext(combined);
-  }
-
-  /** 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));
-  }
-
-  /** 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);
-  }
-
-
-  /** Perform some simple checks on sslContext. */
-  public static void doChecksOnSslContext(boolean server, SslContext sslContext,
-      List<String> expectedApnProtos) {
-    if (server) {
-      assertThat(sslContext.isServer()).isTrue();
-    } else {
-      assertThat(sslContext.isClient()).isTrue();
-    }
-    List<String> apnProtos = sslContext.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 SslContext updatedSslContext;
-    public Throwable updatedThrowable;
-
-    public TestCallback(Executor executor) {
-      super(executor);
-    }
-
-    @Override
-    public void updateSecret(SslContext sslContext) {
-      updatedSslContext = sslContext;
-    }
-
-    @Override
-    public void onException(Throwable throwable) {
-      updatedThrowable = throwable;
-    }
-  }
-}
diff --git a/xds/src/test/java/io/grpc/xds/internal/sds/SdsClientFileBasedMetadataTest.java b/xds/src/test/java/io/grpc/xds/internal/sds/SdsClientFileBasedMetadataTest.java
deleted file mode 100644
index b5a0eb03b60..00000000000
--- a/xds/src/test/java/io/grpc/xds/internal/sds/SdsClientFileBasedMetadataTest.java
+++ /dev/null
@@ -1,231 +0,0 @@
-/*
- * 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.sds;
-
-import static com.google.common.truth.Truth.assertThat;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.SERVER_0_KEY_FILE;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.SERVER_0_PEM_FILE;
-import static org.junit.Assert.fail;
-import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.mock;
-
-import com.google.common.io.Files;
-import com.google.common.util.concurrent.MoreExecutors;
-import com.google.protobuf.Struct;
-import com.google.protobuf.Value;
-import io.envoyproxy.envoy.api.v2.core.Node;
-import io.envoyproxy.envoy.config.core.v3.ApiConfigSource;
-import io.envoyproxy.envoy.config.core.v3.ConfigSource;
-import io.envoyproxy.envoy.config.core.v3.GrpcService;
-import io.envoyproxy.envoy.config.core.v3.GrpcService.GoogleGrpc;
-import io.envoyproxy.envoy.config.core.v3.GrpcService.GoogleGrpc.CallCredentials;
-import io.envoyproxy.envoy.config.core.v3.GrpcService.GoogleGrpc.CallCredentials.MetadataCredentialsFromPlugin;
-import io.envoyproxy.envoy.config.core.v3.GrpcService.GoogleGrpc.ChannelCredentials;
-import io.envoyproxy.envoy.config.core.v3.GrpcService.GoogleGrpc.GoogleLocalCredentials;
-import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.SdsSecretConfig;
-import io.grpc.Metadata;
-import java.io.File;
-import java.io.IOException;
-import java.nio.charset.StandardCharsets;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Ignore;
-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 SdsClient} and {@link FileBasedPluginCredential}. */
-@RunWith(JUnit4.class)
-@Ignore // FIXME(#7166): fix the test when FileBasedPluginCredential for xds V3 is implemented.
-public class SdsClientFileBasedMetadataTest {
-
-  /**
-   * K8S_SA_JWT_TOKEN_HEADER_KEYNAME is the request header key for k8s jwt token. Binary header name
-   * must have suffix "-bin".
-   */
-  private static final String K8S_SA_JWT_TOKEN_HEADER_KEYNAME = "istio_sds_credentials_header-bin";
-
-  static final Metadata.Key<byte[]> K8S_SA_JWT_TOKEN_HEADER_METADATA_KEY =
-      Metadata.Key.of(K8S_SA_JWT_TOKEN_HEADER_KEYNAME, Metadata.BINARY_BYTE_MARSHALLER);
-  private static final String TOKEN_FILE_NAME = "tempFile.txt";
-  @Rule public TemporaryFolder tempFolder = new TemporaryFolder();
-  private TestSdsServer.ServerMock serverMock;
-  private TestSdsServer server;
-  private SdsClient sdsClient;
-  private Node node;
-  private SdsSecretConfig sdsSecretConfig;
-  private File tempTokenFile;
-
-  @SuppressWarnings("deprecation")
-  static ConfigSource buildConfigSourceWithCreds(
-      String targetUri,
-      String channelType,
-      String filename,
-      String headerPrefix,
-      String pluginName) {
-    GoogleGrpc.Builder googleGrpcBuilder = GoogleGrpc.newBuilder().setTargetUri(targetUri);
-
-    if (filename != null) {
-      googleGrpcBuilder.setStatPrefix("sdsstat");
-      googleGrpcBuilder.setCredentialsFactoryName(pluginName);
-      googleGrpcBuilder.setChannelCredentials(
-          ChannelCredentials.newBuilder()
-              .setLocalCredentials(GoogleLocalCredentials.newBuilder())
-              .build());
-
-      Struct.Builder configStructBuilder =
-          Struct.newBuilder()
-              .putFields(
-                  "header_key",
-                  Value.newBuilder().setStringValue(K8S_SA_JWT_TOKEN_HEADER_KEYNAME).build())
-              .putFields(
-                  FileBasedPluginCredential.SECRET_DATA,
-                  Value.newBuilder()
-                      .setStructValue(
-                          Struct.newBuilder()
-                              .putFields(
-                                  FileBasedPluginCredential.FILENAME,
-                                  Value.newBuilder().setStringValue(filename).build()))
-                      .build());
-
-      if (headerPrefix != null) {
-        configStructBuilder.putFields(
-            FileBasedPluginCredential.HEADER_PREFIX,
-            Value.newBuilder().setStringValue(headerPrefix).build());
-      }
-
-      MetadataCredentialsFromPlugin.Builder metadataCredBuilder =
-              MetadataCredentialsFromPlugin.newBuilder().setName(pluginName);
-      // metadataCredBuilder.setConfig(configStructBuilder);
-
-      CallCredentials.Builder callCredBuilder =
-          CallCredentials.newBuilder().setFromPlugin(metadataCredBuilder);
-      googleGrpcBuilder.addCallCredentials(callCredBuilder);
-    }
-    if (channelType != null) {
-      Struct.Builder structBuilder = Struct.newBuilder();
-      structBuilder.putFields(
-          "channelType", Value.newBuilder().setStringValue(channelType).build());
-      googleGrpcBuilder.setConfig(structBuilder.build());
-    }
-    return ConfigSource.newBuilder()
-        .setApiConfigSource(
-            ApiConfigSource.newBuilder()
-                .setApiType(ApiConfigSource.ApiType.GRPC)
-                .addGrpcServices(
-                    GrpcService.newBuilder().setGoogleGrpc(googleGrpcBuilder.build()).build())
-                .build())
-        .build();
-  }
-
-  @Before
-  public void setUp() throws IOException {
-    serverMock = mock(TestSdsServer.ServerMock.class);
-    server = new TestSdsServer(serverMock);
-    server.startServer("inproc", /* useUds= */ false, /* useInterceptor= */ true);
-
-    tempTokenFile = tempFolder.newFile(TOKEN_FILE_NAME);
-    Files.write("test-token-content".getBytes(StandardCharsets.UTF_8), tempTokenFile);
-
-    ConfigSource configSource =
-        buildConfigSourceWithCreds(
-            "inproc",
-            "inproc",
-            tempTokenFile.getAbsolutePath(),
-            null,
-            FileBasedPluginCredential.PLUGIN_NAME);
-    sdsSecretConfig =
-        SdsSecretConfig.newBuilder().setSdsConfig(configSource).setName("name1").build();
-    node = Node.newBuilder().setId("sds-client-temp-test1").build();
-    sdsClient =
-        SdsClient.Factory.createSdsClient(
-            sdsSecretConfig, node, MoreExecutors.directExecutor(), MoreExecutors.directExecutor());
-    sdsClient.start();
-  }
-
-  @After
-  public void teardown() throws InterruptedException {
-    sdsClient.shutdown();
-    server.shutdown();
-  }
-
-  @Test
-  public void configSourceUdsTarget_noHeaderPrefix() {
-    ConfigSource configSource =
-        buildConfigSourceWithCreds(
-            "unix:/tmp/uds_path",
-            null,
-            "/var/run/secrets/tokens/istio-token",
-            null,
-            FileBasedPluginCredential.PLUGIN_NAME);
-    SdsClient.ChannelInfo channelInfo = SdsClient.Factory.extractChannelInfo(configSource);
-    assertThat(channelInfo.callCredentials).isInstanceOf(FileBasedPluginCredential.class);
-    FileBasedPluginCredential fileBasedPluginCredential =
-        (FileBasedPluginCredential) channelInfo.callCredentials;
-    assertThat(fileBasedPluginCredential.headerKey).isEqualTo(K8S_SA_JWT_TOKEN_HEADER_KEYNAME);
-    assertThat(fileBasedPluginCredential.headerPrefix).isEmpty();
-  }
-
-  @Test
-  public void configSourceUdsTarget_withHeaderPrefix() {
-    ConfigSource configSource =
-        buildConfigSourceWithCreds(
-            "unix:/tmp/uds_path",
-            null,
-            "/var/run/secrets/tokens/istio-token",
-            "test-header-prefix",
-            FileBasedPluginCredential.PLUGIN_NAME);
-    SdsClient.ChannelInfo channelInfo = SdsClient.Factory.extractChannelInfo(configSource);
-    assertThat(channelInfo.callCredentials).isInstanceOf(FileBasedPluginCredential.class);
-    FileBasedPluginCredential fileBasedPluginCredential =
-        (FileBasedPluginCredential) channelInfo.callCredentials;
-    assertThat(fileBasedPluginCredential.headerPrefix).isEqualTo("test-header-prefix");
-  }
-
-  @Test
-  public void configSource_badPluginName_expectException() {
-    ConfigSource configSource =
-        buildConfigSourceWithCreds(
-            "unix:/tmp/uds_path",
-            null,
-            "/var/run/secrets/tokens/istio-token",
-            null,
-            "bad-plugin-name");
-    try {
-      SdsClient.Factory.extractChannelInfo(configSource);
-      fail("expected exception");
-    } catch (IllegalArgumentException expected) {
-      assertThat(expected)
-          .hasMessageThat()
-          .isEqualTo("factory name should be envoy.grpc_credentials.file_based_metadata");
-    }
-  }
-
-  @Test
-  public void testSecretWatcher_tlsCertificate() throws IOException {
-    SdsClient.SecretWatcher mockWatcher = mock(SdsClient.SecretWatcher.class);
-
-    doReturn(SdsClientTest.getOneTlsCertSecret("name1", SERVER_0_KEY_FILE, SERVER_0_PEM_FILE))
-        .when(serverMock)
-        .getSecretFor("name1");
-
-    sdsClient.watchSecret(mockWatcher);
-    assertThat(server.lastK8sJwtTokenValue).isEqualTo("test-token-content");
-  }
-}
diff --git a/xds/src/test/java/io/grpc/xds/internal/sds/SdsClientTest.java b/xds/src/test/java/io/grpc/xds/internal/sds/SdsClientTest.java
deleted file mode 100644
index a41681eb954..00000000000
--- a/xds/src/test/java/io/grpc/xds/internal/sds/SdsClientTest.java
+++ /dev/null
@@ -1,348 +0,0 @@
-/*
- * 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.sds;
-
-import static com.google.common.truth.Truth.assertThat;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.CA_PEM_FILE;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.SERVER_0_KEY_FILE;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.SERVER_0_PEM_FILE;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.SERVER_1_KEY_FILE;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.SERVER_1_PEM_FILE;
-import static org.junit.Assert.fail;
-import static org.mockito.Mockito.any;
-import static org.mockito.Mockito.doThrow;
-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.MoreExecutors;
-import com.google.protobuf.ByteString;
-import com.google.protobuf.Struct;
-import com.google.protobuf.Value;
-import io.envoyproxy.envoy.api.v2.DiscoveryRequest;
-import io.envoyproxy.envoy.api.v2.core.Node;
-import io.envoyproxy.envoy.config.core.v3.ApiConfigSource;
-import io.envoyproxy.envoy.config.core.v3.ConfigSource;
-import io.envoyproxy.envoy.config.core.v3.DataSource;
-import io.envoyproxy.envoy.config.core.v3.GrpcService;
-import io.envoyproxy.envoy.config.core.v3.GrpcService.GoogleGrpc;
-import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.CertificateValidationContext;
-import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.SdsSecretConfig;
-import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.Secret;
-import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.TlsCertificate;
-import io.grpc.Status;
-import io.grpc.Status.Code;
-import io.grpc.internal.testing.TestUtils;
-import java.io.IOException;
-import java.nio.charset.StandardCharsets;
-import java.nio.file.Files;
-import java.nio.file.Paths;
-import java.util.ArrayList;
-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;
-import org.mockito.ArgumentCaptor;
-import org.mockito.ArgumentMatchers;
-import org.mockito.invocation.InvocationOnMock;
-import org.mockito.stubbing.Answer;
-
-/** Unit tests for {@link SdsClient}. */
-@RunWith(JUnit4.class)
-public class SdsClientTest {
-
-  private TestSdsServer.ServerMock serverMock;
-  private TestSdsServer server;
-  private SdsClient sdsClient;
-  private Node node;
-  private SdsSecretConfig sdsSecretConfig;
-
-  /**
-   * Builds a {@link ConfigSource} for the given targetUri.
-   *
-   * @param channelType specifying "inproc" creates an Inprocess channel for testing.
-   */
-  static ConfigSource buildConfigSource(String targetUri, String channelType) {
-    GoogleGrpc.Builder googleGrpcBuilder = GoogleGrpc.newBuilder().setTargetUri(targetUri);
-    if (channelType != null) {
-      Struct.Builder structBuilder = Struct.newBuilder();
-      structBuilder.putFields(
-          "channelType", Value.newBuilder().setStringValue(channelType).build());
-      googleGrpcBuilder.setConfig(structBuilder.build());
-    }
-    return ConfigSource.newBuilder()
-        .setApiConfigSource(
-            ApiConfigSource.newBuilder()
-                .setApiType(ApiConfigSource.ApiType.GRPC)
-                .addGrpcServices(
-                    GrpcService.newBuilder().setGoogleGrpc(googleGrpcBuilder.build()).build())
-                .build())
-        .build();
-  }
-
-  private static String getResourcesFileContent(String resFile) throws IOException {
-    String tempFile = TestUtils.loadCert(resFile).getAbsolutePath();
-    return new String(Files.readAllBytes(Paths.get(tempFile)), StandardCharsets.UTF_8);
-  }
-
-  @Before
-  public void setUp() throws IOException {
-    serverMock = mock(TestSdsServer.ServerMock.class);
-    server = new TestSdsServer(serverMock);
-    server.startServer("inproc", /* useUds= */ false, /* useInterceptor= */ false);
-    ConfigSource configSource = buildConfigSource("inproc", "inproc");
-    sdsSecretConfig =
-        SdsSecretConfig.newBuilder().setSdsConfig(configSource).setName("name1").build();
-    node = Node.newBuilder().setId("sds-client-temp-test1").build();
-    sdsClient =
-        SdsClient.Factory.createSdsClient(
-            sdsSecretConfig, node, MoreExecutors.directExecutor(), MoreExecutors.directExecutor());
-    sdsClient.start();
-  }
-
-  @After
-  public void teardown() throws InterruptedException {
-    sdsClient.shutdown();
-    server.shutdown();
-  }
-
-  @Test
-  public void configSourceUdsTarget() {
-    ConfigSource configSource = buildConfigSource("unix:/tmp/uds_path", null);
-    SdsClient.ChannelInfo channelInfo = SdsClient.Factory.extractChannelInfo(configSource);
-    assertThat(channelInfo.targetUri).isEqualTo("unix:/tmp/uds_path");
-    assertThat(channelInfo.channelType).isNull();
-  }
-
-  @Test
-  public void testSecretWatcher_tlsCertificate() throws IOException {
-    SdsClient.SecretWatcher mockWatcher = mock(SdsClient.SecretWatcher.class);
-
-    when(serverMock.getSecretFor("name1"))
-        .thenReturn(getOneTlsCertSecret("name1", SERVER_0_KEY_FILE, SERVER_0_PEM_FILE));
-
-    sdsClient.watchSecret(mockWatcher);
-    verifyDiscoveryRequest(server.lastGoodRequest, "", "", node, "name1");
-    verifyDiscoveryRequest(
-        server.lastRequestOnlyForAck,
-        server.lastResponse.getVersionInfo(),
-        server.lastResponse.getNonce(),
-        node,
-        "name1");
-    verifySecretWatcher(mockWatcher, "name1", SERVER_0_KEY_FILE, SERVER_0_PEM_FILE);
-
-    reset(mockWatcher);
-    when(serverMock.getSecretFor("name1"))
-        .thenReturn(getOneTlsCertSecret("name1", SERVER_1_KEY_FILE, SERVER_1_PEM_FILE));
-    server.generateAsyncResponse("name1");
-    verifySecretWatcher(mockWatcher, "name1", SERVER_1_KEY_FILE, SERVER_1_PEM_FILE);
-
-    reset(mockWatcher);
-    sdsClient.cancelSecretWatch(mockWatcher);
-    server.generateAsyncResponse("name1");
-    verify(mockWatcher, never()).onSecretChanged(ArgumentMatchers.any(Secret.class));
-  }
-
-  @Test
-  public void testSecretWatcher_certificateValidationContext() throws IOException {
-    SdsClient.SecretWatcher mockWatcher = mock(SdsClient.SecretWatcher.class);
-
-    when(serverMock.getSecretFor("name1"))
-        .thenReturn(getOneCertificateValidationContextSecret("name1", CA_PEM_FILE));
-
-    sdsClient.watchSecret(mockWatcher);
-    verifyDiscoveryRequest(server.lastGoodRequest, "", "", node, "name1");
-    verifyDiscoveryRequest(
-        server.lastRequestOnlyForAck,
-        server.lastResponse.getVersionInfo(),
-        server.lastResponse.getNonce(),
-        node,
-        "name1");
-    verifySecretWatcher(mockWatcher, "name1", CA_PEM_FILE);
-
-    reset(mockWatcher);
-    when(serverMock.getSecretFor("name1"))
-        .thenReturn(getOneCertificateValidationContextSecret("name1", SERVER_1_PEM_FILE));
-    server.generateAsyncResponse("name1");
-    verifySecretWatcher(mockWatcher, "name1", SERVER_1_PEM_FILE);
-
-    reset(mockWatcher);
-    sdsClient.cancelSecretWatch(mockWatcher);
-    server.generateAsyncResponse("name1");
-    verify(mockWatcher, never()).onSecretChanged(ArgumentMatchers.any(Secret.class));
-  }
-
-  @Test
-  public void testSecretWatcher_multipleWatchers_expectException() throws IOException {
-    SdsClient.SecretWatcher mockWatcher1 = mock(SdsClient.SecretWatcher.class);
-    SdsClient.SecretWatcher mockWatcher2 = mock(SdsClient.SecretWatcher.class);
-
-    when(serverMock.getSecretFor("name1"))
-        .thenReturn(getOneTlsCertSecret("name1", SERVER_0_KEY_FILE, SERVER_0_PEM_FILE));
-
-    sdsClient.watchSecret(mockWatcher1);
-    verifyDiscoveryRequest(server.lastGoodRequest, "", "", node, "name1");
-    verifyDiscoveryRequest(
-        server.lastRequestOnlyForAck,
-        server.lastResponse.getVersionInfo(),
-        server.lastResponse.getNonce(),
-        node,
-        "name1");
-    verifySecretWatcher(mockWatcher1, "name1", SERVER_0_KEY_FILE, SERVER_0_PEM_FILE);
-
-    // add mockWatcher2
-    try {
-      sdsClient.watchSecret(mockWatcher2);
-      fail("exception expected");
-    } catch (IllegalStateException expected) {
-      assertThat(expected).hasMessageThat().isEqualTo("watcher already set");
-    }
-  }
-
-  @Test
-  public void testSecretWatcher_onError_expectOnError() throws IOException {
-    SdsClient.SecretWatcher mockWatcher = mock(SdsClient.SecretWatcher.class);
-    final ArrayList<DiscoveryRequest> requestArrayList = new ArrayList<>();
-
-    when(serverMock.onNext(any(DiscoveryRequest.class)))
-        .thenAnswer(
-            new Answer<Boolean>() {
-              @Override
-              public Boolean answer(InvocationOnMock invocation) throws Throwable {
-                Object[] args = invocation.getArguments();
-                DiscoveryRequest req = (DiscoveryRequest) args[0];
-                requestArrayList.add(req);
-                server.discoveryService.inboundStreamObserver.responseObserver.onError(
-                    Status.NOT_FOUND.asException());
-                return true;
-              }
-            });
-    sdsClient.watchSecret(mockWatcher);
-    ArgumentCaptor<Status> statusCaptor = ArgumentCaptor.forClass(Status.class);
-    verify(mockWatcher, times(1)).onError(statusCaptor.capture());
-    Status status = statusCaptor.getValue();
-    assertThat(status).isEqualTo(Status.NOT_FOUND);
-    assertThat(requestArrayList.size()).isEqualTo(1);
-  }
-
-  @Test
-  public void testSecretWatcher_onSecretChangedException_expectNack() throws IOException {
-    SdsClient.SecretWatcher mockWatcher = mock(SdsClient.SecretWatcher.class);
-
-    when(serverMock.getSecretFor("name1"))
-        .thenReturn(getOneTlsCertSecret("name1", SERVER_0_KEY_FILE, SERVER_0_PEM_FILE));
-    doThrow(new RuntimeException("test exception-abc"))
-        .when(mockWatcher)
-        .onSecretChanged(any(Secret.class));
-
-    sdsClient.watchSecret(mockWatcher);
-    verifyDiscoveryRequest(server.lastGoodRequest, "", "", node, "name1");
-    assertThat(server.lastRequestOnlyForAck).isNull();
-    assertThat(server.lastNack).isNotNull();
-    assertThat(server.lastNack.getVersionInfo()).isEmpty();
-    assertThat(server.lastNack.getResponseNonce()).isEmpty();
-    com.google.rpc.Status errorDetail = server.lastNack.getErrorDetail();
-    assertThat(errorDetail.getCode()).isEqualTo(Code.UNKNOWN.value());
-    assertThat(errorDetail.getMessage()).isEqualTo("Secret not updated");
-  }
-
-  static void verifyDiscoveryRequest(
-      DiscoveryRequest request,
-      String versionInfo,
-      String responseNonce,
-      Node node,
-      String... resourceNames) {
-    assertThat(request).isNotNull();
-    assertThat(request.getNode()).isEqualTo(node);
-    assertThat(request.getResourceNamesList()).isEqualTo(Arrays.asList(resourceNames));
-    assertThat(request.getTypeUrl()).isEqualTo("type.googleapis.com/envoy.api.v2.auth.Secret");
-    if (versionInfo != null) {
-      assertThat(request.getVersionInfo()).isEqualTo(versionInfo);
-    }
-    if (responseNonce != null) {
-      assertThat(request.getResponseNonce()).isEqualTo(responseNonce);
-    }
-  }
-
-  static void verifySecretWatcher(
-      SdsClient.SecretWatcher mockWatcher,
-      String secretName,
-      String keyFileName,
-      String certFileName)
-      throws IOException {
-    ArgumentCaptor<Secret> secretCaptor = ArgumentCaptor.forClass(Secret.class);
-    verify(mockWatcher, times(1)).onSecretChanged(secretCaptor.capture());
-    Secret secret = secretCaptor.getValue();
-    assertThat(secret.getName()).isEqualTo(secretName);
-    assertThat(secret.hasTlsCertificate()).isTrue();
-    TlsCertificate tlsCertificate = secret.getTlsCertificate();
-    assertThat(tlsCertificate.getPrivateKey().getInlineBytes().toStringUtf8())
-        .isEqualTo(getResourcesFileContent(keyFileName));
-    assertThat(tlsCertificate.getCertificateChain().getInlineBytes().toStringUtf8())
-        .isEqualTo(getResourcesFileContent(certFileName));
-  }
-
-  private void verifySecretWatcher(
-      SdsClient.SecretWatcher mockWatcher, String secretName, String caFileName)
-      throws IOException {
-    ArgumentCaptor<Secret> secretCaptor = ArgumentCaptor.forClass(Secret.class);
-    verify(mockWatcher, times(1)).onSecretChanged(secretCaptor.capture());
-    Secret secret = secretCaptor.getValue();
-    assertThat(secret.getName()).isEqualTo(secretName);
-    assertThat(secret.hasValidationContext()).isTrue();
-    CertificateValidationContext certificateValidationContext = secret.getValidationContext();
-    assertThat(certificateValidationContext.getTrustedCa().getInlineBytes().toStringUtf8())
-        .isEqualTo(getResourcesFileContent(caFileName));
-  }
-
-  static Secret getOneTlsCertSecret(String name, String keyFileName, String certFileName)
-      throws IOException {
-    TlsCertificate tlsCertificate =
-        TlsCertificate.newBuilder()
-            .setPrivateKey(
-                DataSource.newBuilder()
-                    .setInlineBytes(ByteString.copyFromUtf8(getResourcesFileContent(keyFileName)))
-                    .build())
-            .setCertificateChain(
-                DataSource.newBuilder()
-                    .setInlineBytes(ByteString.copyFromUtf8(getResourcesFileContent(certFileName)))
-                    .build())
-            .build();
-    return Secret.newBuilder().setName(name).setTlsCertificate(tlsCertificate).build();
-  }
-
-  static Secret getOneCertificateValidationContextSecret(String name, String trustFileName)
-      throws IOException {
-    CertificateValidationContext certificateValidationContext =
-        CertificateValidationContext.newBuilder()
-            .setTrustedCa(
-                DataSource.newBuilder()
-                    .setInlineBytes(ByteString.copyFromUtf8(getResourcesFileContent(trustFileName)))
-                    .build())
-            .build();
-
-    return Secret.newBuilder()
-        .setName(name)
-        .setValidationContext(certificateValidationContext)
-        .build();
-  }
-}
diff --git a/xds/src/test/java/io/grpc/xds/internal/sds/SdsClientUdsFileBasedMetadataTest.java b/xds/src/test/java/io/grpc/xds/internal/sds/SdsClientUdsFileBasedMetadataTest.java
deleted file mode 100644
index f1fdc87d720..00000000000
--- a/xds/src/test/java/io/grpc/xds/internal/sds/SdsClientUdsFileBasedMetadataTest.java
+++ /dev/null
@@ -1,110 +0,0 @@
-/*
- * 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.sds;
-
-import static com.google.common.truth.Truth.assertThat;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.SERVER_0_KEY_FILE;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.SERVER_0_PEM_FILE;
-import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.mock;
-
-import com.google.common.io.Files;
-import com.google.common.util.concurrent.MoreExecutors;
-import io.envoyproxy.envoy.api.v2.core.Node;
-import io.envoyproxy.envoy.config.core.v3.ConfigSource;
-import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.SdsSecretConfig;
-import io.netty.channel.epoll.Epoll;
-import java.io.File;
-import java.io.IOException;
-import java.nio.charset.StandardCharsets;
-import java.util.concurrent.TimeUnit;
-import org.junit.After;
-import org.junit.Assume;
-import org.junit.Before;
-import org.junit.Ignore;
-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 SdsClient} & {@link FileBasedPluginCredential} using UDS transport. */
-@RunWith(JUnit4.class)
-@Ignore // FIXME(#7166): fix the test when FileBasedPluginCredential for xds V3 is implemented
-public class SdsClientUdsFileBasedMetadataTest {
-
-  private static final String SDSCLIENT_TEST_SOCKET = "/tmp/sdsclient-test.socket";
-
-  private static final String TOKEN_FILE_NAME = "tempFile.txt";
-  @Rule public TemporaryFolder tempFolder = new TemporaryFolder();
-  private TestSdsServer.ServerMock serverMock;
-  private TestSdsServer server;
-  private SdsClient sdsClient;
-  private Node node;
-  private SdsSecretConfig sdsSecretConfig;
-  private File tempTokenFile;
-
-  @Before
-  public void setUp() throws IOException {
-    Assume.assumeTrue(Epoll.isAvailable());
-    serverMock = mock(TestSdsServer.ServerMock.class);
-    server = new TestSdsServer(serverMock);
-    server.startServer(SDSCLIENT_TEST_SOCKET, /* useUds= */ true, /* useInterceptor= */ true);
-
-    tempTokenFile = tempFolder.newFile(TOKEN_FILE_NAME);
-    Files.write("test-token-content".getBytes(StandardCharsets.UTF_8), tempTokenFile);
-
-    ConfigSource configSource =
-        SdsClientFileBasedMetadataTest.buildConfigSourceWithCreds(
-            "unix:" + SDSCLIENT_TEST_SOCKET,
-            null,
-            tempTokenFile.getAbsolutePath(),
-            null,
-            FileBasedPluginCredential.PLUGIN_NAME);
-    sdsSecretConfig =
-        SdsSecretConfig.newBuilder().setSdsConfig(configSource).setName("name1").build();
-    node = Node.newBuilder().setId("sds-client-temp-test2").build();
-    sdsClient =
-        SdsClient.Factory.createSdsClient(
-            sdsSecretConfig, node, MoreExecutors.directExecutor(), MoreExecutors.directExecutor());
-    sdsClient.start();
-  }
-
-  @After
-  public void teardown() throws InterruptedException {
-    if (sdsClient != null) {
-      sdsClient.shutdown();
-    }
-    if (server != null) {
-      server.shutdown();
-    }
-  }
-
-  @Test
-  public void testSecretWatcher_tlsCertificate() throws IOException, InterruptedException {
-    final SdsClient.SecretWatcher mockWatcher = mock(SdsClient.SecretWatcher.class);
-
-    doReturn(SdsClientTest.getOneTlsCertSecret("name1", SERVER_0_KEY_FILE, SERVER_0_PEM_FILE))
-        .when(serverMock)
-        .getSecretFor("name1");
-
-    sdsClient.watchSecret(mockWatcher);
-    // wait until our server received the requests
-    assertThat(server.requestsCounter.tryAcquire(2, 1000, TimeUnit.MILLISECONDS)).isTrue();
-    assertThat(server.lastK8sJwtTokenValue).isEqualTo("test-token-content");
-  }
-}
diff --git a/xds/src/test/java/io/grpc/xds/internal/sds/SdsClientUdsTest.java b/xds/src/test/java/io/grpc/xds/internal/sds/SdsClientUdsTest.java
deleted file mode 100644
index 72250e6f147..00000000000
--- a/xds/src/test/java/io/grpc/xds/internal/sds/SdsClientUdsTest.java
+++ /dev/null
@@ -1,136 +0,0 @@
-/*
- * 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.sds;
-
-import static com.google.common.truth.Truth.assertThat;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.SERVER_0_KEY_FILE;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.SERVER_0_PEM_FILE;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.SERVER_1_KEY_FILE;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.SERVER_1_PEM_FILE;
-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.when;
-
-import com.google.common.util.concurrent.MoreExecutors;
-import io.envoyproxy.envoy.api.v2.core.Node;
-import io.envoyproxy.envoy.config.core.v3.ApiConfigSource;
-import io.envoyproxy.envoy.config.core.v3.ConfigSource;
-import io.envoyproxy.envoy.config.core.v3.GrpcService;
-import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.SdsSecretConfig;
-import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.Secret;
-import io.netty.channel.epoll.Epoll;
-import java.io.IOException;
-import java.util.concurrent.TimeUnit;
-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.JUnit4;
-import org.mockito.ArgumentMatchers;
-
-/** Unit tests for {@link SdsClient} using UDS transport. */
-@RunWith(JUnit4.class)
-public class SdsClientUdsTest {
-
-  private static final String SDSCLIENT_TEST_SOCKET = "/tmp/sdsclient-test.socket";
-
-  private TestSdsServer.ServerMock serverMock;
-  private TestSdsServer server;
-  private SdsClient sdsClient;
-  private Node node;
-  private SdsSecretConfig sdsSecretConfig;
-
-  private static ConfigSource buildConfigSource(String targetUri) {
-    return ConfigSource.newBuilder()
-        .setApiConfigSource(
-            ApiConfigSource.newBuilder()
-                .setApiType(ApiConfigSource.ApiType.GRPC)
-                .addGrpcServices(
-                    GrpcService.newBuilder()
-                        .setGoogleGrpc(
-                            GrpcService.GoogleGrpc.newBuilder().setTargetUri(targetUri).build())
-                        .build())
-                .build())
-        .build();
-  }
-
-  @Before
-  public void setUp() throws IOException {
-    Assume.assumeTrue(Epoll.isAvailable());
-    serverMock = mock(TestSdsServer.ServerMock.class);
-    server = new TestSdsServer(serverMock);
-    server.startServer(SDSCLIENT_TEST_SOCKET, /* useUds= */ true, /* useInterceptor= */ false);
-    ConfigSource configSource = buildConfigSource("unix:" + SDSCLIENT_TEST_SOCKET);
-    sdsSecretConfig =
-        SdsSecretConfig.newBuilder().setSdsConfig(configSource).setName("name1").build();
-    node = Node.newBuilder().setId("sds-client-temp-test2").build();
-    sdsClient =
-        SdsClient.Factory.createSdsClient(
-            sdsSecretConfig, node, MoreExecutors.directExecutor(), MoreExecutors.directExecutor());
-    sdsClient.start();
-  }
-
-  @After
-  public void teardown() throws InterruptedException {
-    if (sdsClient != null) {
-      sdsClient.shutdown();
-    }
-    if (server != null) {
-      server.shutdown();
-    }
-  }
-
-  @Test
-  public void testSecretWatcher_tlsCertificate() throws IOException, InterruptedException {
-    final SdsClient.SecretWatcher mockWatcher = mock(SdsClient.SecretWatcher.class);
-
-    when(serverMock.getSecretFor("name1"))
-        .thenReturn(
-            SdsClientTest.getOneTlsCertSecret("name1", SERVER_0_KEY_FILE, SERVER_0_PEM_FILE));
-
-    sdsClient.watchSecret(mockWatcher);
-    // wait until our server received the requests
-    assertThat(server.requestsCounter.tryAcquire(2, 1000, TimeUnit.MILLISECONDS)).isTrue();
-    SdsClientTest.verifyDiscoveryRequest(server.lastGoodRequest, "", "", node, "name1");
-    SdsClientTest.verifySecretWatcher(mockWatcher, "name1", SERVER_0_KEY_FILE, SERVER_0_PEM_FILE);
-    SdsClientTest.verifyDiscoveryRequest(
-        server.lastRequestOnlyForAck,
-        server.lastResponse.getVersionInfo(),
-        server.lastResponse.getNonce(),
-        node,
-        "name1");
-
-    reset(mockWatcher);
-    when(serverMock.getSecretFor("name1"))
-        .thenReturn(
-            SdsClientTest.getOneTlsCertSecret("name1", SERVER_1_KEY_FILE, SERVER_1_PEM_FILE));
-    server.generateAsyncResponse("name1");
-    // wait until our server received the request
-    assertThat(server.requestsCounter.tryAcquire(1, 1000, TimeUnit.MILLISECONDS)).isTrue();
-    SdsClientTest.verifySecretWatcher(mockWatcher, "name1", SERVER_1_KEY_FILE, SERVER_1_PEM_FILE);
-
-    reset(mockWatcher);
-    sdsClient.cancelSecretWatch(mockWatcher);
-    server.generateAsyncResponse("name1");
-    // wait until our server received the request
-    assertThat(server.requestsCounter.tryAcquire(1, 1000, TimeUnit.MILLISECONDS)).isTrue();
-    verify(mockWatcher, never()).onSecretChanged(ArgumentMatchers.any(Secret.class));
-  }
-}
diff --git a/xds/src/test/java/io/grpc/xds/internal/sds/SdsProtocolNegotiatorsTest.java b/xds/src/test/java/io/grpc/xds/internal/sds/SdsProtocolNegotiatorsTest.java
deleted file mode 100644
index 64294151912..00000000000
--- a/xds/src/test/java/io/grpc/xds/internal/sds/SdsProtocolNegotiatorsTest.java
+++ /dev/null
@@ -1,409 +0,0 @@
-/*
- * 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.sds;
-
-import static com.google.common.truth.Truth.assertThat;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.CA_PEM_FILE;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.CLIENT_KEY_FILE;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.CLIENT_PEM_FILE;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.SERVER_1_KEY_FILE;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.SERVER_1_PEM_FILE;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
-
-import com.google.common.base.Strings;
-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.grpc.Attributes;
-import io.grpc.internal.testing.TestUtils;
-import io.grpc.netty.GrpcHttp2ConnectionHandler;
-import io.grpc.netty.InternalProtocolNegotiationEvent;
-import io.grpc.netty.InternalProtocolNegotiator.ProtocolNegotiator;
-import io.grpc.netty.InternalProtocolNegotiators;
-import io.grpc.xds.EnvoyServerProtoData.DownstreamTlsContext;
-import io.grpc.xds.EnvoyServerProtoData.UpstreamTlsContext;
-import io.grpc.xds.InternalXdsAttributes;
-import io.grpc.xds.XdsClientWrapperForServerSds;
-import io.grpc.xds.XdsClientWrapperForServerSdsTestMisc;
-import io.grpc.xds.internal.sds.SdsProtocolNegotiators.ClientSdsHandler;
-import io.grpc.xds.internal.sds.SdsProtocolNegotiators.ClientSdsProtocolNegotiator;
-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.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.Iterator;
-import java.util.Map;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-
-/** Unit tests for {@link SdsProtocolNegotiators}. */
-@RunWith(JUnit4.class)
-public class SdsProtocolNegotiatorsTest {
-
-  private final GrpcHttp2ConnectionHandler grpcHandler =
-      FakeGrpcHttp2ConnectionHandler.newHandler();
-
-  private EmbeddedChannel channel = new EmbeddedChannel();
-  private ChannelPipeline pipeline = channel.pipeline();
-  private ChannelHandlerContext channelHandlerCtx;
-
-  private static String getTempFileNameForResourcesFile(String resFile) throws IOException {
-    return Strings.isNullOrEmpty(resFile) ? null : TestUtils.loadCert(resFile).getAbsolutePath();
-  }
-
-  /** Builds DownstreamTlsContext from file-names. */
-  private static DownstreamTlsContext buildDownstreamTlsContextFromFilenames(
-      String privateKey, String certChain, String trustCa) throws IOException {
-    return buildDownstreamTlsContext(
-        buildCommonTlsContextFromFilenames(privateKey, certChain, trustCa));
-  }
-
-  /** Builds UpstreamTlsContext from file-names. */
-  private static UpstreamTlsContext buildUpstreamTlsContextFromFilenames(
-      String privateKey, String certChain, String trustCa) throws IOException {
-    return CommonTlsContextTestsUtil.buildUpstreamTlsContext(
-        buildCommonTlsContextFromFilenames(privateKey, certChain, trustCa));
-  }
-
-  /** Builds DownstreamTlsContext from commonTlsContext. */
-  private static DownstreamTlsContext buildDownstreamTlsContext(CommonTlsContext commonTlsContext) {
-    io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.DownstreamTlsContext
-        downstreamTlsContext =
-            io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.DownstreamTlsContext
-                .newBuilder()
-                .setCommonTlsContext(commonTlsContext)
-                .build();
-    return DownstreamTlsContext.fromEnvoyProtoDownstreamTlsContext(downstreamTlsContext);
-  }
-
-  private static CommonTlsContext buildCommonTlsContextFromFilenames(
-      String privateKey, String certChain, String trustCa) throws IOException {
-    TlsCertificate tlsCert = null;
-    privateKey = getTempFileNameForResourcesFile(privateKey);
-    certChain = getTempFileNameForResourcesFile(certChain);
-    trustCa = getTempFileNameForResourcesFile(trustCa);
-    if (!Strings.isNullOrEmpty(privateKey) && !Strings.isNullOrEmpty(certChain)) {
-      tlsCert =
-          TlsCertificate.newBuilder()
-              .setCertificateChain(DataSource.newBuilder().setFilename(certChain))
-              .setPrivateKey(DataSource.newBuilder().setFilename(privateKey))
-              .build();
-    }
-    CertificateValidationContext certContext = null;
-    if (!Strings.isNullOrEmpty(trustCa)) {
-      certContext =
-          CertificateValidationContext.newBuilder()
-              .setTrustedCa(DataSource.newBuilder().setFilename(trustCa))
-              .build();
-    }
-    return getCommonTlsContext(tlsCert, certContext);
-  }
-
-  private static CommonTlsContext getCommonTlsContext(
-      TlsCertificate tlsCertificate, CertificateValidationContext certContext) {
-    CommonTlsContext.Builder builder = CommonTlsContext.newBuilder();
-    if (tlsCertificate != null) {
-      builder = builder.addTlsCertificates(tlsCertificate);
-    }
-    if (certContext != null) {
-      builder = builder.setValidationContext(certContext);
-    }
-    return builder.build();
-  }
-
-  @Test
-  public void clientSdsProtocolNegotiatorNewHandler_noTlsContextAttribute() {
-    ChannelHandler mockChannelHandler = mock(ChannelHandler.class);
-    ProtocolNegotiator mockProtocolNegotiator = mock(ProtocolNegotiator.class);
-    when(mockProtocolNegotiator.newHandler(grpcHandler)).thenReturn(mockChannelHandler);
-    ClientSdsProtocolNegotiator pn = new ClientSdsProtocolNegotiator(mockProtocolNegotiator);
-    ChannelHandler newHandler = pn.newHandler(grpcHandler);
-    assertThat(newHandler).isNotNull();
-    assertThat(newHandler).isSameInstanceAs(mockChannelHandler);
-  }
-
-  @Test
-  public void clientSdsProtocolNegotiatorNewHandler_noFallback_expectException() {
-    ClientSdsProtocolNegotiator pn =
-        new ClientSdsProtocolNegotiator(/* 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 clientSdsProtocolNegotiatorNewHandler_withTlsContextAttribute() {
-    UpstreamTlsContext upstreamTlsContext =
-        CommonTlsContextTestsUtil.buildUpstreamTlsContext(
-            getCommonTlsContext(/* tlsCertificate= */ null, /* certContext= */ null));
-    ClientSdsProtocolNegotiator pn =
-        new ClientSdsProtocolNegotiator(InternalProtocolNegotiators.plaintext());
-    GrpcHttp2ConnectionHandler mockHandler = mock(GrpcHttp2ConnectionHandler.class);
-    TlsContextManager mockTlsContextManager = mock(TlsContextManager.class);
-    when(mockHandler.getEagAttributes())
-        .thenReturn(
-            Attributes.newBuilder()
-                .set(InternalXdsAttributes.ATTR_SSL_CONTEXT_PROVIDER_SUPPLIER,
-                    new SslContextProviderSupplier(upstreamTlsContext, mockTlsContextManager))
-                .build());
-    ChannelHandler newHandler = pn.newHandler(mockHandler);
-    assertThat(newHandler).isNotNull();
-    assertThat(newHandler).isInstanceOf(ClientSdsHandler.class);
-  }
-
-  @Test
-  public void clientSdsHandler_addLast() throws IOException {
-    UpstreamTlsContext upstreamTlsContext =
-        buildUpstreamTlsContextFromFilenames(CLIENT_KEY_FILE, CLIENT_PEM_FILE, CA_PEM_FILE);
-
-    SslContextProviderSupplier sslContextProviderSupplier =
-        new SslContextProviderSupplier(upstreamTlsContext, TlsContextManagerImpl.getInstance());
-    SdsProtocolNegotiators.ClientSdsHandler clientSdsHandler =
-        new SdsProtocolNegotiators.ClientSdsHandler(grpcHandler, sslContextProviderSupplier);
-    pipeline.addLast(clientSdsHandler);
-    channelHandlerCtx = pipeline.context(clientSdsHandler);
-    assertNotNull(channelHandlerCtx); // clientSdsHandler ctx is non-null since we just added it
-
-    // kick off protocol negotiation.
-    pipeline.fireUserEventTriggered(InternalProtocolNegotiationEvent.getDefault());
-    channel.runPendingTasks(); // need this for tasks to execute on eventLoop
-    channelHandlerCtx = pipeline.context(clientSdsHandler);
-    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");
-  }
-
-  @Test
-  public void serverSdsHandler_addLast() throws IOException {
-    // 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();
-    DownstreamTlsContext downstreamTlsContext =
-        buildDownstreamTlsContextFromFilenames(SERVER_1_KEY_FILE, SERVER_1_PEM_FILE, CA_PEM_FILE);
-
-    XdsClientWrapperForServerSds xdsClientWrapperForServerSds =
-        XdsClientWrapperForServerSdsTestMisc.createXdsClientWrapperForServerSds(
-            80, downstreamTlsContext);
-    SdsProtocolNegotiators.HandlerPickerHandler handlerPickerHandler =
-        new SdsProtocolNegotiators.HandlerPickerHandler(grpcHandler, xdsClientWrapperForServerSds,
-            InternalProtocolNegotiators.serverPlaintext());
-    pipeline.addLast(handlerPickerHandler);
-    channelHandlerCtx = pipeline.context(handlerPickerHandler);
-    assertThat(channelHandlerCtx).isNotNull(); // should find HandlerPickerHandler
-
-    // kick off protocol negotiation: should replace HandlerPickerHandler with ServerSdsHandler
-    pipeline.fireUserEventTriggered(InternalProtocolNegotiationEvent.getDefault());
-    channelHandlerCtx = pipeline.context(handlerPickerHandler);
-    assertThat(channelHandlerCtx).isNull();
-    channelHandlerCtx = pipeline.context(SdsProtocolNegotiators.ServerSdsHandler.class);
-    assertThat(channelHandlerCtx).isNotNull();
-    channel.runPendingTasks(); // need this for tasks to execute on eventLoop
-    channelHandlerCtx = pipeline.context(SdsProtocolNegotiators.ServerSdsHandler.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");
-  }
-
-  @Test
-  public void serverSdsHandler_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();
-    DownstreamTlsContext downstreamTlsContext =
-        DownstreamTlsContext.fromEnvoyProtoDownstreamTlsContext(
-            io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.DownstreamTlsContext
-                .getDefaultInstance());
-
-    XdsClientWrapperForServerSds xdsClientWrapperForServerSds =
-        XdsClientWrapperForServerSdsTestMisc.createXdsClientWrapperForServerSds(
-            80, downstreamTlsContext);
-    SdsProtocolNegotiators.HandlerPickerHandler handlerPickerHandler =
-        new SdsProtocolNegotiators.HandlerPickerHandler(
-            grpcHandler, xdsClientWrapperForServerSds, mockProtocolNegotiator);
-    pipeline.addLast(handlerPickerHandler);
-    channelHandlerCtx = pipeline.context(handlerPickerHandler);
-    assertThat(channelHandlerCtx).isNotNull(); // should find HandlerPickerHandler
-
-    // kick off protocol negotiation: should replace HandlerPickerHandler with ServerSdsHandler
-    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 serverSdsHandler_nullTlsContext_expectFallbackProtocolNegotiator() {
-    ChannelHandler mockChannelHandler = mock(ChannelHandler.class);
-    ProtocolNegotiator mockProtocolNegotiator = mock(ProtocolNegotiator.class);
-    when(mockProtocolNegotiator.newHandler(grpcHandler)).thenReturn(mockChannelHandler);
-    SdsProtocolNegotiators.HandlerPickerHandler handlerPickerHandler =
-        new SdsProtocolNegotiators.HandlerPickerHandler(
-            grpcHandler, /* xdsClientWrapperForServerSds= */ null,
-            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() {
-    SdsProtocolNegotiators.HandlerPickerHandler handlerPickerHandler =
-        new SdsProtocolNegotiators.HandlerPickerHandler(
-            grpcHandler, /* xdsClientWrapperForServerSds= */ null,
-            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 clientSdsProtocolNegotiatorNewHandler_fireProtocolNegotiationEvent()
-      throws IOException, InterruptedException {
-    UpstreamTlsContext upstreamTlsContext =
-        buildUpstreamTlsContextFromFilenames(CLIENT_KEY_FILE, CLIENT_PEM_FILE, CA_PEM_FILE);
-
-    SslContextProviderSupplier sslContextProviderSupplier =
-        new SslContextProviderSupplier(upstreamTlsContext, TlsContextManagerImpl.getInstance());
-    SdsProtocolNegotiators.ClientSdsHandler clientSdsHandler =
-        new SdsProtocolNegotiators.ClientSdsHandler(grpcHandler, sslContextProviderSupplier);
-
-    pipeline.addLast(clientSdsHandler);
-    channelHandlerCtx = pipeline.context(clientSdsHandler);
-    assertNotNull(channelHandlerCtx); // non-null since we just added it
-
-    // kick off protocol negotiation.
-    pipeline.fireUserEventTriggered(InternalProtocolNegotiationEvent.getDefault());
-    channel.runPendingTasks(); // need this for tasks to execute on eventLoop
-    channelHandlerCtx = pipeline.context(clientSdsHandler);
-    assertThat(channelHandlerCtx).isNull();
-    Object sslEvent = SslHandshakeCompletionEvent.SUCCESS;
-
-    pipeline.fireUserEventTriggered(sslEvent);
-    channel.runPendingTasks(); // need this for tasks to execute on eventLoop
-    assertTrue(channel.isOpen());
-  }
-
-  private static final class FakeGrpcHttp2ConnectionHandler extends GrpcHttp2ConnectionHandler {
-
-    FakeGrpcHttp2ConnectionHandler(
-        ChannelPromise channelUnused,
-        Http2ConnectionDecoder decoder,
-        Http2ConnectionEncoder encoder,
-        Http2Settings initialSettings) {
-      super(channelUnused, decoder, encoder, initialSettings);
-    }
-
-    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/internal/sds/SdsSslContextProviderTest.java b/xds/src/test/java/io/grpc/xds/internal/sds/SdsSslContextProviderTest.java
deleted file mode 100644
index 6ecb533e280..00000000000
--- a/xds/src/test/java/io/grpc/xds/internal/sds/SdsSslContextProviderTest.java
+++ /dev/null
@@ -1,263 +0,0 @@
-/*
- * 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.sds;
-
-import static com.google.common.truth.Truth.assertThat;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.CA_PEM_FILE;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.CLIENT_KEY_FILE;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.CLIENT_PEM_FILE;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.SERVER_1_KEY_FILE;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.SERVER_1_PEM_FILE;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.doChecksOnSslContext;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.getValueThruCallback;
-import static io.grpc.xds.internal.sds.SdsClientTest.getOneCertificateValidationContextSecret;
-import static io.grpc.xds.internal.sds.SdsClientTest.getOneTlsCertSecret;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
-
-import com.google.common.util.concurrent.MoreExecutors;
-import io.envoyproxy.envoy.api.v2.core.Node;
-import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.CommonTlsContext;
-import io.envoyproxy.envoy.type.matcher.v3.StringMatcher;
-import io.grpc.Status.Code;
-import io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.TestCallback;
-import java.io.IOException;
-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 SdsClientSslContextProvider}. */
-@RunWith(JUnit4.class)
-public class SdsSslContextProviderTest {
-
-  private TestSdsServer.ServerMock serverMock;
-  private TestSdsServer server;
-  private Node node;
-
-  @Before
-  public void setUp() throws Exception {
-    serverMock = mock(TestSdsServer.ServerMock.class);
-    server = new TestSdsServer(serverMock);
-    server.startServer(/* name= */ "inproc", /* useUds= */ false, /* useInterceptor= */ false);
-
-    node = Node.newBuilder().setId("sds-client-temp-test1").build();
-  }
-
-  @After
-  public void teardown() throws InterruptedException {
-    server.shutdown();
-  }
-
-  /** Helper method to build SdsClientSslContextProvider from given names. */
-  private SdsClientSslContextProvider getSdsClientSslContextProvider(
-      String certName,
-      String validationContextName,
-      Iterable<StringMatcher> matchSubjectAltNames,
-      Iterable<String> alpnProtocols)
-      throws IOException {
-
-    CommonTlsContext commonTlsContext =
-        CommonTlsContextTestsUtil.buildCommonTlsContextWithAdditionalValues(
-            certName,
-            /* certTargetUri= */ "inproc",
-            validationContextName,
-            /* validationContextTargetUri= */ "inproc",
-            matchSubjectAltNames,
-            alpnProtocols,
-            /* channelType= */ "inproc");
-
-    return SdsClientSslContextProvider.getProvider(
-        CommonTlsContextTestsUtil.buildUpstreamTlsContext(commonTlsContext),
-        node,
-        MoreExecutors.directExecutor(),
-        MoreExecutors.directExecutor());
-  }
-
-  /** Helper method to build SdsServerSslContextProvider from given names. */
-  private SdsServerSslContextProvider getSdsServerSslContextProvider(
-      String certName,
-      String validationContextName,
-      Iterable<StringMatcher> matchSubjectAltNames,
-      Iterable<String> alpnProtocols)
-      throws IOException {
-
-    CommonTlsContext commonTlsContext =
-        CommonTlsContextTestsUtil.buildCommonTlsContextWithAdditionalValues(
-            certName,
-            /* certTargetUri= */ "inproc",
-            validationContextName,
-            /* validationContextTargetUri= */ "inproc",
-            matchSubjectAltNames,
-            alpnProtocols,
-            /* channelType= */ "inproc");
-
-    return SdsServerSslContextProvider.getProvider(
-        CommonTlsContextTestsUtil.buildInternalDownstreamTlsContext(
-            commonTlsContext, /* requireClientCert= */ false),
-        node,
-        MoreExecutors.directExecutor(),
-        MoreExecutors.directExecutor());
-  }
-
-  @Test
-  public void testProviderForServer() throws IOException {
-    when(serverMock.getSecretFor(/* name= */ "cert1"))
-        .thenReturn(getOneTlsCertSecret(/* name= */ "cert1", SERVER_1_KEY_FILE, SERVER_1_PEM_FILE));
-    when(serverMock.getSecretFor(/* name= */ "valid1"))
-        .thenReturn(getOneCertificateValidationContextSecret(/* name= */ "valid1", CA_PEM_FILE));
-
-    SdsServerSslContextProvider provider =
-        getSdsServerSslContextProvider("cert1", "valid1", null, null);
-    TestCallback testCallback = getValueThruCallback(provider);
-
-    doChecksOnSslContext(true, testCallback.updatedSslContext, /* expectedApnProtos= */ null);
-  }
-
-  @Test
-  public void testProviderForClient() throws IOException {
-    when(serverMock.getSecretFor(/* name= */ "cert1"))
-        .thenReturn(getOneTlsCertSecret(/* name= */ "cert1", CLIENT_KEY_FILE, CLIENT_PEM_FILE));
-    when(serverMock.getSecretFor("valid1"))
-        .thenReturn(getOneCertificateValidationContextSecret(/* name= */ "valid1", CA_PEM_FILE));
-
-    SdsClientSslContextProvider provider =
-        getSdsClientSslContextProvider(
-            /* certName= */ "cert1",
-            /* validationContextName= */ "valid1",
-            /* matchSubjectAltNames= */ null,
-            /* alpnProtocols= */ null);
-    TestCallback testCallback = getValueThruCallback(provider);
-
-    doChecksOnSslContext(false, testCallback.updatedSslContext, /* expectedApnProtos= */ null);
-  }
-
-  @Test
-  public void testProviderForServer_onlyCert() throws IOException {
-    when(serverMock.getSecretFor(/* name= */ "cert1"))
-        .thenReturn(getOneTlsCertSecret(/* name= */ "cert1", SERVER_1_KEY_FILE, SERVER_1_PEM_FILE));
-
-    SdsServerSslContextProvider provider =
-        getSdsServerSslContextProvider(
-            /* certName= */ "cert1",
-            /* validationContextName= */ null,
-            /* matchSubjectAltNames= */ null,
-            /* alpnProtocols= */ null);
-    TestCallback testCallback = getValueThruCallback(provider);
-
-    doChecksOnSslContext(true, testCallback.updatedSslContext, /* expectedApnProtos= */ null);
-  }
-
-  @Test
-  public void getProviderForClient_onlyTrust() throws IOException {
-    when(serverMock.getSecretFor(/* name= */ "valid1"))
-        .thenReturn(getOneCertificateValidationContextSecret(/* name= */ "valid1", CA_PEM_FILE));
-
-    SdsClientSslContextProvider provider =
-        getSdsClientSslContextProvider(
-            /* certName= */ null,
-            /* validationContextName= */ "valid1",
-            /* matchSubjectAltNames= */ null,
-            null);
-    TestCallback testCallback = getValueThruCallback(provider);
-
-    doChecksOnSslContext(false, testCallback.updatedSslContext, /* expectedApnProtos= */ null);
-  }
-
-  @Test
-  public void getProviderForServer_noCert_throwsException() throws IOException {
-    when(serverMock.getSecretFor(/* name= */ "valid1"))
-        .thenReturn(getOneCertificateValidationContextSecret(/* name= */ "valid1", CA_PEM_FILE));
-
-    SdsServerSslContextProvider provider =
-        getSdsServerSslContextProvider(
-            /* certName= */ null,
-            /* validationContextName= */ "valid1",
-            /* matchSubjectAltNames= */ null,
-            /* alpnProtocols= */ null);
-    TestCallback testCallback = getValueThruCallback(provider);
-
-    assertThat(server.lastNack).isNotNull();
-    assertThat(server.lastNack.getVersionInfo()).isEmpty();
-    assertThat(server.lastNack.getResponseNonce()).isEmpty();
-    com.google.rpc.Status errorDetail = server.lastNack.getErrorDetail();
-    assertThat(errorDetail.getCode()).isEqualTo(Code.UNKNOWN.value());
-    assertThat(errorDetail.getMessage()).isEqualTo("Secret not updated");
-    assertThat(testCallback.updatedSslContext).isNull();
-  }
-
-  @Test
-  public void testProviderForClient_withSubjectAltNames() throws IOException {
-    when(serverMock.getSecretFor(/* name= */ "cert1"))
-        .thenReturn(getOneTlsCertSecret(/* name= */ "cert1", CLIENT_KEY_FILE, CLIENT_PEM_FILE));
-    when(serverMock.getSecretFor("valid1"))
-        .thenReturn(getOneCertificateValidationContextSecret(/* name= */ "valid1", CA_PEM_FILE));
-
-    SdsClientSslContextProvider provider =
-        getSdsClientSslContextProvider(
-            /* certName= */ "cert1",
-            /* validationContextName= */ "valid1",
-            Arrays.asList(
-                StringMatcher.newBuilder()
-                    .setExact("spiffe://grpc-sds-testing.svc.id.goog/ns/default/sa/bob")
-                    .build()),
-            /* alpnProtocols= */ null);
-
-    TestCallback testCallback = getValueThruCallback(provider);
-    doChecksOnSslContext(false, testCallback.updatedSslContext, /* expectedApnProtos= */ null);
-  }
-
-  @Test
-  public void testProviderForClient_withAlpnProtocols() throws IOException {
-    when(serverMock.getSecretFor(/* name= */ "cert1"))
-        .thenReturn(getOneTlsCertSecret(/* name= */ "cert1", CLIENT_KEY_FILE, CLIENT_PEM_FILE));
-    when(serverMock.getSecretFor("valid1"))
-        .thenReturn(getOneCertificateValidationContextSecret(/* name= */ "valid1", CA_PEM_FILE));
-
-    SdsClientSslContextProvider provider =
-        getSdsClientSslContextProvider(
-            /* certName= */ "cert1",
-            /* validationContextName= */ "valid1",
-            /* matchSubjectAltNames= */ null,
-            /* alpnProtocols= */ Arrays.asList("managed-mtls", "h2"));
-    TestCallback testCallback = getValueThruCallback(provider);
-
-    doChecksOnSslContext(
-        false, testCallback.updatedSslContext, Arrays.asList("managed-mtls", "h2"));
-  }
-
-  @Test
-  public void testProviderForServer_withAlpnProtocols() throws IOException {
-    when(serverMock.getSecretFor(/* name= */ "cert1"))
-        .thenReturn(getOneTlsCertSecret(/* name= */ "cert1", SERVER_1_KEY_FILE, SERVER_1_PEM_FILE));
-    when(serverMock.getSecretFor(/* name= */ "valid1"))
-        .thenReturn(getOneCertificateValidationContextSecret(/* name= */ "valid1", CA_PEM_FILE));
-
-    SdsServerSslContextProvider provider =
-        getSdsServerSslContextProvider(
-            /* certName= */ "cert1",
-            /* validationContextName= */ "valid1",
-            /* matchSubjectAltNames= */ null,
-            /* alpnProtocols= */ Arrays.asList("managed-mtls", "h2"));
-    TestCallback testCallback = getValueThruCallback(provider);
-
-    doChecksOnSslContext(
-        true, testCallback.updatedSslContext, Arrays.asList("managed-mtls", "h2"));
-  }
-}
diff --git a/xds/src/test/java/io/grpc/xds/internal/sds/SecretVolumeSslContextProviderTest.java b/xds/src/test/java/io/grpc/xds/internal/sds/SecretVolumeSslContextProviderTest.java
deleted file mode 100644
index 44a5c461dc7..00000000000
--- a/xds/src/test/java/io/grpc/xds/internal/sds/SecretVolumeSslContextProviderTest.java
+++ /dev/null
@@ -1,444 +0,0 @@
-/*
- * 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.sds;
-
-import static com.google.common.truth.Truth.assertThat;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.CA_PEM_FILE;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.CLIENT_KEY_FILE;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.CLIENT_PEM_FILE;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.SERVER_1_KEY_FILE;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.SERVER_1_PEM_FILE;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.doChecksOnSslContext;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.getValueThruCallback;
-
-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.TlsCertificate;
-import io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.TestCallback;
-import io.netty.handler.ssl.SslContext;
-import java.io.IOException;
-import java.security.cert.CertStoreException;
-import java.security.cert.CertificateException;
-import org.junit.Assert;
-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 SecretVolumeClientSslContextProvider}. */
-@RunWith(JUnit4.class)
-public class SecretVolumeSslContextProviderTest {
-
-  @Rule public TemporaryFolder temporaryFolder = new TemporaryFolder();
-
-  @Test
-  public void validateCertificateContext_nullAndNotOptional_throwsException() {
-    // expect exception when certContext is null and not optional
-    try {
-      CommonTlsContextUtil.validateCertificateContext(
-          /* certContext= */ null, /* optional= */ false);
-      Assert.fail("no exception thrown");
-    } catch (IllegalArgumentException expected) {
-      assertThat(expected).hasMessageThat().isEqualTo("certContext is required");
-    }
-  }
-
-  @Test
-  public void validateCertificateContext_missingTrustCa_throwsException() {
-    // expect exception when certContext has no CA and not optional
-    CertificateValidationContext certContext = CertificateValidationContext.getDefaultInstance();
-    try {
-      CommonTlsContextUtil.validateCertificateContext(certContext, /* optional= */ false);
-      Assert.fail("no exception thrown");
-    } catch (IllegalArgumentException expected) {
-      assertThat(expected).hasMessageThat().isEqualTo("certContext is required");
-    }
-  }
-
-  @Test
-  public void validateCertificateContext_nullAndOptional() {
-    // certContext argument can be null when optional
-    CertificateValidationContext certContext =
-        CommonTlsContextUtil.validateCertificateContext(
-            /* certContext= */ null, /* optional= */ true);
-    assertThat(certContext).isNull();
-  }
-
-  @Test
-  public void validateCertificateContext_missingTrustCaOptional() {
-    // certContext argument can have missing CA when optional
-    CertificateValidationContext certContext = CertificateValidationContext.getDefaultInstance();
-    assertThat(CommonTlsContextUtil.validateCertificateContext(certContext, /* optional= */ true))
-        .isNull();
-  }
-
-  @Test
-  public void validateCertificateContext_inlineString_throwsException() {
-    // expect exception when certContext doesn't use filename (inline string)
-    CertificateValidationContext certContext =
-        CertificateValidationContext.newBuilder()
-            .setTrustedCa(DataSource.newBuilder().setInlineString("foo"))
-            .build();
-    try {
-      CommonTlsContextUtil.validateCertificateContext(certContext, /* optional= */ false);
-      Assert.fail("no exception thrown");
-    } catch (IllegalArgumentException expected) {
-      assertThat(expected).hasMessageThat().isEqualTo("filename expected");
-    }
-  }
-
-  @Test
-  public void validateCertificateContext_filename() {
-    // validation succeeds and returns same instance when filename provided
-    CertificateValidationContext certContext =
-        CertificateValidationContext.newBuilder()
-            .setTrustedCa(DataSource.newBuilder().setFilename("bar"))
-            .build();
-    assertThat(CommonTlsContextUtil.validateCertificateContext(certContext, /* optional= */ false))
-        .isSameInstanceAs(certContext);
-  }
-
-  @Test
-  public void validateTlsCertificate_nullAndNotOptional_throwsException() {
-    // expect exception when tlsCertificate is null and not optional
-    try {
-      CommonTlsContextUtil.validateTlsCertificate(
-          /* tlsCertificate= */ null, /* optional= */ false);
-      Assert.fail("no exception thrown");
-    } catch (IllegalArgumentException expected) {
-      assertThat(expected).hasMessageThat().isEqualTo("tlsCertificate is required");
-    }
-  }
-
-  @Test
-  public void validateTlsCertificate_nullOptional() {
-    assertThat(
-            CommonTlsContextUtil.validateTlsCertificate(
-                /* tlsCertificate= */ null, /* optional= */ true))
-        .isNull();
-  }
-
-  @Test
-  public void validateTlsCertificate_defaultInstance_returnsNull() {
-    // tlsCertificate is not null but has no value (default instance): expect null
-    TlsCertificate tlsCert = TlsCertificate.getDefaultInstance();
-    assertThat(CommonTlsContextUtil.validateTlsCertificate(tlsCert, /* optional= */ true)).isNull();
-  }
-
-  @Test
-  public void validateTlsCertificate_missingCertChainNotOptional_throwsException() {
-    // expect exception when tlsCertificate has missing certChain and not optional
-    TlsCertificate tlsCert =
-        TlsCertificate.newBuilder()
-            .setPrivateKey(DataSource.newBuilder().setInlineString("foo"))
-            .build();
-    try {
-      CommonTlsContextUtil.validateTlsCertificate(tlsCert, /* optional= */ false);
-      Assert.fail("no exception thrown");
-    } catch (IllegalArgumentException expected) {
-      assertThat(expected).hasMessageThat().isEqualTo("filename expected");
-    }
-  }
-
-  @Test
-  public void validateTlsCertificate_missingCertChainOptional_throwsException() {
-    // expect exception when tlsCertificate has missing certChain even if optional
-    TlsCertificate tlsCert =
-        TlsCertificate.newBuilder()
-            .setPrivateKey(DataSource.newBuilder().setInlineString("foo"))
-            .build();
-    try {
-      CommonTlsContextUtil.validateTlsCertificate(tlsCert, /* optional= */ true);
-      Assert.fail("no exception thrown");
-    } catch (IllegalArgumentException expected) {
-      assertThat(expected).hasMessageThat().isEqualTo("filename expected");
-    }
-  }
-
-  @Test
-  public void validateTlsCertificate_missingPrivateKeyNotOptional_throwsException() {
-    // expect exception when tlsCertificate has missing private key and not optional
-    TlsCertificate tlsCert =
-        TlsCertificate.newBuilder()
-            .setCertificateChain(DataSource.newBuilder().setInlineString("foo"))
-            .build();
-    try {
-      CommonTlsContextUtil.validateTlsCertificate(tlsCert, /* optional= */ false);
-      Assert.fail("no exception thrown");
-    } catch (IllegalArgumentException expected) {
-      assertThat(expected).hasMessageThat().isEqualTo("filename expected");
-    }
-  }
-
-  @Test
-  public void validateTlsCertificate_missingPrivateKeyOptional_throwsException() {
-    // expect exception when tlsCertificate has missing private key even if optional
-    TlsCertificate tlsCert =
-        TlsCertificate.newBuilder()
-            .setCertificateChain(DataSource.newBuilder().setInlineString("foo"))
-            .build();
-    try {
-      CommonTlsContextUtil.validateTlsCertificate(tlsCert, /* optional= */ true);
-      Assert.fail("no exception thrown");
-    } catch (IllegalArgumentException expected) {
-      assertThat(expected).hasMessageThat().isEqualTo("filename expected");
-    }
-  }
-
-  @Test
-  public void validateTlsCertificate_optional_returnsSameInstance() {
-    TlsCertificate tlsCert =
-        TlsCertificate.newBuilder()
-            .setCertificateChain(DataSource.newBuilder().setFilename("foo"))
-            .setPrivateKey(DataSource.newBuilder().setFilename("bar"))
-            .build();
-    assertThat(CommonTlsContextUtil.validateTlsCertificate(tlsCert, /* optional= */ true))
-        .isSameInstanceAs(tlsCert);
-  }
-
-  @Test
-  public void validateTlsCertificate_notOptional_returnsSameInstance() {
-    TlsCertificate tlsCert =
-        TlsCertificate.newBuilder()
-            .setCertificateChain(DataSource.newBuilder().setFilename("foo"))
-            .setPrivateKey(DataSource.newBuilder().setFilename("bar"))
-            .build();
-    assertThat(CommonTlsContextUtil.validateTlsCertificate(tlsCert, /* optional= */ false))
-        .isSameInstanceAs(tlsCert);
-  }
-
-  @Test
-  public void validateTlsCertificate_certChainInlineString_throwsException() {
-    // expect exception when tlsCertificate has certChain as inline string
-    TlsCertificate tlsCert =
-        TlsCertificate.newBuilder()
-            .setCertificateChain(DataSource.newBuilder().setInlineString("foo"))
-            .setPrivateKey(DataSource.newBuilder().setFilename("bar"))
-            .build();
-    try {
-      CommonTlsContextUtil.validateTlsCertificate(tlsCert, /* optional= */ true);
-      Assert.fail("no exception thrown");
-    } catch (IllegalArgumentException expected) {
-      assertThat(expected).hasMessageThat().isEqualTo("filename expected");
-    }
-  }
-
-  @Test
-  public void validateTlsCertificate_privateKeyInlineString_throwsException() {
-    // expect exception when tlsCertificate has private key as inline string
-    TlsCertificate tlsCert =
-        TlsCertificate.newBuilder()
-            .setPrivateKey(DataSource.newBuilder().setInlineString("foo"))
-            .setCertificateChain(DataSource.newBuilder().setFilename("bar"))
-            .build();
-    try {
-      CommonTlsContextUtil.validateTlsCertificate(tlsCert, /* optional= */ true);
-      Assert.fail("no exception thrown");
-    } catch (IllegalArgumentException expected) {
-      assertThat(expected).hasMessageThat().isEqualTo("filename expected");
-    }
-  }
-
-  @Test
-  public void getProviderForServer_defaultTlsCertificate_throwsException() {
-    TlsCertificate tlsCert = TlsCertificate.getDefaultInstance();
-    try {
-      SecretVolumeServerSslContextProvider.getProvider(
-          CommonTlsContextTestsUtil.buildInternalDownstreamTlsContext(
-              CommonTlsContextTestsUtil.getCommonTlsContext(tlsCert, /* certContext= */ null),
-              /* requireClientCert= */ false));
-      Assert.fail("no exception thrown");
-    } catch (IllegalArgumentException expected) {
-      assertThat(expected).hasMessageThat().isEqualTo("filename expected");
-    }
-  }
-
-  @Test
-  public void getProviderForServer_certContextWithInlineString_throwsException() {
-    TlsCertificate tlsCert =
-        TlsCertificate.newBuilder()
-            .setCertificateChain(DataSource.newBuilder().setFilename("foo"))
-            .setPrivateKey(DataSource.newBuilder().setFilename("bar"))
-            .build();
-    CertificateValidationContext certContext =
-        CertificateValidationContext.newBuilder()
-            .setTrustedCa(DataSource.newBuilder().setInlineString("foo"))
-            .build();
-    try {
-      SecretVolumeServerSslContextProvider.getProvider(
-          CommonTlsContextTestsUtil.buildInternalDownstreamTlsContext(
-              CommonTlsContextTestsUtil.getCommonTlsContext(tlsCert, certContext),
-              /* requireClientCert= */ false));
-      Assert.fail("no exception thrown");
-    } catch (IllegalArgumentException expected) {
-      assertThat(expected.getMessage()).isEqualTo("filename expected");
-    }
-  }
-
-  @Test
-  public void getProviderForClient_defaultCertContext_throwsException() {
-    CertificateValidationContext certContext = CertificateValidationContext.getDefaultInstance();
-    try {
-      SecretVolumeClientSslContextProvider.getProvider(
-          CommonTlsContextTestsUtil.buildUpstreamTlsContext(
-              CommonTlsContextTestsUtil.getCommonTlsContext(
-                  /* tlsCertificate= */ null, certContext)));
-      Assert.fail("no exception thrown");
-    } catch (IllegalArgumentException expected) {
-      assertThat(expected).hasMessageThat().isEqualTo("certContext is required");
-    }
-  }
-
-  @Test
-  public void getProviderForClient_certWithPrivateKeyInlineString_throwsException() {
-    TlsCertificate tlsCert =
-        TlsCertificate.newBuilder()
-            .setCertificateChain(DataSource.newBuilder().setFilename("foo"))
-            .setPrivateKey(DataSource.newBuilder().setInlineString("bar"))
-            .build();
-    CertificateValidationContext certContext =
-        CertificateValidationContext.newBuilder()
-            .setTrustedCa(DataSource.newBuilder().setFilename("foo"))
-            .build();
-    try {
-      SecretVolumeClientSslContextProvider.getProvider(
-          CommonTlsContextTestsUtil.buildUpstreamTlsContext(
-              CommonTlsContextTestsUtil.getCommonTlsContext(tlsCert, certContext)));
-      Assert.fail("no exception thrown");
-    } catch (IllegalArgumentException expected) {
-      assertThat(expected).hasMessageThat().isEqualTo("filename expected");
-    }
-  }
-
-  @Test
-  public void getProviderForClient_certWithCertChainInlineString_throwsException() {
-    TlsCertificate tlsCert =
-        TlsCertificate.newBuilder()
-            .setCertificateChain(DataSource.newBuilder().setInlineString("foo"))
-            .setPrivateKey(DataSource.newBuilder().setFilename("bar"))
-            .build();
-    CertificateValidationContext certContext =
-        CertificateValidationContext.newBuilder()
-            .setTrustedCa(DataSource.newBuilder().setFilename("foo"))
-            .build();
-    try {
-      SecretVolumeClientSslContextProvider.getProvider(
-          CommonTlsContextTestsUtil.buildUpstreamTlsContext(
-              CommonTlsContextTestsUtil.getCommonTlsContext(tlsCert, certContext)));
-      Assert.fail("no exception thrown");
-    } catch (IllegalArgumentException expected) {
-      assertThat(expected).hasMessageThat().isEqualTo("filename expected");
-    }
-  }
-
-  /**
-   * Helper method to build SecretVolumeSslContextProvider, call buildSslContext on it and
-   * check returned SslContext.
-   */
-  private static void sslContextForEitherWithBothCertAndTrust(
-      boolean server, String pemFile, String keyFile, String caFile)
-      throws IOException, CertificateException, CertStoreException {
-    SslContext sslContext = null;
-    if (server) {
-      SecretVolumeServerSslContextProvider provider =
-          SecretVolumeServerSslContextProvider.getProvider(
-              CommonTlsContextTestsUtil.buildDownstreamTlsContextFromFilenames(
-                  keyFile, pemFile, caFile));
-
-      sslContext = provider.buildSslContextFromSecrets();
-    } else {
-      SecretVolumeClientSslContextProvider provider =
-          SecretVolumeClientSslContextProvider.getProvider(
-              CommonTlsContextTestsUtil.buildUpstreamTlsContextFromFilenames(
-                  keyFile, pemFile, caFile));
-
-      sslContext = provider.buildSslContextFromSecrets();
-    }
-    doChecksOnSslContext(server, sslContext, /* expectedApnProtos= */ null);
-  }
-
-  @Test
-  public void getProviderForServer() throws IOException, CertificateException, CertStoreException {
-    sslContextForEitherWithBothCertAndTrust(
-        true, SERVER_1_PEM_FILE, SERVER_1_KEY_FILE, CA_PEM_FILE);
-  }
-
-  @Test
-  public void getProviderForClient() throws IOException, CertificateException, CertStoreException {
-    sslContextForEitherWithBothCertAndTrust(false, CLIENT_PEM_FILE, CLIENT_KEY_FILE, CA_PEM_FILE);
-  }
-
-  @Test
-  public void getProviderForServer_onlyCert()
-      throws IOException, CertificateException, CertStoreException {
-    sslContextForEitherWithBothCertAndTrust(true, SERVER_1_PEM_FILE, SERVER_1_KEY_FILE, null);
-  }
-
-  @Test
-  public void getProviderForClient_onlyTrust()
-      throws IOException, CertificateException, CertStoreException {
-    sslContextForEitherWithBothCertAndTrust(false, null, null, CA_PEM_FILE);
-  }
-
-  @Test
-  public void getProviderForServer_badFile_throwsException()
-      throws IOException, CertificateException, CertStoreException {
-    try {
-      sslContextForEitherWithBothCertAndTrust(true, SERVER_1_PEM_FILE, SERVER_1_PEM_FILE, null);
-      Assert.fail("no exception thrown");
-    } catch (IllegalArgumentException expected) {
-      assertThat(expected).hasMessageThat().contains("File does not contain valid private key");
-    }
-  }
-
-  @Test
-  public void getProviderForServer_both_callsback() throws IOException {
-    SecretVolumeServerSslContextProvider provider =
-        SecretVolumeServerSslContextProvider.getProvider(
-            CommonTlsContextTestsUtil.buildDownstreamTlsContextFromFilenames(
-                SERVER_1_KEY_FILE, SERVER_1_PEM_FILE, CA_PEM_FILE));
-
-    TestCallback testCallback = getValueThruCallback(provider);
-    doChecksOnSslContext(true, testCallback.updatedSslContext, /* expectedApnProtos= */ null);
-  }
-
-  @Test
-  public void getProviderForClient_both_callsback() throws IOException {
-    SecretVolumeClientSslContextProvider provider =
-        SecretVolumeClientSslContextProvider.getProvider(
-            CommonTlsContextTestsUtil.buildUpstreamTlsContextFromFilenames(
-                CLIENT_KEY_FILE, CLIENT_PEM_FILE, CA_PEM_FILE));
-
-    TestCallback testCallback = getValueThruCallback(provider);
-    doChecksOnSslContext(false, testCallback.updatedSslContext, /* expectedApnProtos= */ null);
-  }
-
-  // note this test generates stack-trace but can be safely ignored
-  @Test
-  public void getProviderForClient_both_callsback_setException() throws IOException {
-    SecretVolumeClientSslContextProvider provider =
-        SecretVolumeClientSslContextProvider.getProvider(
-            CommonTlsContextTestsUtil.buildUpstreamTlsContextFromFilenames(
-                CLIENT_PEM_FILE, CLIENT_PEM_FILE, CA_PEM_FILE));
-    TestCallback testCallback = getValueThruCallback(provider);
-    assertThat(testCallback.updatedSslContext).isNull();
-    assertThat(testCallback.updatedThrowable).isInstanceOf(IllegalArgumentException.class);
-    assertThat(testCallback.updatedThrowable).hasMessageThat()
-        .contains("File does not contain valid private key");
-  }
-}
diff --git a/xds/src/test/java/io/grpc/xds/internal/sds/ServerSslContextProviderFactoryTest.java b/xds/src/test/java/io/grpc/xds/internal/sds/ServerSslContextProviderFactoryTest.java
deleted file mode 100644
index 43fbf41b75f..00000000000
--- a/xds/src/test/java/io/grpc/xds/internal/sds/ServerSslContextProviderFactoryTest.java
+++ /dev/null
@@ -1,303 +0,0 @@
-/*
- * 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.sds;
-
-import static com.google.common.truth.Truth.assertThat;
-import static io.grpc.xds.internal.sds.ClientSslContextProviderFactoryTest.createAndRegisterProviderProvider;
-import static io.grpc.xds.internal.sds.ClientSslContextProviderFactoryTest.verifyWatcher;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.CA_PEM_FILE;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.SERVER_1_KEY_FILE;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.SERVER_1_PEM_FILE;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
-
-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.Bootstrapper;
-import io.grpc.xds.CommonBootstrapperTestUtils;
-import io.grpc.xds.EnvoyServerProtoData;
-import io.grpc.xds.EnvoyServerProtoData.DownstreamTlsContext;
-import io.grpc.xds.XdsInitializationException;
-import io.grpc.xds.internal.certprovider.CertProviderServerSslContextProvider;
-import io.grpc.xds.internal.certprovider.CertificateProvider;
-import io.grpc.xds.internal.certprovider.CertificateProviderRegistry;
-import io.grpc.xds.internal.certprovider.CertificateProviderStore;
-import java.io.IOException;
-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 ServerSslContextProviderFactory}. */
-@RunWith(JUnit4.class)
-public class ServerSslContextProviderFactoryTest {
-
-  Bootstrapper bootstrapper;
-  CertificateProviderRegistry certificateProviderRegistry;
-  CertificateProviderStore certificateProviderStore;
-  CertProviderServerSslContextProvider.Factory certProviderServerSslContextProviderFactory;
-  ServerSslContextProviderFactory serverSslContextProviderFactory;
-
-  @Before
-  public void setUp() {
-    bootstrapper = mock(Bootstrapper.class);
-    certificateProviderRegistry = new CertificateProviderRegistry();
-    certificateProviderStore = new CertificateProviderStore(certificateProviderRegistry);
-    certProviderServerSslContextProviderFactory =
-        new CertProviderServerSslContextProvider.Factory(certificateProviderStore);
-    serverSslContextProviderFactory =
-        new ServerSslContextProviderFactory(
-            bootstrapper, certProviderServerSslContextProviderFactory);
-  }
-
-  @Test
-  public void createSslContextProvider_allFilenames() {
-    DownstreamTlsContext downstreamTlsContext =
-        CommonTlsContextTestsUtil.buildDownstreamTlsContextFromFilenames(
-            SERVER_1_KEY_FILE, SERVER_1_PEM_FILE, CA_PEM_FILE);
-
-    SslContextProvider sslContextProvider =
-        serverSslContextProviderFactory.create(downstreamTlsContext);
-    assertThat(sslContextProvider).isNotNull();
-  }
-
-  @Test
-  public void createSslContextProvider_sdsConfigForTlsCert_expectException() {
-    CommonTlsContext commonTlsContext =
-        CommonTlsContextTestsUtil.buildCommonTlsContextFromSdsConfigForTlsCertificate(
-            "name", "unix:/tmp/sds/path", CA_PEM_FILE);
-    DownstreamTlsContext downstreamTlsContext =
-        CommonTlsContextTestsUtil.buildInternalDownstreamTlsContext(
-            commonTlsContext, /* requireClientCert= */ false);
-
-    try {
-      SslContextProvider unused =
-          serverSslContextProviderFactory.create(downstreamTlsContext);
-      Assert.fail("no exception thrown");
-    } catch (IllegalArgumentException expected) {
-      assertThat(expected).hasMessageThat().isEqualTo("unexpected TlsCertificateSdsSecretConfigs");
-    }
-  }
-
-  @Test
-  public void createSslContextProvider_sdsConfigForCertValidationContext_expectException() {
-    CommonTlsContext commonTlsContext =
-        CommonTlsContextTestsUtil.buildCommonTlsContextFromSdsConfigForValidationContext(
-            "name", "unix:/tmp/sds/path", SERVER_1_KEY_FILE, SERVER_1_PEM_FILE);
-    DownstreamTlsContext downstreamTlsContext =
-        CommonTlsContextTestsUtil.buildInternalDownstreamTlsContext(
-            commonTlsContext, /* requireClientCert= */ false);
-
-    try {
-      SslContextProvider unused =
-          serverSslContextProviderFactory.create(downstreamTlsContext);
-      Assert.fail("no exception thrown");
-    } catch (IllegalStateException expected) {
-      assertThat(expected).hasMessageThat().isEqualTo("incorrect ValidationContextTypeCase");
-    }
-  }
-
-  @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();
-    when(bootstrapper.bootstrap()).thenReturn(bootstrapInfo);
-    SslContextProvider sslContextProvider =
-        serverSslContextProviderFactory.create(downstreamTlsContext);
-    assertThat(sslContextProvider).isInstanceOf(CertProviderServerSslContextProvider.class);
-    verifyWatcher(sslContextProvider, watcherCaptor[0]);
-  }
-
-  @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();
-    when(bootstrapper.bootstrap()).thenReturn(bootstrapInfo);
-    SslContextProvider sslContextProvider =
-        serverSslContextProviderFactory.create(downstreamTlsContext);
-    assertThat(sslContextProvider).isInstanceOf(CertProviderServerSslContextProvider.class);
-    verifyWatcher(sslContextProvider, watcherCaptor[0]);
-  }
-
-  @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();
-    when(bootstrapper.bootstrap()).thenReturn(bootstrapInfo);
-    SslContextProvider sslContextProvider =
-            serverSslContextProviderFactory.create(downstreamTlsContext);
-    assertThat(sslContextProvider).isInstanceOf(CertProviderServerSslContextProvider.class);
-    verifyWatcher(sslContextProvider, watcherCaptor[0]);
-  }
-
-  @Test
-  public void createCertProviderServerSslContextProvider_withStaticContext()
-      throws XdsInitializationException {
-    final CertificateProvider.DistributorWatcher[] watcherCaptor =
-            new CertificateProvider.DistributorWatcher[1];
-    createAndRegisterProviderProvider(certificateProviderRegistry, watcherCaptor, "testca", 0);
-    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();
-    when(bootstrapper.bootstrap()).thenReturn(bootstrapInfo);
-    SslContextProvider sslContextProvider =
-            serverSslContextProviderFactory.create(downstreamTlsContext);
-    assertThat(sslContextProvider).isInstanceOf(CertProviderServerSslContextProvider.class);
-    verifyWatcher(sslContextProvider, watcherCaptor[0]);
-  }
-
-  @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();
-    when(bootstrapper.bootstrap()).thenReturn(bootstrapInfo);
-    SslContextProvider sslContextProvider =
-        serverSslContextProviderFactory.create(downstreamTlsContext);
-    assertThat(sslContextProvider).isInstanceOf(CertProviderServerSslContextProvider.class);
-    verifyWatcher(sslContextProvider, watcherCaptor[0]);
-    verifyWatcher(sslContextProvider, watcherCaptor[1]);
-  }
-
-  @Test
-  public void createCertProviderServerSslContextProvider_exception()
-      throws XdsInitializationException {
-    DownstreamTlsContext downstreamTlsContext =
-        CommonTlsContextTestsUtil.buildDownstreamTlsContextForCertProviderInstance(
-            "gcp_id",
-            "cert-default",
-            "gcp_id",
-            "root-default",
-            /* alpnProtocols= */ null,
-            /* staticCertValidationContext= */ null,
-            /* requireClientCert= */ true);
-    when(bootstrapper.bootstrap())
-        .thenThrow(new XdsInitializationException("test exception"));
-    try {
-      serverSslContextProviderFactory.create(downstreamTlsContext);
-      Assert.fail("no exception thrown");
-    } catch (RuntimeException expected) {
-      assertThat(expected).hasMessageThat().contains("test exception");
-    }
-  }
-
-  @Test
-  public void createEmptyCommonTlsContext_exception() throws IOException {
-    DownstreamTlsContext downstreamTlsContext =
-        CommonTlsContextTestsUtil.buildDownstreamTlsContextFromFilenames(null, null, null);
-    try {
-      serverSslContextProviderFactory.create(downstreamTlsContext);
-      Assert.fail("no exception thrown");
-    } catch (UnsupportedOperationException expected) {
-      assertThat(expected)
-          .hasMessageThat()
-          .isEqualTo("Unsupported configurations in DownstreamTlsContext!");
-    }
-  }
-
-  @Test
-  public void createNullCommonTlsContext_exception() throws IOException {
-    DownstreamTlsContext downstreamTlsContext = new DownstreamTlsContext(null, true);
-    try {
-      serverSslContextProviderFactory.create(downstreamTlsContext);
-      Assert.fail("no exception thrown");
-    } catch (NullPointerException expected) {
-      assertThat(expected)
-              .hasMessageThat()
-              .isEqualTo("downstreamTlsContext should have CommonTlsContext");
-    }
-  }
-}
diff --git a/xds/src/test/java/io/grpc/xds/internal/sds/SslContextProviderSupplierTest.java b/xds/src/test/java/io/grpc/xds/internal/sds/SslContextProviderSupplierTest.java
deleted file mode 100644
index 881d2f1efd2..00000000000
--- a/xds/src/test/java/io/grpc/xds/internal/sds/SslContextProviderSupplierTest.java
+++ /dev/null
@@ -1,122 +0,0 @@
-/*
- * 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.sds;
-
-import static com.google.common.truth.Truth.assertThat;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.CA_PEM_FILE;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.CLIENT_KEY_FILE;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.CLIENT_PEM_FILE;
-import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.Mockito.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 io.grpc.xds.EnvoyServerProtoData;
-import io.netty.handler.ssl.SslContext;
-import java.util.concurrent.Executor;
-import org.junit.Assert;
-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.Mock;
-import org.mockito.MockitoAnnotations;
-
-/**
- * Unit tests for {@link SslContextProviderSupplier}.
- */
-@RunWith(JUnit4.class)
-public class SslContextProviderSupplierTest {
-
-  @Mock private TlsContextManager mockTlsContextManager;
-  private SslContextProviderSupplier supplier;
-  private SslContextProvider mockSslContextProvider;
-  private EnvoyServerProtoData.UpstreamTlsContext upstreamTlsContext;
-  private SslContextProvider.Callback mockCallback;
-
-  @Before
-  public void setUp() {
-    MockitoAnnotations.initMocks(this);
-  }
-
-  private void prepareSupplier() {
-    upstreamTlsContext =
-            CommonTlsContextTestsUtil.buildUpstreamTlsContextFromFilenames(
-                    CLIENT_KEY_FILE, CLIENT_PEM_FILE, CA_PEM_FILE);
-    mockSslContextProvider = mock(SslContextProvider.class);
-    doReturn(mockSslContextProvider)
-            .when(mockTlsContextManager)
-            .findOrCreateClientSslContextProvider(eq(upstreamTlsContext));
-    mockCallback = mock(SslContextProvider.Callback.class);
-    Executor mockExecutor = mock(Executor.class);
-    doReturn(mockExecutor).when(mockCallback).getExecutor();
-    supplier = new SslContextProviderSupplier(upstreamTlsContext, mockTlsContextManager);
-    supplier.updateSslContext(mockCallback);
-  }
-
-  @Test
-  public void get_updateSecret() {
-    prepareSupplier();
-    verify(mockTlsContextManager, times(2))
-        .findOrCreateClientSslContextProvider(eq(upstreamTlsContext));
-    verify(mockTlsContextManager, times(0))
-        .releaseClientSslContextProvider(any(SslContextProvider.class));
-    ArgumentCaptor<SslContextProvider.Callback> callbackCaptor = ArgumentCaptor.forClass(null);
-    verify(mockSslContextProvider, times(1)).addCallback(callbackCaptor.capture());
-    SslContextProvider.Callback capturedCallback = callbackCaptor.getValue();
-    assertThat(capturedCallback).isNotNull();
-    SslContext mockSslContext = mock(SslContext.class);
-    capturedCallback.updateSecret(mockSslContext);
-    verify(mockCallback, times(1)).updateSecret(eq(mockSslContext));
-    verify(mockTlsContextManager, times(1))
-            .releaseClientSslContextProvider(eq(mockSslContextProvider));
-    SslContextProvider.Callback mockCallback = mock(SslContextProvider.Callback.class);
-    supplier.updateSslContext(mockCallback);
-    verify(mockTlsContextManager, times(3))
-            .findOrCreateClientSslContextProvider(eq(upstreamTlsContext));
-  }
-
-  @Test
-  public void get_onException() {
-    prepareSupplier();
-    ArgumentCaptor<SslContextProvider.Callback> callbackCaptor = ArgumentCaptor.forClass(null);
-    verify(mockSslContextProvider, times(1)).addCallback(callbackCaptor.capture());
-    SslContextProvider.Callback capturedCallback = callbackCaptor.getValue();
-    assertThat(capturedCallback).isNotNull();
-    capturedCallback.onException(new Exception("test"));
-    verify(mockTlsContextManager, times(1))
-            .releaseClientSslContextProvider(eq(mockSslContextProvider));
-  }
-
-  @Test
-  public void testClose() {
-    prepareSupplier();
-    supplier.close();
-    verify(mockTlsContextManager, times(1))
-            .releaseClientSslContextProvider(eq(mockSslContextProvider));
-    SslContextProvider.Callback mockCallback = mock(SslContextProvider.Callback.class);
-    try {
-      supplier.updateSslContext(mockCallback);
-      Assert.fail("no exception thrown");
-    } catch (IllegalStateException expected) {
-      assertThat(expected).hasMessageThat().isEqualTo("Supplier is shutdown!");
-    }
-  }
-}
diff --git a/xds/src/test/java/io/grpc/xds/internal/sds/TestSdsServer.java b/xds/src/test/java/io/grpc/xds/internal/sds/TestSdsServer.java
deleted file mode 100644
index e0f47c87872..00000000000
--- a/xds/src/test/java/io/grpc/xds/internal/sds/TestSdsServer.java
+++ /dev/null
@@ -1,322 +0,0 @@
-/*
- * 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.sds;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Strings;
-import com.google.protobuf.Any;
-import com.google.protobuf.ByteString;
-import com.google.protobuf.ProtocolStringList;
-import io.envoyproxy.envoy.api.v2.DiscoveryRequest;
-import io.envoyproxy.envoy.api.v2.DiscoveryResponse;
-import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.Secret;
-import io.envoyproxy.envoy.service.discovery.v2.SecretDiscoveryServiceGrpc;
-import io.grpc.ForwardingServerCall.SimpleForwardingServerCall;
-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.ServerInterceptors;
-import io.grpc.ServerServiceDefinition;
-import io.grpc.inprocess.InProcessServerBuilder;
-import io.grpc.netty.NettyServerBuilder;
-import io.grpc.stub.StreamObserver;
-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 java.nio.charset.StandardCharsets;
-import java.util.Arrays;
-import java.util.List;
-import java.util.concurrent.ScheduledExecutorService;
-import java.util.concurrent.ScheduledFuture;
-import java.util.concurrent.Semaphore;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-import javax.annotation.Nullable;
-
-/** Server used only in testing {@link SdsClient} so does not contain actual server logic. */
-final class TestSdsServer {
-  private static final Logger logger = Logger.getLogger(TestSdsServer.class.getName());
-
-  // SecretTypeURL defines the type URL for Envoy secret proto.
-  private static final String SECRET_TYPE_URL = "type.googleapis.com/envoy.api.v2.auth.Secret";
-
-  private String currentVersion;
-  private String lastRespondedNonce;
-  private List<String> lastResourceNames;
-  @VisibleForTesting SecretDiscoveryServiceImpl discoveryService;
-
-  /** Used for signalling test clients that request received and processed. */
-  @VisibleForTesting final Semaphore requestsCounter = new Semaphore(0);
-
-  @VisibleForTesting String lastK8sJwtTokenValue;
-
-  private EventLoopGroup elg;
-  private EventLoopGroup boss;
-  private Server server;
-  private final ServerMock serverMock;
-
-  /** last "good" discovery request we processed and sent a response to. */
-  @VisibleForTesting DiscoveryRequest lastGoodRequest;
-
-  /** last discovery request that was only used as Ack since it contained no new resources. */
-  @VisibleForTesting DiscoveryRequest lastRequestOnlyForAck;
-
-  /** last Nack. */
-  @VisibleForTesting DiscoveryRequest lastNack;
-
-  /** last response we sent. */
-  @VisibleForTesting DiscoveryResponse lastResponse;
-
-  TestSdsServer(ServerMock serverMock) {
-    checkNotNull(serverMock, "serverMock");
-    this.serverMock = serverMock;
-  }
-
-  /**
-   * Starts the server with given transport params.
-   *
-   * @param name UDS pathname or server name for {@link InProcessServerBuilder}
-   * @param useUds creates a UDS based server if true.
-   * @param useInterceptor if true, uses {@link SdsServerInterceptor} to grab & save Jwt Token.
-   */
-  void startServer(String name, boolean useUds, boolean useInterceptor) throws IOException {
-    checkNotNull(name, "name");
-    discoveryService = new SecretDiscoveryServiceImpl();
-    ServerServiceDefinition serviceDefinition = discoveryService.bindService();
-
-    if (useInterceptor) {
-      serviceDefinition =
-          ServerInterceptors.intercept(serviceDefinition, new SdsServerInterceptor());
-    }
-    if (useUds) {
-      elg = new EpollEventLoopGroup();
-      boss = new EpollEventLoopGroup(1);
-      server =
-          NettyServerBuilder.forAddress(new DomainSocketAddress(name))
-              .bossEventLoopGroup(boss)
-              .workerEventLoopGroup(elg)
-              .channelType(EpollServerDomainSocketChannel.class)
-              .addService(serviceDefinition)
-              .directExecutor()
-              .build()
-              .start();
-    } else {
-      server =
-          InProcessServerBuilder.forName(name)
-              .addService(serviceDefinition)
-              .directExecutor()
-              .build()
-              .start();
-    }
-  }
-
-  @SuppressWarnings("FutureReturnValueIgnored")
-  void shutdown() throws InterruptedException {
-    server.shutdown();
-    if (boss != null) {
-      boss.shutdownGracefully().sync();
-    }
-    if (elg != null) {
-      elg.shutdownGracefully().sync();
-    }
-  }
-
-  /** Interface that allows mocking server behavior. */
-  interface ServerMock {
-    Secret getSecretFor(String name);
-
-    boolean onNext(DiscoveryRequest discoveryRequest);
-  }
-
-  /** Callers can call this to return an "async" response for given resource names. */
-  void generateAsyncResponse(String... names) {
-    discoveryService.inboundStreamObserver.generateAsyncResponse(Arrays.asList(names));
-  }
-
-  /** Main streaming service implementation. */
-  final class SecretDiscoveryServiceImpl
-      extends SecretDiscoveryServiceGrpc.SecretDiscoveryServiceImplBase {
-
-    // we use startTime for generating version string.
-    final long startTime = System.nanoTime();
-    SdsInboundStreamObserver inboundStreamObserver;
-
-    @Override
-    public StreamObserver<DiscoveryRequest> streamSecrets(
-        StreamObserver<DiscoveryResponse> responseObserver) {
-      checkNotNull(responseObserver, "responseObserver");
-      inboundStreamObserver = new SdsInboundStreamObserver(responseObserver);
-      return inboundStreamObserver;
-    }
-
-    @Override
-    public void fetchSecrets(
-        DiscoveryRequest discoveryRequest, StreamObserver<DiscoveryResponse> responseObserver) {
-      throw new UnsupportedOperationException("unary fetchSecrets not implemented!");
-    }
-
-    private DiscoveryResponse buildResponse(DiscoveryRequest discoveryRequest) {
-      checkNotNull(discoveryRequest, "discoveryRequest");
-      String requestVersion = discoveryRequest.getVersionInfo();
-      String requestNonce = discoveryRequest.getResponseNonce();
-      ProtocolStringList resourceNames = discoveryRequest.getResourceNamesList();
-      return buildResponse(requestVersion, requestNonce, resourceNames, false, discoveryRequest);
-    }
-
-    private DiscoveryResponse buildResponse(
-        String requestVersion,
-        String requestNonce,
-        List<String> resourceNames,
-        boolean forcedAsync,
-        DiscoveryRequest discoveryRequest) {
-      checkNotNull(resourceNames, "resourceNames");
-      if (discoveryRequest != null && discoveryRequest.hasErrorDetail()) {
-        lastNack = discoveryRequest;
-        return null;
-      }
-      // for stale version or nonce don't send a response
-      if (!Strings.isNullOrEmpty(requestVersion) && !requestVersion.equals(currentVersion)) {
-        return null;
-      }
-      if (!Strings.isNullOrEmpty(requestNonce) && !requestNonce.equals(lastRespondedNonce)) {
-        return null;
-      }
-      // check if any new resources are being requested...
-      if (!forcedAsync && isSubset(resourceNames, lastResourceNames)) {
-        if (discoveryRequest != null) {
-          lastRequestOnlyForAck = discoveryRequest;
-        }
-        return null;
-      }
-
-      final String version = generateVersionFromCurrentTime();
-      DiscoveryResponse.Builder responseBuilder =
-          DiscoveryResponse.newBuilder()
-              .setVersionInfo(version)
-              .setNonce(generateAndSaveNonce())
-              .setTypeUrl(SECRET_TYPE_URL);
-
-      for (String resourceName : resourceNames) {
-        buildAndAddResource(responseBuilder, resourceName);
-      }
-      DiscoveryResponse response = responseBuilder.build();
-      currentVersion = version;
-      lastResponse = response;
-      lastResourceNames = resourceNames;
-      return response;
-    }
-
-    private String generateVersionFromCurrentTime() {
-      return "" + ((System.nanoTime() - startTime) / 1000000L);
-    }
-
-    private void buildAndAddResource(
-        DiscoveryResponse.Builder responseBuilder, String resourceName) {
-      Secret secret = serverMock.getSecretFor(resourceName);
-      ByteString data = secret.toByteString();
-      Any anyValue = Any.newBuilder().setTypeUrl(SECRET_TYPE_URL).setValue(data).build();
-      responseBuilder.addResources(anyValue);
-    }
-
-    /** Inbound {@link StreamObserver} to process incoming requests. */
-    final class SdsInboundStreamObserver implements StreamObserver<DiscoveryRequest> {
-      final StreamObserver<DiscoveryResponse> responseObserver;
-      ScheduledExecutorService periodicScheduler;
-      ScheduledFuture<?> future;
-
-      SdsInboundStreamObserver(StreamObserver<DiscoveryResponse> responseObserver) {
-        this.responseObserver = responseObserver;
-      }
-
-      private void generateAsyncResponse(List<String> nameList) {
-        checkNotNull(nameList, "nameList");
-        if (!nameList.isEmpty()) {
-          responseObserver.onNext(
-              buildResponse(
-                  currentVersion,
-                  lastRespondedNonce,
-                  nameList,
-                  /* forcedAsync= */ true,
-                  /* discoveryRequest= */ null));
-        }
-      }
-
-      @Override
-      public void onNext(DiscoveryRequest discoveryRequest) {
-        if (!serverMock.onNext(discoveryRequest)) {
-          DiscoveryResponse discoveryResponse = buildResponse(discoveryRequest);
-          if (discoveryResponse != null) {
-            lastGoodRequest = discoveryRequest;
-            responseObserver.onNext(discoveryResponse);
-          }
-        }
-        requestsCounter.release();
-      }
-
-      @Override
-      public void onError(Throwable t) {
-        logger.log(Level.SEVERE, "onError", t);
-      }
-
-      @Override
-      public void onCompleted() {
-        responseObserver.onCompleted();
-      }
-    }
-  }
-
-  /** Checks if resourceNames is a "subset" of lastResourceNames. */
-  private static boolean isSubset(
-      @Nullable List<String> resourceNames, @Nullable List<String> lastResourceNames) {
-    if (lastResourceNames == null) {
-      return resourceNames == null || resourceNames.isEmpty();
-    }
-    if (resourceNames == null) {
-      return true; // since lastResourceNames is NOT null
-    }
-    return lastResourceNames.containsAll(resourceNames);
-  }
-
-  private String generateAndSaveNonce() {
-    lastRespondedNonce = Long.toHexString(System.currentTimeMillis());
-    return lastRespondedNonce;
-  }
-
-  private class SdsServerInterceptor implements ServerInterceptor {
-
-    @Override
-    public <ReqT, RespT> Listener<ReqT> interceptCall(
-        ServerCall<ReqT, RespT> call,
-        Metadata requestHeaders,
-        ServerCallHandler<ReqT, RespT> next) {
-      lastK8sJwtTokenValue = null;
-      byte[] value =
-          requestHeaders.get(SdsClientFileBasedMetadataTest.K8S_SA_JWT_TOKEN_HEADER_METADATA_KEY);
-      if (value != null) {
-        lastK8sJwtTokenValue = new String(value, StandardCharsets.UTF_8);
-      }
-      return next.startCall(new SimpleForwardingServerCall<ReqT, RespT>(call) {}, requestHeaders);
-    }
-  }
-}
diff --git a/xds/src/test/java/io/grpc/xds/internal/sds/TlsContextManagerTest.java b/xds/src/test/java/io/grpc/xds/internal/sds/TlsContextManagerTest.java
deleted file mode 100644
index 06b51a5553b..00000000000
--- a/xds/src/test/java/io/grpc/xds/internal/sds/TlsContextManagerTest.java
+++ /dev/null
@@ -1,243 +0,0 @@
-/*
- * 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.sds;
-
-import static com.google.common.truth.Truth.assertThat;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.CA_PEM_FILE;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.CLIENT_KEY_FILE;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.CLIENT_PEM_FILE;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.SERVER_0_KEY_FILE;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.SERVER_0_PEM_FILE;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.SERVER_1_KEY_FILE;
-import static io.grpc.xds.internal.sds.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.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.SdsSecretConfig;
-import io.grpc.xds.EnvoyServerProtoData.DownstreamTlsContext;
-import io.grpc.xds.EnvoyServerProtoData.UpstreamTlsContext;
-import io.grpc.xds.internal.sds.ReferenceCountingMap.ValueFactory;
-import java.lang.reflect.Field;
-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 TlsContextManagerImpl}. */
-@RunWith(JUnit4.class)
-public class TlsContextManagerTest {
-
-  @Rule public final MockitoRule mockitoRule = MockitoJUnit.rule();
-
-  @Mock ValueFactory<UpstreamTlsContext, SslContextProvider> mockClientFactory;
-
-  @Mock ValueFactory<DownstreamTlsContext, SslContextProvider> mockServerFactory;
-
-  @Before
-  public void clearInstance() throws NoSuchFieldException, IllegalAccessException {
-    Field field = TlsContextManagerImpl.class.getDeclaredField("instance");
-    field.setAccessible(true);
-    field.set(null, null);
-  }
-
-  @Test
-  public void createServerSslContextProvider() {
-    DownstreamTlsContext downstreamTlsContext =
-        CommonTlsContextTestsUtil.buildDownstreamTlsContextFromFilenames(
-            SERVER_1_KEY_FILE, SERVER_1_PEM_FILE, /* trustCa= */ null);
-
-    TlsContextManagerImpl tlsContextManagerImpl = TlsContextManagerImpl.getInstance();
-    SslContextProvider serverSecretProvider =
-        tlsContextManagerImpl.findOrCreateServerSslContextProvider(downstreamTlsContext);
-    assertThat(serverSecretProvider).isNotNull();
-
-    SslContextProvider serverSecretProvider1 =
-        tlsContextManagerImpl.findOrCreateServerSslContextProvider(downstreamTlsContext);
-    assertThat(serverSecretProvider1).isSameInstanceAs(serverSecretProvider);
-  }
-
-  @Test
-  public void createClientSslContextProvider() {
-    UpstreamTlsContext upstreamTlsContext =
-        CommonTlsContextTestsUtil.buildUpstreamTlsContextFromFilenames(
-            /* privateKey= */ null, /* certChain= */ null, CA_PEM_FILE);
-
-    TlsContextManagerImpl tlsContextManagerImpl = TlsContextManagerImpl.getInstance();
-    SslContextProvider clientSecretProvider =
-        tlsContextManagerImpl.findOrCreateClientSslContextProvider(upstreamTlsContext);
-    assertThat(clientSecretProvider).isNotNull();
-
-    SslContextProvider clientSecretProvider1 =
-        tlsContextManagerImpl.findOrCreateClientSslContextProvider(upstreamTlsContext);
-    assertThat(clientSecretProvider1).isSameInstanceAs(clientSecretProvider);
-  }
-
-  @Test
-  public void createServerSslContextProvider_differentInstance() {
-    DownstreamTlsContext downstreamTlsContext =
-        CommonTlsContextTestsUtil.buildDownstreamTlsContextFromFilenames(
-            SERVER_1_KEY_FILE, SERVER_1_PEM_FILE, /* trustCa= */ null);
-
-    TlsContextManagerImpl tlsContextManagerImpl = TlsContextManagerImpl.getInstance();
-    SslContextProvider serverSecretProvider =
-        tlsContextManagerImpl.findOrCreateServerSslContextProvider(downstreamTlsContext);
-    assertThat(serverSecretProvider).isNotNull();
-
-    DownstreamTlsContext downstreamTlsContext1 =
-        CommonTlsContextTestsUtil.buildDownstreamTlsContextFromFilenames(
-            SERVER_0_KEY_FILE, SERVER_0_PEM_FILE, CA_PEM_FILE);
-    SslContextProvider serverSecretProvider1 =
-        tlsContextManagerImpl.findOrCreateServerSslContextProvider(downstreamTlsContext1);
-    assertThat(serverSecretProvider1).isNotNull();
-    assertThat(serverSecretProvider1).isNotSameInstanceAs(serverSecretProvider);
-  }
-
-  @Test
-  public void createClientSslContextProvider_differentInstance() {
-    UpstreamTlsContext upstreamTlsContext =
-        CommonTlsContextTestsUtil.buildUpstreamTlsContextFromFilenames(
-            /* privateKey= */ null, /* certChain= */ null, CA_PEM_FILE);
-
-    TlsContextManagerImpl tlsContextManagerImpl = TlsContextManagerImpl.getInstance();
-    SslContextProvider clientSecretProvider =
-        tlsContextManagerImpl.findOrCreateClientSslContextProvider(upstreamTlsContext);
-    assertThat(clientSecretProvider).isNotNull();
-
-    UpstreamTlsContext upstreamTlsContext1 =
-        CommonTlsContextTestsUtil.buildUpstreamTlsContextFromFilenames(
-            CLIENT_KEY_FILE, CLIENT_PEM_FILE, CA_PEM_FILE);
-
-    SslContextProvider clientSecretProvider1 =
-        tlsContextManagerImpl.findOrCreateClientSslContextProvider(upstreamTlsContext1);
-    assertThat(clientSecretProvider1).isNotSameInstanceAs(clientSecretProvider);
-  }
-
-  @Test
-  public void createServerSslContextProvider_releaseInstance() {
-    DownstreamTlsContext downstreamTlsContext =
-        CommonTlsContextTestsUtil.buildDownstreamTlsContextFromFilenames(
-            SERVER_1_KEY_FILE, SERVER_1_PEM_FILE, /* trustCa= */ null);
-
-    TlsContextManagerImpl tlsContextManagerImpl =
-        new TlsContextManagerImpl(mockClientFactory, mockServerFactory, false);
-    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.buildUpstreamTlsContextFromFilenames(
-            CLIENT_KEY_FILE, CLIENT_PEM_FILE, CA_PEM_FILE);
-
-    TlsContextManagerImpl tlsContextManagerImpl =
-        new TlsContextManagerImpl(mockClientFactory, mockServerFactory, false);
-    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();
-  }
-
-  @Test
-  public void certInstanceOverrideForTlsCert() {
-    TlsContextManagerImpl tlsContextManagerImpl =
-        new TlsContextManagerImpl(mockClientFactory, mockServerFactory, true);
-    CommonTlsContext commonTlsContext =
-        CommonTlsContextTestsUtil.buildCommonTlsContextFromSdsConfigForTlsCertificate(
-            /* name= */ "name", /* targetUri= */ "unix:/tmp/sds/path", CA_PEM_FILE);
-    CommonTlsContext.Builder origBuilder = commonTlsContext.toBuilder();
-    CommonTlsContext.Builder modBuilder =
-        tlsContextManagerImpl.performCertInstanceOverride(origBuilder);
-    assertThat(modBuilder.hasValidationContextCertificateProviderInstance()).isFalse();
-    assertThat(modBuilder.hasCombinedValidationContext()).isFalse();
-    assertThat(modBuilder.hasTlsCertificateCertificateProviderInstance()).isTrue();
-    CommonTlsContext.CertificateProviderInstance instance =
-        modBuilder.getTlsCertificateCertificateProviderInstance();
-    assertThat(instance.getInstanceName()).isEqualTo("google_cloud_private_spiffe");
-  }
-
-  @Test
-  public void certInstanceOverrideForValidationContext() {
-    TlsContextManagerImpl tlsContextManagerImpl =
-        new TlsContextManagerImpl(mockClientFactory, mockServerFactory, true);
-    CommonTlsContext commonTlsContext =
-        CommonTlsContextTestsUtil.buildCommonTlsContextFromSdsConfigForValidationContext(
-            /* name= */ "name",
-            /* targetUri= */ "unix:/tmp/sds/path",
-            CLIENT_KEY_FILE,
-            CLIENT_PEM_FILE);
-    CommonTlsContext.Builder origBuilder = commonTlsContext.toBuilder();
-    CommonTlsContext.Builder modBuilder =
-        tlsContextManagerImpl.performCertInstanceOverride(origBuilder);
-    assertThat(modBuilder.hasTlsCertificateCertificateProviderInstance()).isFalse();
-    assertThat(modBuilder.hasCombinedValidationContext()).isFalse();
-    assertThat(modBuilder.hasValidationContextCertificateProviderInstance()).isTrue();
-    CommonTlsContext.CertificateProviderInstance instance =
-        modBuilder.getValidationContextCertificateProviderInstance();
-    assertThat(instance.getInstanceName()).isEqualTo("google_cloud_private_spiffe");
-  }
-
-  @Test
-  public void certInstanceOverrideForCombinedValidationContext() {
-    TlsContextManagerImpl tlsContextManagerImpl =
-        new TlsContextManagerImpl(mockClientFactory, mockServerFactory, true);
-
-    CertificateValidationContext staticCertContext =
-        CertificateValidationContext.newBuilder()
-            .setTrustedCa(DataSource.newBuilder().setFilename("/tmp/a.pem"))
-            .build();
-
-    CommonTlsContext.Builder builder = CommonTlsContext.newBuilder();
-    builder =
-        CommonTlsContextTestsUtil.addCertificateValidationContext(
-            builder, "name", /* targetUri= */ "unix:/tmp/sds/path", "uds", staticCertContext);
-    CommonTlsContext.Builder modBuilder =
-        tlsContextManagerImpl.performCertInstanceOverride(builder);
-    assertThat(modBuilder.hasTlsCertificateCertificateProviderInstance()).isFalse();
-    assertThat(modBuilder.hasCombinedValidationContext()).isTrue();
-    assertThat(modBuilder.hasValidationContextCertificateProviderInstance()).isFalse();
-    CommonTlsContext.CombinedCertificateValidationContext combined =
-        modBuilder.getCombinedValidationContext();
-    CommonTlsContext.CertificateProviderInstance instance =
-        combined.getValidationContextCertificateProviderInstance();
-    assertThat(instance.getInstanceName()).isEqualTo("google_cloud_private_spiffe");
-    SdsSecretConfig validationContextSdsConfig = combined.getValidationContextSdsSecretConfig();
-    assertThat(validationContextSdsConfig.getName()).isEqualTo("name");
-  }
-}
diff --git a/xds/src/test/java/io/grpc/xds/internal/sds/XdsChannelBuilderTest.java b/xds/src/test/java/io/grpc/xds/internal/sds/XdsChannelBuilderTest.java
deleted file mode 100644
index b09e42a1a79..00000000000
--- a/xds/src/test/java/io/grpc/xds/internal/sds/XdsChannelBuilderTest.java
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
- * 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.sds;
-
-import static com.google.common.truth.Truth.assertThat;
-
-import io.grpc.ManagedChannel;
-import io.grpc.netty.NettyChannelBuilder;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-
-/**
- * Unit tests for {@link XdsChannelBuilder}.
- */
-@RunWith(JUnit4.class)
-public class XdsChannelBuilderTest {
-
-  @Test
-  public void buildsXdsChannelBuilder() {
-    XdsChannelBuilder builder = XdsChannelBuilder.forTarget("localhost:8080");
-    assertThat(builder).isNotNull();
-    assertThat(builder.delegate()).isInstanceOf(NettyChannelBuilder.class);
-    ManagedChannel channel = builder.build();
-    assertThat(channel).isNotNull();
-  }
-}
diff --git a/xds/src/test/java/io/grpc/xds/internal/sds/trust/SdsTrustManagerFactoryTest.java b/xds/src/test/java/io/grpc/xds/internal/sds/trust/SdsTrustManagerFactoryTest.java
deleted file mode 100644
index 47ac9e6bb42..00000000000
--- a/xds/src/test/java/io/grpc/xds/internal/sds/trust/SdsTrustManagerFactoryTest.java
+++ /dev/null
@@ -1,263 +0,0 @@
-/*
- * 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.sds.trust;
-
-import static com.google.common.truth.Truth.assertThat;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.BAD_CLIENT_PEM_FILE;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.BAD_SERVER_PEM_FILE;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.CA_PEM_FILE;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.CLIENT_PEM_FILE;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.SERVER_1_PEM_FILE;
-
-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 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 SdsTrustManagerFactory}. */
-@RunWith(JUnit4.class)
-public class SdsTrustManagerFactoryTest {
-
-  @Test
-  public void constructor_fromFile() throws CertificateException, IOException, CertStoreException {
-    SdsTrustManagerFactory factory =
-        new SdsTrustManagerFactory(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(SdsX509TrustManager.class);
-    SdsX509TrustManager sdsX509TrustManager = (SdsX509TrustManager) myTm;
-    X509Certificate[] acceptedIssuers = sdsX509TrustManager.getAcceptedIssuers();
-    assertThat(acceptedIssuers).isNotNull();
-    assertThat(acceptedIssuers).hasLength(1);
-    X509Certificate caCert = acceptedIssuers[0];
-    assertThat(caCert)
-        .isEqualTo(CertificateUtils.toX509Certificates(TestUtils.loadCert(CA_PEM_FILE))[0]);
-  }
-
-  @Test
-  public void constructor_fromInlineBytes()
-      throws CertificateException, IOException, CertStoreException {
-    SdsTrustManagerFactory factory =
-        new SdsTrustManagerFactory(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(SdsX509TrustManager.class);
-    SdsX509TrustManager sdsX509TrustManager = (SdsX509TrustManager) myTm;
-    X509Certificate[] acceptedIssuers = sdsX509TrustManager.getAcceptedIssuers();
-    assertThat(acceptedIssuers).isNotNull();
-    assertThat(acceptedIssuers).hasLength(1);
-    X509Certificate caCert = acceptedIssuers[0];
-    assertThat(caCert)
-        .isEqualTo(CertificateUtils.toX509Certificates(TestUtils.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");
-    SdsTrustManagerFactory factory =
-        new SdsTrustManagerFactory(new X509Certificate[]{x509Cert}, staticValidationContext);
-    assertThat(factory).isNotNull();
-    TrustManager[] tms = factory.getTrustManagers();
-    assertThat(tms).isNotNull();
-    assertThat(tms).hasLength(1);
-    TrustManager myTm = tms[0];
-    assertThat(myTm).isInstanceOf(SdsX509TrustManager.class);
-    SdsX509TrustManager sdsX509TrustManager = (SdsX509TrustManager) myTm;
-    X509Certificate[] acceptedIssuers = sdsX509TrustManager.getAcceptedIssuers();
-    assertThat(acceptedIssuers).isNotNull();
-    assertThat(acceptedIssuers).hasLength(1);
-    X509Certificate caCert = acceptedIssuers[0];
-    assertThat(caCert)
-        .isEqualTo(CertificateUtils.toX509Certificates(TestUtils.loadCert(CA_PEM_FILE))[0]);
-  }
-
-  @Test
-  public void constructorRootCert_checkServerTrusted()
-      throws CertificateException, IOException, CertStoreException {
-    X509Certificate x509Cert = TestUtils.loadX509Cert(CA_PEM_FILE);
-    CertificateValidationContext staticValidationContext = buildStaticValidationContext("san1",
-        "waterzooi.test.google.be");
-    SdsTrustManagerFactory factory =
-        new SdsTrustManagerFactory(new X509Certificate[]{x509Cert}, staticValidationContext);
-    SdsX509TrustManager sdsX509TrustManager = (SdsX509TrustManager) factory.getTrustManagers()[0];
-    X509Certificate[] serverChain =
-        CertificateUtils.toX509Certificates(TestUtils.loadCert(SERVER_1_PEM_FILE));
-    sdsX509TrustManager.checkServerTrusted(serverChain, "RSA");
-  }
-
-  @Test
-  public void constructorRootCert_nonStaticContext_throwsException()
-          throws CertificateException, IOException, CertStoreException {
-    X509Certificate x509Cert = TestUtils.loadX509Cert(CA_PEM_FILE);
-    try {
-      new SdsTrustManagerFactory(
-              new X509Certificate[] {x509Cert}, getCertContextFromPath(CA_PEM_FILE));
-      Assert.fail("no exception thrown");
-    } catch (IllegalArgumentException expected) {
-      assertThat(expected)
-              .hasMessageThat()
-              .contains("only static certificateValidationContext expected");
-    }
-  }
-
-  @Test
-  public void constructorRootCert_checkServerTrusted_throwsException()
-      throws CertificateException, IOException, CertStoreException {
-    X509Certificate x509Cert = TestUtils.loadX509Cert(CA_PEM_FILE);
-    CertificateValidationContext staticValidationContext = buildStaticValidationContext("san1",
-        "san2");
-    SdsTrustManagerFactory factory =
-        new SdsTrustManagerFactory(new X509Certificate[]{x509Cert}, staticValidationContext);
-    SdsX509TrustManager sdsX509TrustManager = (SdsX509TrustManager) factory.getTrustManagers()[0];
-    X509Certificate[] serverChain =
-        CertificateUtils.toX509Certificates(TestUtils.loadCert(SERVER_1_PEM_FILE));
-    try {
-      sdsX509TrustManager.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");
-    SdsTrustManagerFactory factory =
-        new SdsTrustManagerFactory(new X509Certificate[]{x509Cert}, staticValidationContext);
-    SdsX509TrustManager sdsX509TrustManager = (SdsX509TrustManager) factory.getTrustManagers()[0];
-    X509Certificate[] clientChain =
-        CertificateUtils.toX509Certificates(TestUtils.loadCert(SERVER_1_PEM_FILE));
-    try {
-      sdsX509TrustManager.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 {
-    SdsTrustManagerFactory factory =
-        new SdsTrustManagerFactory(getCertContextFromPath(CA_PEM_FILE));
-    SdsX509TrustManager sdsX509TrustManager = (SdsX509TrustManager) factory.getTrustManagers()[0];
-    X509Certificate[] serverChain =
-        CertificateUtils.toX509Certificates(TestUtils.loadCert(SERVER_1_PEM_FILE));
-    sdsX509TrustManager.checkServerTrusted(serverChain, "RSA");
-  }
-
-  @Test
-  public void checkClientTrusted_goodCert()
-      throws CertificateException, IOException, CertStoreException {
-    SdsTrustManagerFactory factory =
-        new SdsTrustManagerFactory(getCertContextFromPath(CA_PEM_FILE));
-    SdsX509TrustManager sdsX509TrustManager = (SdsX509TrustManager) factory.getTrustManagers()[0];
-    X509Certificate[] clientChain =
-        CertificateUtils.toX509Certificates(TestUtils.loadCert(CLIENT_PEM_FILE));
-    sdsX509TrustManager.checkClientTrusted(clientChain, "RSA");
-  }
-
-  @Test
-  public void checkServerTrusted_badCert_throwsException()
-      throws CertificateException, IOException, CertStoreException {
-    SdsTrustManagerFactory factory =
-        new SdsTrustManagerFactory(getCertContextFromPath(CA_PEM_FILE));
-    SdsX509TrustManager sdsX509TrustManager = (SdsX509TrustManager) factory.getTrustManagers()[0];
-    X509Certificate[] serverChain =
-        CertificateUtils.toX509Certificates(TestUtils.loadCert(BAD_SERVER_PEM_FILE));
-    try {
-      sdsX509TrustManager.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 {
-    SdsTrustManagerFactory factory =
-        new SdsTrustManagerFactory(getCertContextFromPath(CA_PEM_FILE));
-    SdsX509TrustManager sdsX509TrustManager = (SdsX509TrustManager) factory.getTrustManagers()[0];
-    X509Certificate[] clientChain =
-        CertificateUtils.toX509Certificates(TestUtils.loadCert(BAD_CLIENT_PEM_FILE));
-    try {
-      sdsX509TrustManager.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) {
-      builder.addMatchSubjectAltNames(StringMatcher.newBuilder().setExact(san));
-    }
-    return builder.build();
-  }
-}
diff --git a/xds/src/test/java/io/grpc/xds/internal/sds/trust/SdsX509TrustManagerTest.java b/xds/src/test/java/io/grpc/xds/internal/sds/trust/SdsX509TrustManagerTest.java
deleted file mode 100644
index 35218929651..00000000000
--- a/xds/src/test/java/io/grpc/xds/internal/sds/trust/SdsX509TrustManagerTest.java
+++ /dev/null
@@ -1,617 +0,0 @@
-/*
- * 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.sds.trust;
-
-import static com.google.common.truth.Truth.assertThat;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.BAD_SERVER_PEM_FILE;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.CA_PEM_FILE;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.CLIENT_PEM_FILE;
-import static io.grpc.xds.internal.sds.CommonTlsContextTestsUtil.SERVER_1_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 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.testing.TestUtils;
-import java.io.IOException;
-import java.security.cert.CertStoreException;
-import java.security.cert.CertificateException;
-import java.security.cert.X509Certificate;
-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.JUnit4;
-import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnit;
-import org.mockito.junit.MockitoRule;
-
-/**
- * Unit tests for {@link SdsX509TrustManager}.
- */
-@RunWith(JUnit4.class)
-public class SdsX509TrustManagerTest {
-
-  @Rule
-  public final MockitoRule mockitoRule = MockitoJUnit.rule();
-
-  @Mock
-  private X509ExtendedTrustManager mockDelegate;
-
-  @Mock
-  private SSLSession mockSession;
-
-  private SdsX509TrustManager trustManager;
-
-  @Test
-  public void nullCertContextTest() throws CertificateException, IOException {
-    trustManager = new SdsX509TrustManager(null, mockDelegate);
-    X509Certificate[] certs =
-        CertificateUtils.toX509Certificates(TestUtils.loadCert(SERVER_1_PEM_FILE));
-    trustManager.verifySubjectAltNameInChain(certs);
-  }
-
-  @Test
-  public void emptySanListContextTest() throws CertificateException, IOException {
-    CertificateValidationContext certContext = CertificateValidationContext.getDefaultInstance();
-    trustManager = new SdsX509TrustManager(certContext, mockDelegate);
-    X509Certificate[] certs =
-        CertificateUtils.toX509Certificates(TestUtils.loadCert(SERVER_1_PEM_FILE));
-    trustManager.verifySubjectAltNameInChain(certs);
-  }
-
-  @Test
-  public void missingPeerCerts() {
-    StringMatcher stringMatcher = StringMatcher.newBuilder().setExact("foo.com").build();
-    CertificateValidationContext certContext =
-        CertificateValidationContext.newBuilder().addMatchSubjectAltNames(stringMatcher).build();
-    trustManager = new SdsX509TrustManager(certContext, mockDelegate);
-    try {
-      trustManager.verifySubjectAltNameInChain(null);
-      fail("no exception thrown");
-    } catch (CertificateException expected) {
-      assertThat(expected).hasMessageThat().isEqualTo("Peer certificate(s) missing");
-    }
-  }
-
-  @Test
-  public void emptyArrayPeerCerts() {
-    StringMatcher stringMatcher = StringMatcher.newBuilder().setExact("foo.com").build();
-    CertificateValidationContext certContext =
-        CertificateValidationContext.newBuilder().addMatchSubjectAltNames(stringMatcher).build();
-    trustManager = new SdsX509TrustManager(certContext, mockDelegate);
-    try {
-      trustManager.verifySubjectAltNameInChain(new X509Certificate[0]);
-      fail("no exception thrown");
-    } catch (CertificateException expected) {
-      assertThat(expected).hasMessageThat().isEqualTo("Peer certificate(s) missing");
-    }
-  }
-
-  @Test
-  public void noSansInPeerCerts() throws CertificateException, IOException {
-    StringMatcher stringMatcher = StringMatcher.newBuilder().setExact("foo.com").build();
-    CertificateValidationContext certContext =
-        CertificateValidationContext.newBuilder().addMatchSubjectAltNames(stringMatcher).build();
-    trustManager = new SdsX509TrustManager(certContext, mockDelegate);
-    X509Certificate[] certs =
-        CertificateUtils.toX509Certificates(TestUtils.loadCert(CLIENT_PEM_FILE));
-    try {
-      trustManager.verifySubjectAltNameInChain(certs);
-      fail("no exception thrown");
-    } catch (CertificateException expected) {
-      assertThat(expected).hasMessageThat().isEqualTo("Peer certificate SAN check failed");
-    }
-  }
-
-  @Test
-  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 SdsX509TrustManager(certContext, mockDelegate);
-    X509Certificate[] certs =
-        CertificateUtils.toX509Certificates(TestUtils.loadCert(SERVER_1_PEM_FILE));
-    trustManager.verifySubjectAltNameInChain(certs);
-  }
-
-  @Test
-  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 SdsX509TrustManager(certContext, mockDelegate);
-    X509Certificate[] certs =
-        CertificateUtils.toX509Certificates(TestUtils.loadCert(SERVER_1_PEM_FILE));
-    try {
-      trustManager.verifySubjectAltNameInChain(certs);
-      fail("no exception thrown");
-    } catch (CertificateException expected) {
-      assertThat(expected).hasMessageThat().isEqualTo("Peer certificate SAN check failed");
-    }
-  }
-
-  @Test
-  public void oneSanInPeerCertsVerifies_ignoreCase() throws CertificateException, IOException {
-    StringMatcher stringMatcher =
-        StringMatcher.newBuilder().setExact("Waterzooi.Test.google.be").setIgnoreCase(true).build();
-    CertificateValidationContext certContext =
-        CertificateValidationContext.newBuilder().addMatchSubjectAltNames(stringMatcher).build();
-    trustManager = new SdsX509TrustManager(certContext, mockDelegate);
-    X509Certificate[] certs =
-        CertificateUtils.toX509Certificates(TestUtils.loadCert(SERVER_1_PEM_FILE));
-    trustManager.verifySubjectAltNameInChain(certs);
-  }
-
-  @Test
-  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 SdsX509TrustManager(certContext, mockDelegate);
-    X509Certificate[] certs =
-        CertificateUtils.toX509Certificates(TestUtils.loadCert(SERVER_1_PEM_FILE));
-    trustManager.verifySubjectAltNameInChain(certs);
-  }
-
-  @Test
-  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 SdsX509TrustManager(certContext, mockDelegate);
-    X509Certificate[] certs =
-        CertificateUtils.toX509Certificates(TestUtils.loadCert(SERVER_1_PEM_FILE));
-    try {
-      trustManager.verifySubjectAltNameInChain(certs);
-      fail("no exception thrown");
-    } catch (CertificateException expected) {
-      assertThat(expected).hasMessageThat().isEqualTo("Peer certificate SAN check failed");
-    }
-  }
-
-  @Test
-  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 SdsX509TrustManager(certContext, mockDelegate);
-    X509Certificate[] certs =
-        CertificateUtils.toX509Certificates(TestUtils.loadCert(SERVER_1_PEM_FILE));
-    trustManager.verifySubjectAltNameInChain(certs);
-  }
-
-  @Test
-  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 SdsX509TrustManager(certContext, mockDelegate);
-    X509Certificate[] certs =
-        CertificateUtils.toX509Certificates(TestUtils.loadCert(SERVER_1_PEM_FILE));
-    trustManager.verifySubjectAltNameInChain(certs);
-  }
-
-  @Test
-  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 SdsX509TrustManager(certContext, mockDelegate);
-    X509Certificate[] certs =
-        CertificateUtils.toX509Certificates(TestUtils.loadCert(SERVER_1_PEM_FILE));
-    try {
-      trustManager.verifySubjectAltNameInChain(certs);
-      fail("no exception thrown");
-    } catch (CertificateException expected) {
-      assertThat(expected).hasMessageThat().isEqualTo("Peer certificate SAN check failed");
-    }
-  }
-
-  @Test
-  public void oneSanInPeerCerts_suffixIgnoreCase() throws CertificateException, IOException {
-    StringMatcher stringMatcher =
-        StringMatcher.newBuilder().setSuffix(".GooGle.BE").setIgnoreCase(true).build();
-    CertificateValidationContext certContext =
-        CertificateValidationContext.newBuilder().addMatchSubjectAltNames(stringMatcher).build();
-    trustManager = new SdsX509TrustManager(certContext, mockDelegate);
-    X509Certificate[] certs =
-        CertificateUtils.toX509Certificates(TestUtils.loadCert(SERVER_1_PEM_FILE));
-    trustManager.verifySubjectAltNameInChain(certs);
-  }
-
-  @Test
-  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 SdsX509TrustManager(certContext, mockDelegate);
-    X509Certificate[] certs =
-        CertificateUtils.toX509Certificates(TestUtils.loadCert(SERVER_1_PEM_FILE));
-    trustManager.verifySubjectAltNameInChain(certs);
-  }
-
-  @Test
-  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 SdsX509TrustManager(certContext, mockDelegate);
-    X509Certificate[] certs =
-        CertificateUtils.toX509Certificates(TestUtils.loadCert(SERVER_1_PEM_FILE));
-    try {
-      trustManager.verifySubjectAltNameInChain(certs);
-      fail("no exception thrown");
-    } catch (CertificateException expected) {
-      assertThat(expected).hasMessageThat().isEqualTo("Peer certificate SAN check failed");
-    }
-  }
-
-  @Test
-  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 SdsX509TrustManager(certContext, mockDelegate);
-    X509Certificate[] certs =
-        CertificateUtils.toX509Certificates(TestUtils.loadCert(SERVER_1_PEM_FILE));
-    trustManager.verifySubjectAltNameInChain(certs);
-  }
-
-  @Test
-  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 SdsX509TrustManager(certContext, mockDelegate);
-    X509Certificate[] certs =
-        CertificateUtils.toX509Certificates(TestUtils.loadCert(SERVER_1_PEM_FILE));
-    trustManager.verifySubjectAltNameInChain(certs);
-  }
-
-  @Test
-  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 SdsX509TrustManager(certContext, mockDelegate);
-    X509Certificate[] certs =
-        CertificateUtils.toX509Certificates(TestUtils.loadCert(SERVER_1_PEM_FILE));
-    trustManager.verifySubjectAltNameInChain(certs);
-  }
-
-  @Test
-  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 SdsX509TrustManager(certContext, mockDelegate);
-    X509Certificate[] certs =
-        CertificateUtils.toX509Certificates(TestUtils.loadCert(SERVER_1_PEM_FILE));
-    trustManager.verifySubjectAltNameInChain(certs);
-  }
-
-  @Test
-  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 SdsX509TrustManager(certContext, mockDelegate);
-    X509Certificate[] certs =
-        CertificateUtils.toX509Certificates(TestUtils.loadCert(SERVER_1_PEM_FILE));
-    try {
-      trustManager.verifySubjectAltNameInChain(certs);
-      fail("no exception thrown");
-    } catch (CertificateException expected) {
-      assertThat(expected).hasMessageThat().isEqualTo("Peer certificate SAN check failed");
-    }
-  }
-
-  @Test
-  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 SdsX509TrustManager(certContext, mockDelegate);
-    X509Certificate[] certs =
-        CertificateUtils.toX509Certificates(TestUtils.loadCert(SERVER_1_PEM_FILE));
-    trustManager.verifySubjectAltNameInChain(certs);
-  }
-
-  @Test
-  public void oneSanInPeerCertsNotFoundException()
-          throws CertificateException, IOException {
-    StringMatcher stringMatcher = StringMatcher.newBuilder().setExact("x.foo.com").build();
-    CertificateValidationContext certContext =
-        CertificateValidationContext.newBuilder().addMatchSubjectAltNames(stringMatcher).build();
-    trustManager = new SdsX509TrustManager(certContext, mockDelegate);
-    X509Certificate[] certs =
-        CertificateUtils.toX509Certificates(TestUtils.loadCert(SERVER_1_PEM_FILE));
-    try {
-      trustManager.verifySubjectAltNameInChain(certs);
-      fail("no exception thrown");
-    } catch (CertificateException expected) {
-      assertThat(expected).hasMessageThat().isEqualTo("Peer certificate SAN check failed");
-    }
-  }
-
-  @Test
-  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 SdsX509TrustManager(certContext, mockDelegate);
-    X509Certificate[] certs =
-        CertificateUtils.toX509Certificates(TestUtils.loadCert(SERVER_1_PEM_FILE));
-    trustManager.verifySubjectAltNameInChain(certs);
-  }
-
-  @Test
-  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 SdsX509TrustManager(certContext, mockDelegate);
-    X509Certificate[] certs =
-        CertificateUtils.toX509Certificates(TestUtils.loadCert(SERVER_1_PEM_FILE));
-    trustManager.verifySubjectAltNameInChain(certs);
-  }
-
-  @Test
-  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 SdsX509TrustManager(certContext, mockDelegate);
-    X509Certificate[] certs =
-        CertificateUtils.toX509Certificates(TestUtils.loadCert(SERVER_1_PEM_FILE));
-    try {
-      trustManager.verifySubjectAltNameInChain(certs);
-      fail("no exception thrown");
-    } catch (CertificateException expected) {
-      assertThat(expected).hasMessageThat().isEqualTo("Peer certificate SAN check failed");
-    }
-  }
-
-  @Test
-  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 SdsX509TrustManager(certContext, mockDelegate);
-    X509Certificate[] certs =
-        CertificateUtils.toX509Certificates(TestUtils.loadCert(SERVER_1_PEM_FILE));
-    trustManager.verifySubjectAltNameInChain(certs);
-  }
-
-  @Test
-  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 SdsX509TrustManager(certContext, mockDelegate);
-    X509Certificate[] certs =
-        CertificateUtils.toX509Certificates(TestUtils.loadCert(SERVER_1_PEM_FILE));
-    try {
-      trustManager.verifySubjectAltNameInChain(certs);
-      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(TestUtils.loadCert(SERVER_1_PEM_FILE));
-    trustManager.checkServerTrusted(serverCerts, "ECDHE_ECDSA", sslEngine);
-    verify(sslEngine, times(1)).getHandshakeSession();
-  }
-
-  @Test
-  public void checkServerTrustedSslEngine_untrustedServer_expectException()
-      throws CertificateException, IOException, CertStoreException {
-    TestSslEngine sslEngine = buildTrustManagerAndGetSslEngine();
-    X509Certificate[] badServerCert =
-        CertificateUtils.toX509Certificates(TestUtils.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(TestUtils.loadCert(SERVER_1_PEM_FILE));
-    trustManager.checkServerTrusted(serverCerts, "ECDHE_ECDSA", sslSocket);
-    verify(sslSocket, times(1)).isConnected();
-    verify(sslSocket, times(1)).getHandshakeSession();
-  }
-
-  @Test
-  public void checkServerTrustedSslSocket_untrustedServer_expectException()
-      throws CertificateException, IOException, CertStoreException {
-    TestSslSocket sslSocket = buildTrustManagerAndGetSslSocket();
-    X509Certificate[] badServerCert =
-        CertificateUtils.toX509Certificates(TestUtils.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();
-  }
-
-  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(TestUtils.loadCert(CA_PEM_FILE));
-    trustManager = SdsTrustManagerFactory.createSdsX509TrustManager(caCerts,
-        null);
-    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;
-  }
-}
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/sds/ReferenceCountingMapTest.java b/xds/src/test/java/io/grpc/xds/internal/security/ReferenceCountingMapTest.java
similarity index 97%
rename from xds/src/test/java/io/grpc/xds/internal/sds/ReferenceCountingMapTest.java
rename to xds/src/test/java/io/grpc/xds/internal/security/ReferenceCountingMapTest.java
index b94aefd2151..d54a61b5510 100644
--- a/xds/src/test/java/io/grpc/xds/internal/sds/ReferenceCountingMapTest.java
+++ b/xds/src/test/java/io/grpc/xds/internal/security/ReferenceCountingMapTest.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.grpc.xds.internal.sds;
+package io.grpc.xds.internal.security;
 
 import static com.google.common.truth.Truth.assertThat;
 import static org.junit.Assert.fail;
@@ -24,7 +24,7 @@
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
-import io.grpc.xds.internal.sds.ReferenceCountingMap.ValueFactory;
+import io.grpc.xds.internal.security.ReferenceCountingMap.ValueFactory;
 import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
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..125b7e65aa6
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/internal/security/SecurityProtocolNegotiatorsTest.java
@@ -0,0 +1,568 @@
+/*
+ * 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.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() {
+    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);
+  }
+
+  @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);
+          }
+        }, true);
+    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() {
+    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);
+  }
+
+  @Test
+  public void sniInClientSecurityHandler_autoHostSni_endpointHostnameIsEmpty_usesSniFromUtc() {
+    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);
+  }
+
+  @Test
+  public void sniInClientSecurityHandler_autoHostSni_endpointHostnameIsNull_usesSniFromUtc() {
+    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);
+  }
+
+  @Test
+  public void sniInClientSecurityHandler_autoHostSniIsFalse_usesSniFromUpstreamTlsContext() {
+    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);
+  }
+
+  @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);
+          }
+        }, true);
+    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 {
+    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);
+          }
+        }, true);
+    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();
+  }
+
+  @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/certprovider/CertificateProviderStoreTest.java b/xds/src/test/java/io/grpc/xds/internal/security/certprovider/CertificateProviderStoreTest.java
similarity index 96%
rename from xds/src/test/java/io/grpc/xds/internal/certprovider/CertificateProviderStoreTest.java
rename to xds/src/test/java/io/grpc/xds/internal/security/certprovider/CertificateProviderStoreTest.java
index 53144c2d48e..c0bc095eab6 100644
--- a/xds/src/test/java/io/grpc/xds/internal/certprovider/CertificateProviderStoreTest.java
+++ b/xds/src/test/java/io/grpc/xds/internal/security/certprovider/CertificateProviderStoreTest.java
@@ -14,13 +14,12 @@
  * limitations under the License.
  */
 
-package io.grpc.xds.internal.certprovider;
+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.anyListOf;
 import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.never;
@@ -38,6 +37,7 @@
 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;
 
@@ -123,7 +123,6 @@ public void notifyCertUpdatesNotSupported_expectExceptionOnSecondCall() {
   }
 
   @Test
-  @SuppressWarnings("deprecation")
   public void onePluginSameConfig_sameInstance() {
     registerPlugin("plugin1");
     CertificateProvider.Watcher mockWatcher1 = mock(CertificateProvider.Watcher.class);
@@ -158,7 +157,7 @@ public void onePluginSameConfig_sameInstance() {
     assertThat(distWatcher.downstreamWatchers).hasSize(1);
     testCertificateProvider.getWatcher().updateCertificate(testKey, testList);
     verify(mockWatcher1, never())
-        .updateCertificate(any(PrivateKey.class), anyListOf(X509Certificate.class));
+        .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));
@@ -167,7 +166,6 @@ public void onePluginSameConfig_sameInstance() {
   }
 
   @Test
-  @SuppressWarnings("deprecation")
   public void onePluginSameConfig_secondWatcherAfterFirstNotify() {
     registerPlugin("plugin1");
     CertificateProvider.Watcher mockWatcher1 = mock(CertificateProvider.Watcher.class);
@@ -199,8 +197,8 @@ public void onePluginSameConfig_secondWatcherAfterFirstNotify() {
     verify(mockWatcher2, never()).onError(eq(Status.CANCELLED));
     // and none to first one
     verify(mockWatcher1, never())
-            .updateCertificate(any(PrivateKey.class), anyListOf(X509Certificate.class));
-    verify(mockWatcher1, never()).updateTrustedRoots(anyListOf(X509Certificate.class));
+            .updateCertificate(any(PrivateKey.class), ArgumentMatchers.<X509Certificate>anyList());
+    verify(mockWatcher1, never()).updateTrustedRoots(ArgumentMatchers.<X509Certificate>anyList());
     verify(mockWatcher1, never()).onError(any(Status.class));
   }
 
@@ -275,7 +273,6 @@ public void twoPlugins_differentInstance() {
         mockWatcher1, handle1, certProviderProvider1, mockWatcher2, handle2, certProviderProvider2);
   }
 
-  @SuppressWarnings("deprecation")
   private static void checkDifferentInstances(
       CertificateProvider.Watcher mockWatcher1,
       CertificateProviderStore.Handle handle1,
@@ -302,7 +299,7 @@ private static void checkDifferentInstances(
     testCertificateProvider1.getWatcher().updateCertificate(testKey1, testList1);
     verify(mockWatcher1, times(1)).updateCertificate(eq(testKey1), eq(testList1));
     verify(mockWatcher2, never())
-        .updateCertificate(any(PrivateKey.class), anyListOf(X509Certificate.class));
+        .updateCertificate(any(PrivateKey.class), ArgumentMatchers.<X509Certificate>anyList());
     reset(mockWatcher1);
 
     PrivateKey testKey2 = mock(PrivateKey.class);
@@ -311,7 +308,7 @@ private static void checkDifferentInstances(
     testCertificateProvider2.getWatcher().updateCertificate(testKey2, testList2);
     verify(mockWatcher2, times(1)).updateCertificate(eq(testKey2), eq(testList2));
     verify(mockWatcher1, never())
-        .updateCertificate(any(PrivateKey.class), anyListOf(X509Certificate.class));
+        .updateCertificate(any(PrivateKey.class), ArgumentMatchers.<X509Certificate>anyList());
     assertThat(testCertificateProvider1.startCalled).isEqualTo(1);
     assertThat(testCertificateProvider2.startCalled).isEqualTo(1);
     handle2.close();
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..f6fdc51dece
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/internal/security/certprovider/FileWatcherCertificateProviderTest.java
@@ -0,0 +1,601 @@
+/*
+ * 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 certFileUpdateOnly()
+      throws IOException, CertificateException, InterruptedException {
+    TestScheduledFuture<?> scheduledFuture =
+        new TestScheduledFuture<>();
+    doReturn(scheduledFuture)
+        .when(timeService)
+        .schedule(any(Runnable.class), any(Long.TYPE), eq(TimeUnit.SECONDS));
+    // Ideally we'd use a matching cert/key pair here, but we don't actually have any ready-made.
+    // The test doesn't notice they don't match though.
+    populateTarget(
+        CLIENT_PEM_FILE, SERVER_0_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);
+    // It's normal to get a newer cert while continuing to use the same private key
+    populateTarget(SERVER_0_PEM_FILE, null, null, null, false, false, false, false);
+    provider.checkAndReloadCertificates();
+    verifyWatcherUpdates(SERVER_0_PEM_FILE, null, null);
+    verifyTimeServiceAndScheduledFuture();
+  }
+
+  @Test
+  public void keyFileUpdateOnly()
+      throws IOException, CertificateException, InterruptedException {
+    TestScheduledFuture<?> scheduledFuture =
+        new TestScheduledFuture<>();
+    doReturn(scheduledFuture)
+        .when(timeService)
+        .schedule(any(Runnable.class), any(Long.TYPE), eq(TimeUnit.SECONDS));
+    // Assume the key/cert is not updated atomically and we see a tear between them. Or maybe this
+    // was just a bug.
+    populateTarget(
+        SERVER_0_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);
+    // Even though it is strange the key updated without a cert update, we do still want to use the
+    // new files, as this recovers from the earlier tear.
+    populateTarget(null, 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/certprovider/TestCertificateProvider.java b/xds/src/test/java/io/grpc/xds/internal/security/certprovider/TestCertificateProvider.java
similarity index 98%
rename from xds/src/test/java/io/grpc/xds/internal/certprovider/TestCertificateProvider.java
rename to xds/src/test/java/io/grpc/xds/internal/security/certprovider/TestCertificateProvider.java
index 9253d071fba..aba7a910813 100644
--- a/xds/src/test/java/io/grpc/xds/internal/certprovider/TestCertificateProvider.java
+++ b/xds/src/test/java/io/grpc/xds/internal/security/certprovider/TestCertificateProvider.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.grpc.xds.internal.certprovider;
+package io.grpc.xds.internal.security.certprovider;
 
 public class TestCertificateProvider extends CertificateProvider {
   Object config;
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/internal/sts/StsCredentialsTest.java b/xds/src/test/java/io/grpc/xds/internal/sts/StsCredentialsTest.java
deleted file mode 100644
index d6adedeca57..00000000000
--- a/xds/src/test/java/io/grpc/xds/internal/sts/StsCredentialsTest.java
+++ /dev/null
@@ -1,214 +0,0 @@
-/*
- * 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.sts;
-
-import static com.google.common.truth.Truth.assertThat;
-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.api.client.http.HttpStatusCodes;
-import com.google.api.client.http.json.JsonHttpContent;
-import com.google.api.client.testing.http.MockHttpTransport;
-import com.google.api.client.testing.http.MockLowLevelHttpRequest;
-import com.google.api.client.testing.http.MockLowLevelHttpResponse;
-import com.google.auth.http.HttpTransportFactory;
-import com.google.auth.oauth2.AccessToken;
-import com.google.common.collect.Range;
-import com.google.common.io.Files;
-import com.google.common.util.concurrent.MoreExecutors;
-import io.grpc.CallCredentials;
-import io.grpc.Metadata;
-import io.grpc.MethodDescriptor;
-import io.grpc.SecurityLevel;
-import io.grpc.auth.MoreCallCredentials;
-import java.io.File;
-import java.io.IOException;
-import java.nio.charset.StandardCharsets;
-import java.util.Map;
-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;
-
-/** Tests for {@link StsCredentials}. */
-@RunWith(JUnit4.class)
-public class StsCredentialsTest {
-  public static final String AUDIENCE_VALUE =
-      "identitynamespace:my-trust-domain:my-identity-provider";
-  public static final String STS_URL = "https://securetoken.googleapis.com/v1/identitybindingtoken";
-  private static final String TOKEN_FILE_NAME = "istio-token.txt";
-  static final Metadata.Key<String> KEY_FOR_AUTHORIZATION =
-          Metadata.Key.of("Authorization", Metadata.ASCII_STRING_MARSHALLER);
-
-  @Rule
-  public TemporaryFolder tempFolder = new TemporaryFolder();
-  private String currentFileContents;
-  private File tempTokenFile;
-
-  @Before
-  public void setUp() throws IOException {
-    tempTokenFile = tempFolder.newFile(TOKEN_FILE_NAME);
-    currentFileContents = "test-token-content-time-" + System.currentTimeMillis();
-    Files.write(currentFileContents.getBytes(StandardCharsets.UTF_8), tempTokenFile);
-  }
-
-  @SuppressWarnings("unchecked")
-  @Test
-  public void testStsRequestResponse() throws IOException {
-    MockHttpTransport.Builder builder = new MockHttpTransport.Builder();
-    MockLowLevelHttpResponse response = new MockLowLevelHttpResponse();
-    response.setContent(MOCK_RESPONSE);
-    builder.setLowLevelHttpResponse(response);
-    MockHttpTransport httpTransport = builder.build();
-    HttpTransportFactory httpTransportFactory = mock(HttpTransportFactory.class);
-    when(httpTransportFactory.create()).thenReturn(httpTransport);
-    StsCredentials stsCredentials =
-        StsCredentials.Factory.create(
-            STS_URL, AUDIENCE_VALUE, tempTokenFile.getAbsolutePath(), httpTransportFactory);
-    AccessToken token = stsCredentials.refreshAccessToken();
-    assertThat(token).isNotNull();
-    assertThat(token.getTokenValue()).isEqualTo(ACCESS_TOKEN);
-    long diff = token.getExpirationTime().getTime() - System.currentTimeMillis();
-    assertThat(diff).isIn(Range.closed(3550000L, 3650000L));
-    MockLowLevelHttpRequest request = httpTransport.getLowLevelHttpRequest();
-    assertThat(request.getUrl()).isEqualTo(STS_URL);
-    assertThat(request.getContentType()).isEqualTo("application/json; charset=UTF-8");
-    assertThat(request.getStreamingContent()).isInstanceOf(JsonHttpContent.class);
-    Map<String, Object> map =
-        (Map<String, Object>) ((JsonHttpContent) request.getStreamingContent()).getData();
-    assertThat(map.get("subject_token_type")).isEqualTo("urn:ietf:params:oauth:token-type:jwt");
-    assertThat(map.get("grant_type")).isEqualTo("urn:ietf:params:oauth:grant-type:token-exchange");
-    assertThat(map.get("subject_token")).isEqualTo(currentFileContents);
-    assertThat(map.get("requested_token_type"))
-        .isEqualTo("urn:ietf:params:oauth:token-type:access_token");
-    assertThat(map.get("scope")).isEqualTo("https://www.googleapis.com/auth/cloud-platform");
-    assertThat(map.get("audience")).isEqualTo(AUDIENCE_VALUE);
-  }
-
-  @Test
-  public void stsCredentialsInCallCreds() throws IOException {
-    MockHttpTransport.Builder builder = new MockHttpTransport.Builder();
-    MockLowLevelHttpResponse response = new MockLowLevelHttpResponse();
-    response.setContent(MOCK_RESPONSE);
-    builder.setLowLevelHttpResponse(response);
-    MockHttpTransport httpTransport = builder.build();
-    HttpTransportFactory httpTransportFactory = mock(HttpTransportFactory.class);
-    when(httpTransportFactory.create()).thenReturn(httpTransport);
-    StsCredentials stsCredentials =
-        StsCredentials.Factory.create(
-            STS_URL, AUDIENCE_VALUE, tempTokenFile.getAbsolutePath(), httpTransportFactory);
-    CallCredentials callCreds = MoreCallCredentials.from(stsCredentials);
-    CallCredentials.RequestInfo requestInfo = mock(CallCredentials.RequestInfo.class);
-    when(requestInfo.getSecurityLevel()).thenReturn(SecurityLevel.PRIVACY_AND_INTEGRITY);
-    when(requestInfo.getAuthority()).thenReturn("auth");
-    MethodDescriptor.Marshaller<?> requestMarshaller = mock(MethodDescriptor.Marshaller.class);
-    MethodDescriptor.Marshaller<?> responseMarshaller = mock(MethodDescriptor.Marshaller.class);
-    MethodDescriptor.Builder<?, ?> mBuilder =
-        MethodDescriptor.newBuilder(requestMarshaller, responseMarshaller);
-    mBuilder.setType(MethodDescriptor.MethodType.UNARY);
-    mBuilder.setFullMethodName("service/method");
-    MethodDescriptor<?, ?> methodDescriptor = mBuilder.build();
-    doReturn(methodDescriptor).when(requestInfo).getMethodDescriptor();
-    CallCredentials.MetadataApplier applier = mock(CallCredentials.MetadataApplier.class);
-    callCreds.applyRequestMetadata(requestInfo, MoreExecutors.directExecutor(), applier);
-    ArgumentCaptor<Metadata> metadataCaptor = ArgumentCaptor.forClass(null);
-    verify(applier).apply(metadataCaptor.capture());
-    Metadata metadata = metadataCaptor.getValue();
-    assertThat(metadata).isNotNull();
-    String authValue = metadata.get(KEY_FOR_AUTHORIZATION);
-    assertThat(authValue).isEqualTo("Bearer " + ACCESS_TOKEN);
-  }
-
-  @Test
-  public void testStsRequest_exception() throws IOException {
-    MockHttpTransport.Builder builder = new MockHttpTransport.Builder();
-    MockLowLevelHttpResponse response = new MockLowLevelHttpResponse();
-    response.setStatusCode(HttpStatusCodes.STATUS_CODE_BAD_REQUEST);
-    response.setContent(MOCK_RESPONSE);
-    builder.setLowLevelHttpResponse(response);
-    MockHttpTransport httpTransport = builder.build();
-    HttpTransportFactory httpTransportFactory = mock(HttpTransportFactory.class);
-    when(httpTransportFactory.create()).thenReturn(httpTransport);
-    StsCredentials stsCredentials =
-            StsCredentials.Factory.create(
-                    STS_URL, AUDIENCE_VALUE, tempTokenFile.getAbsolutePath(), httpTransportFactory);
-    try {
-      stsCredentials.refreshAccessToken();
-      fail("exception expected");
-    } catch (IOException ioe) {
-      assertThat(ioe.getMessage()).isEqualTo("Error requesting access token");
-    }
-  }
-
-  @Test
-  public void testStsRequest_nonSuccessCode() throws IOException {
-    MockHttpTransport.Builder builder = new MockHttpTransport.Builder();
-    MockLowLevelHttpResponse response = new MockLowLevelHttpResponse();
-    response.setStatusCode(HttpStatusCodes.STATUS_CODE_NO_CONTENT);
-    response.setContent(MOCK_RESPONSE);
-    builder.setLowLevelHttpResponse(response);
-    MockHttpTransport httpTransport = builder.build();
-    HttpTransportFactory httpTransportFactory = mock(HttpTransportFactory.class);
-    when(httpTransportFactory.create()).thenReturn(httpTransport);
-    StsCredentials stsCredentials =
-            StsCredentials.Factory.create(
-                    STS_URL, AUDIENCE_VALUE, tempTokenFile.getAbsolutePath(), httpTransportFactory);
-    try {
-      stsCredentials.refreshAccessToken();
-      fail("exception expected");
-    } catch (IOException ioe) {
-      assertThat(ioe.getMessage()).isEqualTo("Error getting access token: 204 : null");
-    }
-  }
-
-  @Test
-  public void toBuilder_unsupportedException() {
-    HttpTransportFactory httpTransportFactory = mock(HttpTransportFactory.class);
-    StsCredentials stsCredentials =
-            StsCredentials.Factory.create(
-                    STS_URL, AUDIENCE_VALUE, tempTokenFile.getAbsolutePath(), httpTransportFactory);
-    try {
-      stsCredentials.toBuilder();
-      fail("exception expected");
-    } catch (UnsupportedOperationException uoe) {
-      assertThat(uoe.getMessage()).isEqualTo("toBuilder not supported");
-    }
-  }
-
-  @Test
-  public void defaultFactory() {
-    StsCredentials stsCreds = StsCredentials.Factory.getInstance()
-        .create(STS_URL, AUDIENCE_VALUE, tempTokenFile.getAbsolutePath());
-    assertThat(stsCreds.transportFactory).isEqualTo(StsCredentials.defaultHttpTransportFactory);
-  }
-
-  private static final String ACCESS_TOKEN = "eyJhbGciOiJSU";
-  private static final String MOCK_RESPONSE =
-      "{\"access_token\": \""
-          + ACCESS_TOKEN
-          + "\",\n"
-          + "  \"issued_token_type\": \"urn:ietf:params:oauth:token-type:access_token\",\n"
-          + "  \"token_type\": \"Bearer\",\n"
-          + "  \"expires_in\": 3600\n"
-          + "}";
-}
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/OrcaOobUtilAccessor.java b/xds/src/test/java/io/grpc/xds/orca/OrcaOobUtilAccessor.java
new file mode 100644
index 00000000000..db9168dd08e
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/orca/OrcaOobUtilAccessor.java
@@ -0,0 +1,35 @@
+/*
+ * 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.xds.orca;
+
+import io.grpc.LoadBalancer;
+
+/**
+ * Accessor for white-box testing involving OrcaOobUtil.
+ */
+public final class OrcaOobUtilAccessor {
+  private OrcaOobUtilAccessor() {
+    // Do not instantiate
+  }
+
+  public static LoadBalancer.SubchannelPicker getDelegate(LoadBalancer.SubchannelPicker picker) {
+    if (picker instanceof OrcaOobUtil.OrcaReportingHelper.OrcaOobPicker) {
+      return ((OrcaOobUtil.OrcaReportingHelper.OrcaOobPicker) picker).delegate;
+    }
+    return picker;
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/OrcaOobUtilTest.java b/xds/src/test/java/io/grpc/xds/orca/OrcaOobUtilTest.java
similarity index 80%
rename from xds/src/test/java/io/grpc/xds/OrcaOobUtilTest.java
rename to xds/src/test/java/io/grpc/xds/orca/OrcaOobUtilTest.java
index b3cf80ee617..e2a361d660c 100644
--- a/xds/src/test/java/io/grpc/xds/OrcaOobUtilTest.java
+++ b/xds/src/test/java/io/grpc/xds/orca/OrcaOobUtilTest.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.grpc.xds;
+package io.grpc.xds.orca;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 import static com.google.common.base.Preconditions.checkState;
@@ -23,7 +23,9 @@
 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;
@@ -34,9 +36,9 @@
 import static org.mockito.Mockito.verifyNoMoreInteractions;
 import static org.mockito.Mockito.when;
 
-import com.github.udpa.udpa.data.orca.v1.OrcaLoadReport;
-import com.github.udpa.udpa.service.orca.v1.OpenRcaServiceGrpc;
-import com.github.udpa.udpa.service.orca.v1.OrcaLoadReportRequest;
+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;
@@ -47,6 +49,7 @@
 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;
@@ -59,12 +62,13 @@
 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.xds.OrcaOobUtil.OrcaOobReportListener;
-import io.grpc.xds.OrcaOobUtil.OrcaReportingConfig;
-import io.grpc.xds.OrcaOobUtil.OrcaReportingHelperWrapper;
-import io.grpc.xds.OrcaOobUtil.SubchannelImpl;
+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;
@@ -85,7 +89,8 @@
 import org.mockito.ArgumentCaptor;
 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 OrcaOobUtil} class.
@@ -103,6 +108,7 @@ public class OrcaOobUtilTest {
   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];
@@ -130,9 +136,10 @@ public void uncaughtException(Thread t, Throwable e) {
   @Mock private BackoffPolicy backoffPolicy1;
   @Mock private BackoffPolicy backoffPolicy2;
   private FakeSubchannel[] subchannels = new FakeSubchannel[NUM_SUBCHANNELS];
-  private OrcaReportingHelperWrapper orcaHelperWrapper;
-  private OrcaReportingHelperWrapper parentHelperWrapper;
-  private OrcaReportingHelperWrapper childHelperWrapper;
+  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();
@@ -146,7 +153,7 @@ private static OrcaLoadReportRequest buildOrcaRequestFromConfig(
   }
 
   private static void assertLog(List<String> logs, String expectedLog) {
-    assertThat(logs).containsExactly(expectedLog);
+    assertThat(logs).contains(expectedLog);
     logs.clear();
   }
 
@@ -175,10 +182,7 @@ public void orcaReportingConfig_construct() {
   }
 
   @Before
-  @SuppressWarnings("unchecked")
   public void setUp() throws Exception {
-    MockitoAnnotations.initMocks(this);
-
     for (int i = 0; i < NUM_SUBCHANNELS; i++) {
       orcaServiceImps[i] = new OpenRcaServiceImp();
       cleanupRule.register(
@@ -202,42 +206,48 @@ public void setUp() throws Exception {
     when(backoffPolicy1.nextBackoffNanos()).thenReturn(11L, 21L);
     when(backoffPolicy2.nextBackoffNanos()).thenReturn(12L, 22L);
 
-    orcaHelperWrapper =
-        OrcaOobUtil.newOrcaReportingHelperWrapper(
-            origHelper,
-            mockOrcaListener0,
-            backoffPolicyProvider,
-            fakeClock.getStopwatchSupplier());
-    parentHelperWrapper =
-        OrcaOobUtil.newOrcaReportingHelperWrapper(
+    orcaHelper =
+        OrcaOobUtil.newOrcaReportingHelper(
             origHelper,
-            mockOrcaListener1,
             backoffPolicyProvider,
             fakeClock.getStopwatchSupplier());
-    childHelperWrapper =
-        OrcaOobUtil.newOrcaReportingHelperWrapper(
-            parentHelperWrapper.asHelper(),
-            mockOrcaListener2,
+    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
-  @SuppressWarnings("unchecked")
   public void singlePolicyTypicalWorkflow() {
-    setOrcaReportConfig(orcaHelperWrapper, SHORT_INTERVAL_CONFIG);
     verify(origHelper, atLeast(0)).getSynchronizationContext();
     verifyNoMoreInteractions(origHelper);
 
     // Calling createSubchannel() on orcaHelper correctly passes augmented CreateSubchannelArgs
     // to origHelper.
-    ArgumentCaptor<CreateSubchannelArgs> createArgsCaptor = ArgumentCaptor.forClass(null);
+    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();
-      assertThat(unwrap(createSubchannel(orcaHelperWrapper.asHelper(), i, attrs)))
-          .isSameInstanceAs(subchannels[i]);
+      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))
@@ -278,7 +288,9 @@ public void singlePolicyTypicalWorkflow() {
       OrcaLoadReport report = OrcaLoadReport.getDefaultInstance();
       serverCall.responseObserver.onNext(report);
       assertLog(subchannel.logs, "DEBUG: Received an ORCA report: " + report);
-      verify(mockOrcaListener0, times(i + 1)).onLoadReport(eq(report));
+      verify(mockOrcaListener0, times(i + 1)).onLoadReport(
+          argThat(new OrcaPerRequestUtilTest.MetricsReportMatcher(
+              OrcaPerRequestUtil.fromOrcaLoadReport(report))));
     }
 
     for (int i = 0; i < NUM_SUBCHANNELS; i++) {
@@ -306,20 +318,20 @@ public void singlePolicyTypicalWorkflow() {
 
   @Test
   public void twoLevelPoliciesTypicalWorkflow() {
-    setOrcaReportConfig(childHelperWrapper, SHORT_INTERVAL_CONFIG);
-    setOrcaReportConfig(parentHelperWrapper, SHORT_INTERVAL_CONFIG);
     verify(origHelper, atLeast(0)).getSynchronizationContext();
     verifyNoMoreInteractions(origHelper);
 
     // Calling createSubchannel() on child helper correctly passes augmented CreateSubchannelArgs
     // to origHelper.
-    ArgumentCaptor<CreateSubchannelArgs> createArgsCaptor = ArgumentCaptor.forClass(null);
+    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();
-      assertThat(unwrap(createSubchannel(childHelperWrapper.asHelper(), i, attrs)))
-          .isSameInstanceAs(subchannels[i]);
+      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))
@@ -363,8 +375,9 @@ public void twoLevelPoliciesTypicalWorkflow() {
       OrcaLoadReport report = OrcaLoadReport.getDefaultInstance();
       serverCall.responseObserver.onNext(report);
       assertLog(subchannel.logs, "DEBUG: Received an ORCA report: " + report);
-      verify(mockOrcaListener1, times(i + 1)).onLoadReport(eq(report));
-      verify(mockOrcaListener2, times(i + 1)).onLoadReport(eq(report));
+      verify(mockOrcaListener1, times(i + 1)).onLoadReport(
+          argThat(new OrcaPerRequestUtilTest.MetricsReportMatcher(
+              OrcaPerRequestUtil.fromOrcaLoadReport(report))));
     }
 
     for (int i = 0; i < NUM_SUBCHANNELS; i++) {
@@ -391,10 +404,9 @@ public void twoLevelPoliciesTypicalWorkflow() {
   }
 
   @Test
-  @SuppressWarnings("unchecked")
   public void orcReportingDisabledWhenServiceNotImplemented() {
-    setOrcaReportConfig(orcaHelperWrapper, SHORT_INTERVAL_CONFIG);
-    createSubchannel(orcaHelperWrapper.asHelper(), 0, Attributes.EMPTY);
+    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];
@@ -421,15 +433,16 @@ public void orcReportingDisabledWhenServiceNotImplemented() {
     OrcaLoadReport report = OrcaLoadReport.getDefaultInstance();
     serverCall.responseObserver.onNext(report);
     assertLog(subchannel.logs, "DEBUG: Received an ORCA report: " + report);
-    verify(mockOrcaListener0).onLoadReport(eq(report));
-
+    verify(mockOrcaListener0).onLoadReport(
+        argThat(new OrcaPerRequestUtilTest.MetricsReportMatcher(
+            OrcaPerRequestUtil.fromOrcaLoadReport(report))));
     verifyNoInteractions(backoffPolicyProvider);
   }
 
   @Test
   public void orcaReportingStreamClosedAndRetried() {
-    setOrcaReportConfig(orcaHelperWrapper, SHORT_INTERVAL_CONFIG);
-    createSubchannel(orcaHelperWrapper.asHelper(), 0, Attributes.EMPTY);
+    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];
@@ -467,8 +480,9 @@ public void orcaReportingStreamClosedAndRetried() {
     OrcaLoadReport report = OrcaLoadReport.getDefaultInstance();
     orcaServiceImp.calls.peek().responseObserver.onNext(report);
     assertLog(subchannel.logs, "DEBUG: Received an ORCA report: " + report);
-    inOrder.verify(mockOrcaListener0).onLoadReport(eq(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(
@@ -494,14 +508,14 @@ public void orcaReportingStreamClosedAndRetried() {
 
   @Test
   public void reportingNotStartedUntilConfigured() {
-    createSubchannel(orcaHelperWrapper.asHelper(), 0, Attributes.EMPTY);
+    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();
-    setOrcaReportConfig(orcaHelperWrapper, SHORT_INTERVAL_CONFIG);
+    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());
@@ -509,10 +523,61 @@ public void reportingNotStartedUntilConfigured() {
         .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() {
-    setOrcaReportConfig(orcaHelperWrapper, SHORT_INTERVAL_CONFIG);
-    createSubchannel(orcaHelperWrapper.asHelper(), 0, Attributes.EMPTY);
+    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)));
 
@@ -525,8 +590,8 @@ public void updateReportingIntervalBeforeCreatingSubchannel() {
 
   @Test
   public void updateReportingIntervalBeforeSubchannelReady() {
-    createSubchannel(orcaHelperWrapper.asHelper(), 0, Attributes.EMPTY);
-    setOrcaReportConfig(orcaHelperWrapper, SHORT_INTERVAL_CONFIG);
+    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)));
 
@@ -541,8 +606,9 @@ public void updateReportingIntervalBeforeSubchannelReady() {
   public void updateReportingIntervalWhenRpcActive() {
     // Sets report interval before creating a Subchannel, reporting starts right after suchannel
     // state becomes READY.
-    setOrcaReportConfig(orcaHelperWrapper, MEDIUM_INTERVAL_CONFIG);
-    createSubchannel(orcaHelperWrapper.asHelper(), 0, Attributes.EMPTY);
+    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)));
 
@@ -553,7 +619,7 @@ public void updateReportingIntervalWhenRpcActive() {
         .isEqualTo(buildOrcaRequestFromConfig(MEDIUM_INTERVAL_CONFIG));
 
     // Make reporting less frequent.
-    setOrcaReportConfig(orcaHelperWrapper, LONG_INTERVAL_CONFIG);
+    OrcaOobUtil.setListener(created, mockOrcaListener0, LONG_INTERVAL_CONFIG);
     assertThat(orcaServiceImps[0].calls.poll().cancelled).isTrue();
     assertThat(orcaServiceImps[0].calls).hasSize(1);
     assertLog(subchannels[0].logs,
@@ -562,12 +628,13 @@ public void updateReportingIntervalWhenRpcActive() {
         .isEqualTo(buildOrcaRequestFromConfig(LONG_INTERVAL_CONFIG));
 
     // Configuring with the same report interval again does not restart ORCA RPC.
-    setOrcaReportConfig(orcaHelperWrapper, LONG_INTERVAL_CONFIG);
+    OrcaOobUtil.setListener(created, mockOrcaListener0, LONG_INTERVAL_CONFIG);
     assertThat(orcaServiceImps[0].calls.peek().cancelled).isFalse();
     assertThat(subchannels[0].logs).isEmpty();
 
     // Make reporting more frequent.
-    setOrcaReportConfig(orcaHelperWrapper, SHORT_INTERVAL_CONFIG);
+    OrcaOobUtil.setListener(created, mockOrcaListener0,
+        SHORT_INTERVAL_CONFIG);
     assertThat(orcaServiceImps[0].calls.poll().cancelled).isTrue();
     assertThat(orcaServiceImps[0].calls).hasSize(1);
     assertLog(subchannels[0].logs,
@@ -578,8 +645,8 @@ public void updateReportingIntervalWhenRpcActive() {
 
   @Test
   public void updateReportingIntervalWhenRpcPendingRetry() {
-    createSubchannel(orcaHelperWrapper.asHelper(), 0, Attributes.EMPTY);
-    setOrcaReportConfig(orcaHelperWrapper, SHORT_INTERVAL_CONFIG);
+    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)));
 
@@ -599,7 +666,7 @@ public void updateReportingIntervalWhenRpcPendingRetry() {
     assertThat(orcaServiceImps[0].calls).isEmpty();
 
     // Make reporting less frequent.
-    setOrcaReportConfig(orcaHelperWrapper, LONG_INTERVAL_CONFIG);
+    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);
@@ -611,7 +678,7 @@ public void updateReportingIntervalWhenRpcPendingRetry() {
 
   @Test
   public void policiesReceiveSameReportIndependently() {
-    createSubchannel(childHelperWrapper.asHelper(), 0, Attributes.EMPTY);
+    Subchannel childSubchannel = createSubchannel(childHelper, 0, Attributes.EMPTY);
     deliverSubchannelState(0, ConnectivityStateInfo.forNonError(READY));
 
     // No helper sets ORCA reporting interval, so load reporting is not started.
@@ -620,7 +687,7 @@ public void policiesReceiveSameReportIndependently() {
     assertThat(subchannels[0].logs).isEmpty();
 
     // Parent helper requests ORCA reports with a certain interval, load reporting starts.
-    setOrcaReportConfig(parentHelperWrapper, SHORT_INTERVAL_CONFIG);
+    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());
@@ -630,17 +697,18 @@ public void policiesReceiveSameReportIndependently() {
     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<OrcaLoadReport> parentReportCaptor = ArgumentCaptor.forClass(null);
+    ArgumentCaptor<MetricReport> parentReportCaptor = ArgumentCaptor.forClass(MetricReport.class);
     verify(mockOrcaListener1).onLoadReport(parentReportCaptor.capture());
-    assertThat(parentReportCaptor.getValue()).isEqualTo(report);
+    assertThat(OrcaPerRequestUtilTest.reportEqual(parentReportCaptor.getValue(),
+        OrcaPerRequestUtil.fromOrcaLoadReport(report))).isTrue();
     verifyNoMoreInteractions(mockOrcaListener2);
 
     // Now child helper also wants to receive reports.
-    setOrcaReportConfig(childHelperWrapper, SHORT_INTERVAL_CONFIG);
+    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<OrcaLoadReport> childReportCaptor = ArgumentCaptor.forClass(null);
+    ArgumentCaptor<MetricReport> childReportCaptor = ArgumentCaptor.forClass(MetricReport.class);
     verify(mockOrcaListener1, times(2))
         .onLoadReport(parentReportCaptor.capture());
     verify(mockOrcaListener2)
@@ -650,9 +718,9 @@ public void policiesReceiveSameReportIndependently() {
 
   @Test
   public void reportWithMostFrequentIntervalRequested() {
-    setOrcaReportConfig(parentHelperWrapper, SHORT_INTERVAL_CONFIG);
-    setOrcaReportConfig(childHelperWrapper, LONG_INTERVAL_CONFIG);
-    createSubchannel(childHelperWrapper.asHelper(), 0, Attributes.EMPTY);
+    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);
@@ -663,14 +731,14 @@ public void reportWithMostFrequentIntervalRequested() {
     assertThat(Durations.toNanos(orcaServiceImps[0].calls.peek().request.getReportInterval()))
         .isEqualTo(SHORT_INTERVAL_CONFIG.getReportIntervalNanos());
 
-    // Child helper wants reporting to be more frequent than its current setting while it is still
+    // 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.
-    setOrcaReportConfig(childHelperWrapper, MEDIUM_INTERVAL_CONFIG);
+    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.
-    setOrcaReportConfig(parentHelperWrapper, MEDIUM_INTERVAL_CONFIG);
+    OrcaOobUtil.setListener(created, mockOrcaListener1, MEDIUM_INTERVAL_CONFIG);
     assertThat(orcaServiceImps[0].calls.poll().cancelled).isTrue();
     assertThat(orcaServiceImps[0].calls).hasSize(1);
     assertLog(subchannels[0].logs,
@@ -723,13 +791,10 @@ public void run() {
   }
 
   private void setOrcaReportConfig(
-      final OrcaReportingHelperWrapper helperWrapper, final OrcaReportingConfig config) {
-    syncContext.execute(new Runnable() {
-      @Override
-      public void run() {
-        helperWrapper.setReportingConfig(config);
-      }
-    });
+      final Subchannel subchannel,
+      final OrcaOobReportListener listener,
+      final OrcaReportingConfig config) {
+    OrcaOobUtil.setListener(subchannel, listener, config);
   }
 
   private static final class OpenRcaServiceImp extends OpenRcaServiceGrpc.OpenRcaServiceImplBase {
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
index 760a01df5b2..d6456956733 100644
--- a/xds/third_party/envoy/LICENSE
+++ b/xds/third_party/envoy/LICENSE
@@ -187,7 +187,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright [yyyy] [name of copyright owner].
+   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.
@@ -199,4 +199,4 @@
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT 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
+   limitations under the License.
diff --git a/xds/third_party/envoy/NOTICE b/xds/third_party/envoy/NOTICE
index 9a9b287cbe8..8604a8bbd60 100644
--- a/xds/third_party/envoy/NOTICE
+++ b/xds/third_party/envoy/NOTICE
@@ -1,4 +1,4 @@
 Envoy
-Copyright 2016-2019 Envoy Project Authors
+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
index f6cd11c70a8..74b8af750ab 100755
--- a/xds/third_party/envoy/import.sh
+++ b/xds/third_party/envoy/import.sh
@@ -13,172 +13,161 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-# Update VERSION then in this directory run ./import.sh
+# Update VERSION then execute this script
 
 set -e
-BRANCH=main
-# import VERSION from one of the google internal CLs
-VERSION=ac9a2637336decdcc52c24add5e8fc39edebb962
-GIT_REPO="https://github.com/envoyproxy/envoy.git"
-GIT_BASE_DIR=envoy
-SOURCE_PROTO_BASE_DIR=envoy/api
+# import VERSION from the google internal go/envoy-import-status
+VERSION=a0b3df32ba54c92a08d3636a9a36013cb920e471
+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/annotations/resource.proto
-envoy/api/v2/auth/cert.proto
-envoy/api/v2/auth/common.proto
-envoy/api/v2/auth/secret.proto
-envoy/api/v2/auth/tls.proto
-envoy/api/v2/cds.proto
-envoy/api/v2/cluster.proto
-envoy/api/v2/cluster/circuit_breaker.proto
-envoy/api/v2/cluster/filter.proto
-envoy/api/v2/cluster/outlier_detection.proto
-envoy/api/v2/core/address.proto
-envoy/api/v2/core/backoff.proto
-envoy/api/v2/core/base.proto
-envoy/api/v2/core/config_source.proto
-envoy/api/v2/core/event_service_config.proto
-envoy/api/v2/core/grpc_service.proto
-envoy/api/v2/core/health_check.proto
-envoy/api/v2/core/http_uri.proto
-envoy/api/v2/core/protocol.proto
-envoy/api/v2/core/socket_option.proto
-envoy/api/v2/discovery.proto
-envoy/api/v2/eds.proto
-envoy/api/v2/endpoint.proto
-envoy/api/v2/endpoint/endpoint.proto
-envoy/api/v2/endpoint/endpoint_components.proto
-envoy/api/v2/endpoint/load_report.proto
-envoy/api/v2/lds.proto
-envoy/api/v2/listener.proto
-envoy/api/v2/listener/listener.proto
-envoy/api/v2/listener/listener_components.proto
-envoy/api/v2/listener/udp_listener_config.proto
-envoy/api/v2/rds.proto
-envoy/api/v2/route.proto
-envoy/api/v2/route/route.proto
-envoy/api/v2/route/route_components.proto
-envoy/api/v2/scoped_route.proto
-envoy/api/v2/srds.proto
 envoy/config/accesslog/v3/accesslog.proto
-envoy/config/cluster/aggregate/v2alpha/cluster.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/cel.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/filter/accesslog/v2/accesslog.proto
-envoy/config/filter/fault/v2/fault.proto
-envoy/config/filter/http/fault/v2/fault.proto
-envoy/config/filter/network/http_connection_manager/v2/http_connection_manager.proto
-envoy/config/listener/v2/api_listener.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/rbac/v2/rbac.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/v2/datadog.proto
-envoy/config/trace/v2/dynamic_ot.proto
-envoy/config/trace/v2/http_tracer.proto
-envoy/config/trace/v2/lightstep.proto
-envoy/config/trace/v2/opencensus.proto
-envoy/config/trace/v2/service.proto
-envoy/config/trace/v2/trace.proto
-envoy/config/trace/v2/zipkin.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/opencensus.proto
+envoy/config/trace/v3/opentelemetry.proto
 envoy/config/trace/v3/service.proto
-envoy/config/trace/v3/trace.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/common/matching/v3/extension_matcher.proto
 envoy/extensions/filters/http/fault/v3/fault.proto
+envoy/extensions/filters/http/composite/v3/composite.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/discovery/v2/ads.proto
-envoy/service/discovery/v2/sds.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/v2/lrs.proto
 envoy/service/load_stats/v3/lrs.proto
-envoy/type/http.proto
-envoy/type/matcher/metadata.proto
-envoy/type/matcher/number.proto
-envoy/type/matcher/path.proto
-envoy/type/matcher/regex.proto
-envoy/type/matcher/string.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/config/common/matcher/v3/matcher.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/matcher/value.proto
-envoy/type/metadata/v2/metadata.proto
 envoy/type/metadata/v3/metadata.proto
-envoy/type/percent.proto
-envoy/type/range.proto
-envoy/type/semantic_version.proto
-envoy/type/tracing/v2/custom_tag.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
+pushd "$(git rev-parse --show-toplevel)/xds/third_party/envoy" > /dev/null
 
-# clone the envoy github repo in a tmp directory
+# 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
 
-pushd "${tmpdir}"
-git clone -b $BRANCH $GIT_REPO
-trap "rm -rf $GIT_BASE_DIR" EXIT
-cd "$GIT_BASE_DIR"
-git checkout $VERSION
-popd
+curl -Ls "${DOWNLOAD_URL}" | tar xz -C "${tmpdir}"
 
-cp -p "${tmpdir}/${GIT_BASE_DIR}/LICENSE" LICENSE
-cp -p "${tmpdir}/${GIT_BASE_DIR}/NOTICE" NOTICE
+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}"
+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}"
+  cp -p "${tmpdir}/${SOURCE_PROTO_BASE_DIR}/${file}" "${file}" && (( ++COPIED ))
 done
-popd
+popd > /dev/null
+
+popd > /dev/null
 
-popd
+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
index 7f9b64e32b0..c9a96f1ae27 100644
--- a/xds/third_party/envoy/src/main/proto/envoy/annotations/deprecation.proto
+++ b/xds/third_party/envoy/src/main/proto/envoy/annotations/deprecation.proto
@@ -1,22 +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]
-// Allows tagging proto fields as fatal by default. One Envoy release after
-// deprecation, deprecated fields will be disallowed by default, a state which
-// is reversible with :ref:`runtime overrides <config_runtime_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"
+// "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"
+// "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/annotations/resource.proto b/xds/third_party/envoy/src/main/proto/envoy/annotations/resource.proto
deleted file mode 100644
index bd794c68dd7..00000000000
--- a/xds/third_party/envoy/src/main/proto/envoy/annotations/resource.proto
+++ /dev/null
@@ -1,18 +0,0 @@
-syntax = "proto3";
-
-package envoy.annotations;
-
-import "google/protobuf/descriptor.proto";
-
-// [#protodoc-title: Resource]
-
-// Magic number in this file derived from top 28bit of SHA256 digest of "envoy.annotation.resource".
-extend google.protobuf.ServiceOptions {
-  ResourceAnnotation resource = 265073217;
-}
-
-message ResourceAnnotation {
-  // Annotation for xDS services that indicates the fully-qualified Protobuf type for the resource
-  // type.
-  string type = 1;
-}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/api/v2/auth/cert.proto b/xds/third_party/envoy/src/main/proto/envoy/api/v2/auth/cert.proto
deleted file mode 100644
index 6a9cbddd250..00000000000
--- a/xds/third_party/envoy/src/main/proto/envoy/api/v2/auth/cert.proto
+++ /dev/null
@@ -1,15 +0,0 @@
-syntax = "proto3";
-
-package envoy.api.v2.auth;
-
-import "udpa/annotations/migrate.proto";
-
-import public "envoy/api/v2/auth/common.proto";
-import public "envoy/api/v2/auth/secret.proto";
-import public "envoy/api/v2/auth/tls.proto";
-
-option java_package = "io.envoyproxy.envoy.api.v2.auth";
-option java_outer_classname = "CertProto";
-option java_multiple_files = true;
-option (udpa.annotations.file_migrate).move_to_package =
-    "envoy.extensions.transport_sockets.tls.v3";
diff --git a/xds/third_party/envoy/src/main/proto/envoy/api/v2/auth/common.proto b/xds/third_party/envoy/src/main/proto/envoy/api/v2/auth/common.proto
deleted file mode 100644
index c8122f40102..00000000000
--- a/xds/third_party/envoy/src/main/proto/envoy/api/v2/auth/common.proto
+++ /dev/null
@@ -1,327 +0,0 @@
-syntax = "proto3";
-
-package envoy.api.v2.auth;
-
-import "envoy/api/v2/core/base.proto";
-import "envoy/type/matcher/string.proto";
-
-import "google/protobuf/any.proto";
-import "google/protobuf/struct.proto";
-import "google/protobuf/wrappers.proto";
-
-import "udpa/annotations/migrate.proto";
-import "udpa/annotations/sensitive.proto";
-import "udpa/annotations/status.proto";
-import "validate/validate.proto";
-
-option java_package = "io.envoyproxy.envoy.api.v2.auth";
-option java_outer_classname = "CommonProto";
-option java_multiple_files = true;
-option (udpa.annotations.file_migrate).move_to_package =
-    "envoy.extensions.transport_sockets.tls.v3";
-option (udpa.annotations.file_status).package_version_status = FROZEN;
-
-// [#protodoc-title: Common TLS configuration]
-
-message 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;
-  }
-
-  // Minimum TLS protocol version. By default, it's ``TLSv1_2`` for clients and ``TLSv1_0`` for
-  // servers.
-  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, the default list will be used.
-  //
-  // In non-FIPS builds, the default 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-AES128-SHA
-  //   ECDHE-RSA-AES128-SHA
-  //   AES128-GCM-SHA256
-  //   AES128-SHA
-  //   ECDHE-ECDSA-AES256-GCM-SHA384
-  //   ECDHE-RSA-AES256-GCM-SHA384
-  //   ECDHE-ECDSA-AES256-SHA
-  //   ECDHE-RSA-AES256-SHA
-  //   AES256-GCM-SHA384
-  //   AES256-SHA
-  //
-  // In builds using :ref:`BoringSSL FIPS <arch_overview_ssl_fips>`, the default cipher list is:
-  //
-  // .. code-block:: none
-  //
-  //   ECDHE-ECDSA-AES128-GCM-SHA256
-  //   ECDHE-RSA-AES128-GCM-SHA256
-  //   ECDHE-ECDSA-AES128-SHA
-  //   ECDHE-RSA-AES128-SHA
-  //   AES128-GCM-SHA256
-  //   AES128-SHA
-  //   ECDHE-ECDSA-AES256-GCM-SHA384
-  //   ECDHE-RSA-AES256-GCM-SHA384
-  //   ECDHE-ECDSA-AES256-SHA
-  //   ECDHE-RSA-AES256-SHA
-  //   AES256-GCM-SHA384
-  //   AES256-SHA
-  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;
-}
-
-// 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 {
-  // Private key method provider name. The name must match a
-  // supported private key method provider type.
-  string provider_name = 1 [(validate.rules).string = {min_bytes: 1}];
-
-  // Private key method provider specific configuration.
-  oneof config_type {
-    google.protobuf.Struct config = 2 [deprecated = true, (udpa.annotations.sensitive) = true];
-
-    google.protobuf.Any typed_config = 3 [(udpa.annotations.sensitive) = true];
-  }
-}
-
-// [#next-free-field: 7]
-message TlsCertificate {
-  // The TLS certificate chain.
-  core.DataSource certificate_chain = 1;
-
-  // The TLS private key.
-  core.DataSource private_key = 2 [(udpa.annotations.sensitive) = true];
-
-  // BoringSSL private key method provider. This is an alternative to :ref:`private_key
-  // <envoy_api_field_auth.TlsCertificate.private_key>` field. This can't be
-  // marked as ``oneof`` due to API compatibility reasons. Setting both :ref:`private_key
-  // <envoy_api_field_auth.TlsCertificate.private_key>` and
-  // :ref:`private_key_provider
-  // <envoy_api_field_auth.TlsCertificate.private_key_provider>` fields will result in an
-  // error.
-  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.
-  core.DataSource password = 3 [(udpa.annotations.sensitive) = true];
-
-  // [#not-implemented-hide:]
-  core.DataSource ocsp_staple = 4;
-
-  // [#not-implemented-hide:]
-  repeated core.DataSource signed_certificate_timestamp = 5;
-}
-
-message 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_api_field_auth.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 core.DataSource keys = 1
-      [(validate.rules).repeated = {min_items: 1}, (udpa.annotations.sensitive) = true];
-}
-
-// [#next-free-field: 11]
-message 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_api_field_route.RouteMatch.TlsContextMatchOptions.validated>` ).
-    ACCEPT_UNTRUSTED = 1;
-  }
-
-  // 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_api_field_auth.DownstreamTlsContext.require_client_certificate>`,
-  // :ref:`verify_certificate_spki
-  // <envoy_api_field_auth.CertificateValidationContext.verify_certificate_spki>`,
-  // :ref:`verify_certificate_hash
-  // <envoy_api_field_auth.CertificateValidationContext.verify_certificate_hash>`, or
-  // :ref:`match_subject_alt_names
-  // <envoy_api_field_auth.CertificateValidationContext.match_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.
-  //
-  // See :ref:`the TLS overview <arch_overview_ssl_enabling_verification>` for a list of common
-  // system CA locations.
-  core.DataSource trusted_ca = 1;
-
-  // 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_api_field_auth.CertificateValidationContext.verify_certificate_hash>` and
-  // :ref:`verify_certificate_spki
-  // <envoy_api_field_auth.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_api_field_auth.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_bytes: 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_api_field_auth.CertificateValidationContext.verify_certificate_hash>` and
-  // :ref:`verify_certificate_spki
-  // <envoy_api_field_auth.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_bytes: 64 max_bytes: 95}}}];
-
-  // An optional list of Subject Alternative Names. If specified, Envoy will verify that the
-  // Subject Alternative Name of the presented certificate matches one of the specified values.
-  //
-  // .. 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_api_field_auth.CertificateValidationContext.trusted_ca>`.
-  repeated string verify_subject_alt_name = 4 [deprecated = true];
-
-  // An optional list of Subject Alternative name matchers. Envoy will verify that the
-  // Subject Alternative Name of the presented certificate matches one of the specified matches.
-  //
-  // 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_api_msg_type.matcher.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_subject_alt_names:
-  //    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_api_field_auth.CertificateValidationContext.trusted_ca>`.
-  repeated type.matcher.StringMatcher match_subject_alt_names = 9;
-
-  // [#not-implemented-hide:] Must present a signed time-stamped OCSP response.
-  google.protobuf.BoolValue require_ocsp_staple = 5;
-
-  // [#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.
-  core.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}];
-}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/api/v2/auth/secret.proto b/xds/third_party/envoy/src/main/proto/envoy/api/v2/auth/secret.proto
deleted file mode 100644
index 3a6d8cf7dcb..00000000000
--- a/xds/third_party/envoy/src/main/proto/envoy/api/v2/auth/secret.proto
+++ /dev/null
@@ -1,50 +0,0 @@
-syntax = "proto3";
-
-package envoy.api.v2.auth;
-
-import "envoy/api/v2/auth/common.proto";
-import "envoy/api/v2/core/base.proto";
-import "envoy/api/v2/core/config_source.proto";
-
-import "udpa/annotations/migrate.proto";
-import "udpa/annotations/sensitive.proto";
-import "udpa/annotations/status.proto";
-
-option java_package = "io.envoyproxy.envoy.api.v2.auth";
-option java_outer_classname = "SecretProto";
-option java_multiple_files = true;
-option (udpa.annotations.file_migrate).move_to_package =
-    "envoy.extensions.transport_sockets.tls.v3";
-option (udpa.annotations.file_status).package_version_status = FROZEN;
-
-// [#protodoc-title: Secrets configuration]
-
-message GenericSecret {
-  // Secret of generic type and is available to filters.
-  core.DataSource secret = 1 [(udpa.annotations.sensitive) = true];
-}
-
-message SdsSecretConfig {
-  // Name (FQDN, UUID, SPKI, SHA256, etc.) 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;
-
-  core.ConfigSource sds_config = 2;
-}
-
-// [#next-free-field: 6]
-message 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/api/v2/auth/tls.proto b/xds/third_party/envoy/src/main/proto/envoy/api/v2/auth/tls.proto
deleted file mode 100644
index 201973a2b9d..00000000000
--- a/xds/third_party/envoy/src/main/proto/envoy/api/v2/auth/tls.proto
+++ /dev/null
@@ -1,152 +0,0 @@
-syntax = "proto3";
-
-package envoy.api.v2.auth;
-
-import "envoy/api/v2/auth/common.proto";
-import "envoy/api/v2/auth/secret.proto";
-
-import "google/protobuf/duration.proto";
-import "google/protobuf/wrappers.proto";
-
-import "udpa/annotations/migrate.proto";
-import "udpa/annotations/status.proto";
-import "validate/validate.proto";
-
-option java_package = "io.envoyproxy.envoy.api.v2.auth";
-option java_outer_classname = "TlsProto";
-option java_multiple_files = true;
-option (udpa.annotations.file_migrate).move_to_package =
-    "envoy.extensions.transport_sockets.tls.v3";
-option (udpa.annotations.file_status).package_version_status = FROZEN;
-
-// [#protodoc-title: TLS transport socket]
-// [#extension: envoy.transport_sockets.tls]
-// The TLS contexts below provide the transport socket configuration for upstream/downstream TLS.
-
-message UpstreamTlsContext {
-  // Common TLS context settings.
-  //
-  // .. attention::
-  //
-  //   Server certificate verification is not enabled by default. Configure
-  //   :ref:`trusted_ca<envoy_api_field_auth.CertificateValidationContext.trusted_ca>` to enable
-  //   verification.
-  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, 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 store for the purpose of session resumption.
-  //
-  // Defaults to 1, setting this to 0 disables session resumption.
-  google.protobuf.UInt32Value max_session_keys = 4;
-}
-
-// [#next-free-field: 8]
-message DownstreamTlsContext {
-  // 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_api_field_auth.DownstreamTlsContext.session_ticket_keys>`
-    // or :ref:`session_ticket_keys_sds_secret_config <envoy_api_field_auth.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 specified, session_timeout will change maximum lifetime (in seconds) of TLS session
-  // Currently this value is used as a hint to `TLS session ticket lifetime (for TLSv1.2)
-  // <https://tools.ietf.org/html/rfc5077#section-5.6>`
-  // only seconds could be specified (fractional seconds are going to be ignored).
-  google.protobuf.Duration session_timeout = 6 [(validate.rules).duration = {
-    lt {seconds: 4294967296}
-    gte {}
-  }];
-}
-
-// TLS context shared by both client and server TLS contexts.
-// [#next-free-field: 9]
-message CommonTlsContext {
-  message CombinedCertificateValidationContext {
-    // How to validate peer certificates.
-    CertificateValidationContext default_validation_context = 1
-        [(validate.rules).message = {required: true}];
-
-    // Config for fetching validation context via SDS API.
-    SdsSecretConfig validation_context_sds_secret_config = 2
-        [(validate.rules).message = {required: true}];
-  }
-
-  reserved 5;
-
-  // TLS protocol versions, cipher suites etc.
-  TlsParameters tls_params = 1;
-
-  // :ref:`Multiple TLS certificates <arch_overview_ssl_cert_select>` can be associated with the
-  // same context to allow both RSA and ECDSA certificates.
-  //
-  // Only a single TLS certificate is supported in client contexts. In server contexts, the first
-  // RSA certificate is used for clients that only support RSA and the first ECDSA certificate is
-  // used for clients that support ECDSA.
-  repeated TlsCertificate tls_certificates = 2;
-
-  // Configs for fetching TLS certificates via SDS API.
-  repeated SdsSecretConfig tls_certificate_sds_secret_configs = 6
-      [(validate.rules).repeated = {max_items: 1}];
-
-  oneof validation_context_type {
-    // How to validate peer certificates.
-    CertificateValidationContext validation_context = 3;
-
-    // Config for fetching validation context via SDS API.
-    SdsSecretConfig validation_context_sds_secret_config = 7;
-
-    // Combined certificate validation context holds a default CertificateValidationContext
-    // and SDS config. When SDS server returns dynamic CertificateValidationContext, both dynamic
-    // and default CertificateValidationContext are merged into a new CertificateValidationContext
-    // for validation. This merge is done by Message::MergeFrom(), so dynamic
-    // CertificateValidationContext overwrites singular fields in default
-    // CertificateValidationContext, and concatenates repeated fields to default
-    // CertificateValidationContext, and logical OR is applied to boolean fields.
-    CombinedCertificateValidationContext combined_validation_context = 8;
-  }
-
-  // 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_api_field_config.filter.network.http_connection_manager.v2.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;
-}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/api/v2/cds.proto b/xds/third_party/envoy/src/main/proto/envoy/api/v2/cds.proto
deleted file mode 100644
index 0b657a0fa45..00000000000
--- a/xds/third_party/envoy/src/main/proto/envoy/api/v2/cds.proto
+++ /dev/null
@@ -1,43 +0,0 @@
-syntax = "proto3";
-
-package envoy.api.v2;
-
-import "envoy/api/v2/discovery.proto";
-
-import "google/api/annotations.proto";
-
-import "envoy/annotations/resource.proto";
-import "udpa/annotations/migrate.proto";
-import "udpa/annotations/status.proto";
-
-import public "envoy/api/v2/cluster.proto";
-
-option java_package = "io.envoyproxy.envoy.api.v2";
-option java_outer_classname = "CdsProto";
-option java_multiple_files = true;
-option java_generic_services = true;
-option (udpa.annotations.file_migrate).move_to_package = "envoy.service.cluster.v3";
-option (udpa.annotations.file_status).package_version_status = FROZEN;
-
-// [#protodoc-title: CDS]
-
-// Return list of all clusters this proxy will load balance to.
-service ClusterDiscoveryService {
-  option (envoy.annotations.resource).type = "envoy.api.v2.Cluster";
-
-  rpc StreamClusters(stream DiscoveryRequest) returns (stream DiscoveryResponse) {
-  }
-
-  rpc DeltaClusters(stream DeltaDiscoveryRequest) returns (stream DeltaDiscoveryResponse) {
-  }
-
-  rpc FetchClusters(DiscoveryRequest) returns (DiscoveryResponse) {
-    option (google.api.http).post = "/v2/discovery:clusters";
-    option (google.api.http).body = "*";
-  }
-}
-
-// [#not-implemented-hide:] Not configuration. Workaround c++ protobuf issue with importing
-// services: https://github.com/google/protobuf/issues/4221 and protoxform to upgrade the file.
-message CdsDummy {
-}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/api/v2/cluster.proto b/xds/third_party/envoy/src/main/proto/envoy/api/v2/cluster.proto
deleted file mode 100644
index fab95f71b76..00000000000
--- a/xds/third_party/envoy/src/main/proto/envoy/api/v2/cluster.proto
+++ /dev/null
@@ -1,867 +0,0 @@
-syntax = "proto3";
-
-package envoy.api.v2;
-
-import "envoy/api/v2/auth/tls.proto";
-import "envoy/api/v2/cluster/circuit_breaker.proto";
-import "envoy/api/v2/cluster/filter.proto";
-import "envoy/api/v2/cluster/outlier_detection.proto";
-import "envoy/api/v2/core/address.proto";
-import "envoy/api/v2/core/base.proto";
-import "envoy/api/v2/core/config_source.proto";
-import "envoy/api/v2/core/health_check.proto";
-import "envoy/api/v2/core/protocol.proto";
-import "envoy/api/v2/endpoint.proto";
-import "envoy/type/percent.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/migrate.proto";
-import "udpa/annotations/status.proto";
-import "validate/validate.proto";
-
-option java_package = "io.envoyproxy.envoy.api.v2";
-option java_outer_classname = "ClusterProto";
-option java_multiple_files = true;
-option (udpa.annotations.file_migrate).move_to_package = "envoy.config.cluster.v3";
-option (udpa.annotations.file_status).package_version_status = FROZEN;
-
-// [#protodoc-title: Cluster configuration]
-
-// Configuration for a single upstream cluster.
-// [#next-free-field: 48]
-message 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 {
-    // 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:`original destination load balancing
-    // policy<arch_overview_load_balancing_types_original_destination>`
-    // for an explanation.
-    //
-    // .. attention::
-    //
-    //   **This load balancing policy is deprecated**. Use CLUSTER_PROVIDED instead.
-    //
-    ORIGINAL_DST_LB = 4 [deprecated = true, (envoy.annotations.disallowed_by_default_enum) = true];
-
-    // 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;
-
-    // [#not-implemented-hide:] Use the new :ref:`load_balancing_policy
-    // <envoy_api_field_Cluster.load_balancing_policy>` field to determine the LB policy.
-    // [#next-major-version: In the v3 API, we should consider deprecating the lb_policy field
-    // and instead using the new load_balancing_policy field as the one and only mechanism for
-    // configuring this.]
-    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.
-  // For cluster types other than
-  // :ref:`STRICT_DNS<envoy_api_enum_value_Cluster.DiscoveryType.STRICT_DNS>` and
-  // :ref:`LOGICAL_DNS<envoy_api_enum_value_Cluster.DiscoveryType.LOGICAL_DNS>`,
-  // this setting is
-  // ignored.
-  enum DnsLookupFamily {
-    AUTO = 0;
-    V4_ONLY = 1;
-    V6_ONLY = 2;
-  }
-
-  enum ClusterProtocolSelection {
-    // Cluster can only operate on one of the possible upstream protocols (HTTP1.1, HTTP2).
-    // If :ref:`http2_protocol_options <envoy_api_field_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 {
-    // The name of the match, used in stats generation.
-    string name = 1 [(validate.rules).string = {min_len: 1}];
-
-    // Optional endpoint 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.
-    core.TransportSocket transport_socket = 3;
-  }
-
-  // Extended cluster type.
-  message CustomClusterType {
-    // The type of the cluster to instantiate. The name must match a supported cluster type.
-    string name = 1 [(validate.rules).string = {min_bytes: 1}];
-
-    // Cluster specific configuration which depends on the cluster being instantiated.
-    // See the supported cluster for further documentation.
-    google.protobuf.Any typed_config = 2;
-  }
-
-  // Only valid when discovery type is EDS.
-  message EdsClusterConfig {
-    // Configuration for the source of EDS updates for this Cluster.
-    core.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.
-    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: 8]
-  message 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;
-    }
-
-    // Specifications for subsets.
-    message 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_api_field_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;
-
-      // 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_api_field_Cluster.LbSubsetConfig.LbSubsetSelector.keys>` used by
-      // :ref:`KEYS_SUBSET<envoy_api_enum_value_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_api_field_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_api_enum_value_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_api_enum_value_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_api_enum_value_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;
-  }
-
-  // Specific configuration for the LeastRequest load balancing policy.
-  message 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}];
-  }
-
-  // Specific configuration for the :ref:`RingHash<arch_overview_load_balancing_types_ring_hash>`
-  // load balancing policy.
-  message 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_api_field_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_api_enum_value_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_api_field_Cluster.RingHashLbConfig.minimum_ring_size>`.
-    google.protobuf.UInt64Value maximum_ring_size = 4 [(validate.rules).uint64 = {lte: 8388608}];
-  }
-
-  // Specific configuration for the
-  // :ref:`Original Destination <arch_overview_load_balancing_types_original_destination>`
-  // load balancing policy.
-  message OriginalDstLbConfig {
-    // When true, :ref:`x-envoy-original-dst-host
-    // <config_http_conn_man_headers_x-envoy-original-dst-host>` can be used to override destination
-    // address.
-    //
-    // .. 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;
-  }
-
-  // Common configuration for all load balancer implementations.
-  // [#next-free-field: 8]
-  message CommonLbConfig {
-    // Configuration for :ref:`zone aware routing
-    // <arch_overview_load_balancing_zone_aware_routing>`.
-    message 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.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 {
-    }
-
-    // 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 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.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 not consider 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.
-    //
-    // Ignoring a host means that for any load balancing calculations that adjust weights based
-    // on the ratio of eligible hosts and total hosts (priority spillover, locality weighting and
-    // panic mode) Envoy will exclude these hosts in the denominator.
-    //
-    // For example, with hosts in two priorities P0 and P1, where P0 looks like
-    // {healthy, unhealthy (new), unhealthy (new)}
-    // and where P1 looks like
-    // {healthy, healthy}
-    // all traffic will still hit P0, as 1 / (3 - 2) = 1.
-    //
-    // Enabling this will allow scaling up the number of hosts for a given cluster without entering
-    // panic mode or triggering priority spillover, assuming the hosts pass the first health check.
-    //
-    // If panic mode is triggered, new hosts are still eligible for traffic; they simply do not
-    // contribute to the calculation when deciding whether panic mode is enabled or not.
-    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;
-  }
-
-  message RefreshRate {
-    // Specifies the base interval between refreshes. This parameter is required and must be greater
-    // than zero and less than
-    // :ref:`max_interval <envoy_api_field_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_api_field_Cluster.RefreshRate.base_interval>`  if set. The default
-    // is 10 times the :ref:`base_interval <envoy_api_field_Cluster.RefreshRate.base_interval>`.
-    google.protobuf.Duration max_interval = 2 [(validate.rules).duration = {gt {nanos: 1000000}}];
-  }
-
-  reserved 12, 15;
-
-  // Configuration to use different transport sockets for different endpoints.
-  // The entry of *envoy.transport_socket_match* in the
-  // :ref:`LbEndpoint.Metadata <envoy_api_field_endpoint.LbEndpoint.metadata>`
-  // is used to match against the transport sockets as they appear in the list. The first
-  // :ref:`match <envoy_api_msg_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_api_msg_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*, 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.
-  //
-  // [#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_api_field_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_bytes: 1}];
-
-  // An optional alternative to the cluster name to be used while emitting stats.
-  // 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;
-
-  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.
-  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;
-
-  // 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}];
-
-  // If the service discovery type is
-  // :ref:`STATIC<envoy_api_enum_value_Cluster.DiscoveryType.STATIC>`,
-  // :ref:`STRICT_DNS<envoy_api_enum_value_Cluster.DiscoveryType.STRICT_DNS>`
-  // or :ref:`LOGICAL_DNS<envoy_api_enum_value_Cluster.DiscoveryType.LOGICAL_DNS>`,
-  // then hosts is required.
-  //
-  // .. attention::
-  //
-  //   **This field is deprecated**. Set the
-  //   :ref:`load_assignment<envoy_api_field_Cluster.load_assignment>` field instead.
-  //
-  repeated core.Address hosts = 7 [deprecated = true];
-
-  // Setting this is required for specifying members of
-  // :ref:`STATIC<envoy_api_enum_value_Cluster.DiscoveryType.STATIC>`,
-  // :ref:`STRICT_DNS<envoy_api_enum_value_Cluster.DiscoveryType.STRICT_DNS>`
-  // or :ref:`LOGICAL_DNS<envoy_api_enum_value_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_api_msg_ClusterLoadAssignment>`.
-  //
-  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.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.
-  google.protobuf.UInt32Value max_requests_per_connection = 9;
-
-  // Optional :ref:`circuit breaking <arch_overview_circuit_break>` for the cluster.
-  cluster.CircuitBreakers circuit_breakers = 10;
-
-  // The TLS configuration for connections to the upstream cluster.
-  //
-  // .. attention::
-  //
-  //   **This field is deprecated**. Use `transport_socket` with name `tls` instead. If both are
-  //   set, `transport_socket` takes priority.
-  auth.UpstreamTlsContext tls_context = 11
-      [deprecated = true, (envoy.annotations.disallowed_by_default) = true];
-
-  // HTTP protocol options that are applied only to upstream HTTP connections.
-  // These options apply to all HTTP versions.
-  core.UpstreamHttpProtocolOptions upstream_http_protocol_options = 46;
-
-  // Additional options when handling HTTP requests upstream. These options will be applicable to
-  // both HTTP1 and HTTP2 requests.
-  core.HttpProtocolOptions common_http_protocol_options = 29;
-
-  // Additional options when handling HTTP1 requests.
-  core.Http1ProtocolOptions http_protocol_options = 13;
-
-  // 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.
-  core.Http2ProtocolOptions http2_protocol_options = 14;
-
-  // 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.
-  map<string, google.protobuf.Struct> extension_protocol_options = 35
-      [deprecated = true, (envoy.annotations.disallowed_by_default) = true];
-
-  // 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.
-  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_api_enum_value_Cluster.DiscoveryType.STRICT_DNS>`,
-  // or :ref:`LOGICAL_DNS<envoy_api_enum_value_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_api_enum_value_Cluster.DiscoveryType.STRICT_DNS>`
-  // and :ref:`LOGICAL_DNS<envoy_api_enum_value_Cluster.DiscoveryType.LOGICAL_DNS>`
-  // this setting is ignored.
-  google.protobuf.Duration dns_refresh_rate = 16
-      [(validate.rules).duration = {gt {nanos: 1000000}}];
-
-  // If the DNS failure refresh rate is specified and the cluster type is either
-  // :ref:`STRICT_DNS<envoy_api_enum_value_Cluster.DiscoveryType.STRICT_DNS>`,
-  // or :ref:`LOGICAL_DNS<envoy_api_enum_value_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_api_enum_value_Cluster.DiscoveryType.STRICT_DNS>` and
-  // :ref:`LOGICAL_DNS<envoy_api_enum_value_Cluster.DiscoveryType.LOGICAL_DNS>` this setting is
-  // ignored.
-  RefreshRate dns_failure_refresh_rate = 44;
-
-  // 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.
-  bool respect_dns_ttl = 39;
-
-  // The DNS IP address resolution policy. If this setting is not specified, the
-  // value defaults to
-  // :ref:`AUTO<envoy_api_enum_value_Cluster.DnsLookupFamily.AUTO>`.
-  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_api_enum_value_Cluster.DiscoveryType.STRICT_DNS>`,
-  // or :ref:`LOGICAL_DNS<envoy_api_enum_value_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_api_enum_value_Cluster.DiscoveryType.STRICT_DNS>`
-  // and :ref:`LOGICAL_DNS<envoy_api_enum_value_Cluster.DiscoveryType.LOGICAL_DNS>`
-  // this setting is ignored.
-  // Setting this value causes failure if the
-  // ``envoy.restart_features.use_apple_api_for_dns_lookups`` runtime value is true during
-  // server startup. Apple's API only allows overriding DNS resolvers via system settings.
-  repeated core.Address dns_resolvers = 18;
-
-  // [#next-major-version: Reconcile DNS options in a single message.]
-  // Always use TCP queries instead of UDP queries for DNS lookups.
-  // Setting this value causes failure if the
-  // ``envoy.restart_features.use_apple_api_for_dns_lookups`` runtime value is true during
-  // server startup. Apple' API only uses UDP for DNS resolution.
-  bool use_tcp_for_dns_lookups = 45;
-
-  // 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>`.
-  cluster.OutlierDetection outlier_detection = 19;
-
-  // The interval for removing stale hosts from a cluster type
-  // :ref:`ORIGINAL_DST<envoy_api_enum_value_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_api_enum_value_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.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_api_enum_value_Cluster.LbPolicy.RING_HASH>` and
-  // :ref:`LEAST_REQUEST<envoy_api_enum_value_Cluster.LbPolicy.LEAST_REQUEST>`
-  // has additional configuration options.
-  // Specifying ring_hash_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 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;
-  }
-
-  // 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 `tls` and
-  // :ref:`UpstreamTlsContexts <envoy_api_msg_auth.UpstreamTlsContext>` in the `typed_config`.
-  // If no transport socket configuration is specified, new connections
-  // will be set up with plaintext.
-  core.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.Metadata metadata = 25;
-
-  // Determines how Envoy selects the protocol used to speak to upstream hosts.
-  ClusterProtocolSelection protocol_selection = 26;
-
-  // 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 drain_connections_on_host_removal = 32
-      [(udpa.annotations.field_migrate).rename = "ignore_health_on_host_removal"];
-
-  // 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 cluster.Filter filters = 40;
-
-  // [#not-implemented-hide:] New mechanism for LB policy configuration. Used only if the
-  // :ref:`lb_policy<envoy_api_field_Cluster.lb_policy>` field has the value
-  // :ref:`LOAD_BALANCING_POLICY_CONFIG<envoy_api_enum_value_Cluster.LbPolicy.LOAD_BALANCING_POLICY_CONFIG>`.
-  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.ConfigSource lrs_server = 42;
-
-  // 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.
-  bool track_timeout_budgets = 47;
-}
-
-// [#not-implemented-hide:] 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 {
-  message Policy {
-    // Required. The name of the LB policy.
-    string name = 1;
-
-    // Optional config for the LB policy.
-    // No more than one of these two fields may be populated.
-    google.protobuf.Struct config = 2 [deprecated = true];
-
-    google.protobuf.Any typed_config = 3;
-  }
-
-  // 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;
-}
-
-// An extensible structure containing the address Envoy should bind to when
-// establishing upstream connections.
-message UpstreamBindConfig {
-  // The address Envoy should bind to when establishing upstream connections.
-  core.Address source_address = 1;
-}
-
-message UpstreamConnectionOptions {
-  // If set then set SO_KEEPALIVE on the socket to enable TCP Keepalives.
-  core.TcpKeepalive tcp_keepalive = 1;
-}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/api/v2/cluster/circuit_breaker.proto b/xds/third_party/envoy/src/main/proto/envoy/api/v2/cluster/circuit_breaker.proto
deleted file mode 100644
index 510619b2642..00000000000
--- a/xds/third_party/envoy/src/main/proto/envoy/api/v2/cluster/circuit_breaker.proto
+++ /dev/null
@@ -1,99 +0,0 @@
-syntax = "proto3";
-
-package envoy.api.v2.cluster;
-
-import "envoy/api/v2/core/base.proto";
-import "envoy/type/percent.proto";
-
-import "google/protobuf/wrappers.proto";
-
-import "udpa/annotations/migrate.proto";
-import "udpa/annotations/status.proto";
-import "validate/validate.proto";
-
-option java_package = "io.envoyproxy.envoy.api.v2.cluster";
-option java_outer_classname = "CircuitBreakerProto";
-option java_multiple_files = true;
-option csharp_namespace = "Envoy.Api.V2.ClusterNS";
-option ruby_package = "Envoy.Api.V2.ClusterNS";
-option (udpa.annotations.file_migrate).move_to_package = "envoy.config.cluster.v3";
-option (udpa.annotations.file_status).package_version_status = FROZEN;
-
-// [#protodoc-title: Circuit breakers]
-
-// :ref:`Circuit breaking<arch_overview_circuit_break>` settings can be
-// specified individually for each defined priority.
-message CircuitBreakers {
-  // A Thresholds defines CircuitBreaker settings for a
-  // :ref:`RoutingPriority<envoy_api_enum_core.RoutingPriority>`.
-  // [#next-free-field: 9]
-  message Thresholds {
-    message 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.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_api_enum_core.RoutingPriority>`
-    // the specified CircuitBreaker settings apply to.
-    core.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.
-    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.
-    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_api_msg_cluster.CircuitBreakers.Thresholds>`
-  // are defined with the same :ref:`RoutingPriority<envoy_api_enum_core.RoutingPriority>`,
-  // the first one in the list is used. If no Thresholds is defined for a given
-  // :ref:`RoutingPriority<envoy_api_enum_core.RoutingPriority>`, the default values
-  // are used.
-  repeated Thresholds thresholds = 1;
-}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/api/v2/cluster/filter.proto b/xds/third_party/envoy/src/main/proto/envoy/api/v2/cluster/filter.proto
deleted file mode 100644
index b87ad79d8f3..00000000000
--- a/xds/third_party/envoy/src/main/proto/envoy/api/v2/cluster/filter.proto
+++ /dev/null
@@ -1,30 +0,0 @@
-syntax = "proto3";
-
-package envoy.api.v2.cluster;
-
-import "google/protobuf/any.proto";
-
-import "udpa/annotations/migrate.proto";
-import "udpa/annotations/status.proto";
-import "validate/validate.proto";
-
-option java_package = "io.envoyproxy.envoy.api.v2.cluster";
-option java_outer_classname = "FilterProto";
-option java_multiple_files = true;
-option csharp_namespace = "Envoy.Api.V2.ClusterNS";
-option ruby_package = "Envoy.Api.V2.ClusterNS";
-option (udpa.annotations.file_migrate).move_to_package = "envoy.config.cluster.v3";
-option (udpa.annotations.file_status).package_version_status = FROZEN;
-
-// [#protodoc-title: Upstream filters]
-// Upstream filters apply to the connections to the upstream cluster hosts.
-
-message Filter {
-  // The name of the filter to instantiate. The name must match a
-  // :ref:`supported filter <config_network_filters>`.
-  string name = 1 [(validate.rules).string = {min_bytes: 1}];
-
-  // Filter specific configuration which depends on the filter being
-  // instantiated. See the supported filters for further documentation.
-  google.protobuf.Any typed_config = 2;
-}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/api/v2/cluster/outlier_detection.proto b/xds/third_party/envoy/src/main/proto/envoy/api/v2/cluster/outlier_detection.proto
deleted file mode 100644
index 6cf35e41ff1..00000000000
--- a/xds/third_party/envoy/src/main/proto/envoy/api/v2/cluster/outlier_detection.proto
+++ /dev/null
@@ -1,151 +0,0 @@
-syntax = "proto3";
-
-package envoy.api.v2.cluster;
-
-import "google/protobuf/duration.proto";
-import "google/protobuf/wrappers.proto";
-
-import "udpa/annotations/migrate.proto";
-import "udpa/annotations/status.proto";
-import "validate/validate.proto";
-
-option java_package = "io.envoyproxy.envoy.api.v2.cluster";
-option java_outer_classname = "OutlierDetectionProto";
-option java_multiple_files = true;
-option csharp_namespace = "Envoy.Api.V2.ClusterNS";
-option ruby_package = "Envoy.Api.V2.ClusterNS";
-option (udpa.annotations.file_migrate).move_to_package = "envoy.config.cluster.v3";
-option (udpa.annotations.file_status).package_version_status = FROZEN;
-
-// [#protodoc-title: Outlier detection]
-
-// See the :ref:`architecture overview <arch_overview_outlier_detection>` for
-// more information on outlier detection.
-// [#next-free-field: 21]
-message OutlierDetection {
-  // The number of consecutive 5xx responses or local origin errors that are mapped
-  // to 5xx error codes 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.
-  // 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% but will eject at least one host regardless of the value.
-  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_api_field_cluster.OutlierDetection.consecutive_local_origin_failure>`,
-  // :ref:`enforcing_consecutive_local_origin_failure<envoy_api_field_cluster.OutlierDetection.enforcing_consecutive_local_origin_failure>`
-  // and
-  // :ref:`enforcing_local_origin_success_rate<envoy_api_field_cluster.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_api_field_cluster.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_api_field_cluster.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_api_field_cluster.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;
-}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/api/v2/core/address.proto b/xds/third_party/envoy/src/main/proto/envoy/api/v2/core/address.proto
deleted file mode 100644
index 804da539583..00000000000
--- a/xds/third_party/envoy/src/main/proto/envoy/api/v2/core/address.proto
+++ /dev/null
@@ -1,134 +0,0 @@
-syntax = "proto3";
-
-package envoy.api.v2.core;
-
-import "envoy/api/v2/core/socket_option.proto";
-
-import "google/protobuf/wrappers.proto";
-
-import "udpa/annotations/migrate.proto";
-import "udpa/annotations/status.proto";
-import "validate/validate.proto";
-
-option java_package = "io.envoyproxy.envoy.api.v2.core";
-option java_outer_classname = "AddressProto";
-option java_multiple_files = true;
-option (udpa.annotations.file_migrate).move_to_package = "envoy.config.core.v3";
-option (udpa.annotations.file_status).package_version_status = FROZEN;
-
-// [#protodoc-title: Network addresses]
-
-message 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_bytes: 1}];
-
-  // The mode for the Pipe. Not applicable for abstract sockets.
-  uint32 mode = 2 [(validate.rules).uint32 = {lte: 511}];
-}
-
-// [#next-free-field: 7]
-message 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_api_msg_listener.FilterChainMatch>`.] When used
-  // within an upstream :ref:`BindConfig <envoy_api_msg_core.BindConfig>`, the address
-  // controls the source address of outbound connections. For :ref:`clusters
-  // <envoy_api_msg_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_api_field_core.SocketAddress.resolver_name>`.
-  string address = 2 [(validate.rules).string = {min_bytes: 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_api_field_core.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;
-}
-
-message 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 BindConfig {
-  // The address to bind to when creating a socket.
-  SocketAddress source_address = 1 [(validate.rules).message = {required: true}];
-
-  // Whether to set the *IP_FREEBIND* option when creating the socket. When this
-  // flag is set to true, allows the :ref:`source_address
-  // <envoy_api_field_UpstreamBindConfig.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;
-}
-
-// 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 {
-  oneof address {
-    option (validate.required) = true;
-
-    SocketAddress socket_address = 1;
-
-    Pipe pipe = 2;
-  }
-}
-
-// 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_bytes: 1}];
-
-  // Length of prefix, e.g. 0, 32.
-  google.protobuf.UInt32Value prefix_len = 2 [(validate.rules).uint32 = {lte: 128}];
-}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/api/v2/core/backoff.proto b/xds/third_party/envoy/src/main/proto/envoy/api/v2/core/backoff.proto
deleted file mode 100644
index e45c71e39be..00000000000
--- a/xds/third_party/envoy/src/main/proto/envoy/api/v2/core/backoff.proto
+++ /dev/null
@@ -1,35 +0,0 @@
-syntax = "proto3";
-
-package envoy.api.v2.core;
-
-import "google/protobuf/duration.proto";
-
-import "udpa/annotations/migrate.proto";
-import "udpa/annotations/status.proto";
-import "validate/validate.proto";
-
-option java_package = "io.envoyproxy.envoy.api.v2.core";
-option java_outer_classname = "BackoffProto";
-option java_multiple_files = true;
-option (udpa.annotations.file_migrate).move_to_package = "envoy.config.core.v3";
-option (udpa.annotations.file_status).package_version_status = FROZEN;
-
-// [#protodoc-title: Backoff Strategy]
-
-// Configuration defining a jittered exponential back off strategy.
-message 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_api_field_core.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_api_field_core.BackoffStrategy.base_interval>` if set. The default
-  // is 10 times the :ref:`base_interval
-  // <envoy_api_field_core.BackoffStrategy.base_interval>`.
-  google.protobuf.Duration max_interval = 2 [(validate.rules).duration = {gt {}}];
-}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/api/v2/core/base.proto b/xds/third_party/envoy/src/main/proto/envoy/api/v2/core/base.proto
deleted file mode 100644
index 32cd90b4ee1..00000000000
--- a/xds/third_party/envoy/src/main/proto/envoy/api/v2/core/base.proto
+++ /dev/null
@@ -1,381 +0,0 @@
-syntax = "proto3";
-
-package envoy.api.v2.core;
-
-import "envoy/api/v2/core/address.proto";
-import "envoy/api/v2/core/backoff.proto";
-import "envoy/api/v2/core/http_uri.proto";
-import "envoy/type/percent.proto";
-import "envoy/type/semantic_version.proto";
-
-import "google/protobuf/any.proto";
-import "google/protobuf/struct.proto";
-import "google/protobuf/wrappers.proto";
-
-import "udpa/annotations/migrate.proto";
-import "udpa/annotations/status.proto";
-import "validate/validate.proto";
-
-import public "envoy/api/v2/core/socket_option.proto";
-
-option java_package = "io.envoyproxy.envoy.api.v2.core";
-option java_outer_classname = "BaseProto";
-option java_multiple_files = true;
-option (udpa.annotations.file_migrate).move_to_package = "envoy.config.core.v3";
-option (udpa.annotations.file_status).package_version_status = FROZEN;
-
-// [#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 {
-  // Region this :ref:`zone <envoy_api_field_core.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_api_field_endpoint.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 {
-  // SemVer version of extension.
-  type.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: 6]
-message 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;
-
-  // 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;
-}
-
-// 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: 12]
-message Node {
-  // 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_api_field_core.HealthCheck.HttpHealthCheck.service_name_matcher>`,
-  // :ref:`runtime override directory <envoy_api_msg_config.bootstrap.v2.Runtime>`,
-  // :ref:`user agent addition
-  // <envoy_api_field_config.filter.network.http_connection_manager.v2.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;
-
-  // Locality specifying where the Envoy instance is running.
-  Locality locality = 4;
-
-  // This is motivated by informing a management server during canary which
-  // version of Envoy is being tested in a heterogeneous fleet. This will be set
-  // by Envoy in management server RPCs.
-  // This field is deprecated in favor of the user_agent_name and user_agent_version values.
-  string build_version = 5 [deprecated = true];
-
-  // 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;
-}
-
-// 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 {
-  // Key is the reverse DNS filter name, e.g. com.acme.widget. The envoy.*
-  // namespace is reserved for Envoy's built-in filters.
-  map<string, google.protobuf.Struct> filter_metadata = 1;
-}
-
-// Runtime derived uint32 with a default when not specified.
-message 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 [(validate.rules).string = {min_bytes: 1}];
-}
-
-// Runtime derived double with a default when not specified.
-message 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 [(validate.rules).string = {min_bytes: 1}];
-}
-
-// Runtime derived bool with a default when not specified.
-message 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 [(validate.rules).string = {min_bytes: 1}];
-}
-
-// Header name/value pair.
-message HeaderValue {
-  // Header name.
-  string key = 1
-      [(validate.rules).string =
-           {min_bytes: 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 `-`.
-  string value = 2 [
-    (validate.rules).string = {max_bytes: 16384 well_known_regex: HTTP_HEADER_VALUE strict: false}
-  ];
-}
-
-// Header name/value pair plus option to control append behavior.
-message HeaderValueOption {
-  // 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.
-  google.protobuf.BoolValue append = 2;
-}
-
-// Wrapper for a set of headers.
-message HeaderMap {
-  repeated HeaderValue headers = 1;
-}
-
-// Data source consisting of either a file or an inline value.
-message DataSource {
-  oneof specifier {
-    option (validate.required) = true;
-
-    // Local filesystem data source.
-    string filename = 1 [(validate.rules).string = {min_bytes: 1}];
-
-    // Bytes inlined in the configuration.
-    bytes inline_bytes = 2 [(validate.rules).bytes = {min_len: 1}];
-
-    // String inlined in the configuration.
-    string inline_string = 3 [(validate.rules).string = {min_bytes: 1}];
-  }
-}
-
-// The message specifies the retry policy of remote data source when fetching fails.
-message RetryPolicy {
-  // Specifies parameters that control :ref:`retry backoff strategy <envoy_api_msg_core.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;
-}
-
-// The message specifies how to fetch data from remote and how to verify it.
-message 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_bytes: 1}];
-
-  // Retry policy for fetching remote data.
-  RetryPolicy retry_policy = 3;
-}
-
-// Async data source which support async data fetch.
-message 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_api_msg_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 {
-  // The name of the transport socket to instantiate. The name must match a supported transport
-  // socket implementation.
-  string name = 1 [(validate.rules).string = {min_bytes: 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.Struct config = 2 [deprecated = true];
-
-    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_api_msg_type.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 {
-  // Default value if the runtime value's for the numerator/denominator keys are not available.
-  type.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 {
-  // 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/api/v2/core/config_source.proto b/xds/third_party/envoy/src/main/proto/envoy/api/v2/core/config_source.proto
deleted file mode 100644
index 6cf44dbe9bb..00000000000
--- a/xds/third_party/envoy/src/main/proto/envoy/api/v2/core/config_source.proto
+++ /dev/null
@@ -1,185 +0,0 @@
-syntax = "proto3";
-
-package envoy.api.v2.core;
-
-import "envoy/api/v2/core/grpc_service.proto";
-
-import "google/protobuf/duration.proto";
-import "google/protobuf/wrappers.proto";
-
-import "envoy/annotations/deprecation.proto";
-import "udpa/annotations/migrate.proto";
-import "udpa/annotations/status.proto";
-import "validate/validate.proto";
-
-option java_package = "io.envoyproxy.envoy.api.v2.core";
-option java_outer_classname = "ConfigSourceProto";
-option java_multiple_files = true;
-option (udpa.annotations.file_migrate).move_to_package = "envoy.config.core.v3";
-option (udpa.annotations.file_status).package_version_status = FROZEN;
-
-// [#protodoc-title: Configuration sources]
-
-// xDS API version. This is used to describe both resource and transport
-// protocol versions (in distinct configuration fields).
-enum ApiVersion {
-  // When not specified, we assume v2, to ease migration to Envoy's stable API
-  // versioning. If a client does not support v2 (e.g. due to deprecation), this
-  // is an invalid value.
-  AUTO = 0 [deprecated = true];
-
-  // Use xDS v2 API.
-  V2 = 1 [deprecated = true];
-
-  // 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: 9]
-message 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.
-    UNSUPPORTED_REST_LEGACY = 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;
-
-    // gRPC v2 API.
-    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;
-  }
-
-  // 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;
-}
-
-// Aggregated Discovery Service (ADS) options. This is currently empty, but when
-// set in :ref:`ConfigSource <envoy_api_msg_core.ConfigSource>` can be used to
-// specify that ADS is to be used.
-message AggregatedConfigSource {
-}
-
-// [#not-implemented-hide:]
-// Self-referencing config source options. This is currently empty, but when
-// set in :ref:`ConfigSource <envoy_api_msg_core.ConfigSource>` can be used to
-// specify that other data can be obtained from the same server.
-message 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 {
-  // 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.
-  google.protobuf.DoubleValue fill_rate = 2 [(validate.rules).double = {gt: 0.0}];
-}
-
-// Configuration for :ref:`listeners <config_listeners>`, :ref:`clusters
-// <config_cluster_manager>`, :ref:`routes
-// <envoy_api_msg_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: 7]
-message ConfigSource {
-  oneof config_source_specifier {
-    option (validate.required) = true;
-
-    // Path on the filesystem to source and watch for configuration updates.
-    // When sourcing configuration for :ref:`secret <envoy_api_msg_auth.Secret>`,
-    // the certificate and key files are also watched for updates.
-    //
-    // .. note::
-    //
-    //  The path to the source must exist at config load time.
-    //
-    // .. note::
-    //
-    //   Envoy will only 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.
-    string path = 1;
-
-    // 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_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}];
-}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/api/v2/core/event_service_config.proto b/xds/third_party/envoy/src/main/proto/envoy/api/v2/core/event_service_config.proto
deleted file mode 100644
index f822f8c6b63..00000000000
--- a/xds/third_party/envoy/src/main/proto/envoy/api/v2/core/event_service_config.proto
+++ /dev/null
@@ -1,26 +0,0 @@
-syntax = "proto3";
-
-package envoy.api.v2.core;
-
-import "envoy/api/v2/core/grpc_service.proto";
-
-import "udpa/annotations/migrate.proto";
-import "udpa/annotations/status.proto";
-import "validate/validate.proto";
-
-option java_package = "io.envoyproxy.envoy.api.v2.core";
-option java_outer_classname = "EventServiceConfigProto";
-option java_multiple_files = true;
-option (udpa.annotations.file_migrate).move_to_package = "envoy.config.core.v3";
-option (udpa.annotations.file_status).package_version_status = FROZEN;
-
-// [#not-implemented-hide:]
-// Configuration of the event reporting service endpoint.
-message 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/api/v2/core/grpc_service.proto b/xds/third_party/envoy/src/main/proto/envoy/api/v2/core/grpc_service.proto
deleted file mode 100644
index dd789644e1d..00000000000
--- a/xds/third_party/envoy/src/main/proto/envoy/api/v2/core/grpc_service.proto
+++ /dev/null
@@ -1,227 +0,0 @@
-syntax = "proto3";
-
-package envoy.api.v2.core;
-
-import "envoy/api/v2/core/base.proto";
-
-import "google/protobuf/any.proto";
-import "google/protobuf/duration.proto";
-import "google/protobuf/empty.proto";
-import "google/protobuf/struct.proto";
-
-import "udpa/annotations/migrate.proto";
-import "udpa/annotations/sensitive.proto";
-import "udpa/annotations/status.proto";
-import "validate/validate.proto";
-
-option java_package = "io.envoyproxy.envoy.api.v2.core";
-option java_outer_classname = "GrpcServiceProto";
-option java_multiple_files = true;
-option (udpa.annotations.file_migrate).move_to_package = "envoy.config.core.v3";
-option (udpa.annotations.file_status).package_version_status = FROZEN;
-
-// [#protodoc-title: gRPC services]
-
-// gRPC service configuration. This is used by :ref:`ApiConfigSource
-// <envoy_api_msg_core.ApiConfigSource>` and filter configurations.
-// [#next-free-field: 6]
-message GrpcService {
-  message EnvoyGrpc {
-    // The name of the upstream gRPC cluster. SSL credentials will be supplied
-    // in the :ref:`Cluster <envoy_api_msg_Cluster>` :ref:`transport_socket
-    // <envoy_api_field_Cluster.transport_socket>`.
-    string cluster_name = 1 [(validate.rules).string = {min_bytes: 1}];
-  }
-
-  // [#next-free-field: 7]
-  message GoogleGrpc {
-    // See https://grpc.io/grpc/cpp/structgrpc_1_1_ssl_credentials_options.html.
-    message 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 {
-    }
-
-    // See https://grpc.io/docs/guides/auth.html#credential-types to understand Channel and Call
-    // credential types.
-    message 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 {
-      message ServiceAccountJWTAccessCredentials {
-        string json_key = 1;
-
-        uint64 token_lifetime_seconds = 2;
-      }
-
-      message GoogleIAMCredentials {
-        string authorization_token = 1;
-
-        string authority_selector = 2;
-      }
-
-      message MetadataCredentialsFromPlugin {
-        string name = 1;
-
-        oneof config_type {
-          google.protobuf.Struct config = 2 [deprecated = true];
-
-          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 {
-        // URI of the token exchange service that handles token exchange requests.
-        // [#comment:TODO(asraa): Add URI validation when implemented. Tracked by
-        // https://github.com/envoyproxy/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_bytes: 1}];
-
-        // Type of the subject token.
-        string subject_token_type = 7 [(validate.rules).string = {min_bytes: 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;
-      }
-    }
-
-    // The target URI when using the `Google C++ gRPC client
-    // <https://github.com/grpc/grpc>`_. SSL credentials will be supplied in
-    // :ref:`channel_credentials <envoy_api_field_core.GrpcService.GoogleGrpc.channel_credentials>`.
-    string target_uri = 1 [(validate.rules).string = {min_bytes: 1}];
-
-    ChannelCredentials channel_credentials = 2;
-
-    // A set of call credentials that can be composed with `channel credentials
-    // <https://grpc.io/docs/guides/auth.html#credential-types>`_.
-    repeated CallCredentials call_credentials = 3;
-
-    // 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_bytes: 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;
-  }
-
-  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.
-  repeated HeaderValue initial_metadata = 5;
-}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/api/v2/core/health_check.proto b/xds/third_party/envoy/src/main/proto/envoy/api/v2/core/health_check.proto
deleted file mode 100644
index bc4ae3e5c86..00000000000
--- a/xds/third_party/envoy/src/main/proto/envoy/api/v2/core/health_check.proto
+++ /dev/null
@@ -1,308 +0,0 @@
-syntax = "proto3";
-
-package envoy.api.v2.core;
-
-import "envoy/api/v2/core/base.proto";
-import "envoy/api/v2/core/event_service_config.proto";
-import "envoy/type/http.proto";
-import "envoy/type/matcher/string.proto";
-import "envoy/type/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/migrate.proto";
-import "udpa/annotations/status.proto";
-import "validate/validate.proto";
-
-option java_package = "io.envoyproxy.envoy.api.v2.core";
-option java_outer_classname = "HealthCheckProto";
-option java_multiple_files = true;
-option (udpa.annotations.file_migrate).move_to_package = "envoy.config.core.v3";
-option (udpa.annotations.file_status).package_version_status = FROZEN;
-
-// [#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;
-}
-
-// [#next-free-field: 23]
-message HealthCheck {
-  // Describes the encoding of the payload bytes in the payload.
-  message Payload {
-    oneof payload {
-      option (validate.required) = true;
-
-      // Hex encoded payload. E.g., "000000FF".
-      string text = 1 [(validate.rules).string = {min_bytes: 1}];
-
-      // [#not-implemented-hide:] Binary payload.
-      bytes binary = 2;
-    }
-  }
-
-  // [#next-free-field: 12]
-  message HttpHealthCheck {
-    // 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_api_field_endpoint.Endpoint.HealthCheckConfig.hostname>` field.
-    string host = 1;
-
-    // Specifies the HTTP path that will be requested during health checking. For example
-    // */healthcheck*.
-    string path = 2 [(validate.rules).string = {min_bytes: 1}];
-
-    // [#not-implemented-hide:] HTTP specific payload.
-    Payload send = 3;
-
-    // [#not-implemented-hide:] HTTP specific response.
-    Payload receive = 4;
-
-    // An optional service name parameter which is used to validate the identity of
-    // the health checked cluster. See the :ref:`architecture overview
-    // <arch_overview_health_checking_identity>` for more information.
-    //
-    // .. attention::
-    //
-    //   This field has been deprecated in favor of `service_name_matcher` for better flexibility
-    //   over matching with service-cluster name.
-    string service_name = 5 [deprecated = true];
-
-    // 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;
-
-    // If set, health checks will be made using http/2.
-    // Deprecated, use :ref:`codec_client_type
-    // <envoy_api_field_core.HealthCheck.HttpHealthCheck.codec_client_type>` instead.
-    bool use_http2 = 7 [deprecated = true, (envoy.annotations.disallowed_by_default) = true];
-
-    // 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_api_msg_type.Int64Range>`. The start and end of each
-    // range are required. Only statuses in the range [100, 600) are allowed.
-    repeated type.Int64Range expected_statuses = 9;
-
-    // Use specified application protocol for health checks.
-    type.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_api_msg_type.matcher.StringMatcher>`. See the :ref:`architecture overview
-    // <arch_overview_health_checking_identity>` for more information.
-    type.matcher.StringMatcher service_name_matcher = 11;
-  }
-
-  message TcpHealthCheck {
-    // Empty payloads imply a connect-only health check.
-    Payload send = 1;
-
-    // When checking the response, “fuzzy” matching is performed such that each
-    // binary block must be found, and in the order specified, but not
-    // necessarily contiguous.
-    repeated Payload receive = 2;
-  }
-
-  message 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 {
-    // 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_api_field_endpoint.Endpoint.HealthCheckConfig.hostname>` field.
-    string authority = 2;
-  }
-
-  // Custom health check.
-  message CustomHealthCheck {
-    // The registered name of the custom health checker.
-    string name = 1 [(validate.rules).string = {min_bytes: 1}];
-
-    // A custom health checker specific configuration which depends on the custom health checker
-    // being instantiated. See :api:`envoy/config/health_checker` for reference.
-    oneof config_type {
-      google.protobuf.Struct config = 2 [deprecated = true];
-
-      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 {
-    // Specifies the ALPN protocols for health check connections. This is useful if the
-    // corresponding upstream is using ALPN-based :ref:`FilterChainMatch
-    // <envoy_api_msg_listener.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 503
-  // this threshold is ignored and the host is considered unhealthy immediately.
-  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 "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>`.
-  // If empty, no event log will be written.
-  string event_log_path = 17;
-
-  // [#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;
-
-  // This allows overriding the cluster TLS settings, just for health check connections.
-  TlsOptions tls_options = 21;
-}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/api/v2/core/http_uri.proto b/xds/third_party/envoy/src/main/proto/envoy/api/v2/core/http_uri.proto
deleted file mode 100644
index cd1a0660e33..00000000000
--- a/xds/third_party/envoy/src/main/proto/envoy/api/v2/core/http_uri.proto
+++ /dev/null
@@ -1,55 +0,0 @@
-syntax = "proto3";
-
-package envoy.api.v2.core;
-
-import "google/protobuf/duration.proto";
-
-import "udpa/annotations/migrate.proto";
-import "udpa/annotations/status.proto";
-import "validate/validate.proto";
-
-option java_package = "io.envoyproxy.envoy.api.v2.core";
-option java_outer_classname = "HttpUriProto";
-option java_multiple_files = true;
-option (udpa.annotations.file_migrate).move_to_package = "envoy.config.core.v3";
-option (udpa.annotations.file_status).package_version_status = FROZEN;
-
-// [#protodoc-title: HTTP Service URI ]
-
-// Envoy external URI descriptor
-message 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_bytes: 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_bytes: 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
-    gte {}
-  }];
-}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/api/v2/core/protocol.proto b/xds/third_party/envoy/src/main/proto/envoy/api/v2/core/protocol.proto
deleted file mode 100644
index ae1a86424cf..00000000000
--- a/xds/third_party/envoy/src/main/proto/envoy/api/v2/core/protocol.proto
+++ /dev/null
@@ -1,297 +0,0 @@
-syntax = "proto3";
-
-package envoy.api.v2.core;
-
-import "google/protobuf/duration.proto";
-import "google/protobuf/wrappers.proto";
-
-import "udpa/annotations/migrate.proto";
-import "udpa/annotations/status.proto";
-import "validate/validate.proto";
-
-option java_package = "io.envoyproxy.envoy.api.v2.core";
-option java_outer_classname = "ProtocolProto";
-option java_multiple_files = true;
-option (udpa.annotations.file_migrate).move_to_package = "envoy.config.core.v3";
-option (udpa.annotations.file_status).package_version_status = FROZEN;
-
-// [#protodoc-title: Protocol options]
-
-// [#not-implemented-hide:]
-message TcpProtocolOptions {
-}
-
-message 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, as seen by the
-  // :ref:`router filter <config_http_filters_router>`.
-  bool auto_sni = 1;
-
-  // Automatic validate upstream presented certificate for new upstream connections based on the
-  // downstream HTTP host/authority header, as seen by the
-  // :ref:`router filter <config_http_filters_router>`.
-  // This field is intended to set with `auto_sni` field.
-  bool auto_san_validation = 2;
-}
-
-// [#next-free-field: 6]
-message 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 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_api_field_config.filter.network.http_connection_manager.v2.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.
-  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 connection will be closed. Drain sequence will occur prior to closing the connection if
-  // if's applicable. See :ref:`drain_timeout
-  // <envoy_api_field_config.filter.network.http_connection_manager.v2.HttpConnectionManager.drain_timeout>`.
-  // Note: not implemented for upstream connections.
-  google.protobuf.Duration max_connection_duration = 3;
-
-  // The maximum number of headers. If unconfigured, the default
-  // maximum number of request headers allowed is 100. Requests that exceed this limit will receive
-  // a 431 response for HTTP/1.x and cause a stream reset for HTTP/2.
-  google.protobuf.UInt32Value max_headers_count = 2 [(validate.rules).uint32 = {gte: 1}];
-
-  // 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.
-  HeadersWithUnderscoresAction headers_with_underscores_action = 5;
-}
-
-// [#next-free-field: 6]
-message Http1ProtocolOptions {
-  message HeaderKeyFormat {
-    message 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;
-    }
-  }
-
-  // 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;
-}
-
-// [#next-free-field: 14]
-message 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 {
-    // The 16 bit parameter identifier.
-    google.protobuf.UInt32Value identifier = 1 [
-      (validate.rules).uint32 = {lte: 65536 gte: 1},
-      (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 2147483647.
-  //
-  // 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).
-  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 268435456
-  // (256 * 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. Currently, this has the same minimum/maximum/default as *initial_stream_window_size*.
-  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 metadata. 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.
-  // [#comment:TODO: implement same limits for upstream outbound frames as well.]
-  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.
-  // [#comment:TODO: implement same limits for upstream outbound frames as well.]
-  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.
-  // [#comment:TODO: implement same limits for upstream inbound frames as well.]
-  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 + inbound_streams)
-  //
-  // the connection is terminated. The ``http2.inbound_priority_frames_flood`` stat tracks
-  // the number of connections terminated due to flood mitigation. The default limit is 100.
-  // [#comment:TODO: implement same limits for upstream inbound frames as well.]
-  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::
-  //
-  //     1 + 2 * (inbound_streams +
-  //              max_inbound_window_update_frames_per_data_frame_sent * outbound_data_frames)
-  //
-  // the connection is terminated. The ``http2.inbound_priority_frames_flood`` stat tracks
-  // the number of connections terminated due to flood mitigation. The default limit 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.
-  // [#comment:TODO: implement same limits for upstream inbound frames as well.]
-  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.
-  //
-  // See `RFC7540, sec. 8.1 <https://tools.ietf.org/html/rfc7540#section-8.1>`_ for details.
-  bool stream_error_on_invalid_http_messaging = 12;
-
-  // [#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;
-}
-
-// [#not-implemented-hide:]
-message GrpcProtocolOptions {
-  Http2ProtocolOptions http2_protocol_options = 1;
-}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/api/v2/core/socket_option.proto b/xds/third_party/envoy/src/main/proto/envoy/api/v2/core/socket_option.proto
deleted file mode 100644
index 39678ad1b8b..00000000000
--- a/xds/third_party/envoy/src/main/proto/envoy/api/v2/core/socket_option.proto
+++ /dev/null
@@ -1,55 +0,0 @@
-syntax = "proto3";
-
-package envoy.api.v2.core;
-
-import "udpa/annotations/migrate.proto";
-import "udpa/annotations/status.proto";
-import "validate/validate.proto";
-
-option java_package = "io.envoyproxy.envoy.api.v2.core";
-option java_outer_classname = "SocketOptionProto";
-option java_multiple_files = true;
-option (udpa.annotations.file_migrate).move_to_package = "envoy.config.core.v3";
-option (udpa.annotations.file_status).package_version_status = FROZEN;
-
-// [#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.
-// [#next-free-field: 7]
-message 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;
-  }
-
-  // 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}];
-}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/api/v2/discovery.proto b/xds/third_party/envoy/src/main/proto/envoy/api/v2/discovery.proto
deleted file mode 100644
index da2690f867f..00000000000
--- a/xds/third_party/envoy/src/main/proto/envoy/api/v2/discovery.proto
+++ /dev/null
@@ -1,234 +0,0 @@
-syntax = "proto3";
-
-package envoy.api.v2;
-
-import "envoy/api/v2/core/base.proto";
-
-import "google/protobuf/any.proto";
-import "google/rpc/status.proto";
-
-import "udpa/annotations/migrate.proto";
-import "udpa/annotations/status.proto";
-
-option java_package = "io.envoyproxy.envoy.api.v2";
-option java_outer_classname = "DiscoveryProto";
-option java_multiple_files = true;
-option (udpa.annotations.file_migrate).move_to_package = "envoy.service.discovery.v3";
-option (udpa.annotations.file_status).package_version_status = FROZEN;
-
-// [#protodoc-title: Common discovery API components]
-
-// A DiscoveryRequest requests a set of versioned resources of the same type for
-// a given Envoy node on some API.
-// [#next-free-field: 7]
-message 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.
-  core.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;
-
-  // 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 1) this is a non-persistent-stream xDS such as HTTP,
-  // or 2) 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_api_msg_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: 7]
-message 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;
-
-  // [#not-implemented-hide:]
-  // The control plane instance that sent the response.
-  core.ControlPlane control_plane = 6;
-}
-
-// 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: [1] informing the server of what resources the
-// client has gained/lost interest in (using resource_names_subscribe and
-// resource_names_unsubscribe), or [2] (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: 8]
-message DeltaDiscoveryRequest {
-  // The node making the request.
-  core.Node node = 1;
-
-  // Type of the resource that is being requested, e.g.
-  // "type.googleapis.com/envoy.api.v2.ClusterLoadAssignment".
-  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;
-
-  // 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: [1] in the very first stream of a session, since the client will
-  // not yet have any resources,  [2] 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_api_msg_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: 7]
-message 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;
-
-  // Resources names of resources that have be deleted and to be removed from the xDS Client.
-  // Removed resources for missing resources can be ignored.
-  repeated string removed_resources = 6;
-
-  // The nonce provides a way for DeltaDiscoveryRequests to uniquely
-  // reference a DeltaDiscoveryResponse when (N)ACKing. The nonce is required.
-  string nonce = 5;
-}
-
-message Resource {
-  // The resource's name, to distinguish it from others of the same type of resource.
-  string name = 3;
-
-  // 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;
-}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/api/v2/eds.proto b/xds/third_party/envoy/src/main/proto/envoy/api/v2/eds.proto
deleted file mode 100644
index d757f17fc2f..00000000000
--- a/xds/third_party/envoy/src/main/proto/envoy/api/v2/eds.proto
+++ /dev/null
@@ -1,45 +0,0 @@
-syntax = "proto3";
-
-package envoy.api.v2;
-
-import "envoy/api/v2/discovery.proto";
-
-import "google/api/annotations.proto";
-
-import "envoy/annotations/resource.proto";
-import "udpa/annotations/migrate.proto";
-import "udpa/annotations/status.proto";
-
-import public "envoy/api/v2/endpoint.proto";
-
-option java_package = "io.envoyproxy.envoy.api.v2";
-option java_outer_classname = "EdsProto";
-option java_multiple_files = true;
-option java_generic_services = true;
-option (udpa.annotations.file_migrate).move_to_package = "envoy.service.endpoint.v3";
-option (udpa.annotations.file_status).package_version_status = FROZEN;
-
-// [#protodoc-title: EDS]
-// Endpoint discovery :ref:`architecture overview <arch_overview_service_discovery_types_eds>`
-
-service EndpointDiscoveryService {
-  option (envoy.annotations.resource).type = "envoy.api.v2.ClusterLoadAssignment";
-
-  // The resource_names field in DiscoveryRequest specifies a list of clusters
-  // to subscribe to updates for.
-  rpc StreamEndpoints(stream DiscoveryRequest) returns (stream DiscoveryResponse) {
-  }
-
-  rpc DeltaEndpoints(stream DeltaDiscoveryRequest) returns (stream DeltaDiscoveryResponse) {
-  }
-
-  rpc FetchEndpoints(DiscoveryRequest) returns (DiscoveryResponse) {
-    option (google.api.http).post = "/v2/discovery:endpoints";
-    option (google.api.http).body = "*";
-  }
-}
-
-// [#not-implemented-hide:] Not configuration. Workaround c++ protobuf issue with importing
-// services: https://github.com/google/protobuf/issues/4221 and protoxform to upgrade the file.
-message EdsDummy {
-}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/api/v2/endpoint.proto b/xds/third_party/envoy/src/main/proto/envoy/api/v2/endpoint.proto
deleted file mode 100644
index 70bac3c6c4f..00000000000
--- a/xds/third_party/envoy/src/main/proto/envoy/api/v2/endpoint.proto
+++ /dev/null
@@ -1,119 +0,0 @@
-syntax = "proto3";
-
-package envoy.api.v2;
-
-import "envoy/api/v2/endpoint/endpoint_components.proto";
-import "envoy/type/percent.proto";
-
-import "google/protobuf/duration.proto";
-import "google/protobuf/wrappers.proto";
-
-import "udpa/annotations/migrate.proto";
-import "udpa/annotations/status.proto";
-import "validate/validate.proto";
-
-option java_package = "io.envoyproxy.envoy.api.v2";
-option java_outer_classname = "EndpointProto";
-option java_multiple_files = true;
-option (udpa.annotations.file_migrate).move_to_package = "envoy.config.endpoint.v3";
-option (udpa.annotations.file_status).package_version_status = FROZEN;
-
-// [#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 {
-  // Load balancing policy settings.
-  // [#next-free-field: 6]
-  message Policy {
-    // [#not-implemented-hide:]
-    message DropOverload {
-      // Identifier for the policy specifying the drop.
-      string category = 1 [(validate.rules).string = {min_bytes: 1}];
-
-      // Percentage of traffic that should be dropped for the category.
-      type.FractionalPercent drop_percentage = 2;
-    }
-
-    reserved 1;
-
-    // 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.
-    // [#not-implemented-hide:]
-    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 percentage 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 {}}];
-
-    // The flag to disable overprovisioning. If it is set to true,
-    // :ref:`overprovisioning factor
-    // <arch_overview_load_balancing_overprovisioning_factor>` will be ignored
-    // and Envoy will not perform graceful failover between priority levels or
-    // localities as endpoints become unhealthy. Otherwise Envoy will perform
-    // graceful failover as :ref:`overprovisioning factor
-    // <arch_overview_load_balancing_overprovisioning_factor>` suggests.
-    // [#not-implemented-hide:]
-    bool disable_overprovisioning = 5 [deprecated = true];
-  }
-
-  // Name of the cluster. This will be the :ref:`service_name
-  // <envoy_api_field_Cluster.EdsClusterConfig.service_name>` value if specified
-  // in the cluster :ref:`EdsClusterConfig
-  // <envoy_api_msg_Cluster.EdsClusterConfig>`.
-  string cluster_name = 1 [(validate.rules).string = {min_bytes: 1}];
-
-  // List of endpoints to load balance to.
-  repeated endpoint.LocalityLbEndpoints endpoints = 2;
-
-  // Map of named endpoints that can be referenced in LocalityLbEndpoints.
-  // [#not-implemented-hide:]
-  map<string, endpoint.Endpoint> named_endpoints = 5;
-
-  // Load balancing policy settings.
-  Policy policy = 4;
-}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/api/v2/endpoint/endpoint.proto b/xds/third_party/envoy/src/main/proto/envoy/api/v2/endpoint/endpoint.proto
deleted file mode 100644
index 247c9ae265a..00000000000
--- a/xds/third_party/envoy/src/main/proto/envoy/api/v2/endpoint/endpoint.proto
+++ /dev/null
@@ -1,9 +0,0 @@
-syntax = "proto3";
-
-package envoy.api.v2.endpoint;
-
-import public "envoy/api/v2/endpoint/endpoint_components.proto";
-
-option java_package = "io.envoyproxy.envoy.api.v2.endpoint";
-option java_outer_classname = "EndpointProto";
-option java_multiple_files = true;
diff --git a/xds/third_party/envoy/src/main/proto/envoy/api/v2/endpoint/endpoint_components.proto b/xds/third_party/envoy/src/main/proto/envoy/api/v2/endpoint/endpoint_components.proto
deleted file mode 100644
index 78d45e2e08d..00000000000
--- a/xds/third_party/envoy/src/main/proto/envoy/api/v2/endpoint/endpoint_components.proto
+++ /dev/null
@@ -1,148 +0,0 @@
-syntax = "proto3";
-
-package envoy.api.v2.endpoint;
-
-import "envoy/api/v2/core/address.proto";
-import "envoy/api/v2/core/base.proto";
-import "envoy/api/v2/core/health_check.proto";
-
-import "google/protobuf/wrappers.proto";
-
-import "udpa/annotations/migrate.proto";
-import "udpa/annotations/status.proto";
-import "validate/validate.proto";
-
-option java_package = "io.envoyproxy.envoy.api.v2.endpoint";
-option java_outer_classname = "EndpointComponentsProto";
-option java_multiple_files = true;
-option (udpa.annotations.file_migrate).move_to_package = "envoy.config.endpoint.v3";
-option (udpa.annotations.file_status).package_version_status = FROZEN;
-
-// [#protodoc-title: Endpoints]
-
-// Upstream host identifier.
-message Endpoint {
-  // The optional health check configuration.
-  message 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_api_field_core.HealthCheck.HttpHealthCheck.host>` and
-    // :ref:`authority <envoy_api_field_core.HealthCheck.GrpcHealthCheck.authority>`). Setting this
-    // to a non-empty value allows overriding the cluster level configuration for a specific
-    // endpoint.
-    string hostname = 2;
-  }
-
-  // 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_api_field_core.SocketAddress.resolver_name>`
-  //   in the Address). For LOGICAL or STRICT DNS, it is expected to be hostname,
-  //   and will be resolved via DNS.
-  core.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_api_field_route.RouteAction.auto_host_rewrite>`.
-  string hostname = 3;
-}
-
-// An Endpoint that Envoy can route traffic to.
-// [#next-free-field: 6]
-message 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.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_api_msg_route.RouteAction>` metadata_match field
-  // to subset the endpoints considered in cluster load balancing.
-  core.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, each host is presumed to have equal
-  // weight in a locality. 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}];
-}
-
-// A group of endpoints belonging to a Locality.
-// One can have multiple LocalityLbEndpoints for a locality, but this is
-// generally only done if the different groups need to have different load
-// balancing weights or different priorities.
-// [#next-free-field: 7]
-message LocalityLbEndpoints {
-  // Identifies location of where the upstream hosts run.
-  core.Locality locality = 1;
-
-  // The group of endpoints belonging to the locality specified.
-  repeated LbEndpoint lb_endpoints = 2;
-
-  // 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 all endpoints for a particular priority are
-  // unavailable/unhealthy, Envoy will fail over to selecting endpoints for the
-  // next highest priority group.
-  //
-  // 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/api/v2/endpoint/load_report.proto b/xds/third_party/envoy/src/main/proto/envoy/api/v2/endpoint/load_report.proto
deleted file mode 100644
index 928aed6102d..00000000000
--- a/xds/third_party/envoy/src/main/proto/envoy/api/v2/endpoint/load_report.proto
+++ /dev/null
@@ -1,157 +0,0 @@
-syntax = "proto3";
-
-package envoy.api.v2.endpoint;
-
-import "envoy/api/v2/core/address.proto";
-import "envoy/api/v2/core/base.proto";
-
-import "google/protobuf/duration.proto";
-import "google/protobuf/struct.proto";
-
-import "udpa/annotations/migrate.proto";
-import "udpa/annotations/status.proto";
-import "validate/validate.proto";
-
-option java_package = "io.envoyproxy.envoy.api.v2.endpoint";
-option java_outer_classname = "LoadReportProto";
-option java_multiple_files = true;
-option (udpa.annotations.file_migrate).move_to_package = "envoy.config.endpoint.v3";
-option (udpa.annotations.file_status).package_version_status = FROZEN;
-
-// These are stats Envoy reports to GLB every so often. Report frequency is
-// defined by
-// :ref:`LoadStatsResponse.load_reporting_interval<envoy_api_field_service.load_stats.v2.LoadStatsResponse.load_reporting_interval>`.
-// Stats per upstream region/zone and optionally per subzone.
-// [#not-implemented-hide:] Not configuration. TBD how to doc proto APIs.
-// [#next-free-field: 9]
-message UpstreamLocalityStats {
-  // Name of zone, region and optionally endpoint group these metrics were
-  // collected from. Zone and region names could be empty if unknown.
-  core.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
-  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.
-  uint64 total_issued_requests = 8;
-
-  // Stats for multi-dimensional load balancing.
-  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_api_field_service.load_stats.v2.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;
-}
-
-// [#not-implemented-hide:] Not configuration. TBD how to doc proto APIs.
-// [#next-free-field: 8]
-message UpstreamEndpointStats {
-  // Upstream host address.
-  core.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;
-}
-
-// [#not-implemented-hide:] Not configuration. TBD how to doc proto APIs.
-message 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;
-}
-
-// Per cluster load stats. Envoy reports these stats a management server in a
-// :ref:`LoadStatsRequest<envoy_api_msg_service.load_stats.v2.LoadStatsRequest>`
-// [#not-implemented-hide:] Not configuration. TBD how to doc proto APIs.
-// Next ID: 7
-// [#next-free-field: 7]
-message ClusterStats {
-  message DroppedRequests {
-    // Identifier for the policy specifying the drop.
-    string category = 1 [(validate.rules).string = {min_bytes: 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_bytes: 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/api/v2/lds.proto b/xds/third_party/envoy/src/main/proto/envoy/api/v2/lds.proto
deleted file mode 100644
index 01d9949777d..00000000000
--- a/xds/third_party/envoy/src/main/proto/envoy/api/v2/lds.proto
+++ /dev/null
@@ -1,47 +0,0 @@
-syntax = "proto3";
-
-package envoy.api.v2;
-
-import "envoy/api/v2/discovery.proto";
-
-import "google/api/annotations.proto";
-
-import "envoy/annotations/resource.proto";
-import "udpa/annotations/migrate.proto";
-import "udpa/annotations/status.proto";
-
-import public "envoy/api/v2/listener.proto";
-
-option java_package = "io.envoyproxy.envoy.api.v2";
-option java_outer_classname = "LdsProto";
-option java_multiple_files = true;
-option java_generic_services = true;
-option (udpa.annotations.file_migrate).move_to_package = "envoy.service.listener.v3";
-option (udpa.annotations.file_status).package_version_status = FROZEN;
-
-// [#protodoc-title: Listener]
-// Listener :ref:`configuration overview <config_listeners>`
-
-// The Envoy instance initiates an RPC at startup to discover a list of
-// listeners. Updates are delivered via streaming from the LDS server and
-// consist of a complete update of all listeners. Existing connections will be
-// allowed to drain from listeners that are no longer present.
-service ListenerDiscoveryService {
-  option (envoy.annotations.resource).type = "envoy.api.v2.Listener";
-
-  rpc DeltaListeners(stream DeltaDiscoveryRequest) returns (stream DeltaDiscoveryResponse) {
-  }
-
-  rpc StreamListeners(stream DiscoveryRequest) returns (stream DiscoveryResponse) {
-  }
-
-  rpc FetchListeners(DiscoveryRequest) returns (DiscoveryResponse) {
-    option (google.api.http).post = "/v2/discovery:listeners";
-    option (google.api.http).body = "*";
-  }
-}
-
-// [#not-implemented-hide:] Not configuration. Workaround c++ protobuf issue with importing
-// services: https://github.com/google/protobuf/issues/4221 and protoxform to upgrade the file.
-message LdsDummy {
-}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/api/v2/listener.proto b/xds/third_party/envoy/src/main/proto/envoy/api/v2/listener.proto
deleted file mode 100644
index 26544c6c4aa..00000000000
--- a/xds/third_party/envoy/src/main/proto/envoy/api/v2/listener.proto
+++ /dev/null
@@ -1,246 +0,0 @@
-syntax = "proto3";
-
-package envoy.api.v2;
-
-import "envoy/api/v2/core/address.proto";
-import "envoy/api/v2/core/base.proto";
-import "envoy/api/v2/core/socket_option.proto";
-import "envoy/api/v2/listener/listener_components.proto";
-import "envoy/api/v2/listener/udp_listener_config.proto";
-import "envoy/config/filter/accesslog/v2/accesslog.proto";
-import "envoy/config/listener/v2/api_listener.proto";
-
-import "google/protobuf/duration.proto";
-import "google/protobuf/wrappers.proto";
-
-import "udpa/annotations/migrate.proto";
-import "udpa/annotations/status.proto";
-import "validate/validate.proto";
-
-option java_package = "io.envoyproxy.envoy.api.v2";
-option java_outer_classname = "ListenerProto";
-option java_multiple_files = true;
-option (udpa.annotations.file_migrate).move_to_package = "envoy.config.listener.v3";
-option (udpa.annotations.file_status).package_version_status = FROZEN;
-
-// [#protodoc-title: Listener configuration]
-// Listener :ref:`configuration overview <config_listeners>`
-
-// [#next-free-field: 23]
-message 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 {
-    // 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 in v2, all Listeners will bind to their port. An
-    // additional filter chain must be created for every original destination
-    // port this listener may redirect to in v2, with the original port
-    // specified in the FilterChainMatch destination_port field.
-    //
-    // [#comment:TODO(PiotrSikora): Remove this once verified that we no longer need it.]
-    google.protobuf.BoolValue bind_to_port = 1;
-  }
-
-  // Configuration for listener connection balancing.
-  message 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 {
-    }
-
-    oneof balance_type {
-      option (validate.required) = true;
-
-      // If specified, the listener will use the exact connection balancer.
-      ExactBalance exact_balance = 1;
-    }
-  }
-
-  reserved 14;
-
-  // 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.
-  core.Address address = 2 [(validate.rules).message = {required: true}];
-
-  // A list of filter chains to consider for this listener. The
-  // :ref:`FilterChain <envoy_api_msg_listener.FilterChain>` with the most specific
-  // :ref:`FilterChainMatch <envoy_api_msg_listener.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 listener.FilterChain filter_chains = 3;
-
-  // 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.
-  //
-  // .. attention::
-  //
-  //   This field is deprecated. Use :ref:`an original_dst <config_listener_filters_original_dst>`
-  //   :ref:`listener filter <envoy_api_field_Listener.listener_filters>` instead.
-  //
-  //   Note that hand off to another listener is *NOT* performed without this flag. Once
-  //   :ref:`FilterChainMatch <envoy_api_msg_listener.FilterChainMatch>` is implemented this flag
-  //   will be removed, as filter chain matching can be used to select a filter chain based on the
-  //   restored destination address.
-  google.protobuf.BoolValue use_original_dst = 4 [deprecated = true];
-
-  // 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;
-
-  // Listener metadata.
-  core.Metadata metadata = 6;
-
-  // [#not-implemented-hide:]
-  DeprecatedV1 deprecated_v1 = 7;
-
-  // 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_api_field_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_api_field_core.SocketAddress.protocol>` is :ref:`UDP
-  // <envoy_api_enum_value_core.SocketAddress.Protocol.UDP>`.
-  // UDP listeners currently support a single filter.
-  repeated listener.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_api_field_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.
-  repeated core.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.
-  core.TrafficDirection traffic_direction = 16;
-
-  // If the protocol in the listener socket address in :ref:`protocol
-  // <envoy_api_field_core.SocketAddress.protocol>` is :ref:`UDP
-  // <envoy_api_enum_value_core.SocketAddress.Protocol.UDP>`, this field specifies the actual udp
-  // listener to create, i.e. :ref:`udp_listener_name
-  // <envoy_api_field_listener.UdpListenerConfig.udp_listener_name>` = "raw_udp_listener" for
-  // creating a packet-oriented UDP listener. If not present, treat it as "raw_udp_listener".
-  listener.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_api_field_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.]
-  config.listener.v2.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.
-  ConnectionBalanceConfig connection_balance_config = 20;
-
-  // 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.
-  //
-  // Before Linux v4.19-rc1, new TCP connections may be rejected during hot restart
-  // (see `3rd paragraph in 'soreuseport' commit message
-  // <https://github.com/torvalds/linux/commit/c617f398edd4db2b8567a28e89>`_).
-  // This issue was fixed by `tcp: Avoid TCP syncookie rejected by SO_REUSEPORT socket
-  // <https://github.com/torvalds/linux/commit/40a1227ea845a37ab197dd1caffb60b047fa36b1>`_.
-  bool reuse_port = 21;
-
-  // Configuration for :ref:`access logs <arch_overview_access_logs>`
-  // emitted by this listener.
-  repeated config.filter.accesslog.v2.AccessLog access_log = 22;
-}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/api/v2/listener/listener.proto b/xds/third_party/envoy/src/main/proto/envoy/api/v2/listener/listener.proto
deleted file mode 100644
index 273b29cb5dd..00000000000
--- a/xds/third_party/envoy/src/main/proto/envoy/api/v2/listener/listener.proto
+++ /dev/null
@@ -1,11 +0,0 @@
-syntax = "proto3";
-
-package envoy.api.v2.listener;
-
-import public "envoy/api/v2/listener/listener_components.proto";
-
-option java_package = "io.envoyproxy.envoy.api.v2.listener";
-option java_outer_classname = "ListenerProto";
-option java_multiple_files = true;
-option csharp_namespace = "Envoy.Api.V2.ListenerNS";
-option ruby_package = "Envoy.Api.V2.ListenerNS";
diff --git a/xds/third_party/envoy/src/main/proto/envoy/api/v2/listener/listener_components.proto b/xds/third_party/envoy/src/main/proto/envoy/api/v2/listener/listener_components.proto
deleted file mode 100644
index a6791c86cd0..00000000000
--- a/xds/third_party/envoy/src/main/proto/envoy/api/v2/listener/listener_components.proto
+++ /dev/null
@@ -1,287 +0,0 @@
-syntax = "proto3";
-
-package envoy.api.v2.listener;
-
-import "envoy/api/v2/auth/tls.proto";
-import "envoy/api/v2/core/address.proto";
-import "envoy/api/v2/core/base.proto";
-import "envoy/type/range.proto";
-
-import "google/protobuf/any.proto";
-import "google/protobuf/struct.proto";
-import "google/protobuf/wrappers.proto";
-
-import "udpa/annotations/migrate.proto";
-import "udpa/annotations/status.proto";
-import "validate/validate.proto";
-
-option java_package = "io.envoyproxy.envoy.api.v2.listener";
-option java_outer_classname = "ListenerComponentsProto";
-option java_multiple_files = true;
-option csharp_namespace = "Envoy.Api.V2.ListenerNS";
-option ruby_package = "Envoy.Api.V2.ListenerNS";
-option (udpa.annotations.file_migrate).move_to_package = "envoy.config.listener.v3";
-option (udpa.annotations.file_status).package_version_status = FROZEN;
-
-// [#protodoc-title: Listener components]
-// Listener :ref:`configuration overview <config_listeners>`
-
-message Filter {
-  reserved 3;
-
-  // The name of the filter to instantiate. The name must match a
-  // :ref:`supported filter <config_network_filters>`.
-  string name = 1 [(validate.rules).string = {min_bytes: 1}];
-
-  // Filter specific configuration which depends on the filter being
-  // instantiated. See the supported filters for further documentation.
-  oneof config_type {
-    google.protobuf.Struct config = 2 [deprecated = true];
-
-    google.protobuf.Any typed_config = 4;
-  }
-}
-
-// 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. Source type (e.g. any, local or external network).
-// 7. Source IP address.
-// 8. 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).
-//
-// [#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: 13]
-message FilterChainMatch {
-  enum ConnectionSourceType {
-    // Any connection source matches.
-    ANY = 0;
-
-    // Match a connection originating from the same host.
-    LOCAL = 1 [(udpa.annotations.enum_value_migrate).rename = "SAME_IP_OR_LOOPBACK"];
-
-    // 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.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;
-
-  // 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.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.
-  //
-  // .. 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: 8]
-message FilterChain {
-  // The criteria to use when matching a connection to this filter chain.
-  FilterChainMatch filter_chain_match = 1;
-
-  // The TLS context for this filter chain.
-  //
-  // .. attention::
-  //
-  //   **This field is deprecated**. Use `transport_socket` with name `tls` instead. If both are
-  //   set, `transport_socket` takes priority.
-  auth.DownstreamTlsContext tls_context = 2 [deprecated = true];
-
-  // 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.
-  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.
-  google.protobuf.BoolValue use_proxy_proto = 4;
-
-  // [#not-implemented-hide:] filter chain metadata.
-  core.Metadata metadata = 5;
-
-  // Optional custom transport socket implementation to use for downstream connections.
-  // To setup TLS, set a transport socket with name `tls` and
-  // :ref:`DownstreamTlsContext <envoy_api_msg_auth.DownstreamTlsContext>` in the `typed_config`.
-  // If no transport socket configuration is specified, new connections
-  // will be set up with plaintext.
-  core.TransportSocket transport_socket = 6;
-
-  // [#not-implemented-hide:] The unique name (or empty) by which this filter chain is known. If no
-  // name is provided, Envoy will allocate an internal UUID for the filter chain. If the filter
-  // chain is to be dynamically updated or removed via FCDS a unique name must be provided.
-  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: 3306
-//      - destination_port_range:
-//          start: 15000
-//          end: 15001
-//
-// [#next-free-field: 6]
-message ListenerFilterChainMatchPredicate {
-  // A set of match configurations used for logical operations.
-  message 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.Int32Range destination_port_range = 5;
-  }
-}
-
-message ListenerFilter {
-  // The name of the filter to instantiate. The name must match a
-  // :ref:`supported filter <config_listener_filters>`.
-  string name = 1 [(validate.rules).string = {min_bytes: 1}];
-
-  // Filter specific configuration which depends on the filter being instantiated.
-  // See the supported filters for further documentation.
-  oneof config_type {
-    google.protobuf.Struct config = 2 [deprecated = true];
-
-    google.protobuf.Any typed_config = 3;
-  }
-
-  // Optional match predicate used to disable the filter. The filter is enabled when this field is empty.
-  // See :ref:`ListenerFilterChainMatchPredicate <envoy_api_msg_listener.ListenerFilterChainMatchPredicate>`
-  // for further examples.
-  ListenerFilterChainMatchPredicate filter_disabled = 4;
-}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/api/v2/listener/udp_listener_config.proto b/xds/third_party/envoy/src/main/proto/envoy/api/v2/listener/udp_listener_config.proto
deleted file mode 100644
index d4d29531f3a..00000000000
--- a/xds/third_party/envoy/src/main/proto/envoy/api/v2/listener/udp_listener_config.proto
+++ /dev/null
@@ -1,38 +0,0 @@
-syntax = "proto3";
-
-package envoy.api.v2.listener;
-
-import "google/protobuf/any.proto";
-import "google/protobuf/struct.proto";
-
-import "udpa/annotations/migrate.proto";
-import "udpa/annotations/status.proto";
-
-option java_package = "io.envoyproxy.envoy.api.v2.listener";
-option java_outer_classname = "UdpListenerConfigProto";
-option java_multiple_files = true;
-option csharp_namespace = "Envoy.Api.V2.ListenerNS";
-option ruby_package = "Envoy.Api.V2.ListenerNS";
-option (udpa.annotations.file_migrate).move_to_package = "envoy.config.listener.v3";
-option (udpa.annotations.file_status).package_version_status = FROZEN;
-
-// [#protodoc-title: UDP Listener Config]
-// Listener :ref:`configuration overview <config_listeners>`
-
-message UdpListenerConfig {
-  // Used to look up UDP listener factory, matches "raw_udp_listener" or
-  // "quic_listener" to create a specific udp listener.
-  // If not specified, treat as "raw_udp_listener".
-  string udp_listener_name = 1;
-
-  // Used to create a specific listener factory. To some factory, e.g.
-  // "raw_udp_listener", config is not needed.
-  oneof config_type {
-    google.protobuf.Struct config = 2 [deprecated = true];
-
-    google.protobuf.Any typed_config = 3;
-  }
-}
-
-message ActiveRawUdpListenerConfig {
-}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/api/v2/rds.proto b/xds/third_party/envoy/src/main/proto/envoy/api/v2/rds.proto
deleted file mode 100644
index faa5fdcf319..00000000000
--- a/xds/third_party/envoy/src/main/proto/envoy/api/v2/rds.proto
+++ /dev/null
@@ -1,64 +0,0 @@
-syntax = "proto3";
-
-package envoy.api.v2;
-
-import "envoy/api/v2/discovery.proto";
-
-import "google/api/annotations.proto";
-
-import "envoy/annotations/resource.proto";
-import "udpa/annotations/migrate.proto";
-import "udpa/annotations/status.proto";
-
-import public "envoy/api/v2/route.proto";
-
-option java_package = "io.envoyproxy.envoy.api.v2";
-option java_outer_classname = "RdsProto";
-option java_multiple_files = true;
-option java_generic_services = true;
-option (udpa.annotations.file_migrate).move_to_package = "envoy.service.route.v3";
-option (udpa.annotations.file_status).package_version_status = FROZEN;
-
-// [#protodoc-title: RDS]
-
-// The resource_names field in DiscoveryRequest specifies a route configuration.
-// This allows an Envoy configuration with multiple HTTP listeners (and
-// associated HTTP connection manager filters) to use different route
-// configurations. Each listener will bind its HTTP connection manager filter to
-// a route table via this identifier.
-service RouteDiscoveryService {
-  option (envoy.annotations.resource).type = "envoy.api.v2.RouteConfiguration";
-
-  rpc StreamRoutes(stream DiscoveryRequest) returns (stream DiscoveryResponse) {
-  }
-
-  rpc DeltaRoutes(stream DeltaDiscoveryRequest) returns (stream DeltaDiscoveryResponse) {
-  }
-
-  rpc FetchRoutes(DiscoveryRequest) returns (DiscoveryResponse) {
-    option (google.api.http).post = "/v2/discovery:routes";
-    option (google.api.http).body = "*";
-  }
-}
-
-// Virtual Host Discovery Service (VHDS) is used to dynamically update the list of virtual hosts for
-// a given RouteConfiguration. If VHDS is configured a virtual host list update will be triggered
-// during the processing of an HTTP request if a route for the request cannot be resolved. The
-// :ref:`resource_names_subscribe <envoy_api_field_DeltaDiscoveryRequest.resource_names_subscribe>`
-// field contains a list of virtual host names or aliases to track. The contents of an alias would
-// be the contents of a *host* or *authority* header used to make an http request. An xDS server
-// will match an alias to a virtual host based on the content of :ref:`domains'
-// <envoy_api_field_route.VirtualHost.domains>` field. The *resource_names_unsubscribe* field
-// contains a list of virtual host names that have been :ref:`unsubscribed
-// <xds_protocol_unsubscribe>` from the routing table associated with the RouteConfiguration.
-service VirtualHostDiscoveryService {
-  option (envoy.annotations.resource).type = "envoy.api.v2.route.VirtualHost";
-
-  rpc DeltaVirtualHosts(stream DeltaDiscoveryRequest) returns (stream DeltaDiscoveryResponse) {
-  }
-}
-
-// [#not-implemented-hide:] Not configuration. Workaround c++ protobuf issue with importing
-// services: https://github.com/google/protobuf/issues/4221 and protoxform to upgrade the file.
-message RdsDummy {
-}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/api/v2/route.proto b/xds/third_party/envoy/src/main/proto/envoy/api/v2/route.proto
deleted file mode 100644
index 549f134a7f4..00000000000
--- a/xds/third_party/envoy/src/main/proto/envoy/api/v2/route.proto
+++ /dev/null
@@ -1,113 +0,0 @@
-syntax = "proto3";
-
-package envoy.api.v2;
-
-import "envoy/api/v2/core/base.proto";
-import "envoy/api/v2/core/config_source.proto";
-import "envoy/api/v2/route/route_components.proto";
-
-import "google/protobuf/wrappers.proto";
-
-import "udpa/annotations/migrate.proto";
-import "udpa/annotations/status.proto";
-import "validate/validate.proto";
-
-option java_package = "io.envoyproxy.envoy.api.v2";
-option java_outer_classname = "RouteProto";
-option java_multiple_files = true;
-option (udpa.annotations.file_migrate).move_to_package = "envoy.config.route.v3";
-option (udpa.annotations.file_status).package_version_status = FROZEN;
-
-// [#protodoc-title: HTTP route configuration]
-// * Routing :ref:`architecture overview <arch_overview_http_routing>`
-// * HTTP :ref:`router filter <config_http_filters_router>`
-
-// [#next-free-field: 11]
-message RouteConfiguration {
-  // The name of the route configuration. For example, it might match
-  // :ref:`route_config_name
-  // <envoy_api_field_config.filter.network.http_connection_manager.v2.Rds.route_config_name>` in
-  // :ref:`envoy_api_msg_config.filter.network.http_connection_manager.v2.Rds`.
-  string name = 1;
-
-  // An array of virtual hosts that make up the route table.
-  repeated route.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_api_msg_route.VirtualHost` or
-  // :ref:`envoy_api_msg_route.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.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_api_msg_route.VirtualHost` or
-  // :ref:`envoy_api_msg_route.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.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}}}
-  ];
-
-  // By default, headers that should be added/removed are evaluated from most to least specific:
-  //
-  // * route level
-  // * virtual host level
-  // * connection manager level
-  //
-  // To allow setting overrides at the route or virtual host level, this order can be reversed
-  // by setting this option to true. Defaults to false.
-  //
-  // [#next-major-version: In the v3 API, this will default to true.]
-  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_api_field_config.filter.network.http_connection_manager.v2.HttpConnectionManager.route_config>`
-  // option. This setting default to false if the route table is loaded dynamically via the
-  // :ref:`rds
-  // <envoy_api_field_config.filter.network.http_connection_manager.v2.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;
-}
-
-message Vhds {
-  // Configuration source specifier for VHDS.
-  core.ConfigSource config_source = 1 [(validate.rules).message = {required: true}];
-}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/api/v2/route/route.proto b/xds/third_party/envoy/src/main/proto/envoy/api/v2/route/route.proto
deleted file mode 100644
index ec13e9e5c80..00000000000
--- a/xds/third_party/envoy/src/main/proto/envoy/api/v2/route/route.proto
+++ /dev/null
@@ -1,9 +0,0 @@
-syntax = "proto3";
-
-package envoy.api.v2.route;
-
-import public "envoy/api/v2/route/route_components.proto";
-
-option java_package = "io.envoyproxy.envoy.api.v2.route";
-option java_outer_classname = "RouteProto";
-option java_multiple_files = true;
diff --git a/xds/third_party/envoy/src/main/proto/envoy/api/v2/route/route_components.proto b/xds/third_party/envoy/src/main/proto/envoy/api/v2/route/route_components.proto
deleted file mode 100644
index d73fbb8674c..00000000000
--- a/xds/third_party/envoy/src/main/proto/envoy/api/v2/route/route_components.proto
+++ /dev/null
@@ -1,1628 +0,0 @@
-syntax = "proto3";
-
-package envoy.api.v2.route;
-
-import "envoy/api/v2/core/base.proto";
-import "envoy/type/matcher/regex.proto";
-import "envoy/type/matcher/string.proto";
-import "envoy/type/percent.proto";
-import "envoy/type/range.proto";
-import "envoy/type/tracing/v2/custom_tag.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/migrate.proto";
-import "udpa/annotations/status.proto";
-import "validate/validate.proto";
-
-option java_package = "io.envoyproxy.envoy.api.v2.route";
-option java_outer_classname = "RouteComponentsProto";
-option java_multiple_files = true;
-option (udpa.annotations.file_migrate).move_to_package = "envoy.config.route.v3";
-option (udpa.annotations.file_status).package_version_status = FROZEN;
-
-// [#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: 21]
-message 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;
-
-  // 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_bytes: 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.
-  repeated Route routes = 3;
-
-  // 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_api_msg_route.Route` and before headers from the
-  // enclosing :ref:`envoy_api_msg_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.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;
-
-  // 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_api_msg_route.Route` and before headers from the
-  // enclosing :ref:`envoy_api_msg_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.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;
-
-  // Indicates that the virtual host has a CORS policy.
-  CorsPolicy cors = 8;
-
-  // The per_filter_config field can be used to provide virtual host-specific
-  // configurations for filters. The key should match the filter name, such as
-  // *envoy.filters.http.buffer* for the HTTP buffer filter. Use of this field is filter
-  // specific; see the :ref:`HTTP filter documentation <config_http_filters>`
-  // for if and how it is utilized.
-  map<string, google.protobuf.Struct> per_filter_config = 12 [deprecated = true];
-
-  // The per_filter_config field can be used to provide virtual host-specific
-  // configurations for filters. The key should match the filter name, such as
-  // *envoy.filters.http.buffer* for the HTTP buffer filter. Use of this field is filter
-  // specific; see the :ref:`HTTP filter documentation <config_http_filters>`
-  // for if and how it is utilized.
-  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_api_field_config.filter.http.router.v2.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_api_field_config.filter.http.router.v2.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_api_field_route.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;
-
-  // The maximum bytes which will be buffered for retries and shadowing.
-  // If set and a route-specific limit is not set, the bytes actually buffered will be the minimum
-  // value of this and the listener per_connection_buffer_limit_bytes.
-  google.protobuf.UInt32Value per_request_buffer_limit_bytes = 18;
-}
-
-// A filter-defined action type.
-message FilterAction {
-  google.protobuf.Any action = 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_api_msg_route.HeaderMatcher>`.
-// [#next-free-field: 18]
-message Route {
-  reserved 6;
-
-  // 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:]
-    // If true, a filter will define the action (e.g., it could dynamically generate the
-    // RouteAction).
-    FilterAction filter_action = 17;
-  }
-
-  // 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.Metadata metadata = 4;
-
-  // Decorator for the matched route.
-  Decorator decorator = 5;
-
-  // The per_filter_config field can be used to provide route-specific
-  // configurations for filters. The key should match the filter name, such as
-  // *envoy.filters.http.buffer* for the HTTP buffer filter. Use of this field is filter
-  // specific; see the :ref:`HTTP filter documentation <config_http_filters>` for
-  // if and how it is utilized.
-  map<string, google.protobuf.Struct> per_filter_config = 8 [deprecated = true];
-
-  // The typed_per_filter_config field can be used to provide route-specific
-  // configurations for filters. The key should match the filter name, such as
-  // *envoy.filters.http.buffer* for the HTTP buffer filter. Use of this field is filter
-  // specific; see the :ref:`HTTP filter documentation <config_http_filters>` for
-  // if and how it is utilized.
-  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_api_msg_route.VirtualHost` and
-  // :ref:`envoy_api_msg_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.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;
-
-  // 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_api_msg_route.VirtualHost` and
-  // :ref:`envoy_api_msg_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.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;
-
-  // 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.
-  google.protobuf.UInt32Value per_request_buffer_limit_bytes = 16;
-}
-
-// Compared to the :ref:`cluster <envoy_api_field_route.RouteAction.cluster>` field that specifies a
-// single upstream cluster as the target of a request, the :ref:`weighted_clusters
-// <envoy_api_field_route.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.
-message WeightedCluster {
-  // [#next-free-field: 11]
-  message ClusterWeight {
-    reserved 7;
-
-    // Name of the upstream cluster. The cluster must exist in the
-    // :ref:`cluster manager configuration <config_cluster_manager>`.
-    string name = 1 [(validate.rules).string = {min_bytes: 1}];
-
-    // An integer between 0 and :ref:`total_weight
-    // <envoy_api_field_route.WeightedCluster.total_weight>`. 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 add up to the total_weight, which defaults to 100.
-    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_api_field_route.RouteAction.metadata_match>`, with
-    // values here taking precedence. The filter name should be specified as *envoy.lb*.
-    core.Metadata metadata_match = 3;
-
-    // Specifies a list of headers to be added to requests when this cluster is selected
-    // through the enclosing :ref:`envoy_api_msg_route.RouteAction`.
-    // Headers specified at this level are applied before headers from the enclosing
-    // :ref:`envoy_api_msg_route.Route`, :ref:`envoy_api_msg_route.VirtualHost`, and
-    // :ref:`envoy_api_msg_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.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_api_msg_route.RouteAction`.
-    repeated string request_headers_to_remove = 9;
-
-    // Specifies a list of headers to be added to responses when this cluster is selected
-    // through the enclosing :ref:`envoy_api_msg_route.RouteAction`.
-    // Headers specified at this level are applied before headers from the enclosing
-    // :ref:`envoy_api_msg_route.Route`, :ref:`envoy_api_msg_route.VirtualHost`, and
-    // :ref:`envoy_api_msg_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.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_api_msg_route.RouteAction`.
-    repeated string response_headers_to_remove = 6;
-
-    // The per_filter_config field can be used to provide weighted cluster-specific
-    // configurations for filters. The key should match the filter name, such as
-    // *envoy.filters.http.buffer* for the HTTP buffer filter. Use of this field is filter
-    // specific; see the :ref:`HTTP filter documentation <config_http_filters>`
-    // for if and how it is utilized.
-    map<string, google.protobuf.Struct> per_filter_config = 8 [deprecated = true];
-
-    // The per_filter_config field can be used to provide weighted cluster-specific
-    // configurations for filters. The key should match the filter name, such as
-    // *envoy.filters.http.buffer* for the HTTP buffer filter. Use of this field is filter
-    // specific; see the :ref:`HTTP filter documentation <config_http_filters>`
-    // for if and how it is utilized.
-    map<string, google.protobuf.Any> typed_per_filter_config = 10;
-  }
-
-  // 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, which must be greater than 0. Defaults to 100.
-  google.protobuf.UInt32Value total_weight = 3 [(validate.rules).uint32 = {gte: 1}];
-
-  // 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;
-}
-
-// [#next-free-field: 12]
-message RouteMatch {
-  message GrpcRouteMatchOptions {
-  }
-
-  message 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.
-    google.protobuf.BoolValue validated = 2;
-  }
-
-  reserved 5;
-
-  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. The regex grammar is defined `here
-    // <https://en.cppreference.com/w/cpp/regex/ecmascript>`_.
-    //
-    // Examples:
-    //
-    // * The regex ``/b[io]t`` matches the path */bit*
-    // * The regex ``/b[io]t`` matches the path */bot*
-    // * The regex ``/b[io]t`` does not match the path */bite*
-    // * The regex ``/b[io]t`` does not match the path */bit/bot*
-    //
-    // .. attention::
-    //   This field has been deprecated in favor of `safe_regex` as it is not safe for use with
-    //   untrusted input in all cases.
-    string regex = 3 [
-      deprecated = true,
-      (validate.rules).string = {max_bytes: 1024},
-      (envoy.annotations.disallowed_by_default) = true
-    ];
-
-    // 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.RegexMatcher safe_regex = 10 [(validate.rules).message = {required: true}];
-  }
-
-  // Indicates that prefix/path matching should be case sensitive. The default
-  // is true.
-  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.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.
-  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;
-}
-
-// [#next-free-field: 12]
-message CorsPolicy {
-  // Specifies the origins that will be allowed to do CORS requests.
-  //
-  // An origin is allowed if either allow_origin or allow_origin_regex match.
-  //
-  // .. attention::
-  //  This field has been deprecated in favor of `allow_origin_string_match`.
-  repeated string allow_origin = 1
-      [deprecated = true, (envoy.annotations.disallowed_by_default) = true];
-
-  // Specifies regex patterns that match allowed origins.
-  //
-  // An origin is allowed if either allow_origin or allow_origin_regex match.
-  //
-  // .. attention::
-  //   This field has been deprecated in favor of `allow_origin_string_match` as it is not safe for
-  //   use with untrusted input in all cases.
-  repeated string allow_origin_regex = 8
-      [deprecated = true, (validate.rules).repeated = {items {string {max_bytes: 1024}}}];
-
-  // Specifies string patterns that match allowed origins. An origin is allowed if any of the
-  // string matchers match.
-  repeated type.matcher.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 if the CORS filter is enabled. Defaults to true. Only effective on route.
-    //
-    // .. attention::
-    //
-    //   **This field is deprecated**. Set the
-    //   :ref:`filter_enabled<envoy_api_field_route.CorsPolicy.filter_enabled>` field instead.
-    google.protobuf.BoolValue enabled = 7
-        [deprecated = true, (envoy.annotations.disallowed_by_default) = true];
-
-    // 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_api_field_core.RuntimeFractionalPercent.runtime_key>` is
-    // specified, Envoy will lookup the runtime key to get the percentage of requests to filter.
-    core.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_api_field_core.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.RuntimeFractionalPercent shadow_enabled = 10;
-}
-
-// [#next-free-field: 34]
-message RouteAction {
-  enum ClusterNotFoundResponseCode {
-    // HTTP status code - 503 Service Unavailable.
-    SERVICE_UNAVAILABLE = 0;
-
-    // HTTP status code - 404 Not Found.
-    NOT_FOUND = 1;
-  }
-
-  // Configures :ref:`internal redirect <arch_overview_internal_redirects>` behavior.
-  enum InternalRedirectAction {
-    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*.
-  //
-  // .. note::
-  //
-  //   Shadowing will not be triggered if the primary cluster does not exist.
-  message RequestMirrorPolicy {
-    // Specifies the cluster that requests will be mirrored to. The cluster must
-    // exist in the cluster manager configuration.
-    string cluster = 1 [(validate.rules).string = {min_bytes: 1}];
-
-    // If not specified, all requests to the target cluster will be mirrored. If
-    // specified, Envoy will lookup the runtime key to get the % of requests to
-    // mirror. Valid values are from 0 to 10000, allowing for increments of
-    // 0.01% of requests to be mirrored. If the runtime key is specified in the
-    // configuration but not present in runtime, 0 is the default and thus 0% of
-    // requests will be mirrored.
-    //
-    // .. attention::
-    //
-    //   **This field is deprecated**. Set the
-    //   :ref:`runtime_fraction
-    //   <envoy_api_field_route.RouteAction.RequestMirrorPolicy.runtime_fraction>`
-    //   field instead. Mirroring occurs if both this and
-    //   <envoy_api_field_route.RouteAction.RequestMirrorPolicy.runtime_fraction>`
-    //   are not set.
-    string runtime_key = 2 [deprecated = true, (envoy.annotations.disallowed_by_default) = true];
-
-    // 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.RuntimeFractionalPercent runtime_fraction = 3;
-
-    // Determines if the trace span should be sampled. Defaults to true.
-    google.protobuf.BoolValue trace_sampled = 4;
-  }
-
-  // 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 {
-    message 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_bytes: 1 well_known_regex: HTTP_HEADER_NAME 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 {
-      // 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_bytes: 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;
-    }
-
-    message ConnectionProperties {
-      // Hash on source IP address.
-      bool source_ip = 1;
-    }
-
-    message 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.
-      string name = 1 [(validate.rules).string = {min_bytes: 1}];
-    }
-
-    message FilterState {
-      // The name of the Object in the per-request filterState, which is an
-      // Envoy::Http::Hashable object. If there is no data associated with the key,
-      // or the stored object is not Envoy::Http::Hashable, no hash will be produced.
-      string key = 1 [(validate.rules).string = {min_bytes: 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_api_field_config.filter.network.http_connection_manager.v2.HttpConnectionManager.upgrade_configs>`
-  // but does not affect any custom filter chain specified there.
-  message 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
-        [(validate.rules).string = {well_known_regex: HTTP_HEADER_VALUE strict: false}];
-
-    // Determines if upgrades are available on this route. Defaults to true.
-    google.protobuf.BoolValue enabled = 2;
-  }
-
-  reserved 12, 18, 19, 16, 22, 21;
-
-  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_bytes: 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_bytes: 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;
-  }
-
-  // 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_api_field_route.RouteAction.weighted_clusters>`, metadata will be merged, with values
-  // provided there taking precedence. The filter name should be specified as *envoy.lb*.
-  core.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 *prefix_rewrite* or
-  // :ref:`regex_rewrite <envoy_api_field_route.RouteAction.regex_rewrite>`
-  // may be specified.
-  //
-  // .. attention::
-  //
-  //   Pay careful attention to the use of trailing slashes in the
-  //   :ref:`route's match <envoy_api_field_route.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_api_msg_route.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:`prefix_rewrite <envoy_api_field_route.RouteAction.prefix_rewrite>`
-  // or *regex_rewrite* 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.RegexMatchAndSubstitute regex_rewrite = 32;
-
-  oneof host_rewrite_specifier {
-    // Indicates that during forwarding, the host header will be swapped with
-    // this value.
-    string host_rewrite = 6 [
-      (validate.rules).string = {well_known_regex: HTTP_HEADER_VALUE strict: false},
-      (udpa.annotations.field_migrate).rename = "host_rewrite_literal"
-    ];
-
-    // 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*. 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 auto_host_rewrite_header = 29 [
-      (validate.rules).string = {well_known_regex: HTTP_HEADER_NAME strict: false},
-      (udpa.annotations.field_migrate).rename = "host_rewrite_header"
-    ];
-  }
-
-  // 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_api_field_config.filter.network.http_connection_manager.v2.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_api_field_route.RouteAction.timeout>`, which provides an upper bound
-  // on the upstream response time; :ref:`idle_timeout
-  // <envoy_api_field_route.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.
-  google.protobuf.Duration idle_timeout = 24;
-
-  // 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_api_field_route.VirtualHost.retry_policy>`
-  // should not be set if this field is used.
-  google.protobuf.Any retry_policy_typed_config = 33;
-
-  // Indicates that the route has a request mirroring policy.
-  //
-  // .. attention::
-  //   This field has been deprecated in favor of `request_mirror_policies` which supports one or
-  //   more mirroring policies.
-  RequestMirrorPolicy request_mirror_policy = 10 [deprecated = true];
-
-  // Indicates that the route has request mirroring policies.
-  repeated RequestMirrorPolicy request_mirror_policies = 30;
-
-  // Optionally specifies the :ref:`routing priority <arch_overview_http_routing_priority>`.
-  core.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_api_field_route.VirtualHost.rate_limits>` are not applied to the
-  // request.
-  google.protobuf.BoolValue include_vh_rate_limits = 14;
-
-  // 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.
-  CorsPolicy cors = 17;
-
-  // 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_api_field_route.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_api_field_route.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;
-
-  // 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;
-
-  repeated UpgradeConfig upgrade_configs = 25;
-
-  InternalRedirectAction internal_redirect_action = 26;
-
-  // 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_api_field_route.RouteAction.internal_redirect_action>`
-  // is set to :ref:`HANDLE_INTERNAL_REDIRECT
-  // <envoy_api_enum_value_route.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_api_field_route.RouteAction.internal_redirect_action>`
-  // set to
-  // :ref:`PASS_THROUGH_INTERNAL_REDIRECT
-  // <envoy_api_enum_value_route.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;
-
-  // 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;
-}
-
-// HTTP retry :ref:`architecture overview <arch_overview_http_routing_retry>`.
-// [#next-free-field: 11]
-message RetryPolicy {
-  message RetryPriority {
-    string name = 1 [(validate.rules).string = {min_bytes: 1}];
-
-    oneof config_type {
-      google.protobuf.Struct config = 2 [deprecated = true];
-
-      google.protobuf.Any typed_config = 3;
-    }
-  }
-
-  message RetryHostPredicate {
-    string name = 1 [(validate.rules).string = {min_bytes: 1}];
-
-    oneof config_type {
-      google.protobuf.Struct config = 2 [deprecated = true];
-
-      google.protobuf.Any typed_config = 3;
-    }
-  }
-
-  message 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 {}}];
-  }
-
-  // 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;
-
-  // Specifies a non-zero upstream timeout per retry 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_api_field_route.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 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;
-
-  // 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 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;
-
-  // 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 {
-  // 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.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_api_msg_route.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: 9]
-message 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_api_field_route.RouteAction.prefix_rewrite>`.
-    string prefix_rewrite = 5
-        [(validate.rules).string = {well_known_regex: HTTP_HEADER_VALUE strict: false}];
-  }
-
-  // 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 {
-  // Specifies the HTTP response status to be returned.
-  uint32 status = 1 [(validate.rules).uint32 = {lt: 600 gte: 100}];
-
-  // 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_api_msg_route.Route`, :ref:`envoy_api_msg_RouteConfiguration` or
-  //   :ref:`envoy_api_msg_route.VirtualHost`.
-  core.DataSource body = 2;
-}
-
-message 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_bytes: 1}];
-
-  // Whether the decorated details should be propagated to the other party. The default is true.
-  google.protobuf.BoolValue propagate = 2;
-}
-
-message 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_sampling' in the :ref:`HTTP Connection Manager
-  // <config_http_conn_man_runtime>`.
-  // Default: 100%
-  type.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.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.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_api_field_config.filter.network.http_connection_manager.v2.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.v2.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 {
-  // Specifies a regex pattern to use for matching requests. The entire path of the request
-  // must match the regex. The regex grammar used is defined `here
-  // <https://en.cppreference.com/w/cpp/regex/ecmascript>`_.
-  //
-  // Examples:
-  //
-  // * The regex ``/rides/\d+`` matches the path */rides/0*
-  // * The regex ``/rides/\d+`` matches the path */rides/123*
-  // * The regex ``/rides/\d+`` does not match the path */rides/123/456*
-  //
-  // .. attention::
-  //   This field has been deprecated in favor of `headers` as it is not safe for use with
-  //   untrusted input in all cases.
-  string pattern = 1 [
-    deprecated = true,
-    (validate.rules).string = {max_bytes: 1024},
-    (envoy.annotations.disallowed_by_default) = true
-  ];
-
-  // 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_bytes: 1}];
-
-  // Optionally specifies the HTTP method to match on. For example GET, PUT,
-  // etc.
-  //
-  // .. attention::
-  //   This field has been deprecated in favor of `headers`.
-  core.RequestMethod method = 3
-      [deprecated = true, (envoy.annotations.disallowed_by_default) = true];
-}
-
-// Global rate limiting :ref:`architecture overview <arch_overview_global_rate_limit>`.
-message RateLimit {
-  // [#next-free-field: 7]
-  message 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 {
-    }
-
-    // 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_api_msg_RouteConfiguration>`
-    // settings:
-    //
-    // * :ref:`cluster <envoy_api_field_route.RouteAction.cluster>` indicates the upstream cluster
-    //   to route to.
-    // * :ref:`weighted_clusters <envoy_api_field_route.RouteAction.weighted_clusters>`
-    //   chooses a cluster randomly from a set of clusters with attributed weight.
-    // * :ref:`cluster_header <envoy_api_field_route.RouteAction.cluster_header>` indicates which
-    //   header in the request contains the target cluster.
-    message 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 {
-      // 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_bytes: 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_bytes: 1}];
-    }
-
-    // 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 {
-    }
-
-    // The following descriptor entry is appended to the descriptor:
-    //
-    // .. code-block:: cpp
-    //
-    //   ("generic_key", "<descriptor_value>")
-    message GenericKey {
-      // The value to use in the descriptor entry.
-      string descriptor_value = 1 [(validate.rules).string = {min_bytes: 1}];
-    }
-
-    // The following descriptor entry is appended to the descriptor:
-    //
-    // .. code-block:: cpp
-    //
-    //   ("header_match", "<descriptor_value>")
-    message HeaderValueMatch {
-      // The value to use in the descriptor entry.
-      string descriptor_value = 1 [(validate.rules).string = {min_bytes: 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}];
-    }
-
-    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 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;
-    }
-  }
-
-  // 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.
-  google.protobuf.UInt32Value stage = 1 [(validate.rules).uint32 = {lte: 10}];
-
-  // The key to be set in runtime to disable this rate limit configuration.
-  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}];
-}
-
-// .. 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",
-//       "exact_match": "POST"
-//     }
-//
-// .. attention::
-//   In the absence of any header match specifier, match will default to :ref:`present_match
-//   <envoy_api_field_route.HeaderMatcher.present_match>`. i.e, a request that has the :ref:`name
-//   <envoy_api_field_route.HeaderMatcher.name>` header will match, regardless of the header's
-//   value.
-//
-//  [#next-major-version: HeaderMatcher should be refactored to use StringMatcher.]
-// [#next-free-field: 12]
-message HeaderMatcher {
-  reserved 2, 3;
-
-  // Specifies the name of the header in the request.
-  string name = 1
-      [(validate.rules).string = {min_bytes: 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.
-    string exact_match = 4;
-
-    // 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. The regex grammar used in the value field is defined
-    // `here <https://en.cppreference.com/w/cpp/regex/ecmascript>`_.
-    //
-    // Examples:
-    //
-    // * The regex ``\d{3}`` matches the value *123*
-    // * The regex ``\d{3}`` does not match the value *1234*
-    // * The regex ``\d{3}`` does not match the value *123.456*
-    //
-    // .. attention::
-    //   This field has been deprecated in favor of `safe_regex_match` as it is not safe for use
-    //   with untrusted input in all cases.
-    string regex_match = 5 [
-      deprecated = true,
-      (validate.rules).string = {max_bytes: 1024},
-      (envoy.annotations.disallowed_by_default) = true
-    ];
-
-    // 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.
-    type.matcher.RegexMatcher safe_regex_match = 11;
-
-    // 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.Int64Range range_match = 6;
-
-    // If specified, header match will be performed based on whether the header is in the
-    // request.
-    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.
-    //
-    // Examples:
-    //
-    // * The prefix *abcd* matches the value *abcdxyz*, but not for *abcxyz*.
-    string prefix_match = 9 [(validate.rules).string = {min_bytes: 1}];
-
-    // 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.
-    //
-    // Examples:
-    //
-    // * The suffix *abcd* matches the value *xyzabcd*, but not for *xyzbcd*.
-    string suffix_match = 10 [(validate.rules).string = {min_bytes: 1}];
-  }
-
-  // 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;
-}
-
-// 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 {
-  // Specifies the name of a key that must be present in the requested
-  // *path*'s query string.
-  string name = 1 [(validate.rules).string = {min_bytes: 1 max_bytes: 1024}];
-
-  // Specifies the value of the key. If the value is absent, a request
-  // that contains the key in its query string will match, whether the
-  // key appears with a value (e.g., "?debug=true") or not (e.g., "?debug")
-  //
-  // ..attention::
-  //   This field is deprecated. Use an `exact` match inside the `string_match` field.
-  string value = 3 [deprecated = true, (envoy.annotations.disallowed_by_default) = true];
-
-  // Specifies whether the query parameter value is a regular expression.
-  // Defaults to false. The entire query parameter value (i.e., the part to
-  // the right of the equals sign in "key=value") must match the regex.
-  // E.g., the regex ``\d+$`` will match *123* but not *a123* or *123a*.
-  //
-  // ..attention::
-  //   This field is deprecated. Use a `safe_regex` match inside the `string_match` field.
-  google.protobuf.BoolValue regex = 4
-      [deprecated = true, (envoy.annotations.disallowed_by_default) = true];
-
-  oneof query_parameter_match_specifier {
-    // Specifies whether a query parameter value should match against a string.
-    type.matcher.StringMatcher string_match = 5 [(validate.rules).message = {required: true}];
-
-    // Specifies whether a query parameter should be present.
-    bool present_match = 6;
-  }
-}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/api/v2/scoped_route.proto b/xds/third_party/envoy/src/main/proto/envoy/api/v2/scoped_route.proto
deleted file mode 100644
index 0841bd08723..00000000000
--- a/xds/third_party/envoy/src/main/proto/envoy/api/v2/scoped_route.proto
+++ /dev/null
@@ -1,109 +0,0 @@
-syntax = "proto3";
-
-package envoy.api.v2;
-
-import "udpa/annotations/migrate.proto";
-import "udpa/annotations/status.proto";
-import "validate/validate.proto";
-
-option java_package = "io.envoyproxy.envoy.api.v2";
-option java_outer_classname = "ScopedRouteProto";
-option java_multiple_files = true;
-option (udpa.annotations.file_migrate).move_to_package = "envoy.config.route.v3";
-option (udpa.annotations.file_status).package_version_status = FROZEN;
-
-// [#protodoc-title: HTTP scoped routing configuration]
-// * Routing :ref:`architecture overview <arch_overview_http_routing>`
-
-// Specifies a routing scope, which associates a
-// :ref:`Key<envoy_api_msg_ScopedRouteConfiguration.Key>` to a
-// :ref:`envoy_api_msg_RouteConfiguration` (identified by its resource name).
-//
-// 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_api_field_config.filter.network.http_connection_manager.v2.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_api_field_config.filter.network.http_connection_manager.v2.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.
-//
-message ScopedRouteConfiguration {
-  // Specifies a key which is matched against the output of the
-  // :ref:`scope_key_builder<envoy_api_field_config.filter.network.http_connection_manager.v2.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 {
-    message 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_api_field_config.filter.network.http_connection_manager.v2.ScopedRoutes.scope_key_builder>`.
-    repeated Fragment fragments = 1 [(validate.rules).repeated = {min_items: 1}];
-  }
-
-  // The name assigned to the routing scope.
-  string name = 1 [(validate.rules).string = {min_bytes: 1}];
-
-  // The resource name to use for a :ref:`envoy_api_msg_DiscoveryRequest` to an
-  // RDS server to fetch the :ref:`envoy_api_msg_RouteConfiguration` associated
-  // with this scope.
-  string route_configuration_name = 2 [(validate.rules).string = {min_bytes: 1}];
-
-  // The key to match against.
-  Key key = 3 [(validate.rules).message = {required: true}];
-}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/api/v2/srds.proto b/xds/third_party/envoy/src/main/proto/envoy/api/v2/srds.proto
deleted file mode 100644
index 0edb99a1ecc..00000000000
--- a/xds/third_party/envoy/src/main/proto/envoy/api/v2/srds.proto
+++ /dev/null
@@ -1,50 +0,0 @@
-syntax = "proto3";
-
-package envoy.api.v2;
-
-import "envoy/api/v2/discovery.proto";
-
-import "google/api/annotations.proto";
-
-import "envoy/annotations/resource.proto";
-import "udpa/annotations/migrate.proto";
-import "udpa/annotations/status.proto";
-
-import public "envoy/api/v2/scoped_route.proto";
-
-option java_package = "io.envoyproxy.envoy.api.v2";
-option java_outer_classname = "SrdsProto";
-option java_multiple_files = true;
-option java_generic_services = true;
-option (udpa.annotations.file_migrate).move_to_package = "envoy.service.route.v3";
-option (udpa.annotations.file_status).package_version_status = FROZEN;
-
-// [#protodoc-title: SRDS]
-// * Routing :ref:`architecture overview <arch_overview_http_routing>`
-
-// The Scoped Routes Discovery Service (SRDS) API distributes
-// :ref:`ScopedRouteConfiguration<envoy_api_msg.ScopedRouteConfiguration>`
-// resources. Each ScopedRouteConfiguration resource represents a "routing
-// scope" containing a mapping that allows the HTTP connection manager to
-// dynamically assign a routing table (specified via a
-// :ref:`RouteConfiguration<envoy_api_msg_RouteConfiguration>` message) to each
-// HTTP request.
-service ScopedRoutesDiscoveryService {
-  option (envoy.annotations.resource).type = "envoy.api.v2.ScopedRouteConfiguration";
-
-  rpc StreamScopedRoutes(stream DiscoveryRequest) returns (stream DiscoveryResponse) {
-  }
-
-  rpc DeltaScopedRoutes(stream DeltaDiscoveryRequest) returns (stream DeltaDiscoveryResponse) {
-  }
-
-  rpc FetchScopedRoutes(DiscoveryRequest) returns (DiscoveryResponse) {
-    option (google.api.http).post = "/v2/discovery:scoped-routes";
-    option (google.api.http).body = "*";
-  }
-}
-
-// [#not-implemented-hide:] Not configuration. Workaround c++ protobuf issue with importing
-// services: https://github.com/google/protobuf/issues/4221 and protoxform to upgrade the file.
-message SrdsDummy {
-}
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
index b709e891994..f273f2e695f 100644
--- 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
@@ -4,6 +4,7 @@ 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";
 
@@ -17,6 +18,7 @@ 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]
@@ -29,32 +31,20 @@ message AccessLog {
 
   reserved "config";
 
-  // The name of the access log implementation to instantiate. The name must
-  // match a statically registered access log. Current built-in loggers include:
-  //
-  // #. "envoy.access_loggers.file"
-  // #. "envoy.access_loggers.http_grpc"
-  // #. "envoy.access_loggers.tcp_grpc"
+  // 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 depends on the access log being instantiated.
-  // Built-in configurations include:
-  //
-  // #. "envoy.access_loggers.file": :ref:`FileAccessLog
-  //    <envoy_api_msg_extensions.access_loggers.file.v3.FileAccessLog>`
-  // #. "envoy.access_loggers.http_grpc": :ref:`HttpGrpcAccessLogConfig
-  //    <envoy_api_msg_extensions.access_loggers.grpc.v3.HttpGrpcAccessLogConfig>`
-  // #. "envoy.access_loggers.tcp_grpc": :ref:`TcpGrpcAccessLogConfig
-  //    <envoy_api_msg_extensions.access_loggers.grpc.v3.TcpGrpcAccessLogConfig>`
+  // 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: 13]
+// [#next-free-field: 14]
 message AccessLogFilter {
   option (udpa.annotations.versioning).previous_message_type =
       "envoy.config.filter.accesslog.v2.AccessLogFilter";
@@ -93,10 +83,14 @@ message AccessLogFilter {
     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;
   }
 }
 
@@ -114,13 +108,16 @@ message ComparisonFilter {
 
     // <=
     LE = 2;
+
+    // !=
+    NE = 3;
   }
 
   // Comparison operator.
   Op op = 1 [(validate.rules).enum = {defined_only: true}];
 
   // Value to compare against.
-  core.v3.RuntimeUInt32 value = 2;
+  core.v3.RuntimeUInt32 value = 2 [(validate.rules).message = {required: true}];
 }
 
 // Filters on HTTP response/status code.
@@ -132,7 +129,10 @@ message StatusCodeFilter {
   ComparisonFilter comparison = 1 [(validate.rules).message = {required: true}];
 }
 
-// Filters on total request duration in milliseconds.
+// 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";
@@ -155,35 +155,38 @@ message TraceableFilter {
       "envoy.config.filter.accesslog.v2.TraceableFilter";
 }
 
-// Filters for random sampling of requests.
+// Filters requests based on runtime-configurable sampling rates.
 message RuntimeFilter {
   option (udpa.annotations.versioning).previous_message_type =
       "envoy.config.filter.accesslog.v2.RuntimeFilter";
 
-  // Runtime key to get an optional overridden numerator for use in the
-  // *percent_sampled* field. If found in runtime, this value will replace the
-  // default numerator.
+  // 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}];
 
-  // The default sampling percentage. If not specified, defaults to 0% with
-  // denominator of 100.
+  // 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;
 
-  // By default, sampling pivots on the header
-  // :ref:`x-request-id<config_http_conn_man_headers_x-request-id>` being
-  // present. If :ref:`x-request-id<config_http_conn_man_headers_x-request-id>`
-  // is present, the filter will consistently sample across multiple hosts based
-  // on the runtime key value and the value extracted from
-  // :ref:`x-request-id<config_http_conn_man_headers_x-request-id>`. If it is
-  // missing, or *use_independent_randomness* is set to true, the filter will
-  // randomly sample based on the runtime key value alone.
-  // *use_independent_randomness* can be used for logging kill switches within
-  // complex nested :ref:`AndFilter
-  // <envoy_api_msg_config.accesslog.v3.AndFilter>` and :ref:`OrFilter
-  // <envoy_api_msg_config.accesslog.v3.OrFilter>` blocks that are easier to
-  // reason about from a probability perspective (i.e., setting to true will
-  // cause the filter to behave like an independent random variable when
-  // composed within logical operator filters).
+  // 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;
 }
 
@@ -254,6 +257,13 @@ message ResponseFlagFilter {
         in: "RFCF"
         in: "NFCF"
         in: "DT"
+        in: "UPE"
+        in: "NC"
+        in: "OM"
+        in: "DF"
+        in: "DO"
+        in: "DR"
+        in: "UDO"
       }
     }
   }];
@@ -314,6 +324,17 @@ message MetadataFilter {
   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 =
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..7b862c1021a
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/config/bootstrap/v3/bootstrap.proto
@@ -0,0 +1,786 @@
+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/matcher/v3/string.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 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::
+  //
+  //   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`` exist,
+  // 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::
+  //
+  //   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 client 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: 8]
+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;
+
+  // List of admin paths that are accessible. If not specified, all admin endpoints are accessible.
+  //
+  // When specified, only paths in this list will be accessible, all others will return ``HTTP 403 Forbidden``.
+  //
+  // Example:
+  //
+  // .. code-block:: yaml
+  //
+  //   allow_paths:
+  //   - exact: /stats
+  //   - exact: /ready
+  //   - prefix: /healthcheck
+  //
+  repeated type.matcher.v3.StringMatcher allow_paths = 7;
+}
+
+// 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.
+//
+// .. note::
+//
+//   If using an unsafe action that could get stuck or deadlock, it is 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 the ``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 contain
+// 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/aggregate/v2alpha/cluster.proto b/xds/third_party/envoy/src/main/proto/envoy/config/cluster/aggregate/v2alpha/cluster.proto
deleted file mode 100644
index a0fdadd7572..00000000000
--- a/xds/third_party/envoy/src/main/proto/envoy/config/cluster/aggregate/v2alpha/cluster.proto
+++ /dev/null
@@ -1,24 +0,0 @@
-syntax = "proto3";
-
-package envoy.config.cluster.aggregate.v2alpha;
-
-import "udpa/annotations/migrate.proto";
-import "udpa/annotations/status.proto";
-import "validate/validate.proto";
-
-option java_package = "io.envoyproxy.envoy.config.cluster.aggregate.v2alpha";
-option java_outer_classname = "ClusterProto";
-option java_multiple_files = true;
-option (udpa.annotations.file_migrate).move_to_package = "envoy.extensions.clusters.aggregate.v3";
-option (udpa.annotations.file_status).package_version_status = FROZEN;
-
-// [#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 {
-  // 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}];
-}
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
index 96e69701cda..fe798ceb090 100644
--- 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
@@ -14,6 +14,7 @@ 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]
@@ -25,7 +26,7 @@ message CircuitBreakers {
       "envoy.api.v2.cluster.CircuitBreakers";
 
   // A Thresholds defines CircuitBreaker settings for a
-  // :ref:`RoutingPriority<envoy_api_enum_config.core.v3.RoutingPriority>`.
+  // :ref:`RoutingPriority<envoy_v3_api_enum_config.core.v3.RoutingPriority>`.
   // [#next-free-field: 9]
   message Thresholds {
     option (udpa.annotations.versioning).previous_message_type =
@@ -49,7 +50,7 @@ message CircuitBreakers {
       google.protobuf.UInt32Value min_retry_concurrency = 2;
     }
 
-    // The :ref:`RoutingPriority<envoy_api_enum_config.core.v3.RoutingPriority>`
+    // 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}];
 
@@ -59,10 +60,12 @@ message CircuitBreakers {
 
     // 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
@@ -96,10 +99,23 @@ message CircuitBreakers {
     google.protobuf.UInt32Value max_connection_pools = 7;
   }
 
-  // If multiple :ref:`Thresholds<envoy_api_msg_config.cluster.v3.CircuitBreakers.Thresholds>`
-  // are defined with the same :ref:`RoutingPriority<envoy_api_enum_config.core.v3.RoutingPriority>`,
+  // 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_api_enum_config.core.v3.RoutingPriority>`, the default values
+  // :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
index 145a8b69519..192409096af 100644
--- 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
@@ -11,7 +11,9 @@ 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";
@@ -20,7 +22,10 @@ import "google/protobuf/struct.proto";
 import "google/protobuf/wrappers.proto";
 
 import "xds/core/v3/collection_entry.proto";
+import "xds/type/matcher/v3/matcher.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";
@@ -29,18 +34,19 @@ 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.
+// 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: 53]
+// [#next-free-field: 60]
 message Cluster {
   option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.Cluster";
 
@@ -107,11 +113,11 @@ message Cluster {
     // this option or not.
     CLUSTER_PROVIDED = 6;
 
-    // [#not-implemented-hide:] Use the new :ref:`load_balancing_policy
-    // <envoy_api_field_config.cluster.v3.Cluster.load_balancing_policy>` field to determine the LB policy.
-    // [#next-major-version: In the v3 API, we should consider deprecating the lb_policy field
-    // and instead using the new load_balancing_policy field as the one and only mechanism for
-    // configuring this.]
+    // 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;
   }
 
@@ -120,20 +126,33 @@ message Cluster {
   // 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_api_enum_value_config.cluster.v3.Cluster.DiscoveryType.STRICT_DNS>` and
-  // :ref:`LOGICAL_DNS<envoy_api_enum_value_config.cluster.v3.Cluster.DiscoveryType.LOGICAL_DNS>`,
+  // :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_api_field_config.cluster.v3.Cluster.http2_protocol_options>` are
+    // 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;
 
@@ -150,14 +169,15 @@ message Cluster {
     // The name of the match, used in stats generation.
     string name = 1 [(validate.rules).string = {min_len: 1}];
 
-    // Optional endpoint metadata match criteria.
+    // 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
+    // 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;
   }
 
@@ -171,6 +191,7 @@ message Cluster {
 
     // 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;
   }
 
@@ -190,7 +211,7 @@ message Cluster {
 
   // Optionally divide the endpoints in this cluster into subsets defined by
   // endpoint metadata and selected by route and weighted cluster metadata.
-  // [#next-free-field: 8]
+  // [#next-free-field: 9]
   message LbSubsetConfig {
     option (udpa.annotations.versioning).previous_message_type =
         "envoy.api.v2.Cluster.LbSubsetConfig";
@@ -206,6 +227,52 @@ message Cluster {
       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 =
@@ -229,7 +296,7 @@ message Cluster {
 
         // If KEYS_SUBSET is selected, subset selector matching is performed again with metadata
         // keys reduced to
-        // :ref:`fallback_keys_subset<envoy_api_field_config.cluster.v3.Cluster.LbSubsetConfig.LbSubsetSelector.fallback_keys_subset>`.
+        // :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;
@@ -241,12 +308,9 @@ message Cluster {
       // 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, unless the host is unhealthy.
-      //
-      // Currently, this mode is only supported if `subset_selectors` has only one entry, and `keys` contains
-      // only one entry.
+      // 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`
+      // 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.
@@ -258,34 +322,34 @@ message Cluster {
           [(validate.rules).enum = {defined_only: true}];
 
       // Subset of
-      // :ref:`keys<envoy_api_field_config.cluster.v3.Cluster.LbSubsetConfig.LbSubsetSelector.keys>` used by
-      // :ref:`KEYS_SUBSET<envoy_api_enum_value_config.cluster.v3.Cluster.LbSubsetConfig.LbSubsetSelector.LbSubsetSelectorFallbackPolicy.KEYS_SUBSET>`
+      // :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_api_field_config.cluster.v3.Cluster.LbSubsetConfig.LbSubsetSelector.keys>` are allowed, but
-      // `fallback_keys_subset` cannot be equal to `keys`.
+      // :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_api_enum_value_config.cluster.v3.Cluster.LbSubsetConfig.LbSubsetFallbackPolicy.NO_FALLBACK>`.
+    // :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_api_enum_value_config.cluster.v3.Cluster.LbSubsetConfig.LbSubsetFallbackPolicy.DEFAULT_SUBSET>`.
+    // :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*
+    // 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_api_enum_value_config.cluster.v3.Cluster.LbSubsetConfig.LbSubsetFallbackPolicy.NO_FALLBACK>`.
+    // :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
+    // ``envoy.lb`` namespace is traversed and a subset is created for each unique
     // combination of key and value. For example:
     //
     // .. code-block:: json
@@ -330,6 +394,50 @@ message Cluster {
     // 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.
@@ -344,18 +452,18 @@ message Cluster {
     // 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`
+    // ``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.
+    // ``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
+    // 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
+    // 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
@@ -365,6 +473,10 @@ message Cluster {
     // .. 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>`
@@ -389,39 +501,39 @@ message Cluster {
     // 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_api_field_config.cluster.v3.Cluster.RingHashLbConfig.maximum_ring_size>`.
+    // :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_api_enum_value_config.cluster.v3.Cluster.RingHashLbConfig.HashFunction.XX_HASH>`.
+    // :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_api_field_config.cluster.v3.Cluster.RingHashLbConfig.minimum_ring_size>`.
+    // :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. The Maglev aims for ‘minimal disruption’ rather than an absolute guarantee.
-    // Minimal disruption means that when the set of upstreams changes, a connection will likely be sent to the same
+    // 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. If it is not specified, the default is 65537.
-    google.protobuf.UInt64Value table_size = 1;
+    // 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, :ref:`x-envoy-original-dst-host
-    // <config_http_conn_man_headers_x-envoy-original-dst-host>` can be used to override destination
-    // address.
+    // 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::
     //
@@ -433,10 +545,22 @@ message Cluster {
     //
     //   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: 8]
+  // [#next-free-field: 9]
   message CommonLbConfig {
     option (udpa.annotations.versioning).previous_message_type =
         "envoy.api.v2.Cluster.CommonLbConfig";
@@ -479,7 +603,7 @@ message Cluster {
       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
+      // 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;
 
@@ -491,7 +615,7 @@ message Cluster {
       // 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
+      // ``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
@@ -499,7 +623,7 @@ message Cluster {
       //
       // 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
+      // 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}];
     }
@@ -529,9 +653,10 @@ message Cluster {
     // 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.
+    // .. 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
@@ -539,12 +664,20 @@ message Cluster {
     // 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
+    // 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 {
@@ -552,7 +685,7 @@ message Cluster {
 
     // Specifies the base interval between refreshes. This parameter is required and must be greater
     // than zero and less than
-    // :ref:`max_interval <envoy_api_field_config.cluster.v3.Cluster.RefreshRate.max_interval>`.
+    // :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}
@@ -560,8 +693,8 @@ message Cluster {
 
     // Specifies the maximum interval between refreshes. This parameter is optional, but must be
     // greater than or equal to the
-    // :ref:`base_interval <envoy_api_field_config.cluster.v3.Cluster.RefreshRate.base_interval>`  if set. The default
-    // is 10 times the :ref:`base_interval <envoy_api_field_config.cluster.v3.Cluster.RefreshRate.base_interval>`.
+    // :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}}];
   }
 
@@ -593,10 +726,10 @@ message Cluster {
     google.protobuf.DoubleValue per_upstream_preconnect_ratio = 1
         [(validate.rules).double = {lte: 3.0 gte: 1.0}];
 
-    // Indicates how many many streams (rounded up) can be anticipated across a cluster for each
+    // 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
+    // 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.
     //
@@ -615,6 +748,9 @@ message Cluster {
     // 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.
+    //
+    // This is limited somewhat arbitrarily to 3 because preconnecting too aggressively can
+    // harm latency more than the preconnecting helps.
     google.protobuf.DoubleValue predictive_preconnect_ratio = 2
         [(validate.rules).double = {lte: 3.0 gte: 1.0}];
   }
@@ -623,12 +759,14 @@ message Cluster {
 
   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_api_field_config.endpoint.v3.LbEndpoint.metadata>`
-  // is used to match against the transport sockets as they appear in the list. The first
-  // :ref:`match <envoy_api_msg_config.cluster.v3.Cluster.TransportSocketMatch>` is used.
-  // For example, with the following match
+  // 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
   //
@@ -644,16 +782,17 @@ message Cluster {
   //    transport_socket:
   //      name: envoy.transport_sockets.raw_buffer
   //
-  // Connections to the endpoints whose metadata value under *envoy.transport_socket_match*
+  // 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_api_msg_config.cluster.v3.Cluster.TransportSocketMatch>` with empty match
+  // 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*, socket configuration fallbacks to use the *tls_context* or
-  // *transport_socket* specified in this cluster.
+  // 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.
   //
@@ -664,28 +803,68 @@ message Cluster {
   //
   // 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.
+  // ``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_api_field_config.core.v3.HealthCheck.transport_socket_match_criteria>` field.
+  // :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;
 
+  // Optional matcher that selects a transport socket from
+  // :ref:`transport_socket_matches <envoy_v3_api_field_config.cluster.v3.Cluster.transport_socket_matches>`.
+  //
+  // This matcher uses the generic xDS matcher framework to select a named transport socket
+  // based on various inputs available at transport socket selection time.
+  //
+  // Supported matching inputs:
+  //
+  // * ``endpoint_metadata``: Extract values from the selected endpoint's metadata.
+  // * ``locality_metadata``: Extract values from the endpoint's locality metadata.
+  // * ``transport_socket_filter_state``: Extract values from filter state that was explicitly shared from
+  //   downstream to upstream via ``TransportSocketOptions``. This enables flexible
+  //   downstream-connection-based matching, such as:
+  //
+  //   - Network namespace matching.
+  //   - Custom connection attributes.
+  //   - Any data explicitly passed via filter state.
+  //
+  // .. note::
+  //   Filter state sharing follows the same pattern as tunneling in Envoy. Filters must explicitly
+  //   share data by setting filter state with the appropriate sharing mode. The filter state is
+  //   then accessible via the ``transport_socket_filter_state`` input during transport socket selection.
+  //
+  // If this field is set, it takes precedence over legacy metadata-based selection
+  // performed by :ref:`transport_socket_matches
+  // <envoy_v3_api_field_config.cluster.v3.Cluster.transport_socket_matches>` alone.
+  // If the matcher does not yield a match, Envoy uses the default transport socket
+  // configured for the cluster.
+  //
+  // When using this field, each entry in
+  // :ref:`transport_socket_matches <envoy_v3_api_field_config.cluster.v3.Cluster.transport_socket_matches>`
+  // must have a unique ``name``. The matcher outcome is expected to reference one of
+  // these names.
+  xds.type.matcher.v3.Matcher transport_socket_matcher = 59;
+
   // 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_api_field_config.cluster.v3.Cluster.alt_stat_name>` is not provided.
+  // <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 while emitting stats.
-  // 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;
+  // 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>`
@@ -700,6 +879,7 @@ message 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
@@ -709,19 +889,18 @@ message Cluster {
 
   // The :ref:`load balancer type <arch_overview_load_balancing_types>` to use
   // when picking a host in the cluster.
-  // [#comment:TODO: Remove enum constraint :ref:`LOAD_BALANCING_POLICY_CONFIG<envoy_api_enum_value_config.cluster.v3.Cluster.LbPolicy.LOAD_BALANCING_POLICY_CONFIG>` when implemented.]
-  LbPolicy lb_policy = 6 [(validate.rules).enum = {defined_only: true not_in: 7}];
+  LbPolicy lb_policy = 6 [(validate.rules).enum = {defined_only: true}];
 
   // Setting this is required for specifying members of
-  // :ref:`STATIC<envoy_api_enum_value_config.cluster.v3.Cluster.DiscoveryType.STATIC>`,
-  // :ref:`STRICT_DNS<envoy_api_enum_value_config.cluster.v3.Cluster.DiscoveryType.STRICT_DNS>`
-  // or :ref:`LOGICAL_DNS<envoy_api_enum_value_config.cluster.v3.Cluster.DiscoveryType.LOGICAL_DNS>` clusters.
-  // This field supersedes the *hosts* field in the v2 API.
+  // :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_api_msg_config.endpoint.v3.ClusterLoadAssignment>`.
+  //   :ref:`endpoint assignments<envoy_v3_api_msg_config.endpoint.v3.ClusterLoadAssignment>`.
   //
   endpoint.v3.ClusterLoadAssignment load_assignment = 33;
 
@@ -735,7 +914,11 @@ message Cluster {
   // 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.
-  google.protobuf.UInt32Value max_requests_per_connection = 9;
+  //
+  // .. 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;
@@ -743,113 +926,190 @@ message Cluster {
   // 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_api_field_extensions.upstreams.http.v3.HttpProtocolOptions.upstream_http_protocol_options>`
-  // in the :ref:`http_protocol_options <envoy_api_msg_extensions.upstreams.http.v3.HttpProtocolOptions>` message.
+  // :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_api_field_config.cluster.v3.Cluster.typed_extension_protocol_options>`.
-  // See ref:`upstream_http_protocol_options
-  // <envoy_api_field_extensions.upstreams.http.v3.HttpProtocolOptions.upstream_http_protocol_options>`
+  // :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];
+  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_api_field_extensions.upstreams.http.v3.HttpProtocolOptions.common_http_protocol_options>`
-  // in the :ref:`http_protocol_options <envoy_api_msg_extensions.upstreams.http.v3.HttpProtocolOptions>` message.
+  // :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_api_field_config.cluster.v3.Cluster.typed_extension_protocol_options>`.
-  // See ref:`upstream_http_protocol_options
-  // <envoy_api_field_extensions.upstreams.http.v3.HttpProtocolOptions.upstream_http_protocol_options>`
+  // :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];
+  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 in the
-  // :ref:`http_protocol_options <envoy_api_msg_extensions.upstreams.http.v3.HttpProtocolOptions>` message.
+  // 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_api_field_config.cluster.v3.Cluster.typed_extension_protocol_options>`.
-  // See ref:`upstream_http_protocol_options
-  // <envoy_api_field_extensions.upstreams.http.v3.HttpProtocolOptions.upstream_http_protocol_options>`
+  // :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];
+  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
+  // 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 in the
-  // :ref:`http_protocol_options <envoy_api_msg_extensions.upstreams.http.v3.HttpProtocolOptions>`
+  // 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_api_field_config.cluster.v3.Cluster.typed_extension_protocol_options>`.
-  // See ref:`upstream_http_protocol_options
-  // <envoy_api_field_extensions.upstreams.http.v3.HttpProtocolOptions.upstream_http_protocol_options>`
+  // :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];
+  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_api_enum_value_config.cluster.v3.Cluster.DiscoveryType.STRICT_DNS>`,
-  // or :ref:`LOGICAL_DNS<envoy_api_enum_value_config.cluster.v3.Cluster.DiscoveryType.LOGICAL_DNS>`,
+  // :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_api_enum_value_config.cluster.v3.Cluster.DiscoveryType.STRICT_DNS>`
-  // and :ref:`LOGICAL_DNS<envoy_api_enum_value_config.cluster.v3.Cluster.DiscoveryType.LOGICAL_DNS>`
+  // :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.
-  google.protobuf.Duration dns_refresh_rate = 16
-      [(validate.rules).duration = {gt {nanos: 1000000}}];
+  // 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_api_enum_value_config.cluster.v3.Cluster.DiscoveryType.STRICT_DNS>`,
-  // or :ref:`LOGICAL_DNS<envoy_api_enum_value_config.cluster.v3.Cluster.DiscoveryType.LOGICAL_DNS>`,
+  // :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_api_enum_value_config.cluster.v3.Cluster.DiscoveryType.STRICT_DNS>` and
-  // :ref:`LOGICAL_DNS<envoy_api_enum_value_config.cluster.v3.Cluster.DiscoveryType.LOGICAL_DNS>` this setting is
+  // 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.
-  RefreshRate dns_failure_refresh_rate = 44;
+  // 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.
-  bool respect_dns_ttl = 39;
+  // 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_api_enum_value_config.cluster.v3.Cluster.DnsLookupFamily.AUTO>`.
+  // :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_api_enum_value_config.cluster.v3.Cluster.DiscoveryType.STRICT_DNS>`,
-  // or :ref:`LOGICAL_DNS<envoy_api_enum_value_config.cluster.v3.Cluster.DiscoveryType.LOGICAL_DNS>`,
+  // :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_api_enum_value_config.cluster.v3.Cluster.DiscoveryType.STRICT_DNS>`
-  // and :ref:`LOGICAL_DNS<envoy_api_enum_value_config.cluster.v3.Cluster.DiscoveryType.LOGICAL_DNS>`
+  // :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.
-  // Setting this value causes failure if the
-  // ``envoy.restart_features.use_apple_api_for_dns_lookups`` runtime value is true during
-  // server startup. Apple's API only allows overriding DNS resolvers via system settings.
-  repeated core.v3.Address dns_resolvers = 18;
+  // 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"];
 
-  // [#next-major-version: Reconcile DNS options in a single message.]
   // Always use TCP queries instead of UDP queries for DNS lookups.
-  // Setting this value causes failure if the
-  // ``envoy.restart_features.use_apple_api_for_dns_lookups`` runtime value is true during
-  // server startup. Apple' API only uses UDP for DNS resolution.
-  bool use_tcp_for_dns_lookups = 45;
+  // 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
@@ -857,7 +1117,7 @@ message Cluster {
   OutlierDetection outlier_detection = 19;
 
   // The interval for removing stale hosts from a cluster type
-  // :ref:`ORIGINAL_DST<envoy_api_enum_value_config.cluster.v3.Cluster.DiscoveryType.ORIGINAL_DST>`.
+  // :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
@@ -867,7 +1127,7 @@ message Cluster {
   // 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_api_enum_value_config.cluster.v3.Cluster.DiscoveryType.ORIGINAL_DST>`
+  // :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 {}}];
 
@@ -881,9 +1141,9 @@ message Cluster {
 
   // Optional configuration for the load balancing algorithm selected by
   // LbPolicy. Currently only
-  // :ref:`RING_HASH<envoy_api_enum_value_config.cluster.v3.Cluster.LbPolicy.RING_HASH>`,
-  // :ref:`MAGLEV<envoy_api_enum_value_config.cluster.v3.Cluster.LbPolicy.MAGLEV>` and
-  // :ref:`LEAST_REQUEST<envoy_api_enum_value_config.cluster.v3.Cluster.LbPolicy.LEAST_REQUEST>`
+  // :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.
@@ -899,14 +1159,17 @@ message Cluster {
 
     // 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 `tls` and
-  // :ref:`UpstreamTlsContexts <envoy_api_msg_extensions.transport_sockets.tls.v3.UpstreamTlsContext>` in the `typed_config`.
+  // 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;
@@ -915,16 +1178,17 @@ message Cluster {
   // 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*.
+  // 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_api_msg_extensions.upstreams.http.v3.HttpProtocolOptions>` message.
+  // <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_api_field_config.cluster.v3.Cluster.typed_extension_protocol_options>`.
-  ClusterProtocolSelection protocol_selection = 26 [deprecated = true];
+  // :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;
@@ -954,9 +1218,8 @@ message Cluster {
   // servers of this cluster.
   repeated Filter filters = 40;
 
-  // [#not-implemented-hide:] New mechanism for LB policy configuration. Used only if the
-  // :ref:`lb_policy<envoy_api_field_config.cluster.v3.Cluster.lb_policy>` field has the value
-  // :ref:`LOAD_BALANCING_POLICY_CONFIG<envoy_api_enum_value_config.cluster.v3.Cluster.LbPolicy.LOAD_BALANCING_POLICY_CONFIG>`.
+  // 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:]
@@ -975,6 +1238,23 @@ message Cluster {
   // 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
@@ -983,9 +1263,10 @@ message Cluster {
   //
   // .. attention::
   //
-  //   This field has been deprecated in favor of `timeout_budgets`, part of
-  //   :ref:`track_cluster_stats <envoy_api_field_config.cluster.v3.Cluster.track_cluster_stats>`.
-  bool track_timeout_budgets = 47 [deprecated = true];
+  //   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.
   //
@@ -993,7 +1274,7 @@ message Cluster {
   // 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`
+  // 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.
@@ -1004,6 +1285,7 @@ message Cluster {
   // 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.
@@ -1012,12 +1294,12 @@ message Cluster {
   // Preconnect configuration for this cluster.
   PreconnectPolicy preconnect_policy = 50;
 
-  // If `connection_pool_per_downstream_connection` is true, the cluster will use a separate
+  // 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;
 }
 
-// [#not-implemented-hide:] Extensible load balancing policy configuration.
+// 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
@@ -1043,14 +1325,12 @@ message LoadBalancingPolicy {
     option (udpa.annotations.versioning).previous_message_type =
         "envoy.api.v2.LoadBalancingPolicy.Policy";
 
-    reserved 2;
-
-    reserved "config";
+    reserved 2, 1, 3;
 
-    // Required. The name of the LB policy.
-    string name = 1;
+    reserved "config", "name", "typed_config";
 
-    google.protobuf.Any typed_config = 3;
+    // [#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
@@ -1059,21 +1339,42 @@ message LoadBalancingPolicy {
   repeated Policy policies = 1;
 }
 
-// An extensible structure containing the address Envoy should bind to when
-// establishing upstream connections.
-message UpstreamBindConfig {
-  option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.UpstreamBindConfig";
-
-  // The address Envoy should bind to when establishing upstream connections.
-  core.v3.Address source_address = 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 {
@@ -1086,6 +1387,21 @@ message TrackClusterStats {
 
   // 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.
+  // 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
index 74f4a1137da..54611edbf16 100644
--- 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
@@ -2,6 +2,8 @@ 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";
@@ -11,19 +13,28 @@ 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 filters]
-// Upstream filters apply to the connections to the upstream cluster hosts.
+// [#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 to instantiate. The name must match a
-  // :ref:`supported filter <config_network_filters>`.
+  // 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
index 9bb5633e626..822d81da850 100644
--- 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
@@ -2,6 +2,8 @@ syntax = "proto3";
 
 package envoy.config.cluster.v3;
 
+import "envoy/config/core/v3/extension.proto";
+
 import "google/protobuf/duration.proto";
 import "google/protobuf/wrappers.proto";
 
@@ -12,20 +14,21 @@ 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: 22]
+// [#next-free-field: 26]
 message OutlierDetection {
   option (udpa.annotations.versioning).previous_message_type =
       "envoy.api.v2.cluster.OutlierDetection";
 
-  // The number of consecutive 5xx responses or local origin errors that are mapped
-  // to 5xx error codes before a consecutive 5xx ejection
-  // occurs. Defaults to 5.
+  // 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
@@ -35,12 +38,12 @@ message OutlierDetection {
 
   // 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_api_field_config.cluster.v3.OutlierDetection.max_ejection_time>`.
+  // 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% but will eject at least one host regardless of the value.
+  // 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
@@ -87,16 +90,16 @@ message OutlierDetection {
 
   // 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_api_field_config.cluster.v3.OutlierDetection.consecutive_local_origin_failure>`,
-  // :ref:`enforcing_consecutive_local_origin_failure<envoy_api_field_config.cluster.v3.OutlierDetection.enforcing_consecutive_local_origin_failure>`
+  // :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_api_field_config.cluster.v3.OutlierDetection.enforcing_local_origin_success_rate>`.
+  // :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_api_field_config.cluster.v3.OutlierDetection.split_external_local_origin_errors>`
+  // :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;
 
@@ -104,7 +107,7 @@ message OutlierDetection {
   // 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_api_field_config.cluster.v3.OutlierDetection.split_external_local_origin_errors>`
+  // :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}];
@@ -113,7 +116,7 @@ message OutlierDetection {
   // 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_api_field_config.cluster.v3.OutlierDetection.split_external_local_origin_errors>`
+  // :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}];
@@ -150,8 +153,28 @@ message OutlierDetection {
   // 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_api_field_config.cluster.v3.OutlierDetection.base_ejection_time>`
-  // for more information.
-  // Defaults to 300000ms or 300s.
+  // 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/matcher/v3/matcher.proto b/xds/third_party/envoy/src/main/proto/envoy/config/common/matcher/v3/matcher.proto
new file mode 100644
index 00000000000..9b189d1aa77
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/config/common/matcher/v3/matcher.proto
@@ -0,0 +1,239 @@
+syntax = "proto3";
+
+package envoy.config.common.matcher.v3;
+
+import "envoy/config/core/v3/extension.proto";
+import "envoy/config/route/v3/route_components.proto";
+import "envoy/type/matcher/v3/string.proto";
+
+import "udpa/annotations/status.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.config.common.matcher.v3";
+option java_outer_classname = "MatcherProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/config/common/matcher/v3;matcherv3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#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.
+//
+// .. note::
+//   Please use the syntactically equivalent :ref:`matching API <envoy_v3_api_msg_.xds.type.matcher.v3.Matcher>`
+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, the action will be taken but the caller will behave as if no
+    // match was found. This applies both to actions directly encoded in the
+    // action field and to actions returned from a nested matcher tree in the
+    // matcher field. A subsequent matcher 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 inverse 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 {
+    option (validate.required) = true;
+
+    // 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 the matcher failed.
+  // If specified, the ``OnMatch`` is used, and the matcher is considered
+  // to have matched.
+  // If not specified, the matcher is considered not to have matched.
+  OnMatch on_no_match = 3;
+}
+
+// Match configuration. This is a recursive structure which allows complex nested match
+// configurations to be built using various logical operators.
+// [#next-free-field: 11]
+message MatchPredicate {
+  // A set of match configurations used for logical operations.
+  message MatchSet {
+    // The list of rules that make up the set.
+    repeated MatchPredicate 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.
+    MatchPredicate not_match = 3;
+
+    // The match configuration will always match.
+    bool any_match = 4 [(validate.rules).bool = {const: true}];
+
+    // HTTP request headers match configuration.
+    HttpHeadersMatch http_request_headers_match = 5;
+
+    // HTTP request trailers match configuration.
+    HttpHeadersMatch http_request_trailers_match = 6;
+
+    // HTTP response headers match configuration.
+    HttpHeadersMatch http_response_headers_match = 7;
+
+    // HTTP response trailers match configuration.
+    HttpHeadersMatch http_response_trailers_match = 8;
+
+    // HTTP request generic body match configuration.
+    HttpGenericBodyMatch http_request_generic_body_match = 9;
+
+    // HTTP response generic body match configuration.
+    HttpGenericBodyMatch http_response_generic_body_match = 10;
+  }
+}
+
+// HTTP headers match configuration.
+message HttpHeadersMatch {
+  // HTTP headers to match.
+  repeated route.v3.HeaderMatcher headers = 1;
+}
+
+// HTTP generic body match configuration.
+// List of text strings and hex strings to be located in HTTP body.
+// All specified strings must be found in the HTTP body for positive match.
+// The search may be limited to specified number of bytes from the body start.
+//
+// .. attention::
+//
+//   Searching for patterns in HTTP body is potentially CPU-intensive. For each specified pattern, HTTP body is scanned byte by byte to find a match.
+//   If multiple patterns are specified, the process is repeated for each pattern. If location of a pattern is known, ``bytes_limit`` should be specified
+//   to scan only part of the HTTP body.
+message HttpGenericBodyMatch {
+  message GenericTextMatch {
+    oneof rule {
+      option (validate.required) = true;
+
+      // Text string to be located in HTTP body.
+      string string_match = 1 [(validate.rules).string = {min_len: 1}];
+
+      // Sequence of bytes to be located in HTTP body.
+      bytes binary_match = 2 [(validate.rules).bytes = {min_len: 1}];
+    }
+  }
+
+  // Limits search to specified number of bytes - default zero (no limit - match entire captured buffer).
+  uint32 bytes_limit = 1;
+
+  // List of patterns to match.
+  repeated GenericTextMatch patterns = 2 [(validate.rules).repeated = {min_items: 1}];
+}
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
index 8228450eb93..17a68269e34 100644
--- 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
@@ -2,10 +2,12 @@ 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";
@@ -13,6 +15,7 @@ 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]
@@ -30,19 +33,24 @@ message Pipe {
   uint32 mode = 2 [(validate.rules).uint32 = {lte: 511}];
 }
 
-// [#not-implemented-hide:] The address represents an envoy internal listener.
-// TODO(lambdai): Make this address available for listener and endpoint.
-// TODO(asraa): When address available, remove workaround from test/server/server_fuzz_test.cc:30.
+// 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;
 
-    // [#not-implemented-hide:] The :ref:`listener name <envoy_api_field_config.listener.v3.Listener.name>` of the destination internal listener.
+    // 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: 7]
+// [#next-free-field: 8]
 message SocketAddress {
   option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.core.SocketAddress";
 
@@ -57,13 +65,13 @@ message SocketAddress {
   // 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_api_msg_config.listener.v3.FilterChainMatch>`.] When used
-  // within an upstream :ref:`BindConfig <envoy_api_msg_config.core.v3.BindConfig>`, the address
+  // 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_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_api_field_config.core.v3.SocketAddress.resolver_name>`.
+  // <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 {
@@ -72,7 +80,7 @@ message SocketAddress {
     uint32 port_value = 3 [(validate.rules).uint32 = {lte: 65535}];
 
     // This is only valid if :ref:`resolver_name
-    // <envoy_api_field_config.core.v3.SocketAddress.resolver_name>` is specified below and the
+    // <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;
   }
@@ -81,7 +89,7 @@ message SocketAddress {
   // 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.
+  // ``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
@@ -89,6 +97,17 @@ message SocketAddress {
   // 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 {
@@ -96,30 +115,47 @@ message 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.)
+  // overridden, Linux defaults to 9.) Setting this to ``0`` disables TCP keepalive.
   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.)
+  // overridden, Linux defaults to 7200s (i.e., 2 hours.) Setting this to ``0`` disables
+  // TCP keepalive.
   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.)
+  // level configuration (unless overridden, Linux defaults to 75s.) Setting this to
+  // ``0`` disables TCP keepalive.
   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 [(validate.rules).message = {required: true}];
+  SocketAddress source_address = 1;
 
-  // Whether to set the *IP_FREEBIND* option when creating the socket. When this
+  // Whether to set the ``IP_FREEBIND`` option when creating the socket. When this
   // flag is set to true, allows the :ref:`source_address
-  // <envoy_api_field_config.cluster.v3.UpstreamBindConfig.source_address>` to be an IP 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
+  // 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;
@@ -127,6 +163,23 @@ message BindConfig {
   // 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
@@ -142,7 +195,8 @@ message Address {
 
     Pipe pipe = 2;
 
-    // [#not-implemented-hide:]
+    // 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;
   }
 }
@@ -155,6 +209,6 @@ 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.
+  // 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
index 55b504e7165..435b36190e0 100644
--- 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
@@ -11,9 +11,10 @@ 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]
+// [#protodoc-title: Backoff strategy]
 
 // Configuration defining a jittered exponential back off strategy.
 message BackoffStrategy {
@@ -21,7 +22,7 @@ message 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_api_field_config.core.v3.BackoffStrategy.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}
@@ -29,8 +30,8 @@ message BackoffStrategy {
 
   // Specifies the maximum interval between retries. This parameter is optional,
   // but must be greater than or equal to the :ref:`base_interval
-  // <envoy_api_field_config.core.v3.BackoffStrategy.base_interval>` if set. The default
+  // <envoy_v3_api_field_config.core.v3.BackoffStrategy.base_interval>` if set. The default
   // is 10 times the :ref:`base_interval
-  // <envoy_api_field_config.core.v3.BackoffStrategy.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
index c1f2a913aa5..978f365d5f9 100644
--- 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
@@ -12,6 +12,9 @@ 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";
@@ -20,6 +23,7 @@ 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]
@@ -66,12 +70,12 @@ enum TrafficDirection {
 message Locality {
   option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.core.Locality";
 
-  // Region this :ref:`zone <envoy_api_field_config.core.v3.Locality.zone>` belongs to.
+  // 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_api_field_config.endpoint.v3.LocalityLbEndpoints.locality>`,
+  // 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>`_
@@ -99,7 +103,7 @@ message BuildVersion {
 }
 
 // Version and identification for an Envoy extension.
-// [#next-free-field: 6]
+// [#next-free-field: 7]
 message Extension {
   option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.core.Extension";
 
@@ -117,7 +121,8 @@ message Extension {
   // [#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;
+  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.
@@ -126,12 +131,15 @@ message Extension {
 
   // 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: 12]
+// [#next-free-field: 13]
 message Node {
   option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.core.Node";
 
@@ -151,10 +159,10 @@ message Node {
   // optional, it should be set if any of the following features are used:
   // :ref:`statsd <arch_overview_statistics>`, :ref:`health check cluster
   // verification
-  // <envoy_api_field_config.core.v3.HealthCheck.HttpHealthCheck.service_name_matcher>`,
-  // :ref:`runtime override directory <envoy_api_msg_config.bootstrap.v3.Runtime>`,
+  // <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_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.add_user_agent>`,
+  // <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
@@ -165,6 +173,13 @@ message Node {
   // 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;
 
@@ -186,7 +201,7 @@ message Node {
 
   // 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`.
+  // 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;
@@ -194,8 +209,9 @@ message Node {
   // 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];
+  // 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,
@@ -223,9 +239,23 @@ message Node {
 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.*
+  // Key is the reverse DNS filter name, e.g. com.acme.widget. The ``envoy.*``
   // namespace is reserved for Envoy's built-in filters.
-  map<string, google.protobuf.Struct> filter_metadata = 1;
+  // 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.
@@ -236,7 +266,7 @@ message RuntimeUInt32 {
   uint32 default_value = 2;
 
   // Runtime key to get value for comparison. This value is used if defined.
-  string runtime_key = 3 [(validate.rules).string = {min_len: 1}];
+  string runtime_key = 3;
 }
 
 // Runtime derived percentage with a default when not specified.
@@ -245,7 +275,7 @@ message RuntimePercent {
   type.v3.Percent default_value = 1;
 
   // Runtime key to get value for comparison. This value is used if defined.
-  string runtime_key = 2 [(validate.rules).string = {min_len: 1}];
+  string runtime_key = 2;
 }
 
 // Runtime derived double with a default when not specified.
@@ -256,7 +286,7 @@ message RuntimeDouble {
   double default_value = 1;
 
   // Runtime key to get value for comparison. This value is used if defined.
-  string runtime_key = 2 [(validate.rules).string = {min_len: 1}];
+  string runtime_key = 2;
 }
 
 // Runtime derived bool with a default when not specified.
@@ -270,7 +300,100 @@ message RuntimeFeatureFlag {
   // 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 [(validate.rules).string = {min_len: 1}];
+  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.
@@ -286,9 +409,19 @@ message HeaderValue {
   //
   // 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 `-`.
+  // 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}
+    (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"
   ];
 }
 
@@ -297,18 +430,61 @@ 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.
-  google.protobuf.BoolValue append = 2;
+  // 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;
 }
 
@@ -319,7 +495,8 @@ message WatchedDirectory {
   string path = 1 [(validate.rules).string = {min_len: 1}];
 }
 
-// Data source consisting of either a file or an inline value.
+// 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";
 
@@ -334,14 +511,52 @@ message DataSource {
 
     // 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";
 
-  // Specifies parameters that control :ref:`retry backoff strategy <envoy_api_msg_config.core.v3.BackoffStrategy>`.
+  // 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;
@@ -350,6 +565,18 @@ message RetryPolicy {
   // 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.
@@ -382,7 +609,7 @@ message AsyncDataSource {
 }
 
 // Configuration for transport socket in :ref:`listeners <config_listeners>` and
-// :ref:`clusters <envoy_api_msg_config.cluster.v3.Cluster>`. If the configuration is
+// :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 {
@@ -409,10 +636,10 @@ message TransportSocket {
 // .. note::
 //
 //   Parsing of the runtime key's data is implemented such that it may be represented as a
-//   :ref:`FractionalPercent <envoy_api_msg_type.v3.FractionalPercent>` proto represented as JSON/YAML
+//   :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.
+//   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";
diff --git a/xds/third_party/envoy/src/main/proto/envoy/config/core/v3/cel.proto b/xds/third_party/envoy/src/main/proto/envoy/config/core/v3/cel.proto
new file mode 100644
index 00000000000..940a66d0b10
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/config/core/v3/cel.proto
@@ -0,0 +1,63 @@
+syntax = "proto3";
+
+package envoy.config.core.v3;
+
+import "udpa/annotations/status.proto";
+
+option java_package = "io.envoyproxy.envoy.config.core.v3";
+option java_outer_classname = "CelProto";
+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: CEL Expression Configuration]
+
+// CEL expression evaluation configuration.
+// These options control the behavior of the Common Expression Language runtime for
+// individual CEL expressions.
+message CelExpressionConfig {
+  // Enable string conversion functions for CEL expressions. When enabled, CEL expressions
+  // can convert values to strings using the ``string()`` function.
+  //
+  // .. attention::
+  //
+  //   This option is disabled by default to avoid unbounded memory allocation.
+  //   CEL evaluation cost is typically bounded by the expression size, but converting
+  //   arbitrary values (e.g., large messages, lists, or maps) to strings may allocate
+  //   memory proportional to input data size, which can be unbounded and lead to
+  //   memory exhaustion.
+  bool enable_string_conversion = 1;
+
+  // Enable string concatenation for CEL expressions. When enabled, CEL expressions
+  // can concatenate strings using the ``+`` operator.
+  //
+  // .. attention::
+  //
+  //   This option is disabled by default to avoid unbounded memory allocation.
+  //   While CEL normally bounds evaluation by expression size, enabling string
+  //   concatenation allows building outputs whose size depends on input data,
+  //   potentially causing large intermediate allocations and memory exhaustion.
+  bool enable_string_concat = 2;
+
+  // Enable string manipulation functions for CEL expressions. When enabled, CEL
+  // expressions can use additional string functions:
+  //
+  // * ``replace(old, new)`` - Replaces all occurrences of ``old`` with ``new``.
+  // * ``split(separator)`` - Splits a string into a list of substrings.
+  // * ``lowerAscii()`` - Converts ASCII characters to lowercase.
+  // * ``upperAscii()`` - Converts ASCII characters to uppercase.
+  //
+  // .. note::
+  //
+  //   Standard CEL string functions like ``contains()``, ``startsWith()``, and
+  //   ``endsWith()`` are always available regardless of this setting.
+  //
+  // .. attention::
+  //
+  //   This option is disabled by default to avoid unbounded memory allocation.
+  //   Although CEL generally bounds evaluation by expression size, functions such as
+  //   ``replace``, ``split``, ``lowerAscii()``, and ``upperAscii()`` can allocate memory
+  //   proportional to input data size. Under adversarial inputs this can lead to
+  //   unbounded allocations and memory exhaustion.
+  bool enable_string_functions = 3;
+}
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
index 9de03625dce..430562aa5bd 100644
--- 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
@@ -2,8 +2,11 @@ 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";
 
@@ -17,6 +20,7 @@ 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]
@@ -24,13 +28,11 @@ option (udpa.annotations.file_status).package_version_status = ACTIVE;
 // 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 v2, to ease migration to Envoy's stable API
-  // versioning. If a client does not support v2 (e.g. due to deprecation), this
-  // is an invalid value.
-  AUTO = 0 [deprecated = true];
+  // When not specified, we assume v3; it is the only supported version.
+  AUTO = 0;
 
-  // Use xDS v2 API.
-  V2 = 1 [deprecated = true];
+  // 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;
@@ -38,7 +40,7 @@ enum ApiVersion {
 
 // API configuration source. This identifies the API type and cluster that Envoy
 // will use to fetch an xDS API.
-// [#next-free-field: 9]
+// [#next-free-field: 10]
 message ApiConfigSource {
   option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.core.ApiConfigSource";
 
@@ -106,10 +108,20 @@ message ApiConfigSource {
 
   // 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_api_msg_config.core.v3.ConfigSource>` can be used to
+// 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 =
@@ -118,7 +130,7 @@ message AggregatedConfigSource {
 
 // [#not-implemented-hide:]
 // Self-referencing config source options. This is currently empty, but when
-// set in :ref:`ConfigSource <envoy_api_msg_config.core.v3.ConfigSource>` can be used to
+// 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";
@@ -138,22 +150,59 @@ message RateLimitSettings {
   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.
+  // 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_api_msg_config.route.v3.RouteConfiguration>`, :ref:`endpoints
+// <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: 8]
+// [#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
+  // 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;
@@ -161,20 +210,11 @@ message ConfigSource {
   oneof config_source_specifier {
     option (validate.required) = true;
 
-    // Path on the filesystem to source and watch for configuration updates.
-    // When sourcing configuration for :ref:`secret <envoy_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::
-    //
-    //   Envoy will only 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.
-    string path = 1;
+    // 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;
@@ -186,7 +226,7 @@ message ConfigSource {
     // [#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_api_field.ConfigSource.ads>` field, except that the client may use a
+    // :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
@@ -211,3 +251,33 @@ message ConfigSource {
   // 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
index b3552e3975a..68c8df4076e 100644
--- 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
@@ -11,6 +11,7 @@ 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:]
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
index ba66da6a8e3..cacc7b00c21 100644
--- 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
@@ -2,8 +2,6 @@ syntax = "proto3";
 
 package envoy.config.core.v3;
 
-import "envoy/config/core/v3/config_source.proto";
-
 import "google/protobuf/any.proto";
 
 import "udpa/annotations/status.proto";
@@ -12,6 +10,7 @@ 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]
@@ -24,38 +23,10 @@ message TypedExtensionConfig {
   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 *udpa.type.v1.TypedStruct*,
-  // the inner type URL of *TypedStruct* will be utilized. See the
+  // 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}];
 }
-
-// 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. 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/grpc_service.proto b/xds/third_party/envoy/src/main/proto/envoy/config/core/v3/grpc_service.proto
index e3730d01741..9c44006b2a9 100644
--- 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
@@ -18,33 +18,63 @@ 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_api_msg_config.core.v3.ApiConfigSource>` and filter configurations.
-// [#next-free-field: 6]
+// <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_api_msg_config.cluster.v3.Cluster>` :ref:`transport_socket
-    // <envoy_api_field_config.cluster.v3.Cluster.transport_socket>`.
+    // 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`.
+    // 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}];
+
+    // Specifies the retry backoff policy for re-establishing long‑lived xDS gRPC streams.
+    //
+    // This field is optional. If ``retry_back_off.max_interval`` is not provided, it will be set to
+    // ten times the configured ``retry_back_off.base_interval``.
+    //
+    // .. note::
+    //
+    //   This field is only honored for management‑plane xDS gRPC streams created from
+    //   :ref:`ApiConfigSource <envoy_v3_api_msg_config.core.v3.ApiConfigSource>` that use
+    //   ``envoy_grpc``. Data‑plane gRPC clients (for example external authorization or external
+    //   processing filters) must use :ref:`GrpcService.retry_policy
+    //   <envoy_v3_api_field_config.core.v3.GrpcService.retry_policy>` instead.
+    //
+    // If not set, xDS gRPC streams default to a base interval of 500ms and a maximum interval of 30s.
+    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: 9]
+  // [#next-free-field: 11]
   message GoogleGrpc {
     option (udpa.annotations.versioning).previous_message_type =
         "envoy.api.v2.core.GrpcService.GoogleGrpc";
@@ -124,6 +154,7 @@ message GrpcService {
 
         string name = 1;
 
+        // [#extension-category: envoy.grpc_credentials]
         oneof config_type {
           google.protobuf.Any typed_config = 3;
         }
@@ -140,7 +171,7 @@ message GrpcService {
 
         // URI of the token exchange service that handles token exchange requests.
         // [#comment:TODO(asraa): Add URI validation when implemented. Tracked by
-        // https://github.com/envoyproxy/protoc-gen-validate/issues/303]
+        // 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
@@ -228,16 +259,31 @@ message GrpcService {
     }
 
     // The target URI when using the `Google C++ gRPC client
-    // <https://github.com/grpc/grpc>`_. SSL credentials will be supplied in
-    // :ref:`channel_credentials <envoy_api_field_config.core.v3.GrpcService.GoogleGrpc.channel_credentials>`.
+    // <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 set of call credentials that can be composed with `channel credentials
+    // 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.
     //
@@ -292,4 +338,18 @@ message GrpcService {
   // documentation on :ref:`custom request headers
   // <config_http_conn_man_headers_custom_request_headers>`.
   repeated HeaderValue initial_metadata = 5;
+
+  // Optional default retry policy for RPCs or streams initiated toward this gRPC service.
+  //
+  // If an async stream does not have a retry policy configured in its per‑stream options, this
+  // policy is used as the default.
+  //
+  // .. note::
+  //
+  //   This field is only applied by Envoy gRPC (``envoy_grpc``) clients. Google gRPC
+  //   (``google_grpc``) clients currently ignore this field.
+  //
+  // If not specified, no default retry policy is applied at the client level and retries only occur
+  // when explicitly configured in per‑stream options.
+  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
index e4ad7429e0d..a4ed6e91818 100644
--- 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
@@ -4,6 +4,8 @@ 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";
@@ -13,6 +15,7 @@ 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";
@@ -20,6 +23,7 @@ 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]
@@ -29,7 +33,7 @@ option (udpa.annotations.file_status).package_version_status = ACTIVE;
 
 // Endpoint health status.
 enum HealthStatus {
-  // The health status is not known. This is interpreted by Envoy as *HEALTHY*.
+  // The health status is not known. This is interpreted by Envoy as ``HEALTHY``.
   UNKNOWN = 0;
 
   // Healthy.
@@ -42,18 +46,24 @@ enum HealthStatus {
   // `<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*.
+  // 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*.
+  // ``UNHEALTHY``.
   TIMEOUT = 4;
 
   // Degraded.
   DEGRADED = 5;
 }
 
-// [#next-free-field: 25]
+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";
 
@@ -68,12 +78,12 @@ message HealthCheck {
       // Hex encoded payload. E.g., "000000FF".
       string text = 1 [(validate.rules).string = {min_len: 1}];
 
-      // [#not-implemented-hide:] Binary payload.
+      // Binary payload.
       bytes binary = 2;
     }
   }
 
-  // [#next-free-field: 12]
+  // [#next-free-field: 15]
   message HttpHealthCheck {
     option (udpa.annotations.versioning).previous_message_type =
         "envoy.api.v2.core.HealthCheck.HttpHealthCheck";
@@ -85,19 +95,31 @@ message HealthCheck {
     // 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_api_field_config.endpoint.v3.Endpoint.HealthCheckConfig.hostname>` field.
-    string host = 1 [(validate.rules).string = {well_known_regex: HTTP_HEADER_VALUE strict: false}];
+    // :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 strict: false}];
+    // ``/healthcheck``.
+    string path = 2 [(validate.rules).string = {min_len: 1 well_known_regex: HTTP_HEADER_VALUE}];
 
-    // [#not-implemented-hide:] HTTP specific payload.
+    // 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;
 
-    // [#not-implemented-hide:] HTTP specific response.
-    Payload receive = 4;
+    // 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
@@ -114,18 +136,37 @@ message HealthCheck {
 
     // 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_api_msg_type.v3.Int64Range>`. The start and end of each
+    // 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_api_msg_type.matcher.v3.StringMatcher>`. See the :ref:`architecture overview
+    // <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 {
@@ -136,9 +177,16 @@ message HealthCheck {
     Payload send = 1;
 
     // When checking the response, “fuzzy” matching is performed such that each
-    // binary block must be found, and in the order specified, but not
+    // 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 {
@@ -170,9 +218,15 @@ message HealthCheck {
     // 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_api_field_config.endpoint.v3.Endpoint.HealthCheckConfig.hostname>` field.
+    // 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.
@@ -189,6 +243,7 @@ message HealthCheck {
 
     // 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;
     }
@@ -204,7 +259,7 @@ message HealthCheck {
 
     // Specifies the ALPN protocols for health check connections. This is useful if the
     // corresponding upstream is using ALPN-based :ref:`FilterChainMatch
-    // <envoy_api_msg_config.listener.v3.FilterChainMatch>` along with different protocols for health checks
+    // <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;
   }
@@ -234,16 +289,18 @@ message HealthCheck {
   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.
+  // 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 503
-  // this threshold is ignored and the host is considered unhealthy immediately.
+  // 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
@@ -288,7 +345,7 @@ message HealthCheck {
   // (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
+  // ``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
@@ -321,8 +378,18 @@ message HealthCheck {
   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>`.
-  // If empty, no event log will be written.
-  string event_log_path = 17;
+  //
+  // .. 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.
@@ -334,11 +401,16 @@ message HealthCheck {
   // 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_api_field_config.cluster.v3.Cluster.transport_socket_matches>`.
+  // :ref:`tranport socket matches <envoy_v3_api_field_config.cluster.v3.Cluster.transport_socket_matches>`.
   // For example, the following match criteria
   //
   // .. code-block:: yaml
@@ -346,7 +418,7 @@ message HealthCheck {
   //  transport_socket_match_criteria:
   //    useMTLS: true
   //
-  // Will match the following :ref:`cluster socket match <envoy_api_msg_config.cluster.v3.Cluster.TransportSocketMatch>`
+  // Will match the following :ref:`cluster socket match <envoy_v3_api_msg_config.cluster.v3.Cluster.TransportSocketMatch>`
   //
   // .. code-block:: yaml
   //
@@ -358,14 +430,14 @@ message HealthCheck {
   //      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_api_field_config.endpoint.v3.LbEndpoint.metadata>`.
+  // 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_api_field_config.cluster.v3.Cluster.transport_socket_matches>`,
-  // the cluster's :ref:`transport socket <envoy_api_field_config.cluster.v3.Cluster.transport_socket>`
+  // :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
index 5d1fc239e07..bac37c0d583 100644
--- 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
@@ -11,9 +11,10 @@ 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 ]
+// [#protodoc-title: HTTP service URI ]
 
 // Envoy external URI descriptor
 message HttpUri {
@@ -29,7 +30,7 @@ message HttpUri {
   //
   string uri = 1 [(validate.rules).string = {min_len: 1}];
 
-  // Specify how `uri` is to be fetched. Today, this requires an explicit
+  // 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>`_.
@@ -51,6 +52,7 @@ message HttpUri {
   // 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
index 069028d25fd..63e189e689e 100644
--- 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
@@ -2,11 +2,16 @@ 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";
@@ -14,6 +19,7 @@ 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]
@@ -24,23 +30,250 @@ message TcpProtocolOptions {
       "envoy.api.v2.core.TcpProtocolOptions";
 }
 
+// Config for keepalive probes in a QUIC connection.
+//
+// .. note::
+//
+//   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: 12]
+message QuicProtocolOptions {
+  // Config for QUIC connection migration across network interfaces, i.e. cellular to WIFI, upon
+  // network change events from the platform, i.e. the current network gets
+  // disconnected, or upon the QUIC detecting a bad connection. After migration, the
+  // connection may be on a different network other than the default network
+  // picked by the platform. Both iOS and Android will use a default network to interact with the internet, usually prefer unmetered network (WIFI)
+  // over metered ones (cellular). And users can specify which network to be used as the default. A connection on non-default network is only allowed to
+  // serve new requests for a certain period of time before being drained, and
+  // meanwhile, QUIC will try to migrate to the default network if possible.
+  message ConnectionMigrationSettings {
+    // Config for options to migrate idle connections which aren't serving any requests.
+    message MigrateIdleConnectionSettings {
+      // If idle connections are allowed to be migrated, only migrate the connection
+      // if it hasn't been idle for longer than this idle period. Otherwise, the
+      // connection will be closed instead.
+      // Default to 30s.
+      google.protobuf.Duration max_idle_time_before_migration = 1
+          [(validate.rules).duration = {gte {seconds: 1}}];
+    }
+
+    // Config whether and how to migrate idle connections.
+    // If absent, idle connections will not be migrated but be closed upon
+    // migration signals.
+    MigrateIdleConnectionSettings migrate_idle_connections = 1;
+
+    // After migrating to a non-default network interface, the connection will
+    // only be allowed to stay on that network for up to this period of time before
+    // being drained unless it migrates to the default network or that network
+    // gets picked as the default by the device by then.
+    // Default to 128s.
+    google.protobuf.Duration max_time_on_non_default_network = 2
+        [(validate.rules).duration = {gte {seconds: 1}}];
+  }
+
+  // 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`` byte 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 ``PING``s 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;
+
+  // A customized UDP socket and a QUIC packet writer using the socket for
+  // client connections. i.e. Mobile uses its own implementation to interact
+  // with platform socket APIs.
+  // If not present, the default platform-independent socket and writer will be used.
+  // [#extension-category: envoy.quic.client_packet_writer]
+  TypedExtensionConfig client_packet_writer = 10;
+
+  // Enable QUIC `connection migration
+  // <https://datatracker.ietf.org/doc/html/rfc9000#name-connection-migration>`
+  // to a different network interface when the current network is degrading or
+  // has become bad.
+  // In order to use a different network interface other than the platform's default one,
+  // a customized :ref:`client_packet_writer <envoy_v3_api_field_config.core.v3.QuicProtocolOptions.client_packet_writer>` needs to be configured to
+  // create UDP sockets on non-default networks.
+  // Only takes effect when runtime key ``envoy.reloadable_features.use_migration_in_quiche`` is true.
+  // If absent, the feature will be disabled.
+  // [#not-implemented-hide:]
+  ConnectionMigrationSettings connection_migration = 11;
+}
+
 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, as seen by the
-  // :ref:`router filter <config_http_filters_router>`.
+  // 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, as seen by the
-  // :ref:`router filter <config_http_filters_router>`.
-  // This field is intended to set with `auto_sni` field.
+  // 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";
@@ -54,14 +287,14 @@ message HttpProtocolOptions {
     // 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
+    // Reject client request. HTTP/1 requests are rejected with ``HTTP 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 header with name containing underscores. The header is dropped before the filter chain is
+    // 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.
+    // ``httpN.dropped_headers_with_underscores`` is incremented for each dropped header.
     DROP_HEADER = 2;
   }
 
@@ -70,9 +303,13 @@ message HttpProtocolOptions {
   // 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_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.
+  // <envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.drain_timeout>`.
+  //
+  // .. note::
+  //
+  //   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
@@ -80,37 +317,75 @@ message HttpProtocolOptions {
   //
   // 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_api_enum_value_config.overload.v3.ScaleTimersOverloadActionConfig.TimerType.HTTP_DOWNSTREAM_CONNECTION_IDLE>`.
+  // :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 connection will be closed. Drain sequence will occur prior to closing the connection if
-  // if's applicable. See :ref:`drain_timeout
-  // <envoy_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.drain_timeout>`.
-  // Note: not implemented for upstream connections.
+  // 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. If unconfigured, the default
-  // maximum number of request headers allowed is 100. Requests that exceed this limit will receive
-  // a 431 response for HTTP/1.x and cause a stream reset for HTTP/2.
+  // 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 ``HTTP 431`` response for HTTP/1.x and cause a stream
+  // reset for HTTP/2.
+  // Upstream responses that exceed this limit will result in a ``HTTP 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 ``80 KiB``.
+  // 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 ``HTTP 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.
+  // 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: 8]
+// [#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";
@@ -125,28 +400,36 @@ message Http1ProtocolOptions {
 
       // 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".
+      // ``"content-type"`` becomes ``"Content-Type"``, and ``"foo$b#$are"`` becomes ``"Foo$B#$Are"``.
+      //
+      // .. note::
+      //
+      //   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.
+  // ``http_proxy`` environment variable.
   google.protobuf.BoolValue allow_absolute_url = 1;
 
-  // Handle incoming HTTP/1.0 and HTTP 0.9 requests.
+  // 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.
+  // ``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
+  // 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.
+  // 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
@@ -157,21 +440,25 @@ message Http1ProtocolOptions {
   //
   // .. attention::
   //
-  //   Note that this only happens when Envoy is chunk encoding which occurs when:
+  //   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.
+  //   - 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`
+  // 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.
+  // 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
@@ -181,17 +468,56 @@ message Http1ProtocolOptions {
   // 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.
-  google.protobuf.Duration interval = 1 [(validate.rules).duration = {
-    required: true
-    gte {nanos: 1000000}
-  }];
+  // 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::
+  //
+  //   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}
@@ -199,11 +525,21 @@ message KeepaliveSettings {
 
   // 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%.
+  // 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: 16]
+// [#next-free-field: 19]
 message Http2ProtocolOptions {
   option (udpa.annotations.versioning).previous_message_type =
       "envoy.api.v2.core.Http2ProtocolOptions";
@@ -226,27 +562,33 @@ message Http2ProtocolOptions {
 
   // `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
+  // 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 2147483647.
+  // 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 268435456
-  // (256 * 1024 * 1024).
+  // <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::
   //
-  // 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.
+  //   ``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
@@ -254,18 +596,18 @@ message Http2ProtocolOptions {
   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. Currently, this has the same minimum/maximum/default as *initial_stream_window_size*.
+  // 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.
+  // [#not-implemented-hide:] Hiding until Envoy has full metadata support.
   // Still under implementation. DO NOT USE.
   //
-  // Allows metadata. See [metadata
+  // 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;
@@ -273,61 +615,51 @@ message Http2ProtocolOptions {
   // 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.
-  // NOTE: flood and abuse mitigation for upstream connections is presently enabled by the
-  // `envoy.reloadable_features.upstream_http2_flood_checks` flag.
+  // 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,
+  // 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.
-  // NOTE: flood and abuse mitigation for upstream connections is presently enabled by the
-  // `envoy.reloadable_features.upstream_http2_flood_checks` flag.
+  // 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
+  // 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``
+  // 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.
-  // NOTE: flood and abuse mitigation for upstream connections is presently enabled by the
-  // `envoy.reloadable_features.upstream_http2_flood_checks` flag.
+  // 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
+  // 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)
+  //   ``max_inbound_priority_frames_per_stream`` * (1 + ``opened_streams``)
   //
-  // the connection is terminated. For downstream connections the `opened_streams` is incremented when
+  // 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
+  // ``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 limit is 100.
-  // NOTE: flood and abuse mitigation for upstream connections is presently enabled by the
-  // `envoy.reloadable_features.upstream_http2_flood_checks` flag.
+  // 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
+  // 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)
+  //   ``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
+  // 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
+  // ``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.
-  // NOTE: flood and abuse mitigation for upstream connections is presently enabled by the
-  // `envoy.reloadable_features.upstream_http2_flood_checks` flag.
+  // 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}];
 
@@ -343,7 +675,8 @@ message Http2ProtocolOptions {
   // <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];
+  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,
@@ -364,8 +697,10 @@ message Http2ProtocolOptions {
   // 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:
+  // .. note::
+  //
+  //   Custom parameters specified through this field can not also be set in the
+  //   corresponding named parameters:
   //
   // .. code-block:: text
   //
@@ -386,6 +721,21 @@ message Http2ProtocolOptions {
   // 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;
+
+  // Controls whether to encode headers using huffman encoding.
+  // This can be useful in cases where the cpu spent encoding the headers isn't
+  // worth the network bandwidth saved e.g. for localhost.
+  // If unset, uses the data plane's default value.
+  google.protobuf.BoolValue enable_huffman_encoding = 18;
 }
 
 // [#not-implemented-hide:]
@@ -396,10 +746,62 @@ message GrpcProtocolOptions {
   Http2ProtocolOptions http2_protocol_options = 1;
 }
 
-// [#not-implemented-hide:]
-//
-// A message which allows using HTTP/3 as an upstream protocol.
-//
-// Eventually this will include configuration for tuning HTTP/3.
+// 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::
+  //
+  //   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 crumbling.
+  // 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
index 40b33f33ff5..2da5fe5fd4d 100644
--- 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
@@ -2,14 +2,65 @@ syntax = "proto3";
 
 package envoy.config.core.v3;
 
+import "envoy/config/core/v3/substitution_format_string.proto";
+
 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]
+// [#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 static value of the TLV.
+  // Only one of ``value`` or ``format_string`` may be set.
+  bytes value = 2;
+
+  // Uses the :ref:`format string <config_access_log_format_strings>` to dynamically
+  // populate the TLV value from stream information. This allows dynamic values
+  // such as metadata, filter state, or other stream properties to be included in
+  // the TLV.
+  //
+  // For example:
+  //
+  // .. code-block:: yaml
+  //
+  //   type: 0xF0
+  //   format_string:
+  //     text_format_source:
+  //       inline_string: "%DYNAMIC_METADATA(envoy.filters.network:key)%"
+  //
+  // The formatted string will be used directly as the TLV value.
+  // Only one of ``value`` or ``format_string`` may be set.
+  SubstitutionFormatString format_string = 3;
+}
 
 message ProxyProtocolConfig {
   enum Version {
@@ -22,4 +73,42 @@ message ProxyProtocolConfig {
 
   // 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.
+  //
+  // If there are multiple TLVs with the same type, only the TLVs from the highest precedence level
+  // will be used.
+  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
index b22169b86ae..ad73d72e490 100644
--- 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
@@ -9,13 +9,34 @@ 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 ]
+// [#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.
-// [#next-free-field: 7]
+//
+// 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";
 
@@ -30,6 +51,29 @@ message SocketOption {
     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;
@@ -53,4 +97,12 @@ message SocketOption {
   // 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
index 5d9c5b2ecd0..3edbf5f5f00 100644
--- 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
@@ -7,19 +7,32 @@ 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: 7]
+// [#next-free-field: 8]
 message SubstitutionFormatString {
   oneof format {
     option (validate.required) = true;
@@ -41,7 +54,8 @@ message SubstitutionFormatString {
     //   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];
+    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>`.
@@ -92,20 +106,31 @@ message SubstitutionFormatString {
   // * 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*.
+  // 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;
+  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
index 2db0ebcd7cd..a149f6095c1 100644
--- 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
@@ -15,6 +15,7 @@ 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]
@@ -34,12 +35,11 @@ message ClusterLoadAssignment {
   option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.ClusterLoadAssignment";
 
   // Load balancing policy settings.
-  // [#next-free-field: 6]
+  // [#next-free-field: 7]
   message Policy {
     option (udpa.annotations.versioning).previous_message_type =
         "envoy.api.v2.ClusterLoadAssignment.Policy";
 
-    // [#not-implemented-hide:]
     message DropOverload {
       option (udpa.annotations.versioning).previous_message_type =
           "envoy.api.v2.ClusterLoadAssignment.Policy.DropOverload";
@@ -74,7 +74,15 @@ message ClusterLoadAssignment {
     //    "throttle"_drop = 60%
     //    "lb"_drop = 20%  // 50% of the remaining 'actual' load, which is 40%.
     //    actual_outgoing_load = 20% // remaining after applying all categories.
-    // [#not-implemented-hide:]
+    //
+    // 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
@@ -98,12 +106,23 @@ message ClusterLoadAssignment {
     // 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_api_field_config.cluster.v3.Cluster.EdsClusterConfig.service_name>` value if specified
+  // <envoy_v3_api_field_config.cluster.v3.Cluster.EdsClusterConfig.service_name>` value if specified
   // in the cluster :ref:`EdsClusterConfig
-  // <envoy_api_msg_config.cluster.v3.Cluster.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.
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
index b880a38d1a3..eacc555df73 100644
--- 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
@@ -4,10 +4,14 @@ 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";
@@ -15,6 +19,7 @@ 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]
@@ -37,11 +42,27 @@ message Endpoint {
     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_api_field_config.core.v3.HealthCheck.HttpHealthCheck.host>` and
-    // :ref:`authority <envoy_api_field_config.core.v3.HealthCheck.GrpcHealthCheck.authority>`). Setting this
+    // (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.
@@ -50,7 +71,7 @@ message Endpoint {
   //
   //   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_api_field_config.core.v3.SocketAddress.resolver_name>`
+  //   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;
@@ -67,8 +88,15 @@ message Endpoint {
   // 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_api_field_config.route.v3.RouteAction.auto_host_rewrite>`.
+  // :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.
@@ -89,10 +117,10 @@ message LbEndpoint {
 
   // 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.
+  // 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_api_msg_config.route.v3.RouteAction>` metadata_match field
+  // :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;
 
@@ -102,27 +130,71 @@ message LbEndpoint {
   // 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, each host is presumed to have equal
-  // weight in a locality. The sum of the weights of all endpoints in the
-  // endpoint's locality must not exceed uint32_t maximal value (4294967295).
+  // 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 this is
-// generally only done if the different groups need to have different load
-// balancing weights or different priorities.
-// [#next-free-field: 7]
+// 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
@@ -140,9 +212,9 @@ message LocalityLbEndpoints {
   // default to the highest priority (0).
   //
   // Under usual circumstances, Envoy will only select endpoints for the highest
-  // priority (0). In the event all endpoints for a particular priority are
+  // 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.
+  // 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}];
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
index 7140ca05afc..6d12765cef5 100644
--- 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
@@ -8,6 +8,8 @@ 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";
@@ -15,14 +17,15 @@ 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_api_field_service.load_stats.v3.LoadStatsResponse.load_reporting_interval>`.
+// :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: 9]
+// [#next-free-field: 15]
 message UpstreamLocalityStats {
   option (udpa.annotations.versioning).previous_message_type =
       "envoy.api.v2.endpoint.UpstreamLocalityStats";
@@ -35,7 +38,8 @@ message UpstreamLocalityStats {
   // locality.
   uint64 total_successful_requests = 2;
 
-  // The total number of unfinished requests
+  // 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,
@@ -44,15 +48,54 @@ message UpstreamLocalityStats {
 
   // 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.
+  // 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;
 
-  // Stats for multi-dimensional load balancing.
+  // 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_api_field_service.load_stats.v3.LoadStatsResponse.report_endpoint_granularity>`.
+  // :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
@@ -117,8 +160,18 @@ message EndpointLoadMetricStats {
   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_api_msg_service.load_stats.v3.LoadStatsRequest>`
+// :ref:`LoadStatsRequest<envoy_v3_api_msg_service.load_stats.v3.LoadStatsRequest>`
 // Next ID: 7
 // [#next-free-field: 7]
 message ClusterStats {
@@ -160,8 +213,8 @@ message ClusterStats {
   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*.
+  // 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/filter/accesslog/v2/accesslog.proto b/xds/third_party/envoy/src/main/proto/envoy/config/filter/accesslog/v2/accesslog.proto
deleted file mode 100644
index 25d27bfbd10..00000000000
--- a/xds/third_party/envoy/src/main/proto/envoy/config/filter/accesslog/v2/accesslog.proto
+++ /dev/null
@@ -1,256 +0,0 @@
-syntax = "proto3";
-
-package envoy.config.filter.accesslog.v2;
-
-import "envoy/api/v2/core/base.proto";
-import "envoy/api/v2/route/route_components.proto";
-import "envoy/type/percent.proto";
-
-import "google/protobuf/any.proto";
-import "google/protobuf/struct.proto";
-
-import "udpa/annotations/migrate.proto";
-import "udpa/annotations/status.proto";
-import "validate/validate.proto";
-
-option java_package = "io.envoyproxy.envoy.config.filter.accesslog.v2";
-option java_outer_classname = "AccesslogProto";
-option java_multiple_files = true;
-option (udpa.annotations.file_migrate).move_to_package = "envoy.config.accesslog.v3";
-option (udpa.annotations.file_status).package_version_status = FROZEN;
-
-// [#protodoc-title: Common access log types]
-
-message AccessLog {
-  // The name of the access log implementation to instantiate. The name must
-  // match a statically registered access log. Current built-in loggers include:
-  //
-  // #. "envoy.access_loggers.file"
-  // #. "envoy.access_loggers.http_grpc"
-  // #. "envoy.access_loggers.tcp_grpc"
-  string name = 1;
-
-  // Filter which is used to determine if the access log needs to be written.
-  AccessLogFilter filter = 2;
-
-  // Custom configuration that depends on the access log being instantiated. Built-in
-  // configurations include:
-  //
-  // #. "envoy.access_loggers.file": :ref:`FileAccessLog
-  //    <envoy_api_msg_config.accesslog.v2.FileAccessLog>`
-  // #. "envoy.access_loggers.http_grpc": :ref:`HttpGrpcAccessLogConfig
-  //    <envoy_api_msg_config.accesslog.v2.HttpGrpcAccessLogConfig>`
-  // #. "envoy.access_loggers.tcp_grpc": :ref:`TcpGrpcAccessLogConfig
-  //    <envoy_api_msg_config.accesslog.v2.TcpGrpcAccessLogConfig>`
-  oneof config_type {
-    google.protobuf.Struct config = 3 [deprecated = true];
-
-    google.protobuf.Any typed_config = 4;
-  }
-}
-
-// [#next-free-field: 12]
-message 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.
-    ExtensionFilter extension_filter = 11;
-  }
-}
-
-// Filter on an integer comparison.
-message ComparisonFilter {
-  enum Op {
-    // =
-    EQ = 0;
-
-    // >=
-    GE = 1;
-
-    // <=
-    LE = 2;
-  }
-
-  // Comparison operator.
-  Op op = 1 [(validate.rules).enum = {defined_only: true}];
-
-  // Value to compare against.
-  api.v2.core.RuntimeUInt32 value = 2;
-}
-
-// Filters on HTTP response/status code.
-message StatusCodeFilter {
-  // Comparison.
-  ComparisonFilter comparison = 1 [(validate.rules).message = {required: true}];
-}
-
-// Filters on total request duration in milliseconds.
-message 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 {
-}
-
-// Filters for requests that are traceable. See the tracing overview for more
-// information on how a request becomes traceable.
-message TraceableFilter {
-}
-
-// Filters for random sampling of requests.
-message RuntimeFilter {
-  // Runtime key to get an optional overridden numerator for use in the *percent_sampled* field.
-  // If found in runtime, this value will replace the default numerator.
-  string runtime_key = 1 [(validate.rules).string = {min_bytes: 1}];
-
-  // The default sampling percentage. If not specified, defaults to 0% with denominator of 100.
-  type.FractionalPercent percent_sampled = 2;
-
-  // By default, sampling pivots on the header
-  // :ref:`x-request-id<config_http_conn_man_headers_x-request-id>` being present. If
-  // :ref:`x-request-id<config_http_conn_man_headers_x-request-id>` is present, the filter will
-  // consistently sample across multiple hosts based on the runtime key value and the value
-  // extracted from :ref:`x-request-id<config_http_conn_man_headers_x-request-id>`. If it is
-  // missing, or *use_independent_randomness* is set to true, the filter will randomly sample based
-  // on the runtime key value alone. *use_independent_randomness* can be used for logging kill
-  // switches within complex nested :ref:`AndFilter
-  // <envoy_api_msg_config.filter.accesslog.v2.AndFilter>` and :ref:`OrFilter
-  // <envoy_api_msg_config.filter.accesslog.v2.OrFilter>` blocks that are easier to reason about
-  // from a probability perspective (i.e., setting to true will cause the filter to behave like
-  // an independent random variable when composed within logical operator filters).
-  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 {
-  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 {
-  repeated AccessLogFilter filters = 2 [(validate.rules).repeated = {min_items: 2}];
-}
-
-// Filters requests based on the presence or value of a request header.
-message HeaderFilter {
-  // Only requests with a header which matches the specified HeaderMatcher will pass the filter
-  // check.
-  api.v2.route.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 {
-  // 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"
-      }
-    }
-  }];
-}
-
-// 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 {
-  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;
-}
-
-// Extension filter is statically registered at runtime.
-message ExtensionFilter {
-  // 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.Struct config = 2 [deprecated = true];
-
-    google.protobuf.Any typed_config = 3;
-  }
-}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/config/filter/fault/v2/fault.proto b/xds/third_party/envoy/src/main/proto/envoy/config/filter/fault/v2/fault.proto
deleted file mode 100644
index 016140d10f8..00000000000
--- a/xds/third_party/envoy/src/main/proto/envoy/config/filter/fault/v2/fault.proto
+++ /dev/null
@@ -1,87 +0,0 @@
-syntax = "proto3";
-
-package envoy.config.filter.fault.v2;
-
-import "envoy/type/percent.proto";
-
-import "google/protobuf/duration.proto";
-
-import "envoy/annotations/deprecation.proto";
-import "udpa/annotations/migrate.proto";
-import "udpa/annotations/status.proto";
-import "validate/validate.proto";
-
-option java_package = "io.envoyproxy.envoy.config.filter.fault.v2";
-option java_outer_classname = "FaultProto";
-option java_multiple_files = true;
-option (udpa.annotations.file_migrate).move_to_package = "envoy.extensions.filters.common.fault.v3";
-option (udpa.annotations.file_status).package_version_status = FROZEN;
-
-// [#protodoc-title: Common fault injection types]
-
-// Delay specification is used to inject latency into the
-// HTTP/gRPC/Mongo/Redis operation or delay proxying of TCP connections.
-// [#next-free-field: 6]
-message 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 {
-  }
-
-  reserved 2;
-
-  // Unused and deprecated. Will be removed in the next release.
-  FaultDelayType type = 1 [deprecated = true, (envoy.annotations.disallowed_by_default) = true];
-
-  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/Redis, the specified
-    // delay will be injected before a new request/operation. For TCP
-    // connections, the proxying of the connection upstream will be delayed
-    // for the specified period. 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.FractionalPercent percentage = 4;
-}
-
-// Describes a rate limit to be applied.
-message FaultRateLimit {
-  // Describes a fixed/constant rate limit.
-  message 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 {
-  }
-
-  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.FractionalPercent percentage = 2;
-}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/config/filter/http/fault/v2/fault.proto b/xds/third_party/envoy/src/main/proto/envoy/config/filter/http/fault/v2/fault.proto
deleted file mode 100644
index cb99b0d71bb..00000000000
--- a/xds/third_party/envoy/src/main/proto/envoy/config/filter/http/fault/v2/fault.proto
+++ /dev/null
@@ -1,129 +0,0 @@
-syntax = "proto3";
-
-package envoy.config.filter.http.fault.v2;
-
-import "envoy/api/v2/route/route_components.proto";
-import "envoy/config/filter/fault/v2/fault.proto";
-import "envoy/type/percent.proto";
-
-import "google/protobuf/wrappers.proto";
-
-import "udpa/annotations/migrate.proto";
-import "udpa/annotations/status.proto";
-import "validate/validate.proto";
-
-option java_package = "io.envoyproxy.envoy.config.filter.http.fault.v2";
-option java_outer_classname = "FaultProto";
-option java_multiple_files = true;
-option (udpa.annotations.file_migrate).move_to_package = "envoy.extensions.filters.http.fault.v3";
-option (udpa.annotations.file_status).package_version_status = FROZEN;
-
-// [#protodoc-title: Fault Injection]
-// Fault Injection :ref:`configuration overview <config_http_filters_fault_injection>`.
-// [#extension: envoy.filters.http.fault]
-
-message 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 {
-  }
-
-  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}];
-
-    // 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.FractionalPercent percentage = 3;
-}
-
-// [#next-free-field: 14]
-message HTTPFault {
-  // If specified, the filter will inject delays based on the values in the
-  // object.
-  filter.fault.v2.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_api_field_config.filter.http.fault.v2.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 api.v2.route.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.
-  filter.fault.v2.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;
-}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/config/filter/network/http_connection_manager/v2/http_connection_manager.proto b/xds/third_party/envoy/src/main/proto/envoy/config/filter/network/http_connection_manager/v2/http_connection_manager.proto
deleted file mode 100644
index c05032df21a..00000000000
--- a/xds/third_party/envoy/src/main/proto/envoy/config/filter/network/http_connection_manager/v2/http_connection_manager.proto
+++ /dev/null
@@ -1,681 +0,0 @@
-syntax = "proto3";
-
-package envoy.config.filter.network.http_connection_manager.v2;
-
-import "envoy/api/v2/core/config_source.proto";
-import "envoy/api/v2/core/protocol.proto";
-import "envoy/api/v2/route.proto";
-import "envoy/api/v2/scoped_route.proto";
-import "envoy/config/filter/accesslog/v2/accesslog.proto";
-import "envoy/config/trace/v2/http_tracer.proto";
-import "envoy/type/percent.proto";
-import "envoy/type/tracing/v2/custom_tag.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/migrate.proto";
-import "udpa/annotations/status.proto";
-import "validate/validate.proto";
-
-option java_package = "io.envoyproxy.envoy.config.filter.network.http_connection_manager.v2";
-option java_outer_classname = "HttpConnectionManagerProto";
-option java_multiple_files = true;
-option (udpa.annotations.file_migrate).move_to_package =
-    "envoy.extensions.filters.network.http_connection_manager.v3";
-option (udpa.annotations.file_status).package_version_status = FROZEN;
-
-// [#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: 37]
-message 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;
-
-    // [#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 = 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;
-  }
-
-  // [#next-free-field: 10]
-  message 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;
-    }
-
-    // The span name will be derived from this field. If
-    // :ref:`traffic_direction <envoy_api_field_Listener.traffic_direction>` is
-    // specified on the parent listener, then it is used instead of this field.
-    //
-    // .. attention::
-    //  This field has been deprecated in favor of `traffic_direction`.
-    OperationName operation_name = 1 [
-      deprecated = true,
-      (validate.rules).enum = {defined_only: true},
-      (envoy.annotations.disallowed_by_default) = true
-    ];
-
-    // A list of header names used to create tags for the active span. The header name is used to
-    // populate the tag name, and the header value is used to populate the tag value. The tag is
-    // created if the specified header name is present in the request's headers.
-    //
-    // .. attention::
-    //  This field has been deprecated in favor of :ref:`custom_tags
-    //  <envoy_api_field_config.filter.network.http_connection_manager.v2.HttpConnectionManager.tracing.custom_tags>`.
-    repeated string request_headers_for_tags = 2 [deprecated = true];
-
-    // 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_sampling' in the :ref:`HTTP Connection Manager
-    // <config_http_conn_man_runtime>`.
-    // Default: 100%
-    type.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.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.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.v2.CustomTag custom_tags = 8;
-
-    // Configuration for an external tracing provider.
-    // If not specified, no tracing will be performed.
-    //
-    // .. attention::
-    //   Please be aware that *envoy.tracers.opencensus* provider can only be configured once
-    //   in Envoy lifetime.
-    //   Any attempts to reconfigure it or to use different configurations for different HCM filters
-    //   will be rejected.
-    //   Such a constraint is inherent to OpenCensus itself. It cannot be overcome without changes
-    //   on OpenCensus side.
-    trace.v2.Tracing.Http provider = 9;
-  }
-
-  message InternalAddressConfig {
-    // Whether unix socket addresses should be considered internal.
-    bool unix_sockets = 1;
-  }
-
-  // [#next-free-field: 7]
-  message 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 {
-    // 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_api_field_route.RouteAction.upgrade_configs>` as documented in the
-    // :ref:`upgrade documentation <arch_overview_upgrades>`.
-    google.protobuf.BoolValue enabled = 3;
-  }
-
-  reserved 27;
-
-  // 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_bytes: 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.
-    api.v2.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_api_msg_config.trace.v2.Tracing>`.
-  Tracing tracing = 7;
-
-  // Additional settings for HTTP requests handled by the connection manager. These will be
-  // applicable to both HTTP1 and HTTP2 requests.
-  api.v2.core.HttpProtocolOptions common_http_protocol_options = 35;
-
-  // Additional HTTP/1 settings that are passed to the HTTP/1 codec.
-  api.v2.core.Http1ProtocolOptions http_protocol_options = 8;
-
-  // Additional HTTP/2 settings that are passed directly to the HTTP/2 codec.
-  api.v2.core.Http2ProtocolOptions http2_protocol_options = 9;
-
-  // 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;
-
-  // 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}];
-
-  // The maximum request headers size for incoming connections.
-  // If unconfigured, the default max request headers allowed is 60 KiB.
-  // Requests that exceed this limit will receive a 431 response.
-  // The max configurable limit is 96 KiB, based on current implementation
-  // constraints.
-  google.protobuf.UInt32Value max_request_headers_kb = 29
-      [(validate.rules).uint32 = {lte: 96 gt: 0}];
-
-  // The idle timeout for connections managed by the connection manager. The
-  // idle timeout is defined as the period in which there are no active
-  // requests. If not set, there is no idle timeout. When the idle timeout is
-  // reached the connection will be closed. If the connection is an HTTP/2
-  // connection a drain sequence will occur prior to closing the connection.
-  // This field is deprecated. Use :ref:`idle_timeout
-  // <envoy_api_field_config.filter.network.http_connection_manager.v2.HttpConnectionManager.common_http_protocol_options>`
-  // instead.
-  google.protobuf.Duration idle_timeout = 11
-      [deprecated = true, (envoy.annotations.disallowed_by_default) = true];
-
-  // 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_api_field_route.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_api_field_config.filter.network.http_connection_manager.v2.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.
-  //
-  // This timeout also 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_api_field_core.HttpProtocolOptions.max_stream_duration>` does not apply to this corner
-  // case.
-  //
-  // 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.
-  google.protobuf.Duration stream_idle_timeout = 24;
-
-  // 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;
-
-  // 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
-  // both when a connection hits the idle timeout 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 accesslog.v2.AccessLog access_log = 13;
-
-  // 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;
-
-  // 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;
-
-  // 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.
-  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_api_field_config.filter.network.http_connection_manager.v2.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;
-
-  // 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;
-
-  // 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_api_field_config.filter.network.http_connection_manager.v2.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_api_field_config.filter.network.http_connection_manager.v2.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>`_
-  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.
-  bool merge_slashes = 33;
-
-  // The configuration of the request ID extension. This includes operations such as
-  // generation, validation, and associated tracing operations.
-  //
-  // If not set, Envoy uses the default UUID-based behavior:
-  //
-  // 1. Request ID is propagated using *x-request-id* header.
-  //
-  // 2. Request ID is a universally unique identifier (UUID).
-  //
-  // 3. Tracing decision (sampled, forced, etc) is set in 14th byte of the UUID.
-  RequestIDExtension request_id_extension = 36;
-}
-
-message Rds {
-  // Configuration source specifier for RDS.
-  api.v2.core.ConfigSource config_source = 1 [(validate.rules).message = {required: true}];
-
-  // 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 [(validate.rules).string = {min_bytes: 1}];
-}
-
-// This message is used to work around the limitations with 'oneof' and repeated fields.
-message ScopedRouteConfigurationsList {
-  repeated api.v2.ScopedRouteConfiguration scoped_route_configurations = 1
-      [(validate.rules).repeated = {min_items: 1}];
-}
-
-// [#next-free-field: 6]
-message ScopedRoutes {
-  // Specifies the mechanism for constructing "scope keys" based on HTTP request attributes. These
-  // keys are matched against a set of :ref:`Key<envoy_api_msg_ScopedRouteConfiguration.Key>`
-  // objects assembled from :ref:`ScopedRouteConfiguration<envoy_api_msg_ScopedRouteConfiguration>`
-  // messages distributed via SRDS (the Scoped Route Discovery Service) or assigned statically via
-  // :ref:`scoped_route_configurations_list<envoy_api_field_config.filter.network.http_connection_manager.v2.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_api_msg_RouteConfiguration>`) to use for the request.
-  message ScopeKeyBuilder {
-    // Specifies the mechanism for constructing key fragments which are composed into scope keys.
-    message 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 {
-        // Specifies a header field's key value pair to match on.
-        message 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_bytes: 1}];
-
-          // The key to match on.
-          string key = 2 [(validate.rules).string = {min_bytes: 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_bytes: 1}];
-
-        // 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_api_msg_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_bytes: 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.
-  api.v2.core.ConfigSource rds_config_source = 3 [(validate.rules).message = {required: true}];
-
-  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_api_msg_config.filter.network.http_connection_manager.v2.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_api_msg_config.filter.network.http_connection_manager.v2.ScopedRoutes.ScopeKeyBuilder>`
-    // in this message.
-    ScopedRds scoped_rds = 5;
-  }
-}
-
-message ScopedRds {
-  // Configuration source specifier for scoped RDS.
-  api.v2.core.ConfigSource scoped_rds_config_source = 1
-      [(validate.rules).message = {required: true}];
-}
-
-message HttpFilter {
-  reserved 3;
-
-  // The name of the filter to instantiate. The name must match a
-  // :ref:`supported filter <config_http_filters>`.
-  string name = 1 [(validate.rules).string = {min_bytes: 1}];
-
-  // Filter specific configuration which depends on the filter being instantiated. See the supported
-  // filters for further documentation.
-  oneof config_type {
-    google.protobuf.Struct config = 2 [deprecated = true];
-
-    google.protobuf.Any typed_config = 4;
-  }
-}
-
-message RequestIDExtension {
-  // Request ID extension specific configuration.
-  google.protobuf.Any typed_config = 1;
-}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/config/listener/v2/api_listener.proto b/xds/third_party/envoy/src/main/proto/envoy/config/listener/v2/api_listener.proto
deleted file mode 100644
index 6709d5fe0b5..00000000000
--- a/xds/third_party/envoy/src/main/proto/envoy/config/listener/v2/api_listener.proto
+++ /dev/null
@@ -1,30 +0,0 @@
-syntax = "proto3";
-
-package envoy.config.listener.v2;
-
-import "google/protobuf/any.proto";
-
-import "udpa/annotations/migrate.proto";
-import "udpa/annotations/status.proto";
-
-option java_package = "io.envoyproxy.envoy.config.listener.v2";
-option java_outer_classname = "ApiListenerProto";
-option java_multiple_files = true;
-option (udpa.annotations.file_migrate).move_to_package = "envoy.config.listener.v3";
-option (udpa.annotations.file_status).package_version_status = FROZEN;
-
-// [#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 {
-  // The type in this field determines the type of API listener. At present, the following
-  // types are supported:
-  // envoy.config.filter.network.http_connection_manager.v2.HttpConnectionManager (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/api_listener.proto b/xds/third_party/envoy/src/main/proto/envoy/config/listener/v3/api_listener.proto
index 4d3879a22b1..a3610e65688 100644
--- 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
@@ -10,6 +10,7 @@ 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]
@@ -22,7 +23,8 @@ message ApiListener {
 
   // The type in this field determines the type of API listener. At present, the following
   // types are supported:
-  // envoy.config.filter.network.http_connection_manager.v2.HttpConnectionManager (HTTP)
+  // 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,
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
index 2b8a1d9298f..54ef2cfed38 100644
--- 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
@@ -5,6 +5,7 @@ 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";
@@ -15,7 +16,9 @@ import "google/protobuf/duration.proto";
 import "google/protobuf/wrappers.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";
@@ -24,18 +27,41 @@ 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>`
 
-// Listener list collections. Entries are *Listener* resources or references.
+// 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;
+
+  // Configures TCP keepalive settings for the additional address.
+  // If not set, the listener :ref:`tcp_keepalive <envoy_v3_api_field_config.listener.v3.Listener.tcp_keepalive>`
+  // configuration is inherited. You can explicitly disable TCP keepalive for the additional address by setting any keepalive field
+  // (:ref:`keepalive_probes <envoy_v3_api_field_config.core.v3.TcpKeepalive.keepalive_probes>`,
+  // :ref:`keepalive_time <envoy_v3_api_field_config.core.v3.TcpKeepalive.keepalive_time>`, or
+  // :ref:`keepalive_interval <envoy_v3_api_field_config.core.v3.TcpKeepalive.keepalive_interval>`) to ``0``.
+  core.v3.TcpKeepalive tcp_keepalive = 3;
+}
+
+// Listener list collections. Entries are ``Listener`` resources or references.
 // [#not-implemented-hide:]
 message ListenerCollection {
   repeated xds.core.v3.CollectionEntry entries = 1;
 }
 
-// [#next-free-field: 27]
+// [#next-free-field: 38]
 message Listener {
   option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.Listener";
 
@@ -60,7 +86,7 @@ message Listener {
     // set use_original_dst parameter to true. Default is true.
     //
     // This is deprecated. Use :ref:`Listener.bind_to_port
-    // <envoy_api_field_config.listener.v3.Listener.bind_to_port>`
+    // <envoy_v3_api_field_config.listener.v3.Listener.bind_to_port>`
     google.protobuf.BoolValue bind_to_port = 1;
   }
 
@@ -85,10 +111,33 @@ message Listener {
 
       // 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;
     }
   }
 
-  reserved 14;
+  // 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
@@ -98,18 +147,59 @@ message Listener {
   // 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.
-  core.v3.Address address = 2 [(validate.rules).message = {required: true}];
+  // Required unless ``api_listener`` or ``listener_specifier`` is populated.
+  //
+  // When the address contains a network namespace filepath (via
+  // :ref:`network_namespace_filepath <envoy_v3_api_field_config.core.v3.SocketAddress.network_namespace_filepath>`),
+  // Envoy automatically populates the filter state with key ``envoy.network.network_namespace``
+  // when a connection is accepted. This provides read-only access to the network namespace for
+  // filters, access logs, and other components.
+  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_api_msg_config.listener.v3.FilterChain>` with the most specific
-  // :ref:`FilterChainMatch <envoy_api_msg_config.listener.v3.FilterChainMatch>` criteria is used on a
+  // :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;
 
-  // If a connection is redirected using *iptables*, the port on which the proxy
+  // 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;
+
+  // 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
@@ -129,25 +219,30 @@ message Listener {
   core.v3.Metadata metadata = 6;
 
   // [#not-implemented-hide:]
-  DeprecatedV1 deprecated_v1 = 7 [deprecated = true];
+  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_api_field_config.listener.v3.Listener.filter_chains>`. Order matters as the
+  // :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_api_field_config.core.v3.SocketAddress.protocol>` is :ref:`UDP
-  // <envoy_api_enum_value_config.core.v3.SocketAddress.Protocol.UDP>`.
-  // UDP listeners currently support a single filter.
+  // :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
+  // ``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;
 
@@ -162,30 +257,33 @@ message Listener {
 
   // 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
+  // ``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_api_field_config.listener.v3.Listener.listener_filters>` to mark the connections' local addresses as
+  // <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
+  // 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.
+  // 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
+  // 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
+  // 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.
@@ -205,19 +303,19 @@ message Listener {
   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_api_field_config.core.v3.SocketAddress.protocol>` is :ref:`UDP
-  // <envoy_api_enum_value_config.core.v3.SocketAddress.Protocol.UDP>`, this field specifies the actual udp
-  // listener to create, i.e. :ref:`udp_listener_name
-  // <envoy_api_field_config.listener.v3.UdpListenerConfig.udp_listener_name>` = "raw_udp_listener" for
-  // creating a packet-oriented UDP listener. If not present, treat it as "raw_udp_listener".
+  // <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_api_field_config.listener.v3.Listener.name>`
+  // 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::
@@ -236,41 +334,122 @@ message Listener {
   // 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;
 
-  // When this flag is set to true, listeners set the *SO_REUSEPORT* socket option and
+  // 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.
+  // 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.
   //
-  // Before Linux v4.19-rc1, new TCP connections may be rejected during hot restart
-  // (see `3rd paragraph in 'soreuseport' commit message
-  // <https://github.com/torvalds/linux/commit/c617f398edd4db2b8567a28e89>`_).
-  // This issue was fixed by `tcp: Avoid TCP syncookie rejected by SO_REUSEPORT socket
-  // <https://github.com/torvalds/linux/commit/40a1227ea845a37ab197dd1caffb60b047fa36b1>`_.
-  bool reuse_port = 21;
+  // .. 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;
 
-  // If the protocol in the listener socket address in :ref:`protocol
-  // <envoy_api_field_config.core.v3.SocketAddress.protocol>` is :ref:`UDP
-  // <envoy_api_enum_value_config.core.v3.SocketAddress.Protocol.UDP>`, this field specifies the actual udp
-  // writer to create, i.e. :ref:`name <envoy_api_field_config.core.v3.TypedExtensionConfig.name>`
-  //    = "udp_default_writer" for creating a udp writer with writing in passthrough mode,
-  //    = "udp_gso_batch_writer" for creating a udp writer with writing in batch mode.
-  // If not present, treat it as "udp_default_writer".
-  // [#not-implemented-hide:]
-  core.v3.TypedExtensionConfig udp_writer_config = 23;
-
   // 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_api_field_config.listener.v3.Listener.use_original_dst>`
+  // :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;
+
+  // If set, TCP keepalive settings are configured for the listener address and inherited by
+  // additional addresses. If not set, TCP keepalive settings are not configured for the
+  // listener address and additional addresses by default. See :ref:`tcp_keepalive <envoy_v3_api_field_config.listener.v3.AdditionalAddress.tcp_keepalive>`
+  // to explicitly configure TCP keepalive settings for individual additional addresses.
+  core.v3.TcpKeepalive tcp_keepalive = 37;
+}
+
+// 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
index 4ee2f1b53fd..16b43568f39 100644
--- 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
@@ -4,13 +4,14 @@ package envoy.config.listener.v3;
 
 import "envoy/config/core/v3/address.proto";
 import "envoy/config/core/v3/base.proto";
-import "envoy/config/core/v3/extension.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";
@@ -18,6 +19,7 @@ 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]
@@ -31,19 +33,18 @@ message Filter {
 
   reserved "config";
 
-  // The name of the filter to instantiate. The name must match a
-  // :ref:`supported filter <config_network_filters>`.
+  // 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.
-    // [#not-implemented-hide:]
     core.v3.ExtensionConfigSource config_discovery = 5;
   }
 }
@@ -62,9 +63,12 @@ message Filter {
 // 3. Server name (e.g. SNI for TLS protocol),
 // 4. Transport protocol.
 // 5. Application protocols (e.g. ALPN for TLS protocol).
-// 6. Source type (e.g. any, local or external network).
-// 7. Source IP address.
-// 8. Source port.
+// 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
@@ -88,7 +92,7 @@ message Filter {
 // 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: 13]
+// [#next-free-field: 14]
 message FilterChainMatch {
   option (udpa.annotations.versioning).previous_message_type =
       "envoy.api.v2.listener.FilterChainMatch";
@@ -122,6 +126,11 @@ message FilterChainMatch {
   // [#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}];
 
@@ -145,6 +154,7 @@ message FilterChainMatch {
   // 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::
   //
@@ -191,24 +201,9 @@ message FilterChainMatch {
 message FilterChain {
   option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.listener.FilterChain";
 
-  // The configuration for on-demand filter chain. If this field is not empty in FilterChain message,
-  // a filter chain will be built on-demand.
-  // On-demand filter chains help speedup the warming up of listeners since the building and initialization of
-  // an on-demand filter chain will be postponed to the arrival of new connection requests that require this filter chain.
-  // Filter chains that are not often used can be set as on-demand.
-  message OnDemandConfiguration {
-    // The timeout to wait for filter chain placeholders to complete rebuilding.
-    // 1. If this field is set to 0, timeout is disabled.
-    // 2. If not specified, a default timeout of 15s is used.
-    // Rebuilding will wait until dependencies are ready, have failed, or this timeout is reached.
-    // Upon failure or timeout, all connections related to this filter chain will be closed.
-    // Rebuilding will start again on the next new connection.
-    google.protobuf.Duration rebuild_timeout = 1;
-  }
-
-  reserved 2;
+  reserved 2, 8;
 
-  reserved "tls_context";
+  reserved "tls_context", "on_demand_configuration";
 
   // The criteria to use when matching a connection to this filter chain.
   FilterChainMatch filter_chain_match = 1;
@@ -217,6 +212,12 @@ message FilterChain {
   // 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
@@ -229,16 +230,18 @@ message FilterChain {
   // 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];
+  google.protobuf.BoolValue use_proxy_proto = 4
+      [deprecated = true, (envoy.annotations.deprecated_at_minor_version) = "3.0"];
 
-  // [#not-implemented-hide:] filter chain metadata.
+  // 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 `tls` and
-  // :ref:`DownstreamTlsContext <envoy_api_msg_extensions.transport_sockets.tls.v3.DownstreamTlsContext>` in the `typed_config`.
+  // 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
@@ -246,15 +249,13 @@ message FilterChain {
   // establishment, the connection is summarily closed.
   google.protobuf.Duration transport_socket_connect_timeout = 9;
 
-  // [#not-implemented-hide:] The unique name (or empty) by which this filter chain is known. If no
-  // name is provided, Envoy will allocate an internal UUID for the filter chain. If the filter
-  // chain is to be dynamically updated or removed via FCDS a unique name must be provided.
+  // 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;
-
-  // [#not-implemented-hide:] The configuration to specify whether the filter chain will be built on-demand.
-  // If this field is not empty, the filter chain will be built on-demand.
-  // Otherwise, the filter chain will be built normally and block listener warming.
-  OnDemandConfiguration on_demand_configuration = 8;
 }
 
 // Listener filter chain match configuration. This is a recursive structure which allows complex
@@ -278,7 +279,7 @@ message FilterChain {
 //    rules:
 //      - destination_port_range:
 //          start: 3306
-//          end: 3306
+//          end: 3307
 //      - destination_port_range:
 //          start: 15000
 //          end: 15001
@@ -321,6 +322,7 @@ message ListenerFilterChainMatchPredicate {
   }
 }
 
+// [#next-free-field: 6]
 message ListenerFilter {
   option (udpa.annotations.versioning).previous_message_type =
       "envoy.api.v2.listener.ListenerFilter";
@@ -329,18 +331,23 @@ message ListenerFilter {
 
   reserved "config";
 
-  // The name of the filter to instantiate. The name must match a
-  // :ref:`supported filter <config_listener_filters>`.
+  // 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.
   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_api_msg_config.listener.v3.ListenerFilterChainMatchPredicate>`
+  // 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..c208a58f4a4
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/config/listener/v3/quic_config.proto
@@ -0,0 +1,108 @@
+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: 15]
+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;
+
+  // Maximum number of QUIC sessions to create per event loop.
+  // If not specified, the default value is 16.
+  // This is an equivalent of the TCP listener option
+  // max_connections_to_accept_per_socket_event.
+  google.protobuf.UInt32Value max_sessions_per_event_loop = 14 [(validate.rules).uint32 = {gt: 0}];
+}
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
index fe39be9b352..4e619b1f760 100644
--- 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
@@ -2,7 +2,9 @@ syntax = "proto3";
 
 package envoy.config.listener.v3;
 
-import "google/protobuf/any.proto";
+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";
@@ -10,29 +12,38 @@ 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]
+// [#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 2;
+  reserved 1, 2, 3, 4, 6;
 
   reserved "config";
 
-  // Used to look up UDP listener factory, matches "raw_udp_listener" or
-  // "quic_listener" to create a specific udp listener.
-  // If not specified, treat as "raw_udp_listener".
-  string udp_listener_name = 1;
-
-  // Used to create a specific listener factory. To some factory, e.g.
-  // "raw_udp_listener", config is not needed.
-  oneof config_type {
-    google.protobuf.Any typed_config = 3;
-  }
+  // 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 {
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..0fcf36c1c71
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/config/metrics/v3/stats.proto
@@ -0,0 +1,411 @@
+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.
+  //
+  // 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/v2/rbac.proto b/xds/third_party/envoy/src/main/proto/envoy/config/rbac/v2/rbac.proto
deleted file mode 100644
index 943ac33e085..00000000000
--- a/xds/third_party/envoy/src/main/proto/envoy/config/rbac/v2/rbac.proto
+++ /dev/null
@@ -1,240 +0,0 @@
-syntax = "proto3";
-
-package envoy.config.rbac.v2;
-
-import "envoy/api/v2/core/address.proto";
-import "envoy/api/v2/route/route_components.proto";
-import "envoy/type/matcher/metadata.proto";
-import "envoy/type/matcher/path.proto";
-import "envoy/type/matcher/string.proto";
-
-import "google/api/expr/v1alpha1/syntax.proto";
-
-import "udpa/annotations/status.proto";
-import "validate/validate.proto";
-
-option java_package = "io.envoyproxy.envoy.config.rbac.v2";
-option java_outer_classname = "RbacProto";
-option java_multiple_files = true;
-option (udpa.annotations.file_status).package_version_status = FROZEN;
-
-// [#protodoc-title: Role Based Access Control (RBAC)]
-
-// Role Based Access Control (RBAC) provides service-level and method-level access control for a
-// service. RBAC policies are additive. The policies are examined in order. A request is allowed
-// once a matching policy is found (suppose the `action` is ALLOW).
-//
-// 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", exact_match: "GET" }
-//                 - url_path:
-//                     path: { prefix: "/products" }
-//                 - or_rules:
-//                     rules:
-//                       - destination_port: 80
-//                       - destination_port: 443
-//       principals:
-//         - any: true
-//
-message RBAC {
-  // Should we do safe-list or block-list style access control?
-  enum Action {
-    // The policies grant access to principals. The rest is denied. This is safe-list style
-    // access control. This is the default type.
-    ALLOW = 0;
-
-    // The policies deny access to principals. The rest is allowed. This is block-list style
-    // access control.
-    DENY = 1;
-  }
-
-  // The action to take if a policy matches. The request is allowed if and only if:
-  //
-  //   * `action` is "ALLOWED" and at least one policy matches
-  //   * `action` is "DENY" and none of the policies match
-  Action action = 1;
-
-  // Maps from policy name to policy. A match occurs when at least one policy matches the request.
-  map<string, Policy> policies = 2;
-}
-
-// 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 {
-  // 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.
-  google.api.expr.v1alpha1.Expr condition = 3;
-}
-
-// Permission defines an action (or actions) that a principal can take.
-// [#next-free-field: 11]
-message 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 {
-    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.
-    api.v2.route.HeaderMatcher header = 4;
-
-    // A URL path on the incoming HTTP request. Only available for HTTP.
-    type.matcher.PathMatcher url_path = 10;
-
-    // A CIDR block that describes the destination IP.
-    api.v2.core.CidrRange destination_ip = 5;
-
-    // A port number that describes the destination port connecting to.
-    uint32 destination_port = 6 [(validate.rules).uint32 = {lte: 65535}];
-
-    // Metadata that describes additional information about the action.
-    type.matcher.MetadataMatcher metadata = 7;
-
-    // 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_api_field_listener.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 to
-    // setup SNI.
-    type.matcher.StringMatcher requested_server_name = 9;
-  }
-}
-
-// Principal defines an identity or a group of identities for a downstream subject.
-// [#next-free-field: 12]
-message 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 {
-    repeated Principal ids = 1 [(validate.rules).repeated = {min_items: 1}];
-  }
-
-  // Authentication attributes for a downstream.
-  message 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
-    // authenticated.
-    type.matcher.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.
-    Authenticated authenticated = 4;
-
-    // A CIDR block that describes the downstream IP.
-    // This address will honor proxy protocol, but will not honor XFF.
-    api.v2.core.CidrRange source_ip = 5 [deprecated = true];
-
-    // A CIDR block that describes the downstream remote/origin address.
-    // Note: This is always the physical peer even if the
-    // :ref:`remote_ip <envoy_api_field_config.rbac.v2.Principal.remote_ip>` is inferred
-    // from for example the x-forwarder-for header, proxy protocol, etc.
-    api.v2.core.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_api_field_config.rbac.v2.Principal.direct_remote_ip>`.
-    // E.g, if the remote ip is inferred from for example the x-forwarder-for header,
-    // proxy protocol, etc.
-    api.v2.core.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.
-    api.v2.route.HeaderMatcher header = 6;
-
-    // A URL path on the incoming HTTP request. Only available for HTTP.
-    type.matcher.PathMatcher url_path = 9;
-
-    // Metadata that describes additional information about the principal.
-    type.matcher.MetadataMatcher metadata = 7;
-
-    // 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;
-  }
-}
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..ef153ad177b
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/config/rbac/v3/rbac.proto
@@ -0,0 +1,470 @@
+syntax = "proto3";
+
+package envoy.config.rbac.v3;
+
+import "envoy/config/core/v3/address.proto";
+import "envoy/config/core/v3/cel.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.
+// [#next-free-field: 6]
+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"];
+
+  // CEL expression configuration that modifies the evaluation behavior of the ``condition`` field.
+  // If specified, string conversion, concatenation, and manipulation functions may be enabled
+  // for the CEL expression. See :ref:`CelExpressionConfig <envoy_v3_api_msg_config.core.v3.CelExpressionConfig>`
+  // for more details.
+  core.v3.CelExpressionConfig cel_config = 5;
+}
+
+// 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
index 4588af78cb4..5bd909f34c3 100644
--- 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
@@ -6,6 +6,7 @@ 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";
@@ -15,30 +16,31 @@ 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: 12]
+// [#next-free-field: 19]
 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_api_field_extensions.filters.network.http_connection_manager.v3.Rds.route_config_name>` in
-  // :ref:`envoy_api_msg_extensions.filters.network.http_connection_manager.v3.Rds`.
+  // <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
+  // 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
+  // generate a routing table for a given RouteConfiguration, with ``vhds`` derived configuration
   // taking precedence.
   Vhds vhds = 9;
 
@@ -52,8 +54,8 @@ message RouteConfiguration {
 
   // 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_api_msg_config.route.v3.VirtualHost` or
-  // :ref:`envoy_api_msg_config.route.v3.RouteAction`. For more information, including details on
+  // 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
@@ -67,8 +69,8 @@ message RouteConfiguration {
 
   // 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_api_msg_config.route.v3.VirtualHost` or
-  // :ref:`envoy_api_msg_config.route.v3.RouteAction`. For more information, including details on
+  // 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
@@ -80,16 +82,12 @@ message RouteConfiguration {
     (validate.rules).repeated = {items {string {well_known_regex: HTTP_HEADER_NAME strict: false}}}
   ];
 
-  // By default, headers that should be added/removed are evaluated from most to least specific:
+  // 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.
   //
-  // * route level
-  // * virtual host level
-  // * connection manager level
-  //
-  // To allow setting overrides at the route or virtual host level, this order can be reversed
-  // by setting this option to true. Defaults to false.
-  //
-  // [#next-major-version: In the v3 API, this will default to true.]
   bool most_specific_header_mutations_wins = 10;
 
   // An optional boolean that specifies whether the clusters that the route
@@ -99,26 +97,71 @@ message RouteConfiguration {
   // 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_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.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_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.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_api_field_config.route.v3.DirectResponseAction.body>` size. If not specified the default
+  // <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_api_field_config.route.v3.DirectResponseAction.body>` in memory. Be careful setting
+  //   <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;
+
+  // Normally, virtual host matching is done using the :authority (or
+  // Host: in HTTP < 2) HTTP header. Setting this will instead, use a
+  // different HTTP header for this purpose.
+  string vhost_header = 18;
+
+  // 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 {
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
index 8fe650ceb98..4587ef10487 100644
--- 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
@@ -2,9 +2,13 @@ syntax = "proto3";
 
 package envoy.config.route.v3;
 
+import "envoy/config/common/mutation_rules/v3/mutation_rules.proto";
 import "envoy/config/core/v3/base.proto";
 import "envoy/config/core/v3/extension.proto";
 import "envoy/config/core/v3/proxy_protocol.proto";
+import "envoy/config/core/v3/substitution_format_string.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";
@@ -16,6 +20,8 @@ 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";
@@ -25,6 +31,7 @@ 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]
@@ -36,7 +43,7 @@ option (udpa.annotations.file_status).package_version_status = ACTIVE;
 // 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: 21]
+// [#next-free-field: 26]
 message VirtualHost {
   option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.route.VirtualHost";
 
@@ -73,7 +80,7 @@ message VirtualHost {
   // .. 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``.
+  //   For example, ``*-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.
@@ -86,7 +93,13 @@ message VirtualHost {
 
   // The list of routes that will be matched, in order, for incoming requests.
   // The first route that matches will be used.
-  repeated Route routes = 3;
+  // 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.
@@ -102,8 +115,8 @@ message VirtualHost {
 
   // 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_api_msg_config.route.v3.Route` and before headers from the
-  // enclosing :ref:`envoy_api_msg_config.route.v3.RouteConfiguration`. For more information, including
+  // 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
@@ -117,8 +130,8 @@ message VirtualHost {
 
   // 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_api_msg_config.route.v3.Route` and before headers from the
-  // enclosing :ref:`envoy_api_msg_config.route.v3.RouteConfiguration`. For more information, including
+  // 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
@@ -130,16 +143,24 @@ message VirtualHost {
     items {string {min_len: 1 well_known_regex: HTTP_HEADER_NAME strict: false}}
   }];
 
-  // Indicates that the virtual host has a CORS policy.
-  CorsPolicy cors = 8;
-
-  // The per_filter_config field can be used to provide virtual host-specific
-  // configurations for filters. The key should match the filter name, such as
-  // *envoy.filters.http.buffer* for the HTTP buffer filter. Use of this field is filter
-  // specific; see the :ref:`HTTP filter documentation <config_http_filters>`
-  // for if and how it is utilized.
+  // 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_api_msg_config.route.v3.FilterConfig>`
+  // :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;
 
@@ -147,10 +168,13 @@ message VirtualHost {
   // <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.
+  // 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_api_field_extensions.filters.http.router.v3.Router.suppress_envoy_headers>` flag.
+  // <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;
@@ -159,33 +183,79 @@ message VirtualHost {
   // <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.
+  // 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_api_field_extensions.filters.http.router.v3.Router.suppress_envoy_headers>` flag.
+  // <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).
+  // 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_api_field_config.route.v3.VirtualHost.retry_policy>` should not be
+  // 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).
+  // independently (e.g., values are not inherited).
   HedgePolicy hedge_policy = 17;
 
-  // The maximum bytes which will be buffered for retries and shadowing.
-  // If set and a route-specific limit is not set, the bytes actually buffered will be the minimum
-  // value of this and the listener per_connection_buffer_limit_bytes.
-  google.protobuf.UInt32Value per_request_buffer_limit_bytes = 18;
+  // 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.
@@ -195,14 +265,21 @@ message 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_api_msg_config.route.v3.HeaderMatcher>`.
-// [#next-free-field: 18]
+//   <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";
 
@@ -229,37 +306,43 @@ message Route {
     DirectResponseAction direct_response = 7;
 
     // [#not-implemented-hide:]
-    // If true, a filter will define the action (e.g., it could dynamically generate the
-    // RouteAction).
+    // 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*.
+  // the filter name should be specified as ``envoy.filters.http.router``.
   core.v3.Metadata metadata = 4;
 
   // Decorator for the matched route.
   Decorator decorator = 5;
 
-  // The typed_per_filter_config field can be used to provide route-specific
-  // configurations for filters. The key should match the filter name, such as
-  // *envoy.filters.http.buffer* for the HTTP buffer filter. Use of this field is filter
-  // specific; see the :ref:`HTTP filter documentation <config_http_filters>` for
-  // if and how it is utilized.
+  // 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_api_msg_config.route.v3.FilterConfig>`
+  // :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_api_msg_config.route.v3.VirtualHost` and
-  // :ref:`envoy_api_msg_config.route.v3.RouteConfiguration`. For more information, including details on
+  // 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
@@ -273,8 +356,8 @@ message Route {
 
   // 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_api_msg_config.route.v3.VirtualHost` and
-  // :ref:`envoy_api_msg_config.route.v3.RouteConfiguration`. For more information, including
+  // 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
@@ -293,19 +376,61 @@ message Route {
   // 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.
-  google.protobuf.UInt32Value per_request_buffer_limit_bytes = 16;
+  //
+  // .. 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_api_field_config.route.v3.RouteAction.cluster>` field that specifies a
+// 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_api_field_config.route.v3.RouteAction.weighted_clusters>` option allows for specification of
+// <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: 11]
+  // [#next-free-field: 13]
   message ClusterWeight {
     option (udpa.annotations.versioning).previous_message_type =
         "envoy.api.v2.route.WeightedCluster.ClusterWeight";
@@ -314,85 +439,147 @@ message WeightedCluster {
 
     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 [(validate.rules).string = {min_len: 1}];
+    string name = 1 [(udpa.annotations.field_migrate).oneof_promotion = "cluster_specifier"];
 
-    // An integer between 0 and :ref:`total_weight
-    // <envoy_api_field_config.route.v3.WeightedCluster.total_weight>`. 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 add up to the total_weight, which defaults to 100.
+    // 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_api_field_config.route.v3.RouteAction.metadata_match>`, with
-    // values here taking precedence. The filter name should be specified as *envoy.lb*.
+    // :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_api_msg_config.route.v3.RouteAction`.
+    // 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_api_msg_config.route.v3.Route`, :ref:`envoy_api_msg_config.route.v3.VirtualHost`, and
-    // :ref:`envoy_api_msg_config.route.v3.RouteConfiguration`. For more information, including details on
+    // :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_api_msg_config.route.v3.RouteAction`.
+    // 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_api_msg_config.route.v3.RouteAction`.
+    // 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_api_msg_config.route.v3.Route`, :ref:`envoy_api_msg_config.route.v3.VirtualHost`, and
-    // :ref:`envoy_api_msg_config.route.v3.RouteConfiguration`. For more information, including details on
+    // :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_api_msg_config.route.v3.RouteAction`.
+    // 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}}
     }];
 
-    // The per_filter_config field can be used to provide weighted cluster-specific
-    // configurations for filters. The key should match the filter name, such as
-    // *envoy.filters.http.buffer* for the HTTP buffer filter. Use of this field is filter
-    // specific; see the :ref:`HTTP filter documentation <config_http_filters>`
-    // for if and how it is utilized.
+    // 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_api_msg_config.route.v3.FilterConfig>`
+    // :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, which must be greater than 0. Defaults to 100.
-  google.protobuf.UInt32Value total_weight = 3 [(validate.rules).uint32 = {gte: 1}];
+  // 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
+  // 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
+  // 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: 13]
+// [#next-free-field: 18]
 message RouteMatch {
   option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.route.RouteMatch";
 
@@ -411,10 +598,20 @@ message RouteMatch {
 
     // 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 requests.
+  // An extensible message for matching CONNECT or CONNECT-UDP requests.
   message ConnectMatcher {
   }
 
@@ -426,41 +623,54 @@ message RouteMatch {
     option (validate.required) = true;
 
     // If specified, the route is a prefix rule meaning that the prefix must
-    // match the beginning of the *:path* header.
+    // 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.
+    // 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
+    // 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.
+    // 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
+    // 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 requests.
-    // Note that this will not match HTTP/2 upgrade-style 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,
+    // 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.
+    // [#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.
+  // 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
@@ -489,15 +699,29 @@ message RouteMatch {
   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
+  // 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.
+  // 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 may be 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;
 
+  // Specifies a set of cookies on which the route should match. The router parses the ``Cookie``
+  // header and evaluates the named cookie against each matcher. If the number of specified cookie
+  // matchers is nonzero, they all must match for the route to be selected.
+  repeated CookieMatcher cookies = 17;
+
   // 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.
+  // that the ``Content-Type`` header has ``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
@@ -505,9 +729,29 @@ message RouteMatch {
   //
   // [#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;
 }
 
-// [#next-free-field: 12]
+// 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";
 
@@ -519,16 +763,16 @@ message CorsPolicy {
   // string matchers match.
   repeated type.matcher.v3.StringMatcher allow_origin_string_match = 11;
 
-  // Specifies the content for the *access-control-allow-methods* header.
+  // Specifies the content for the ``access-control-allow-methods`` header.
   string allow_methods = 2;
 
-  // Specifies the content for the *access-control-allow-headers* header.
+  // Specifies the content for the ``access-control-allow-headers`` header.
   string allow_headers = 3;
 
-  // Specifies the content for the *access-control-expose-headers* header.
+  // Specifies the content for the ``access-control-expose-headers`` header.
   string expose_headers = 4;
 
-  // Specifies the content for the *access-control-max-age* header.
+  // Specifies the content for the ``access-control-max-age`` header.
   string max_age = 5;
 
   // Specifies whether the resource allows credentials.
@@ -540,7 +784,7 @@ message CorsPolicy {
     // 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_api_field_config.core.v3.RuntimeFractionalPercent.runtime_key>` is
+    // 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;
   }
@@ -551,13 +795,23 @@ message CorsPolicy {
   // 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_api_field_config.core.v3.RuntimeFractionalPercent.runtime_key>` is specified,
+  // 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.
+  // 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: 37]
+// [#next-free-field: 46]
 message RouteAction {
   option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.route.RouteAction";
 
@@ -567,6 +821,9 @@ message RouteAction {
 
     // 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.
@@ -583,12 +840,18 @@ message RouteAction {
   // 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*.
+  // 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: 9]
   message RequestMirrorPolicy {
     option (udpa.annotations.versioning).previous_message_type =
         "envoy.api.v2.route.RouteAction.RequestMirrorPolicy";
@@ -597,13 +860,34 @@ message RouteAction {
 
     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 [(validate.rules).string = {min_len: 1}];
+    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
+    // 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
@@ -611,8 +895,30 @@ message RouteAction {
     // value, the request will be mirrored.
     core.v3.RuntimeFractionalPercent runtime_fraction = 3;
 
-    // Determines if the trace span should be sampled. Defaults to true.
+    // 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 a list of header mutations that should be applied to each mirrored request.
+    // Header mutations are applied in the order they are specified. 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 common.mutation_rules.v3.HeaderMutation request_headers_mutations = 7
+        [(validate.rules).repeated = {max_items: 1000}];
+
+    // Indicates that during mirroring, the host header will be swapped with this value.
+    // :ref:`disable_shadow_host_suffix_append
+    // <envoy_v3_api_field_config.route.v3.RouteAction.RequestMirrorPolicy.disable_shadow_host_suffix_append>`
+    // is implicitly enabled if this field is set.
+    string host_rewrite_literal = 8
+        [(validate.rules).string = {well_known_regex: HTTP_HEADER_VALUE strict: false}];
   }
 
   // Specifies the route's hashing policy if the upstream cluster uses a hashing :ref:`load balancer
@@ -636,6 +942,18 @@ message RouteAction {
       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
@@ -667,6 +985,9 @@ message RouteAction {
       // 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 {
@@ -683,7 +1004,8 @@ message RouteAction {
 
       // 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.
+      // 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}];
     }
 
@@ -692,8 +1014,8 @@ message RouteAction {
           "envoy.api.v2.route.RouteAction.HashPolicy.FilterState";
 
       // The name of the Object in the per-request filterState, which is an
-      // Envoy::Http::Hashable object. If there is no data associated with the key,
-      // or the stored object is not Envoy::Http::Hashable, no hash will be produced.
+      // 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}];
     }
 
@@ -742,7 +1064,7 @@ message RouteAction {
   // This overrides any enabled/disabled upgrade filter chain specified in the
   // HttpConnectionManager
   // :ref:`upgrade_configs
-  // <envoy_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.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 =
@@ -758,28 +1080,30 @@ message RouteAction {
       bool allow_post = 2;
     }
 
-    // The case-insensitive name of this upgrade, e.g. "websocket".
+    // The case-insensitive name of this upgrade, for example, "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.
+    // 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.
+    // [#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_api_field_config.core.v3.HttpProtocolOptions.max_stream_duration>` field in
+    // <envoy_v3_api_field_config.core.v3.HttpProtocolOptions.max_stream_duration>` field in
     // :ref:`HttpConnectionManager.common_http_protocol_options
-    // <envoy_api_field_extensions.filters.network.http_connection_manager.v3.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.
@@ -787,11 +1111,11 @@ message RouteAction {
 
     // 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.
+    // ``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
+    // 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
@@ -818,8 +1142,8 @@ message RouteAction {
     //
     // .. 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.
+    //   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::
     //
@@ -833,6 +1157,16 @@ message RouteAction {
     // :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.
@@ -843,8 +1177,8 @@ message RouteAction {
   // 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_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*.
+  // <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
@@ -853,17 +1187,19 @@ message RouteAction {
   // 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 *prefix_rewrite* or
-  // :ref:`regex_rewrite <envoy_api_field_config.route.v3.RouteAction.regex_rewrite>`
+  // 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>`,
+  // :ref:`path_rewrite <envoy_v3_api_field_config.route.v3.RouteAction.path_rewrite>`,
+  // 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_api_field_config.route.v3.Route.match>` prefix value.
+  //   :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_api_msg_config.route.v3.Route>`, as shown by the below config entries:
+  //   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
   //
@@ -876,8 +1212,8 @@ message RouteAction {
   //       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*.
+  //   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}];
 
@@ -890,8 +1226,11 @@ message RouteAction {
   // before the rewrite into the :ref:`x-envoy-original-path
   // <config_http_filters_router_x-envoy-original-path>` header.
   //
-  // Only one of :ref:`prefix_rewrite <envoy_api_field_config.route.v3.RouteAction.prefix_rewrite>`
-  // or *regex_rewrite* may be specified.
+  // 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>`,
+  // :ref:`path_rewrite <envoy_v3_api_field_config.route.v3.RouteAction.path_rewrite>`,
+  // or :ref:`prefix_rewrite <envoy_v3_api_field_config.route.v3.RouteAction.prefix_rewrite>`
+  // may be specified.
   //
   // Examples using Google's `RE2 <https://github.com/google/re2>`_ engine:
   //
@@ -911,6 +1250,48 @@ message RouteAction {
   //   ``/aaa/yyy/bbb``.
   type.matcher.v3.RegexMatchAndSubstitute regex_rewrite = 32;
 
+  // [#extension-category: envoy.path.rewrite]
+  core.v3.TypedExtensionConfig path_rewrite_policy = 41;
+
+  // Rewrites the whole path (without query parameters) with the given path value.
+  // 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>`,
+  // :ref:`path_rewrite <envoy_v3_api_field_config.route.v3.RouteAction.path_rewrite>`,
+  // or :ref:`prefix_rewrite <envoy_v3_api_field_config.route.v3.RouteAction.prefix_rewrite>`
+  // may be specified.
+  //
+  // The :ref:`substitution format specifier <config_access_log_format>` could be applied here.
+  // For example, with the following config:
+  //
+  //   .. code-block:: yaml
+  //
+  //     path_rewrite: "/new_path_prefix%REQ(custom-path-header-name)%"
+  //
+  // Would rewrite the path to ``/new_path_prefix/some_value`` given the header
+  // ``custom-path-header-name: some_value``. If the header is not present, the path will be
+  // rewritten to ``/new_path_prefix``.
+  //
+  //
+  // If the final output of the path rewrite is empty, then the update will be ignored and the
+  // original path will be preserved.
+  string path_rewrite = 45;
+
+  // 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.
@@ -920,8 +1301,10 @@ message RouteAction {
     // 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*. Setting this to true with other cluster
-    // types has no effect.
+    // 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
@@ -953,10 +1336,38 @@ message RouteAction {
     //         regex: "^/(.+)/.+$"
     //       substitution: \1
     //
-    // Would rewrite the host header to `envoyproxy.io` given the path `/envoyproxy.io/some/path`.
+    // Would rewrite the host header to ``envoyproxy.io`` given the path ``/envoyproxy.io/some/path``.
     type.matcher.v3.RegexMatchAndSubstitute host_rewrite_path_regex = 35;
+
+    // Rewrites the host header with the value of this field. 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.
+    //
+    // The :ref:`substitution format specifier <config_access_log_format>` could be applied here.
+    // For example, with the following config:
+    //
+    //   .. code-block:: yaml
+    //
+    //     host_rewrite: "prefix-%REQ(custom-host-header-name)%"
+    //
+    // Would rewrite the host header to ``prefix-some_value`` given the header
+    // ``custom-host-header-name: some_value``. If the header is not present, the host header will
+    // be rewritten to an value of ``prefix-``.
+    //
+    // If the final output of the host rewrite is empty, then the update will be ignored and the
+    // original host header will be preserved.
+    string host_rewrite = 44;
   }
 
+  // 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
@@ -972,14 +1383,14 @@ message RouteAction {
 
   // 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_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.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_api_field_config.route.v3.RouteAction.timeout>`, which provides an upper bound
+  // <envoy_v3_api_field_config.route.v3.RouteAction.timeout>`, which provides an upper bound
   // on the upstream response time; :ref:`idle_timeout
-  // <envoy_api_field_config.route.v3.RouteAction.idle_timeout>` instead bounds the amount
+  // <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
@@ -991,22 +1402,49 @@ message RouteAction {
   //
   // 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_api_enum_value_config.overload.v3.ScaleTimersOverloadActionConfig.TimerType.HTTP_DOWNSTREAM_STREAM_IDLE>`.
+  // :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).
+  // (e.g., policies are not merged, the 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_api_field_config.route.v3.VirtualHost.retry_policy>`
+  // precedence over the virtual host level retry policy entirely (e.g., policies are not merged,
+  // the 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;
 
-  // Indicates that the route has request mirroring policies.
+  // 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>`.
@@ -1018,11 +1456,14 @@ message RouteAction {
 
   // 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_api_field_config.route.v3.VirtualHost.rate_limits>` are not applied to the
+  // :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];
+  // .. attention::
+  //
+  //   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
@@ -1038,18 +1479,27 @@ message RouteAction {
   // ignoring the rest of the hash policy list.
   repeated HashPolicy hash_policy = 15;
 
-  // Indicates that the route has a CORS policy.
-  CorsPolicy cors = 17;
+  // 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_api_field_config.route.v3.RouteAction.MaxStreamDuration.grpc_timeout_header_max>`
+  // 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_api_field_config.route.v3.RouteAction.timeout>`, but limit the applied timeout
+  // :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
+  // 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_api_field_config.route.v3.RouteAction.timeout>` or its default.
+  // :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.
   //
@@ -1061,47 +1511,51 @@ message RouteAction {
   //    :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];
+  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_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
+  // 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];
+  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_api_field_config.route.v3.InternalRedirectPolicy.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];
+  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_api_field_config.route.v3.RouteAction.internal_redirect_action>`
+  // :ref:`internal_redirect_action <envoy_v3_api_field_config.route.v3.RouteAction.internal_redirect_action>`
   // is set to :ref:`HANDLE_INTERNAL_REDIRECT
-  // <envoy_api_enum_value_config.route.v3.RouteAction.InternalRedirectAction.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_api_field_config.route.v3.RouteAction.internal_redirect_action>`
+  // :ref:`internal_redirect_action <envoy_v3_api_field_config.route.v3.RouteAction.internal_redirect_action>`
   // set to
   // :ref:`PASS_THROUGH_INTERNAL_REDIRECT
-  // <envoy_api_enum_value_config.route.v3.RouteAction.InternalRedirectAction.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];
+  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).
+  // (e.g., policies are not merged, the most internal one becomes the enforced policy).
   HedgePolicy hedge_policy = 27;
 
   // Specifies the maximum stream duration for this route.
@@ -1109,7 +1563,7 @@ message RouteAction {
 }
 
 // HTTP retry :ref:`architecture overview <arch_overview_http_routing_retry>`.
-// [#next-free-field: 12]
+// [#next-free-field: 14]
 message RetryPolicy {
   option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.route.RetryPolicy";
 
@@ -1128,6 +1582,7 @@ message RetryPolicy {
 
     string name = 1 [(validate.rules).string = {min_len: 1}];
 
+    // [#extension-category: envoy.retry_priorities]
     oneof config_type {
       google.protobuf.Any typed_config = 3;
     }
@@ -1143,6 +1598,7 @@ message RetryPolicy {
 
     string name = 1 [(validate.rules).string = {min_len: 1}];
 
+    // [#extension-category: envoy.retry_host_predicates]
     oneof config_type {
       google.protobuf.Any typed_config = 3;
     }
@@ -1162,8 +1618,8 @@ message RetryPolicy {
     }];
 
     // 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
+    // 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 {}}];
   }
@@ -1233,7 +1689,9 @@ message RetryPolicy {
 
     // 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.
+    // the next header will be tried.
+    //
+    // Defaults to 300 seconds.
     google.protobuf.Duration max_interval = 2 [(validate.rules).duration = {gt {}}];
   }
 
@@ -1248,19 +1706,40 @@ message RetryPolicy {
   google.protobuf.UInt32Value num_retries = 2
       [(udpa.annotations.field_migrate).rename = "max_retries"];
 
-  // Specifies a non-zero upstream timeout per retry attempt. This parameter is optional. The
-  // same conditions documented for
+  // 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_api_field_config.route.v3.RouteAction.timeout>` for the request.
+  //   :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.
@@ -1272,6 +1751,11 @@ message RetryPolicy {
   // 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.
@@ -1282,7 +1766,7 @@ message RetryPolicy {
 
   // 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
+  // ``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;
@@ -1292,7 +1776,7 @@ message RetryPolicy {
   // 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`)
+  // default exponential back off strategy (configured using ``retry_back_off``)
   // whenever a response includes the matching headers.
   RateLimitedRetryBackOff rate_limited_retry_back_off = 11;
 
@@ -1311,12 +1795,14 @@ message 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;
@@ -1326,14 +1812,16 @@ message HedgePolicy {
   // 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
+  // * Before per-try timeout, an error response (per retry-on conditions) would be retried immediately or returned to 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_api_msg_config.route.v3.RetryPolicy>` that retries at least
-  // one error code and specifies a maximum number of retries.
+  // .. 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.
+  // Defaults to ``false``.
   bool hedge_on_per_try_timeout = 3;
 }
 
@@ -1359,10 +1847,10 @@ message RedirectAction {
   }
 
   // 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
+  //  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;
@@ -1405,7 +1893,7 @@ message RedirectAction {
     // .. attention::
     //
     //   Pay attention to the use of trailing slashes as mentioned in
-    //   :ref:`RouteAction's prefix_rewrite <envoy_api_field_config.route.v3.RouteAction.prefix_rewrite>`.
+    //   :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}];
 
@@ -1449,17 +1937,27 @@ message DirectResponseAction {
       "envoy.api.v2.route.DirectResponseAction";
 
   // Specifies the HTTP response status to be returned.
-  uint32 status = 1 [(validate.rules).uint32 = {lt: 600 gte: 100}];
+  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_api_msg_config.route.v3.Route`, :ref:`envoy_api_msg_config.route.v3.RouteConfiguration` or
-  //   :ref:`envoy_api_msg_config.route.v3.VirtualHost`.
+  //   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;
+
+  // Specifies a format string for the response body. If present, the contents of
+  // ``body_format`` will be formatted and used as the response body, where the
+  // contents of ``body`` (may be empty) will be passed as the variable ``%LOCAL_REPLY_BODY%``.
+  // If neither are provided, no body is included in the generated response.
+  core.v3.SubstitutionFormatString body_format = 3;
+}
+
+// [#not-implemented-hide:]
+message NonForwardingAction {
 }
 
 message Decorator {
@@ -1475,17 +1973,18 @@ message Decorator {
   //   <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.
+  // Whether the decorated details should be propagated to the other party. The default is ``true``.
   google.protobuf.BoolValue propagate = 2;
 }
 
+// [#next-free-field: 7]
 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_sampling' in the :ref:`HTTP Connection Manager
+  // 'tracing.client_enabled' in the :ref:`HTTP Connection Manager
   // <config_http_conn_man_runtime>`.
   // Default: 100%
   type.v3.FractionalPercent client_sampling = 1;
@@ -1509,11 +2008,39 @@ message Tracing {
 
   // 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_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.Tracing.custom_tags>`
+  // <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;
+
+  // The operation name of the span which will be used for tracing.
+  //
+  // The same :ref:`format specifier <config_access_log_format>` as used for
+  // :ref:`HTTP access logging <config_access_log>` applies here, however
+  // unknown specifier values are replaced with the empty string instead of ``-``.
+  //
+  // This field will take precedence over and make following settings ineffective:
+  //
+  // * :ref:`route decorator <envoy_v3_api_field_config.route.v3.Route.decorator>`.
+  // * :ref:`x-envoy-decorator-operation <config_http_filters_router_x-envoy-decorator-operation>`.
+  // * :ref:`HCM tracing operation
+  //   <envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.Tracing.operation>`.
+  string operation = 5;
+
+  // The operation name of the upstream span which will be used for tracing.
+  // This only takes effect when ``spawn_upstream_span`` is set to true and the upstream
+  // span is created.
+  //
+  // The same :ref:`format specifier <config_access_log_format>` as used for
+  // :ref:`HTTP access logging <config_access_log>` applies here, however
+  // unknown specifier values are replaced with the empty string instead of ``-``.
+  //
+  // This field will take precedence over and make following settings ineffective:
+  //
+  // * :ref:`HCM tracing upstream operation
+  //   <envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.Tracing.upstream_operation>`
+  string upstream_operation = 6;
 }
 
 // A virtual cluster is a way of specifying a regex matching rule against
@@ -1541,7 +2068,7 @@ message VirtualCluster {
   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
+  // match. The pseudo-headers ``:path`` and ``:method`` can be used to match the request path and
   // method, respectively.
   repeated HeaderMatcher headers = 4;
 
@@ -1553,10 +2080,11 @@ message VirtualCluster {
 
 // 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: 10]
+  // [#next-free-field: 13]
   message Action {
     option (udpa.annotations.versioning).previous_message_type =
         "envoy.api.v2.route.RateLimit.Action";
@@ -1580,14 +2108,14 @@ message RateLimit {
     //   ("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_api_msg_config.route.v3.RouteConfiguration>`
+    // the following :ref:`route table configuration <envoy_v3_api_msg_config.route.v3.RouteConfiguration>`
     // settings:
     //
-    // * :ref:`cluster <envoy_api_field_config.route.v3.RouteAction.cluster>` indicates the upstream cluster
+    // * :ref:`cluster <envoy_v3_api_field_config.route.v3.RouteAction.cluster>` indicates the upstream cluster
     //   to route to.
-    // * :ref:`weighted_clusters <envoy_api_field_config.route.v3.RouteAction.weighted_clusters>`
+    // * :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_api_field_config.route.v3.RouteAction.cluster_header>` indicates which
+    // * :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 =
@@ -1595,7 +2123,7 @@ message RateLimit {
     }
 
     // The following descriptor entry is appended when a header contains a key that matches the
-    // *header_name*:
+    // ``header_name``:
     //
     // .. code-block:: cpp
     //
@@ -1613,9 +2141,48 @@ message RateLimit {
       // The key to use in the descriptor entry.
       string descriptor_key = 2 [(validate.rules).string = {min_len: 1}];
 
-      // If set to true, Envoy skips the descriptor while calling rate limiting service
-      // when header is not present in the request. By default it skips calling the
-      // rate limiting service if this header is not present in the request.
+      // 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. This 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;
     }
 
@@ -1630,6 +2197,32 @@ message RateLimit {
           "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
@@ -1639,9 +2232,40 @@ message RateLimit {
       option (udpa.annotations.versioning).previous_message_type =
           "envoy.api.v2.route.RateLimit.Action.GenericKey";
 
-      // The value to use in the descriptor entry.
+      // Descriptor value of entry.
+      //
+      // The same :ref:`format specifier <config_access_log_format>` as used for
+      // :ref:`HTTP access logging <config_access_log>` applies here, however
+      // unknown specifier values are replaced with the empty string instead of ``-``.
+      //
+      // .. note::
+      //
+      //   Formatter parsing is controlled by the runtime feature flag
+      //   ``envoy.reloadable_features.enable_formatter_for_ratelimit_action_descriptor_value``
+      //   (disabled by default).
+      //
+      //   When enabled: The format string can contain multiple valid substitution
+      //   fields. If multiple substitution fields are present, their results will be concatenated
+      //   to form the final descriptor value. If it contains no substitution fields, the value
+      //   will be used as is. If the final concatenated result is empty and ``default_value`` is set,
+      //   the ``default_value`` will be used. If ``default_value`` is not set and the result is
+      //   empty, this descriptor will be skipped and not included in the rate limit call.
+      //
+      //   When disabled (default): The descriptor_value is used as a literal string without any formatter
+      //   parsing or substitution.
+      //
+      // For example, ``static_value`` will be used as is since there are no substitution fields.
+      // ``%REQ(:method)%`` will be replaced with the HTTP method, and
+      // ``%REQ(:method)%%REQ(:path)%`` will be replaced with the concatenation of the HTTP method and path.
+      // ``%CEL(request.headers['user-id'])%`` will use CEL to extract the user ID from request headers.
+      //
       string descriptor_value = 1 [(validate.rules).string = {min_len: 1}];
 
+      // An optional value to use if the final concatenated ``descriptor_value`` result is empty.
+      // Only applicable when formatter parsing is enabled by the runtime feature flag
+      // ``envoy.reloadable_features.enable_formatter_for_ratelimit_action_descriptor_value`` (disabled by default).
+      string default_value = 3;
+
       // 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;
@@ -1652,13 +2276,51 @@ message RateLimit {
     // .. code-block:: cpp
     //
     //   ("header_match", "<descriptor_value>")
+    // [#next-free-field: 6]
     message HeaderValueMatch {
       option (udpa.annotations.versioning).previous_message_type =
           "envoy.api.v2.route.RateLimit.Action.HeaderValueMatch";
 
-      // The value to use in the descriptor entry.
+      // Descriptor value of entry.
+      //
+      // The same :ref:`format specifier <config_access_log_format>` as used for
+      // :ref:`HTTP access logging <config_access_log>` applies here, however
+      // unknown specifier values are replaced with the empty string instead of ``-``.
+      //
+      // .. note::
+      //
+      //   Formatter parsing is controlled by the runtime feature flag
+      //   ``envoy.reloadable_features.enable_formatter_for_ratelimit_action_descriptor_value``
+      //   (disabled by default).
+      //
+      //   When enabled: The format string can contain multiple valid substitution
+      //   fields. If multiple substitution fields are present, their results will be concatenated
+      //   to form the final descriptor value. If it contains no substitution fields, the value
+      //   will be used as is. All substitution fields will be evaluated and their results
+      //   concatenated. If the final concatenated result is empty and ``default_value`` is set,
+      //   the ``default_value`` will be used. If ``default_value`` is not set and the result is
+      //   empty, this descriptor will be skipped and not included in the rate limit call.
+      //
+      //   When disabled (default): The descriptor_value is used as a literal string without any formatter
+      //   parsing or substitution.
+      //
+      // For example, ``static_value`` will be used as is since there are no substitution fields.
+      // ``%REQ(:method)%`` will be replaced with the HTTP method, and
+      // ``%REQ(:method)%%REQ(:path)%`` will be replaced with the concatenation of the HTTP method and path.
+      // ``%CEL(request.headers['user-id'])%`` will use CEL to extract the user ID from request headers.
+      //
       string descriptor_value = 1 [(validate.rules).string = {min_len: 1}];
 
+      // An optional value to use if the final concatenated ``descriptor_value`` result is empty.
+      // Only applicable when formatter parsing is enabled by the runtime feature flag
+      // ``envoy.reloadable_features.enable_formatter_for_ratelimit_action_descriptor_value`` (disabled by default).
+      string default_value = 5;
+
+      // The key to use in the descriptor entry.
+      //
+      // Defaults to ``header_match``.
+      string descriptor_key = 4;
+
       // 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
@@ -1666,7 +2328,7 @@ message RateLimit {
       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
+      // 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).
@@ -1681,7 +2343,7 @@ message RateLimit {
     //   ("<descriptor_key>", "<value_queried_from_dynamic_metadata>")
     //
     // .. attention::
-    //   This action has been deprecated in favor of the :ref:`metadata <envoy_api_msg_config.route.v3.RateLimit.Action.MetaData>` action
+    //   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}];
@@ -1690,7 +2352,7 @@ message RateLimit {
       // 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
+      // 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;
     }
@@ -1700,12 +2362,13 @@ message RateLimit {
     // .. 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_api_field_config.route.v3.Route.metadata>`
+        // Query :ref:`route entry metadata <envoy_v3_api_field_config.route.v3.Route.metadata>`
         ROUTE_ENTRY = 1;
       }
 
@@ -1716,12 +2379,90 @@ message RateLimit {
       // 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 no descriptor is generated.
+      // 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>")
+    // [#next-free-field: 6]
+    message QueryParameterValueMatch {
+      // Descriptor value of entry.
+      //
+      // The same :ref:`format specifier <config_access_log_format>` as used for
+      // :ref:`HTTP access logging <config_access_log>` applies here, however
+      // unknown specifier values are replaced with the empty string instead of ``-``.
+      //
+      // .. note::
+      //
+      //   Formatter parsing is controlled by the runtime feature flag
+      //   ``envoy.reloadable_features.enable_formatter_for_ratelimit_action_descriptor_value``
+      //   (disabled by default).
+      //
+      //   When enabled: The format string can contain multiple valid substitution
+      //   fields. If multiple substitution fields are present, their results will be concatenated
+      //   to form the final descriptor value. If it contains no substitution fields, the value
+      //   will be used as is. All substitution fields will be evaluated and their results
+      //   concatenated. If the final concatenated result is empty and ``default_value`` is set,
+      //   the ``default_value`` will be used. If ``default_value`` is not set and the result is
+      //   empty, this descriptor will be skipped and not included in the rate limit call.
+      //
+      //   When disabled (default): The descriptor_value is used as a literal string without any formatter
+      //   parsing or substitution.
+      //
+      // For example, ``static_value`` will be used as is since there are no substitution fields.
+      // ``%REQ(:method)%`` will be replaced with the HTTP method, and
+      // ``%REQ(:method)%%REQ(:path)%`` will be replaced with the concatenation of the HTTP method and path.
+      // ``%CEL(request.headers['user-id'])%`` will use CEL to extract the user ID from request headers.
+      //
+      string descriptor_value = 1 [(validate.rules).string = {min_len: 1}];
+
+      // An optional value to use if the final concatenated ``descriptor_value`` result is empty.
+      // Only applicable when formatter parsing is enabled by the runtime feature flag
+      // ``envoy.reloadable_features.enable_formatter_for_ratelimit_action_descriptor_value`` (disabled by default).
+      string default_value = 5;
+
+      // The key to use in the descriptor entry.
+      //
+      // Defaults to ``query_match``.
+      string descriptor_key = 4;
+
+      // 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 {
@@ -1736,6 +2477,9 @@ message RateLimit {
       // 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;
 
@@ -1748,15 +2492,31 @@ message RateLimit {
       // Rate limit on dynamic metadata.
       //
       // .. attention::
-      //   This field has been deprecated in favor of the :ref:`metadata <envoy_api_field_config.route.v3.RateLimit.Action.metadata>` field
-      DynamicMetaData dynamic_metadata = 7
-          [deprecated = true, (envoy.annotations.disallowed_by_default) = true];
+      //   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;
     }
   }
 
@@ -1766,7 +2526,7 @@ message RateLimit {
       // 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_api_enum_type.v3.RateLimitUnit>`
+      // enum <envoy_v3_api_enum_type.v3.RateLimitUnit>`
       type.metadata.v3.MetadataKey metadata_key = 1 [(validate.rules).message = {required: true}];
     }
 
@@ -1778,6 +2538,33 @@ message RateLimit {
     }
   }
 
+  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.
@@ -1785,9 +2572,19 @@ message RateLimit {
   // .. 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.
@@ -1802,34 +2599,67 @@ message RateLimit {
   // 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.
+//   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
+//   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",
-//       "exact_match": "POST"
+//       "string_match": {
+//         "exact": "POST"
+//       }
 //     }
 //
 // .. attention::
 //   In the absence of any header match specifier, match will default to :ref:`present_match
-//   <envoy_api_field_config.route.v3.HeaderMatcher.present_match>`. i.e, a request that has the :ref:`name
-//   <envoy_api_field_config.route.v3.HeaderMatcher.name>` header will match, regardless of the header's
+//   <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: 13]
+// [#next-free-field: 15]
 message HeaderMatcher {
   option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.route.HeaderMatcher";
 
@@ -1844,12 +2674,22 @@ message HeaderMatcher {
   // 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.
-    string exact_match = 4;
+    //
+    // .. attention::
+    //
+    //   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.
-    type.matcher.v3.RegexMatcher safe_regex_match = 11;
+    //
+    // .. attention::
+    //
+    //   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.
@@ -1860,47 +2700,115 @@ message HeaderMatcher {
     //
     // Examples:
     //
-    // * For range [-10,0), route will match for header value -1, but not for 0, "somestring", 10.9,
-    //   "-1somestring"
+    // * 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, header match will be performed based on whether the header is in the
-    // request.
+    // 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.
+    //
+    // .. note::
+    //
+    //   Empty prefix is not allowed. Please use ``present_match`` instead.
+    //
+    // .. attention::
+    //
+    //   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 [(validate.rules).string = {min_len: 1}];
+    // * 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.
+    //
+    // .. note::
+    //
+    //   Empty suffix is not allowed. Please use ``present_match`` instead.
+    //
+    // .. attention::
+    //
+    //   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 [(validate.rules).string = {min_len: 1}];
+    // * 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.
+    //
+    // .. note::
+    //
+    //   Empty contains match is not allowed. Please use ``present_match`` instead.
+    //
+    // .. attention::
+    //
+    //   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 [(validate.rules).string = {min_len: 1}];
+    // * 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.
+  // 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 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
@@ -1915,7 +2823,7 @@ message QueryParameterMatcher {
   reserved "value", "regex";
 
   // Specifies the name of a key that must be present in the requested
-  // *path*'s query string.
+  // ``path``'s query string.
   string name = 1 [(validate.rules).string = {min_len: 1 max_bytes: 1024}];
 
   oneof query_parameter_match_specifier {
@@ -1927,13 +2835,28 @@ message QueryParameterMatcher {
   }
 }
 
+// Cookie matching inspects individual name/value pairs parsed from the ``Cookie`` header.
+message CookieMatcher {
+  // Specifies the cookie name to evaluate.
+  string name = 1 [(validate.rules).string = {min_len: 1 max_bytes: 1024}];
+
+  // Match the cookie value using :ref:`StringMatcher
+  // <envoy_v3_api_msg_type.matcher.v3.StringMatcher>` semantics.
+  type.matcher.v3.StringMatcher string_match = 2 [(validate.rules).message = {required: true}];
+
+  // Invert the match result. If the cookie is not present, the match result is false, so
+  // ``invert_match`` will cause the matcher to succeed when the cookie is absent.
+  bool invert_match = 3;
+}
+
 // 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_api_field_config.route.v3.RouteAction.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.
@@ -1947,20 +2870,28 @@ message InternalRedirectPolicy {
   // 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.
+  // 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_api_field_config.route.v3.VirtualHost.typed_per_filter_config>`,
-// :ref:`Route.typed_per_filter_config<envoy_api_field_config.route.v3.Route.typed_per_filter_config>`,
-// or :ref:`WeightedCluster.ClusterWeight.typed_per_filter_config<envoy_api_field_config.route.v3.WeightedCluster.ClusterWeight.typed_per_filter_config>`
+// :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.
-// [#not-implemented-hide:]
 message FilterConfig {
   // The filter config.
   google.protobuf.Any config = 1;
@@ -1969,4 +2900,19 @@ message FilterConfig {
   // 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.
+  //
+  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
index b7e3aa66e07..ff4cc689c89 100644
--- 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
@@ -2,6 +2,9 @@ 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";
@@ -9,19 +12,23 @@ 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_api_msg_config.route.v3.ScopedRouteConfiguration.Key>` to a
-// :ref:`envoy_api_msg_config.route.v3.RouteConfiguration` (identified by its resource name).
+// :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_api_field_extensions.filters.network.http_connection_manager.v3.ScopedRoutes.scope_key_builder>`
+// :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):
@@ -37,13 +44,13 @@ option (udpa.annotations.file_status).package_version_status = ACTIVE;
 //       fragments:
 //         - header_value_extractor:
 //             name: X-Route-Selector
-//             element_separator: ,
+//             element_separator: ","
 //             element:
 //               separator: =
 //               key: vip
 //
 // ScopedRouteConfiguration resources (specified statically via
-// :ref:`scoped_route_configurations_list<envoy_api_field_extensions.filters.network.http_connection_manager.v3.ScopedRoutes.scoped_route_configurations_list>`
+// :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::
@@ -70,15 +77,16 @@ option (udpa.annotations.file_status).package_version_status = ACTIVE;
 //     Host: foo.com
 //     X-Route-Selector: vip=172.10.10.20
 //
-// would result in the routing table defined by the `route-config1`
+// 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_api_field_extensions.filters.network.http_connection_manager.v3.ScopedRoutes.scope_key_builder>`
+  // :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.
@@ -100,7 +108,7 @@ message ScopedRouteConfiguration {
 
     // The ordered set of fragments to match against. The order must match the
     // fragments in the corresponding
-    // :ref:`scope_key_builder<envoy_api_field_extensions.filters.network.http_connection_manager.v3.ScopedRoutes.scope_key_builder>`.
+    // :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}];
   }
 
@@ -110,10 +118,15 @@ message ScopedRouteConfiguration {
   // 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_api_msg_service.discovery.v3.DiscoveryRequest` to an
-  // RDS server to fetch the :ref:`envoy_api_msg_config.route.v3.RouteConfiguration` associated
+  // 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 [(validate.rules).string = {min_len: 1}];
+  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/v2/datadog.proto b/xds/third_party/envoy/src/main/proto/envoy/config/trace/v2/datadog.proto
deleted file mode 100644
index 0992601a8ac..00000000000
--- a/xds/third_party/envoy/src/main/proto/envoy/config/trace/v2/datadog.proto
+++ /dev/null
@@ -1,23 +0,0 @@
-syntax = "proto3";
-
-package envoy.config.trace.v2;
-
-import "udpa/annotations/status.proto";
-import "validate/validate.proto";
-
-option java_package = "io.envoyproxy.envoy.config.trace.v2";
-option java_outer_classname = "DatadogProto";
-option java_multiple_files = true;
-option (udpa.annotations.file_status).package_version_status = FROZEN;
-
-// [#protodoc-title: Datadog tracer]
-
-// Configuration for the Datadog tracer.
-// [#extension: envoy.tracers.datadog]
-message DatadogConfig {
-  // The cluster to use for submitting traces to the Datadog agent.
-  string collector_cluster = 1 [(validate.rules).string = {min_bytes: 1}];
-
-  // The name used for the service when traces are generated by envoy.
-  string service_name = 2 [(validate.rules).string = {min_bytes: 1}];
-}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/config/trace/v2/dynamic_ot.proto b/xds/third_party/envoy/src/main/proto/envoy/config/trace/v2/dynamic_ot.proto
deleted file mode 100644
index 55c6d401b33..00000000000
--- a/xds/third_party/envoy/src/main/proto/envoy/config/trace/v2/dynamic_ot.proto
+++ /dev/null
@@ -1,29 +0,0 @@
-syntax = "proto3";
-
-package envoy.config.trace.v2;
-
-import "google/protobuf/struct.proto";
-
-import "udpa/annotations/status.proto";
-import "validate/validate.proto";
-
-option java_package = "io.envoyproxy.envoy.config.trace.v2";
-option java_outer_classname = "DynamicOtProto";
-option java_multiple_files = true;
-option (udpa.annotations.file_status).package_version_status = FROZEN;
-
-// [#protodoc-title: Dynamically loadable OpenTracing tracer]
-
-// DynamicOtConfig is used to dynamically load a tracer from a shared library
-// that implements the `OpenTracing dynamic loading API
-// <https://github.com/opentracing/opentracing-cpp>`_.
-// [#extension: envoy.tracers.dynamic_ot]
-message DynamicOtConfig {
-  // Dynamic library implementing the `OpenTracing API
-  // <https://github.com/opentracing/opentracing-cpp>`_.
-  string library = 1 [(validate.rules).string = {min_bytes: 1}];
-
-  // The configuration to use when creating a tracer from the given dynamic
-  // library.
-  google.protobuf.Struct config = 2;
-}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/config/trace/v2/http_tracer.proto b/xds/third_party/envoy/src/main/proto/envoy/config/trace/v2/http_tracer.proto
deleted file mode 100644
index fba830b987b..00000000000
--- a/xds/third_party/envoy/src/main/proto/envoy/config/trace/v2/http_tracer.proto
+++ /dev/null
@@ -1,65 +0,0 @@
-syntax = "proto3";
-
-package envoy.config.trace.v2;
-
-import "google/protobuf/any.proto";
-import "google/protobuf/struct.proto";
-
-import "udpa/annotations/status.proto";
-import "validate/validate.proto";
-
-option java_package = "io.envoyproxy.envoy.config.trace.v2";
-option java_outer_classname = "HttpTracerProto";
-option java_multiple_files = true;
-option (udpa.annotations.file_status).package_version_status = FROZEN;
-
-// [#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_api_msg_config.trace.v2.Tracing.Http>`.
-message Tracing {
-  // Configuration for an HTTP tracer provider used by Envoy.
-  //
-  // The configuration is defined by the
-  // :ref:`HttpConnectionManager.Tracing <envoy_api_msg_config.filter.network.http_connection_manager.v2.HttpConnectionManager.Tracing>`
-  // :ref:`provider <envoy_api_field_config.filter.network.http_connection_manager.v2.HttpConnectionManager.Tracing.provider>`
-  // field.
-  message Http {
-    // The name of the HTTP trace driver to instantiate. The name must match a
-    // supported HTTP trace driver. Built-in trace drivers:
-    //
-    // - *envoy.tracers.lightstep*
-    // - *envoy.tracers.zipkin*
-    // - *envoy.tracers.dynamic_ot*
-    // - *envoy.tracers.datadog*
-    // - *envoy.tracers.opencensus*
-    // - *envoy.tracers.xray*
-    string name = 1 [(validate.rules).string = {min_bytes: 1}];
-
-    // Trace driver specific configuration which depends on the driver being instantiated.
-    // See the trace drivers for examples:
-    //
-    // - :ref:`LightstepConfig <envoy_api_msg_config.trace.v2.LightstepConfig>`
-    // - :ref:`ZipkinConfig <envoy_api_msg_config.trace.v2.ZipkinConfig>`
-    // - :ref:`DynamicOtConfig <envoy_api_msg_config.trace.v2.DynamicOtConfig>`
-    // - :ref:`DatadogConfig <envoy_api_msg_config.trace.v2.DatadogConfig>`
-    // - :ref:`OpenCensusConfig <envoy_api_msg_config.trace.v2.OpenCensusConfig>`
-    // - :ref:`AWS X-Ray <envoy_api_msg_config.trace.v2alpha.XRayConfig>`
-    oneof config_type {
-      google.protobuf.Struct config = 2 [deprecated = true];
-
-      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/v2/lightstep.proto b/xds/third_party/envoy/src/main/proto/envoy/config/trace/v2/lightstep.proto
deleted file mode 100644
index 849749baaa0..00000000000
--- a/xds/third_party/envoy/src/main/proto/envoy/config/trace/v2/lightstep.proto
+++ /dev/null
@@ -1,43 +0,0 @@
-syntax = "proto3";
-
-package envoy.config.trace.v2;
-
-import "udpa/annotations/status.proto";
-import "validate/validate.proto";
-
-option java_package = "io.envoyproxy.envoy.config.trace.v2";
-option java_outer_classname = "LightstepProto";
-option java_multiple_files = true;
-option (udpa.annotations.file_status).package_version_status = FROZEN;
-
-// [#protodoc-title: LightStep tracer]
-
-// Configuration for the LightStep tracer.
-// [#extension: envoy.tracers.lightstep]
-message 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_bytes: 1}];
-
-  // File containing the access token to the `LightStep
-  // <https://lightstep.com/>`_ API.
-  string access_token_file = 2 [(validate.rules).string = {min_bytes: 1}];
-
-  // 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/v2/opencensus.proto b/xds/third_party/envoy/src/main/proto/envoy/config/trace/v2/opencensus.proto
deleted file mode 100644
index 1a9a879b21e..00000000000
--- a/xds/third_party/envoy/src/main/proto/envoy/config/trace/v2/opencensus.proto
+++ /dev/null
@@ -1,92 +0,0 @@
-syntax = "proto3";
-
-package envoy.config.trace.v2;
-
-import "envoy/api/v2/core/grpc_service.proto";
-
-import "opencensus/proto/trace/v1/trace_config.proto";
-
-import "udpa/annotations/status.proto";
-
-option java_package = "io.envoyproxy.envoy.config.trace.v2";
-option java_outer_classname = "OpencensusProto";
-option java_multiple_files = true;
-option (udpa.annotations.file_status).package_version_status = FROZEN;
-
-// [#protodoc-title: OpenCensus tracer]
-
-// Configuration for the OpenCensus tracer.
-// [#next-free-field: 15]
-// [#extension: envoy.tracers.opencensus]
-message OpenCensusConfig {
-  enum TraceContext {
-    // No-op default, no trace context is utilized.
-    NONE = 0;
-
-    // W3C Trace-Context format "traceparent:" header.
-    TRACE_CONTEXT = 1;
-
-    // Binary "grpc-trace-bin:" header.
-    GRPC_TRACE_BIN = 2;
-
-    // "X-Cloud-Trace-Context:" header.
-    CLOUD_TRACE_CONTEXT = 3;
-
-    // X-B3-* headers.
-    B3 = 4;
-  }
-
-  reserved 7;
-
-  // Configures tracing, e.g. the sampler, max number of annotations, etc.
-  opencensus.proto.trace.v1.TraceConfig trace_config = 1;
-
-  // Enables the stdout exporter if set to true. This is intended for debugging
-  // purposes.
-  bool stdout_exporter_enabled = 2;
-
-  // Enables the Stackdriver exporter if set to true. The project_id must also
-  // be set.
-  bool stackdriver_exporter_enabled = 3;
-
-  // The Cloud project_id to use for Stackdriver tracing.
-  string stackdriver_project_id = 4;
-
-  // (optional) By default, the Stackdriver exporter will connect to production
-  // Stackdriver. If stackdriver_address is non-empty, it will instead connect
-  // to this address, which is in the gRPC format:
-  // https://github.com/grpc/grpc/blob/master/doc/naming.md
-  string stackdriver_address = 10;
-
-  // (optional) The gRPC server that hosts Stackdriver tracing service. Only
-  // Google gRPC is supported. If :ref:`target_uri <envoy_v3_api_field_config.core.v3.GrpcService.GoogleGrpc.target_uri>`
-  // is not provided, the default production Stackdriver address will be used.
-  api.v2.core.GrpcService stackdriver_grpc_service = 13;
-
-  // Enables the Zipkin exporter if set to true. The url and service name must
-  // also be set.
-  bool zipkin_exporter_enabled = 5;
-
-  // The URL to Zipkin, e.g. "http://127.0.0.1:9411/api/v2/spans"
-  string zipkin_url = 6;
-
-  // Enables the OpenCensus Agent exporter if set to true. The ocagent_address or
-  // ocagent_grpc_service must also be set.
-  bool ocagent_exporter_enabled = 11;
-
-  // The address of the OpenCensus Agent, if its exporter is enabled, in gRPC
-  // format: https://github.com/grpc/grpc/blob/master/doc/naming.md
-  // [#comment:TODO: deprecate this field]
-  string ocagent_address = 12;
-
-  // (optional) The gRPC server hosted by the OpenCensus Agent. Only Google gRPC is supported.
-  // This is only used if the ocagent_address is left empty.
-  api.v2.core.GrpcService ocagent_grpc_service = 14;
-
-  // List of incoming trace context headers we will accept. First one found
-  // wins.
-  repeated TraceContext incoming_trace_context = 8;
-
-  // List of outgoing trace context headers we will produce.
-  repeated TraceContext outgoing_trace_context = 9;
-}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/config/trace/v2/service.proto b/xds/third_party/envoy/src/main/proto/envoy/config/trace/v2/service.proto
deleted file mode 100644
index d102499b626..00000000000
--- a/xds/third_party/envoy/src/main/proto/envoy/config/trace/v2/service.proto
+++ /dev/null
@@ -1,21 +0,0 @@
-syntax = "proto3";
-
-package envoy.config.trace.v2;
-
-import "envoy/api/v2/core/grpc_service.proto";
-
-import "udpa/annotations/status.proto";
-import "validate/validate.proto";
-
-option java_package = "io.envoyproxy.envoy.config.trace.v2";
-option java_outer_classname = "ServiceProto";
-option java_multiple_files = true;
-option (udpa.annotations.file_status).package_version_status = FROZEN;
-
-// [#protodoc-title: Trace Service]
-
-// Configuration structure.
-message TraceServiceConfig {
-  // The upstream gRPC cluster that hosts the metrics service.
-  api.v2.core.GrpcService grpc_service = 1 [(validate.rules).message = {required: true}];
-}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/config/trace/v2/trace.proto b/xds/third_party/envoy/src/main/proto/envoy/config/trace/v2/trace.proto
deleted file mode 100644
index 6ed394147db..00000000000
--- a/xds/third_party/envoy/src/main/proto/envoy/config/trace/v2/trace.proto
+++ /dev/null
@@ -1,15 +0,0 @@
-syntax = "proto3";
-
-package envoy.config.trace.v2;
-
-import public "envoy/config/trace/v2/datadog.proto";
-import public "envoy/config/trace/v2/dynamic_ot.proto";
-import public "envoy/config/trace/v2/http_tracer.proto";
-import public "envoy/config/trace/v2/lightstep.proto";
-import public "envoy/config/trace/v2/opencensus.proto";
-import public "envoy/config/trace/v2/service.proto";
-import public "envoy/config/trace/v2/zipkin.proto";
-
-option java_package = "io.envoyproxy.envoy.config.trace.v2";
-option java_outer_classname = "TraceProto";
-option java_multiple_files = true;
diff --git a/xds/third_party/envoy/src/main/proto/envoy/config/trace/v2/zipkin.proto b/xds/third_party/envoy/src/main/proto/envoy/config/trace/v2/zipkin.proto
deleted file mode 100644
index a825d85bb7f..00000000000
--- a/xds/third_party/envoy/src/main/proto/envoy/config/trace/v2/zipkin.proto
+++ /dev/null
@@ -1,64 +0,0 @@
-syntax = "proto3";
-
-package envoy.config.trace.v2;
-
-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.config.trace.v2";
-option java_outer_classname = "ZipkinProto";
-option java_multiple_files = true;
-option (udpa.annotations.file_status).package_version_status = FROZEN;
-
-// [#protodoc-title: Zipkin tracer]
-
-// Configuration for the Zipkin tracer.
-// [#extension: envoy.tracers.zipkin]
-// [#next-free-field: 6]
-message ZipkinConfig {
-  // 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.]
-    HTTP_JSON_V1 = 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 that the
-  // Zipkin cluster must be defined in the :ref:`Bootstrap static cluster
-  // resources <envoy_api_field_config.bootstrap.v2.Bootstrap.StaticResources.clusters>`.
-  string collector_cluster = 1 [(validate.rules).string = {min_bytes: 1}];
-
-  // The API endpoint of the Zipkin service where the spans will be sent. When
-  // using a standard Zipkin installation, the API endpoint is typically
-  // /api/v1/spans, which is the default value.
-  string collector_endpoint = 2 [(validate.rules).string = {min_bytes: 1}];
-
-  // 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. By default, the ``HTTP_JSON_V1`` will be
-  // used.
-  CollectorEndpointVersion collector_endpoint_version = 5;
-}
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
index c101ab2f03c..5359ec74267 100644
--- 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
@@ -2,6 +2,8 @@ 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";
@@ -10,11 +12,19 @@ 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 {
@@ -26,4 +36,15 @@ message DatadogConfig {
 
   // 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
index c2810687154..40fe8526a5f 100644
--- 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
@@ -4,6 +4,7 @@ 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";
@@ -12,25 +13,35 @@ 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 is used to dynamically load a tracer from a shared library
+// 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>`_.
-// [#extension: envoy.tracers.dynamic_ot]
+// [#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 [(validate.rules).string = {min_len: 1}];
+  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;
+  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
index 7146687b831..8bd5151f4b1 100644
--- 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
@@ -11,6 +11,7 @@ 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]
@@ -24,15 +25,15 @@ option (udpa.annotations.file_status).package_version_status = ACTIVE;
 // .. attention::
 //
 //   Use of this message type has been deprecated in favor of direct use of
-//   :ref:`Tracing.Http <envoy_api_msg_config.trace.v3.Tracing.Http>`.
+//   :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_api_msg_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.Tracing>`
-  // :ref:`provider <envoy_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.Tracing.provider>`
+  // :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 =
@@ -43,25 +44,12 @@ message Tracing {
     reserved "config";
 
     // The name of the HTTP trace driver to instantiate. The name must match a
-    // supported HTTP trace driver. Built-in trace drivers:
-    //
-    // - *envoy.tracers.lightstep*
-    // - *envoy.tracers.zipkin*
-    // - *envoy.tracers.dynamic_ot*
-    // - *envoy.tracers.datadog*
-    // - *envoy.tracers.opencensus*
-    // - *envoy.tracers.xray*
+    // 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 depends on the driver being instantiated.
-    // See the trace drivers for examples:
-    //
-    // - :ref:`LightstepConfig <envoy_api_msg_config.trace.v3.LightstepConfig>`
-    // - :ref:`ZipkinConfig <envoy_api_msg_config.trace.v3.ZipkinConfig>`
-    // - :ref:`DynamicOtConfig <envoy_api_msg_config.trace.v3.DynamicOtConfig>`
-    // - :ref:`DatadogConfig <envoy_api_msg_config.trace.v3.DatadogConfig>`
-    // - :ref:`OpenCensusConfig <envoy_api_msg_config.trace.v3.OpenCensusConfig>`
-    // - :ref:`AWS X-Ray <envoy_api_msg_config.trace.v3.XRayConfig>`
+    // 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;
     }
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
index 0b7be7c4e60..96dbbedd542 100644
--- 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
@@ -2,6 +2,9 @@ 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";
@@ -10,6 +13,7 @@ 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;
@@ -18,6 +22,7 @@ option (udpa.annotations.file_status).package_version_status = ACTIVE;
 
 // 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";
@@ -42,7 +47,11 @@ message LightstepConfig {
 
   // File containing the access token to the `LightStep
   // <https://lightstep.com/>`_ API.
-  string access_token_file = 2 [(validate.rules).string = {min_len: 1}];
+  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
diff --git a/xds/third_party/envoy/src/main/proto/envoy/config/trace/v3/opencensus.proto b/xds/third_party/envoy/src/main/proto/envoy/config/trace/v3/opencensus.proto
deleted file mode 100644
index 6ffce02392f..00000000000
--- a/xds/third_party/envoy/src/main/proto/envoy/config/trace/v3/opencensus.proto
+++ /dev/null
@@ -1,102 +0,0 @@
-syntax = "proto3";
-
-package envoy.config.trace.v3;
-
-import "envoy/config/core/v3/grpc_service.proto";
-
-import "opencensus/proto/trace/v1/trace_config.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 = "OpencensusProto";
-option java_multiple_files = true;
-option (udpa.annotations.file_migrate).move_to_package =
-    "envoy.extensions.tracers.opencensus.v4alpha";
-option (udpa.annotations.file_status).package_version_status = ACTIVE;
-
-// [#protodoc-title: OpenCensus tracer]
-
-// Configuration for the OpenCensus tracer.
-// [#next-free-field: 15]
-// [#extension: envoy.tracers.opencensus]
-message OpenCensusConfig {
-  option (udpa.annotations.versioning).previous_message_type =
-      "envoy.config.trace.v2.OpenCensusConfig";
-
-  enum TraceContext {
-    // No-op default, no trace context is utilized.
-    NONE = 0;
-
-    // W3C Trace-Context format "traceparent:" header.
-    TRACE_CONTEXT = 1;
-
-    // Binary "grpc-trace-bin:" header.
-    GRPC_TRACE_BIN = 2;
-
-    // "X-Cloud-Trace-Context:" header.
-    CLOUD_TRACE_CONTEXT = 3;
-
-    // X-B3-* headers.
-    B3 = 4;
-  }
-
-  reserved 7;
-
-  // Configures tracing, e.g. the sampler, max number of annotations, etc.
-  opencensus.proto.trace.v1.TraceConfig trace_config = 1;
-
-  // Enables the stdout exporter if set to true. This is intended for debugging
-  // purposes.
-  bool stdout_exporter_enabled = 2;
-
-  // Enables the Stackdriver exporter if set to true. The project_id must also
-  // be set.
-  bool stackdriver_exporter_enabled = 3;
-
-  // The Cloud project_id to use for Stackdriver tracing.
-  string stackdriver_project_id = 4;
-
-  // (optional) By default, the Stackdriver exporter will connect to production
-  // Stackdriver. If stackdriver_address is non-empty, it will instead connect
-  // to this address, which is in the gRPC format:
-  // https://github.com/grpc/grpc/blob/master/doc/naming.md
-  string stackdriver_address = 10;
-
-  // (optional) The gRPC server that hosts Stackdriver tracing service. Only
-  // Google gRPC is supported. If :ref:`target_uri <envoy_v3_api_field_config.core.v3.GrpcService.GoogleGrpc.target_uri>`
-  // is not provided, the default production Stackdriver address will be used.
-  core.v3.GrpcService stackdriver_grpc_service = 13;
-
-  // Enables the Zipkin exporter if set to true. The url and service name must
-  // also be set. This is deprecated, prefer to use Envoy's :ref:`native Zipkin
-  // tracer <envoy_v3_api_msg_config.trace.v3.ZipkinConfig>`.
-  bool zipkin_exporter_enabled = 5 [deprecated = true];
-
-  // The URL to Zipkin, e.g. "http://127.0.0.1:9411/api/v2/spans". This is
-  // deprecated, prefer to use Envoy's :ref:`native Zipkin tracer
-  // <envoy_v3_api_msg_config.trace.v3.ZipkinConfig>`.
-  string zipkin_url = 6 [deprecated = true];
-
-  // Enables the OpenCensus Agent exporter if set to true. The ocagent_address or
-  // ocagent_grpc_service must also be set.
-  bool ocagent_exporter_enabled = 11;
-
-  // The address of the OpenCensus Agent, if its exporter is enabled, in gRPC
-  // format: https://github.com/grpc/grpc/blob/master/doc/naming.md
-  // [#comment:TODO: deprecate this field]
-  string ocagent_address = 12;
-
-  // (optional) The gRPC server hosted by the OpenCensus Agent. Only Google gRPC is supported.
-  // This is only used if the ocagent_address is left empty.
-  core.v3.GrpcService ocagent_grpc_service = 14;
-
-  // List of incoming trace context headers we will accept. First one found
-  // wins.
-  repeated TraceContext incoming_trace_context = 8;
-
-  // List of outgoing trace context headers we will produce.
-  repeated TraceContext outgoing_trace_context = 9;
-}
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
index 1e01ff61847..4cb8c44c424 100644
--- 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
@@ -11,6 +11,7 @@ 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]
diff --git a/xds/third_party/envoy/src/main/proto/envoy/config/trace/v3/trace.proto b/xds/third_party/envoy/src/main/proto/envoy/config/trace/v3/trace.proto
deleted file mode 100644
index 472e38b5abb..00000000000
--- a/xds/third_party/envoy/src/main/proto/envoy/config/trace/v3/trace.proto
+++ /dev/null
@@ -1,15 +0,0 @@
-syntax = "proto3";
-
-package envoy.config.trace.v3;
-
-import public "envoy/config/trace/v3/datadog.proto";
-import public "envoy/config/trace/v3/dynamic_ot.proto";
-import public "envoy/config/trace/v3/http_tracer.proto";
-import public "envoy/config/trace/v3/lightstep.proto";
-import public "envoy/config/trace/v3/opencensus.proto";
-import public "envoy/config/trace/v3/service.proto";
-import public "envoy/config/trace/v3/zipkin.proto";
-
-option java_package = "io.envoyproxy.envoy.config.trace.v3";
-option java_outer_classname = "TraceProto";
-option java_multiple_files = 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
index 2c1026b8304..2364983efc5 100644
--- 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
@@ -2,17 +2,19 @@ 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";
-import "validate/validate.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;
 
@@ -20,10 +22,22 @@ option (udpa.annotations.file_status).package_version_status = ACTIVE;
 
 // Configuration for the Zipkin tracer.
 // [#extension: envoy.tracers.zipkin]
-// [#next-free-field: 7]
+// [#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.
@@ -47,12 +61,23 @@ message ZipkinConfig {
   }
 
   // The cluster manager cluster that hosts the Zipkin collectors.
-  string collector_cluster = 1 [(validate.rules).string = {min_len: 1}];
+  //
+  // .. 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, the API endpoint is typically
-  // /api/v1/spans, which is the default value.
-  string collector_endpoint = 2 [(validate.rules).string = {min_len: 1}];
+  // 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.
@@ -62,11 +87,90 @@ message ZipkinConfig {
   // The default value is true.
   google.protobuf.BoolValue shared_span_context = 4;
 
-  // Determines the selected collector endpoint version. By default, the ``HTTP_JSON_V1`` will be
-  // used.
+  // 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
index aead1c45173..d23d767f73b 100644
--- 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
@@ -2,6 +2,8 @@ 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";
@@ -9,6 +11,7 @@ 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]
@@ -24,3 +27,18 @@ message ClusterConfig {
   // 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/common/matching/v3/extension_matcher.proto b/xds/third_party/envoy/src/main/proto/envoy/extensions/common/matching/v3/extension_matcher.proto
new file mode 100644
index 00000000000..817cd27a37a
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/extensions/common/matching/v3/extension_matcher.proto
@@ -0,0 +1,42 @@
+syntax = "proto3";
+
+package envoy.extensions.common.matching.v3;
+
+import "envoy/config/common/matcher/v3/matcher.proto";
+import "envoy/config/core/v3/extension.proto";
+
+import "xds/type/matcher/v3/matcher.proto";
+
+import "envoy/annotations/deprecation.proto";
+import "udpa/annotations/status.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.extensions.common.matching.v3";
+option java_outer_classname = "ExtensionMatcherProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/extensions/common/matching/v3;matchingv3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: Extension matcher]
+
+// Wrapper around an existing extension that provides an associated matcher. This allows
+// decorating an existing extension with a matcher, which can be used to match against
+// relevant protocol data.
+message ExtensionWithMatcher {
+  // The associated matcher. This is deprecated in favor of xds_matcher.
+  config.common.matcher.v3.Matcher matcher = 1
+      [deprecated = true, (envoy.annotations.deprecated_at_minor_version) = "3.0"];
+
+  // The associated matcher.
+  xds.type.matcher.v3.Matcher xds_matcher = 3;
+
+  // The underlying extension config.
+  config.core.v3.TypedExtensionConfig extension_config = 2
+      [(validate.rules).message = {required: true}];
+}
+
+// Extra settings on a per virtualhost/route/weighted-cluster level.
+message ExtensionWithMatcherPerRoute {
+  // Matcher override.
+  xds.type.matcher.v3.Matcher xds_matcher = 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
index b5b1dbd463f..ab24f5d2374 100644
--- 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
@@ -13,12 +13,13 @@ 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/gRPC/Mongo/Redis operation or delay proxying of TCP connections.
+// HTTP/Mongo operation.
 // [#next-free-field: 6]
 message FaultDelay {
   option (udpa.annotations.versioning).previous_message_type =
@@ -46,10 +47,9 @@ message FaultDelay {
 
     // 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/Redis, the specified
-    // delay will be injected before a new request/operation. For TCP
-    // connections, the proxying of the connection upstream will be delayed
-    // for the specified period. This is required if type is FIXED.
+    // 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).
diff --git a/xds/third_party/envoy/src/main/proto/envoy/extensions/filters/http/composite/v3/composite.proto b/xds/third_party/envoy/src/main/proto/envoy/extensions/filters/http/composite/v3/composite.proto
new file mode 100644
index 00000000000..1ab6c5eb1ef
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/extensions/filters/http/composite/v3/composite.proto
@@ -0,0 +1,106 @@
+syntax = "proto3";
+
+package envoy.extensions.filters.http.composite.v3;
+
+import "envoy/config/core/v3/base.proto";
+import "envoy/config/core/v3/config_source.proto";
+import "envoy/config/core/v3/extension.proto";
+
+import "udpa/annotations/migrate.proto";
+import "udpa/annotations/status.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.extensions.filters.http.composite.v3";
+option java_outer_classname = "CompositeProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/extensions/filters/http/composite/v3;compositev3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: Composite]
+// Composite Filter :ref:`configuration overview <config_http_filters_composite>`.
+// [#extension: envoy.filters.http.composite]
+
+// :ref:`Composite filter <config_http_filters_composite>` config. The composite filter config
+// allows delegating filter handling to another filter as determined by matching on the request
+// headers. This makes it possible to use different filters or filter configurations based on the
+// incoming request.
+//
+// This is intended to be used with
+// :ref:`ExtensionWithMatcher <envoy_v3_api_msg_extensions.common.matching.v3.ExtensionWithMatcher>`
+// where a match tree is specified that indicates (via
+// :ref:`ExecuteFilterAction <envoy_v3_api_msg_extensions.filters.http.composite.v3.ExecuteFilterAction>`)
+// which filter configuration to create and delegate to.
+message Composite {
+  // Named filter chain definitions that can be referenced from
+  // :ref:`ExecuteFilterAction.filter_chain_name
+  // <envoy_v3_api_field_extensions.filters.http.composite.v3.ExecuteFilterAction.filter_chain_name>`.
+  // The filter chains are compiled at configuration time and can be referenced by name.
+  // This is useful when the same filter chain needs to be applied across many routes,
+  // as it avoids duplicating the filter chain configuration.
+  map<string, FilterChainConfiguration> named_filter_chains = 1;
+}
+
+// A list of filter configurations to be called in order. Note that this can be used as the type
+// inside of an ECDS :ref:`TypedExtensionConfig
+// <envoy_v3_api_msg_config.core.v3.TypedExtensionConfig>` extension, which allows a chain of
+// filters to be configured dynamically. In that case, the types of all filters in the chain must
+// be present in the :ref:`ExtensionConfigSource.type_urls
+// <envoy_v3_api_field_config.core.v3.ExtensionConfigSource.type_urls>` field.
+message FilterChainConfiguration {
+  repeated config.core.v3.TypedExtensionConfig typed_config = 1;
+}
+
+// Configuration for an extension configuration discovery service with name.
+message DynamicConfig {
+  // The name of the extension configuration. It also serves as a resource name in ExtensionConfigDS.
+  // The resource type in the ``DiscoveryRequest`` will be :ref:`TypedExtensionConfig
+  // <envoy_v3_api_msg_config.core.v3.TypedExtensionConfig>`.
+  string name = 1 [(validate.rules).string = {min_len: 1}];
+
+  // Configuration source specifier for an extension configuration discovery
+  // service. In case of a failure and without the default configuration,
+  // 500(Internal Server Error) will be returned.
+  config.core.v3.ExtensionConfigSource config_discovery = 2;
+}
+
+// Composite match action (see :ref:`matching docs <arch_overview_matching_api>` for more info on match actions).
+// This specifies the filter configuration of the filter that the composite filter should delegate filter interactions to.
+// [#next-free-field: 6]
+message ExecuteFilterAction {
+  // Filter specific configuration which depends on the filter being
+  // instantiated. See the supported filters for further documentation.
+  // Only one of ``typed_config``, ``dynamic_config``, ``filter_chain``, or ``filter_chain_name``
+  // can be set.
+  // [#extension-category: envoy.filters.http]
+  config.core.v3.TypedExtensionConfig typed_config = 1
+      [(udpa.annotations.field_migrate).oneof_promotion = "config_type"];
+
+  // Dynamic configuration of filter obtained via extension configuration discovery service.
+  // Only one of ``typed_config``, ``dynamic_config``, ``filter_chain``, or ``filter_chain_name``
+  // can be set.
+  DynamicConfig dynamic_config = 2
+      [(udpa.annotations.field_migrate).oneof_promotion = "config_type"];
+
+  // An inlined list of filter configurations. The specified filters will be executed in order.
+  // Only one of ``typed_config``, ``dynamic_config``, ``filter_chain``, or ``filter_chain_name``
+  // can be set.
+  FilterChainConfiguration filter_chain = 4;
+
+  // The name of a filter chain defined in
+  // :ref:`Composite.named_filter_chains
+  // <envoy_v3_api_field_extensions.filters.http.composite.v3.Composite.named_filter_chains>`.
+  // At runtime, if the named filter chain is not found in the Composite filter's configuration,
+  // no filter will be applied for this match (the action is silently skipped).
+  // Only one of ``typed_config``, ``dynamic_config``, ``filter_chain``, or ``filter_chain_name``
+  // can be set.
+  string filter_chain_name = 5;
+
+  // Probability of the action execution. If not specified, this is 100%.
+  // This allows sampling behavior for the configured actions.
+  // For example, if
+  // :ref:`default_value <envoy_v3_api_field_config.core.v3.RuntimeFractionalPercent.default_value>`
+  // under the ``sample_percent`` is configured with 30%, a dice roll with that
+  // probability is done. The underline action will only be executed if the
+  // dice roll returns positive. Otherwise, the action is skipped.
+  config.core.v3.RuntimeFractionalPercent sample_percent = 3;
+}
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..7f70b70013b
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/extensions/filters/http/ext_authz/v3/ext_authz.proto
@@ -0,0 +1,602 @@
+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: 32]
+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>`.
+  //
+  // Defaults to ``false``.
+  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 all of the following holds:
+  //
+  // * This 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.
+  //
+  // Defaults to ``false``.
+  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 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 response is invalid, the filter 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``.
+  //
+  // Defaults to ``false``.
+  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.
+  //
+  // .. note::
+  //
+  //   This field is only evaluated if the filter is instantiated. If the filter is marked with
+  //   ``disabled: true`` in the :ref:`HttpFilter
+  //   <envoy_v3_api_msg_extensions.filters.network.http_connection_manager.v3.HttpFilter>`
+  //   configuration or in per-route configuration via :ref:`ExtAuthzPerRoute
+  //   <envoy_v3_api_msg_extensions.filters.http.ext_authz.v3.ExtAuthzPerRoute>`,
+  //   the filter will not be instantiated and this field will have no effect.
+  //
+  // .. tip::
+  //
+  //   For dynamic filter activation based on metadata (such as metadata set by a preceding
+  //   filter), consider using :ref:`ExtensionWithMatcher
+  //   <envoy_v3_api_msg_extensions.common.matching.v3.ExtensionWithMatcher>` instead. This
+  //   provides a more flexible matching framework that can evaluate conditions before filter
+  //   instantiation. See the :ref:`ext_authz filter documentation
+  //   <config_http_filters_ext_authz>` for examples.
+  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 list. 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 or forwarding upstream.
+  //
+  // If set, enables header mutation checking against the 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,
+  // ext_authz can no longer append to ``:``-prefixed headers.
+  //
+  // If unset, 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 and query parameter mutations (for example, 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::
+  //   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;
+
+  // Sets the maximum size (in bytes) of the response body that the filter will send downstream
+  // when a request is denied by the external authorization service.
+  //
+  // If the authorization server returns a response body larger than this configured limit,
+  // the body will be truncated to ``max_denied_response_body_bytes`` before being sent to the
+  // downstream client.
+  //
+  // If this field is not set or is set to 0, no truncation will occur, and the entire
+  // denied response body will be forwarded.
+  uint32 max_denied_response_body_bytes = 30;
+
+  // When set to ``true``, the filter will enforce the response header map's count and size limits
+  // by sending a local reply when those limits are violated.
+  //
+  // When set to ``false``, the filter will ignore the response header map's limits and add / set
+  // all response headers as specified by the external authorization service.
+  //
+  // Recommendation: enable if the external authorization service is not trusted. Otherwise, leave
+  // it ``false``.
+  //
+  // Defaults to ``false``.
+  bool enforce_response_header_limits = 31;
+}
+
+// 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::
+  //   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.
+  //
+  // Defaults to ``false``.
+  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.
+  //
+  // Defaults to ``false``.
+  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::
+//   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: 10]
+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;
+
+  // Optional retry policy for requests to the authorization server.
+  // If not set, no retries will be performed.
+  //
+  // .. note::
+  //   When this field is set, the ``ext_authz`` filter will buffer the request body for retry purposes.
+  config.core.v3.RetryPolicy retry_policy = 9;
+}
+
+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 list.
+  // 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::
+  //   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 list is set, authorization
+  // response headers that have a correspondent match will be added to the original client request.
+  //
+  // .. note::
+  //   Existing headers will be overridden.
+  type.matcher.v3.ListStringMatcher allowed_upstream_headers = 1;
+
+  // When this list is set, authorization
+  // response headers that have a correspondent match will be added to the original client request.
+  //
+  // .. note::
+  //   Existing headers will be appended.
+  type.matcher.v3.ListStringMatcher allowed_upstream_headers_to_append = 3;
+
+  // When this list is set, authorization
+  // response headers that have a correspondent match will be added to the client's response.
+  // When a header is included in this list, ``Path``, ``Status``, ``Content-Length``, ``WWW-Authenticate`` and
+  // ``Location`` are automatically added.
+  //
+  // .. note::
+  //   When this list is *not* set, all the authorization response headers, except
+  //   ``Authority (Host)``, will be in the response to the client.
+  type.matcher.v3.ListStringMatcher allowed_client_headers = 2;
+
+  // When this list 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 list 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
index d28ed28b111..01f056e7927 100644
--- 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
@@ -6,6 +6,7 @@ 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";
@@ -15,6 +16,7 @@ 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]
@@ -54,7 +56,7 @@ message FaultAbort {
   type.v3.FractionalPercent percentage = 3;
 }
 
-// [#next-free-field: 15]
+// [#next-free-field: 17]
 message HTTPFault {
   option (udpa.annotations.versioning).previous_message_type =
       "envoy.config.filter.http.fault.v2.HTTPFault";
@@ -64,7 +66,7 @@ message HTTPFault {
   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.
+  // the object. At least ``abort`` or ``delay`` must be specified.
   FaultAbort abort = 2;
 
   // Specifies the name of the (destination) upstream cluster that the
@@ -76,11 +78,11 @@ message HTTPFault {
   // 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_api_field_extensions.filters.http.fault.v3.FaultAbort.percentage>` field.
+  // <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).
+  // 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
@@ -95,9 +97,9 @@ message HTTPFault {
   // 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.
+  // ``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
@@ -141,4 +143,17 @@ message HTTPFault {
   // 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..a37efe157db
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/extensions/filters/http/rbac/v3/rbac.proto
@@ -0,0 +1,86 @@
+syntax = "proto3";
+
+package envoy.extensions.filters.http.rbac.v3;
+
+import "envoy/config/rbac/v3/rbac.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"];
+
+  // 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..7da658bcb33
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/extensions/filters/http/router/v3/router.proto
@@ -0,0 +1,143 @@
+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: 11]
+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;
+
+  // If set to true, Envoy will reject ``CONNECT`` requests that send data before
+  // receiving a ``200`` response from the upstream. This early data behavior
+  // is common for latency reduction but can cause issues with some upstreams.
+  // Defaults to false to allow early data and be compatible with common behavior.
+  google.protobuf.BoolValue reject_connect_request_early_data = 10;
+}
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
index 877569ee470..9d8cf8bf4fd 100644
--- 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
@@ -3,6 +3,7 @@ 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";
@@ -11,6 +12,7 @@ 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";
 
@@ -18,6 +20,9 @@ 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/security.proto";
 import "udpa/annotations/status.proto";
@@ -27,13 +32,14 @@ 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: 43]
+// [#next-free-field: 61]
 message HttpConnectionManager {
   option (udpa.annotations.versioning).previous_message_type =
       "envoy.config.filter.network.http_connection_manager.v2.HttpConnectionManager";
@@ -54,9 +60,8 @@ message HttpConnectionManager {
     // Prior knowledge is allowed).
     HTTP2 = 2;
 
-    // [#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.
+    // 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;
   }
 
@@ -96,11 +101,53 @@ message HttpConnectionManager {
     ALWAYS_FORWARD_ONLY = 4;
   }
 
-  // [#next-free-field: 10]
+  // 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: 13]
   message Tracing {
     option (udpa.annotations.versioning).previous_message_type =
         "envoy.config.filter.network.http_connection_manager.v2.HttpConnectionManager.Tracing";
 
+    // This OperationName makes no sense and is unnecessary in the current tracing API.
+    // [#not-implemented-hide:]
     enum OperationName {
       // The HTTP listener is used for ingress/incoming requests.
       INGRESS = 0;
@@ -116,7 +163,7 @@ message HttpConnectionManager {
     // 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_sampling' in the :ref:`HTTP Connection Manager
+    // 'tracing.client_enabled' in the :ref:`HTTP Connection Manager
     // <config_http_conn_man_runtime>`.
     // Default: 100%
     type.v3.Percent client_sampling = 3;
@@ -152,15 +199,50 @@ message HttpConnectionManager {
 
     // Configuration for an external tracing provider.
     // If not specified, no tracing will be performed.
-    //
-    // .. attention::
-    //   Please be aware that *envoy.tracers.opencensus* provider can only be configured once
-    //   in Envoy lifetime.
-    //   Any attempts to reconfigure it or to use different configurations for different HCM filters
-    //   will be rejected.
-    //   Such a constraint is inherent to OpenCensus itself. It cannot be overcome without changes
-    //   on OpenCensus side.
     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;
+
+    // The operation name of the span which will be used for tracing.
+    //
+    // The same :ref:`format specifier <config_access_log_format>` as used for
+    // :ref:`HTTP access logging <config_access_log>` applies here, however
+    // unknown specifier values are replaced with the empty string instead of ``-``.
+    //
+    // This field will take precedence over and make following settings ineffective:
+    //
+    // * :ref:`route decorator <envoy_v3_api_field_config.route.v3.Route.decorator>` and
+    // * :ref:`x-envoy-decorator-operation <config_http_filters_router_x-envoy-decorator-operation>`
+    //   header will be ignored.
+    string operation = 11;
+
+    // The operation name of the upstream span which will be used for tracing.
+    // This only takes effect when ``spawn_upstream_span`` is set to true and the upstream
+    // span is created.
+    //
+    // The same :ref:`format specifier <config_access_log_format>` as used for
+    // :ref:`HTTP access logging <config_access_log>` applies here, however
+    // unknown specifier values are replaced with the empty string instead of ``-``.
+    string upstream_operation = 12;
   }
 
   message InternalAddressConfig {
@@ -170,6 +252,10 @@ message HttpConnectionManager {
 
     // 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]
@@ -203,18 +289,26 @@ message HttpConnectionManager {
     bool uri = 5;
   }
 
+  // The configuration for forwarding client cert details.
+  message ForwardClientCertConfig {
+    // How to handle the XFCC header.
+    ForwardClientCertDetails forward_client_cert_details = 1;
+
+    // How to set the current client cert details.
+    SetCurrentClientCertDetails set_current_client_cert_details = 2;
+  }
+
   // 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.
+  //    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.
+  //    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."
@@ -233,11 +327,117 @@ message HttpConnectionManager {
 
     // 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_api_field_config.route.v3.RouteAction.upgrade_configs>` as documented in the
+    // <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";
@@ -277,23 +477,45 @@ message HttpConnectionManager {
 
   // Presence of the object defines whether the connection manager
   // emits :ref:`tracing <arch_overview_tracing>` data to the :ref:`configured tracing provider
-  // <envoy_api_msg_config.trace.v3.Tracing>`.
+  // <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 HTTP1 and HTTP2 requests.
+  // 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*.
+  // 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}];
 
@@ -303,13 +525,25 @@ message HttpConnectionManager {
   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.
-  // The max configurable limit is 96 KiB, based on current implementation
-  // constraints.
+  //
+  // .. 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: 96 gt: 0}];
+      [(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
@@ -319,28 +553,18 @@ message HttpConnectionManager {
   //
   // This idle timeout applies to new streams and is overridable by the
   // :ref:`route-level idle_timeout
-  // <envoy_api_field_config.route.v3.RouteAction.idle_timeout>`. Even on a stream in
+  // <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_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.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.
   //
-  // This timeout also 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_api_field_config.core.v3.HttpProtocolOptions.max_stream_duration>` does not apply to
-  // this corner case.
-  //
   // 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_api_enum_value_config.overload.v3.ScaleTimersOverloadActionConfig.TimerType.HTTP_DOWNSTREAM_STREAM_IDLE>`.
+  // :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
@@ -350,9 +574,29 @@ message HttpConnectionManager {
   //
   // 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
@@ -374,9 +618,10 @@ message HttpConnectionManager {
   // 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
-  // both when a connection hits the idle timeout or during general server
-  // draining. The default grace period is 5000 milliseconds (5 seconds) if this
-  // option is not specified.
+  // 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.
@@ -384,37 +629,73 @@ message HttpConnectionManager {
   // 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>.
+  //
+  // .. 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,
+  // ``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::
+  // .. 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
+  // .. 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
@@ -432,25 +713,80 @@ message HttpConnectionManager {
   // :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_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.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
+  // 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;
+  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
@@ -475,14 +811,61 @@ message HttpConnectionManager {
       [(validate.rules).enum = {defined_only: true}];
 
   // This field is valid only when :ref:`forward_client_cert_details
-  // <envoy_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.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
+  // :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;
 
+  // The matcher for forwarding client cert details. This allows per-request configuration
+  // of forward client cert behavior based on request properties. If a matcher is configured
+  // and matches a request, the matched action's forward client cert config will be used.
+  // If the matcher is not configured or doesn't match, the static
+  // :ref:`forward_client_cert_details
+  // <envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.forward_client_cert_details>`
+  // and
+  // :ref:`set_current_client_cert_details
+  // <envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.set_current_client_cert_details>`
+  // config will be used as fallback.
+  //
+  // Example: If the x-forwarded-client-cert header contains "trusted-client", use APPEND_FORWARD,
+  // otherwise use SANITIZE_SET:
+  //
+  // .. code-block:: yaml
+  //
+  //   forward_client_cert_matcher:
+  //     matcher_list:
+  //       matchers:
+  //       - predicate:
+  //           single_predicate:
+  //             input:
+  //               name: envoy.matching.inputs.request_headers
+  //               typed_config:
+  //                 "@type": type.googleapis.com/envoy.type.matcher.v3.HttpRequestHeaderMatchInput
+  //                 header_name: "x-forwarded-client-cert"
+  //             value_match:
+  //               string_match:
+  //                 contains: "trusted-client"
+  //         on_match:
+  //           action:
+  //             name: forward_client_cert
+  //             typed_config:
+  //               "@type": type.googleapis.com/envoy.extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.ForwardClientCertConfig
+  //               forward_client_cert_details: APPEND_FORWARD
+  //               set_current_client_cert_details:
+  //                 uri: true
+  //     on_no_match:
+  //       action:
+  //         name: forward_client_cert
+  //         typed_config:
+  //           "@type": type.googleapis.com/envoy.extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.ForwardClientCertConfig
+  //           forward_client_cert_details: SANITIZE_SET
+  //           set_current_client_cert_details:
+  //             uri: true
+  xds.type.matcher.v3.Matcher forward_client_cert_matcher = 60;
+
   // 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
@@ -491,9 +874,9 @@ message HttpConnectionManager {
 
   // If
   // :ref:`use_remote_address
-  // <envoy_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.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*.
+  // 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
@@ -507,7 +890,7 @@ message HttpConnectionManager {
   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
+  // 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
@@ -517,25 +900,47 @@ message HttpConnectionManager {
   // 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
+  // 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 not set, Envoy uses the default UUID-based behavior:
+  // 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:
   //
-  // 1. Request ID is propagated using *x-request-id* header.
+  // .. validated-code-block:: yaml
+  //   :type-name: envoy.extensions.filters.network.http_connection_manager.v3.RequestIDExtension
   //
-  // 2. Request ID is a universally unique identifier (UUID).
+  //   typed_config:
+  //     "@type": type.googleapis.com/envoy.extensions.request_id.uuid.v3.UuidRequestIdConfig
+  //     pack_trace_reason: false
   //
-  // 3. Tracing decision (sampled, forced, etc) is set in 14th byte of the UUID.
+  // [#extension-category: envoy.request_id]
   RequestIDExtension request_id_extension = 36;
 
   // The configuration to customize local reply returned by Envoy. It can customize status code,
@@ -544,23 +949,26 @@ message HttpConnectionManager {
   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_api_field_config.listener.v3.Listener.address>`
-  // local port and request method is not CONNECT. This affects the upstream host header as well.
-  // Without setting this option, incoming requests with host `example:443` will not match against
-  // route with :ref:`domains<envoy_api_field_config.route.v3.VirtualHost.domains>` match set to `example`. Defaults to `false`. Note that port removal is not part
+  // 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.
+  // 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. The port would be removed only if request method is not CONNECT.
-    // This affects the upstream host header as well.
-    // Without setting this option, incoming requests with host `example:443` will not match against
-    // route with :ref:`domains<envoy_api_field_config.route.v3.VirtualHost.domains>` match set to `example`. Defaults to `false`. Note that port removal is not part
+    // 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.
+    // Only one of ``strip_matching_host_port`` or ``strip_any_host_port`` can be set.
     bool strip_any_host_port = 42;
   }
 
@@ -578,9 +986,71 @@ message HttpConnectionManager {
   // <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
+  // ``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.
@@ -639,11 +1109,11 @@ message ResponseMapper {
   // 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`.
+  // 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>`.
+  // 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;
 
@@ -658,7 +1128,7 @@ message Rds {
       "envoy.config.filter.network.http_connection_manager.v2.Rds";
 
   // Configuration source specifier for RDS.
-  config.core.v3.ConfigSource config_source = 1 [(validate.rules).message = {required: true}];
+  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
@@ -682,14 +1152,14 @@ message ScopedRoutes {
       "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_api_msg_config.route.v3.ScopedRouteConfiguration.Key>`
-  // objects assembled from :ref:`ScopedRouteConfiguration<envoy_api_msg_config.route.v3.ScopedRouteConfiguration>`
+  // 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_api_field_extensions.filters.network.http_connection_manager.v3.ScopedRoutes.scoped_route_configurations_list>`.
+  // :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_api_msg_config.route.v3.RouteConfiguration>`) to use for the request.
+  // :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";
@@ -744,7 +1214,9 @@ message ScopedRoutes {
         // .. note::
         //
         //   If the header appears multiple times only the first value is used.
-        string name = 1 [(validate.rules).string = {min_len: 1}];
+        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.
@@ -772,7 +1244,7 @@ message ScopedRoutes {
     }
 
     // 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_api_msg_config.route.v3.ScopedRouteConfiguration>`.
+    // 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}];
   }
@@ -786,7 +1258,7 @@ message ScopedRoutes {
   // 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 [(validate.rules).message = {required: true}];
+  config.core.v3.ConfigSource rds_config_source = 3;
 
   oneof config_specifier {
     option (validate.required) = true;
@@ -794,14 +1266,14 @@ message ScopedRoutes {
     // 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_api_msg_extensions.filters.network.http_connection_manager.v3.ScopedRoutes.ScopeKeyBuilder>`
+    // :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_api_msg_extensions.filters.network.http_connection_manager.v3.ScopedRoutes.ScopeKeyBuilder>`
+    // :ref:`ScopeKeyBuilder<envoy_v3_api_msg_extensions.filters.network.http_connection_manager.v3.ScopedRoutes.ScopeKeyBuilder>`
     // in this message.
     ScopedRds scoped_rds = 5;
   }
@@ -814,9 +1286,13 @@ message 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: 7]
+// [#next-free-field: 8]
 message HttpFilter {
   option (udpa.annotations.versioning).previous_message_type =
       "envoy.config.filter.network.http_connection_manager.v2.HttpFilter";
@@ -825,27 +1301,42 @@ message HttpFilter {
 
   reserved "config";
 
-  // The name of the filter configuration. The name is used as a fallback to
-  // select an extension if the type of the configuration proto is not
-  // sufficient. It also serves as a resource name in ExtensionConfigDS.
+  // 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.
-  // [#not-implemented-hide:]
   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 {
@@ -855,3 +1346,12 @@ message 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..c55d30b89e0
--- /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,91 @@
+syntax = "proto3";
+
+package envoy.extensions.load_balancing_policies.client_side_weighted_round_robin.v3;
+
+import "envoy/extensions/load_balancing_policies/common/v3/common.proto";
+
+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: 9]
+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;
+
+  // Configuration for slow start mode.
+  // If this configuration is not set, slow start will not be not enabled.
+  common.v3.SlowStartConfig slow_start_config = 8;
+}
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..e2e4ade8236
--- /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]
+// [#extension: envoy.load_balancing_policies.wrr_locality]
+
+// 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
index b451d45381c..8a5f8962bd1 100644
--- 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
@@ -9,3 +9,4 @@ 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
index 1def231a379..9bc5fb5d029 100644
--- 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
@@ -3,11 +3,14 @@ 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";
@@ -16,10 +19,12 @@ 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";
 
@@ -40,8 +45,31 @@ message TlsParameters {
     TLSv1_3 = 4;
   }
 
-  // Minimum TLS protocol version. By default, it's ``TLSv1_2`` for clients and ``TLSv1_0`` for
-  // servers.
+  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
@@ -50,42 +78,48 @@ message TlsParameters {
 
   // 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, the default list will be used.
+  // 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 non-FIPS builds, the default cipher list is:
+  // 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-AES128-SHA
-  //   ECDHE-RSA-AES128-SHA
-  //   AES128-GCM-SHA256
-  //   AES128-SHA
   //   ECDHE-ECDSA-AES256-GCM-SHA384
   //   ECDHE-RSA-AES256-GCM-SHA384
-  //   ECDHE-ECDSA-AES256-SHA
-  //   ECDHE-RSA-AES256-SHA
-  //   AES256-GCM-SHA384
-  //   AES256-SHA
   //
-  // In builds using :ref:`BoringSSL FIPS <arch_overview_ssl_fips>`, the default cipher list is:
+  // 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-AES128-SHA
-  //   ECDHE-RSA-AES128-SHA
-  //   AES128-GCM-SHA256
-  //   AES128-SHA
   //   ECDHE-ECDSA-AES256-GCM-SHA384
   //   ECDHE-RSA-AES256-GCM-SHA384
-  //   ECDHE-ECDSA-AES256-SHA
-  //   ECDHE-RSA-AES256-SHA
-  //   AES256-GCM-SHA384
-  //   AES256-SHA
   repeated string cipher_suites = 3;
 
   // If specified, the TLS connection will only support the specified ECDH
@@ -104,6 +138,47 @@ message TlsParameters {
   //
   //   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
@@ -125,46 +200,67 @@ message PrivateKeyProvider {
   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: 8]
+// [#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
+  // 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
+  // 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
+  // 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.
+  // applies to dynamic secrets, when the ``TlsCertificate`` is delivered via SDS.
   config.core.v3.DataSource private_key = 2 [(udpa.annotations.sensitive) = true];
 
-  // If specified, updates of file-based *certificate_chain* and *private_key*
+  // ``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
+  // ``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_api_field_extensions.transport_sockets.tls.v3.TlsCertificate.private_key>` field. This can't be
-  // marked as ``oneof`` due to API compatibility reasons. Setting both :ref:`private_key
-  // <envoy_api_field_extensions.transport_sockets.tls.v3.TlsCertificate.private_key>` and
-  // :ref:`private_key_provider
-  // <envoy_api_field_extensions.transport_sockets.tls.v3.TlsCertificate.private_key_provider>` fields will result in an
-  // error.
+  // <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
@@ -189,7 +285,7 @@ message TlsSessionTicketKeys {
   // 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_api_field_extensions.transport_sockets.tls.v3.DownstreamTlsContext.session_ticket_keys>`
+  // 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.
@@ -211,7 +307,69 @@ message TlsSessionTicketKeys {
       [(validate.rules).repeated = {min_items: 1}, (udpa.annotations.sensitive) = true];
 }
 
-// [#next-free-field: 12]
+// 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";
@@ -223,10 +381,13 @@ message CertificateValidationContext {
 
     // 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_api_field_config.route.v3.RouteMatch.TlsContextMatchOptions.validated>` ).
+    // 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";
@@ -236,13 +397,13 @@ message CertificateValidationContext {
   // 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_api_field_extensions.transport_sockets.tls.v3.DownstreamTlsContext.require_client_certificate>`,
+  // <envoy_v3_api_field_extensions.transport_sockets.tls.v3.DownstreamTlsContext.require_client_certificate>`,
   // :ref:`verify_certificate_spki
-  // <envoy_api_field_extensions.transport_sockets.tls.v3.CertificateValidationContext.verify_certificate_spki>`,
+  // <envoy_v3_api_field_extensions.transport_sockets.tls.v3.CertificateValidationContext.verify_certificate_spki>`,
   // :ref:`verify_certificate_hash
-  // <envoy_api_field_extensions.transport_sockets.tls.v3.CertificateValidationContext.verify_certificate_hash>`, or
-  // :ref:`match_subject_alt_names
-  // <envoy_api_field_extensions.transport_sockets.tls.v3.CertificateValidationContext.match_subject_alt_names>`) is also
+  // <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
@@ -250,21 +411,44 @@ message CertificateValidationContext {
   // 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
+  // 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
+  // applies to dynamic secrets, when the ``CertificateValidationContext`` is
   // delivered via SDS.
-  config.core.v3.DataSource trusted_ca = 1;
+  //
+  // 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
+  // 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
+  // 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
+  // ``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;
@@ -288,15 +472,15 @@ message CertificateValidationContext {
   //
   // When both:
   // :ref:`verify_certificate_hash
-  // <envoy_api_field_extensions.transport_sockets.tls.v3.CertificateValidationContext.verify_certificate_hash>` and
+  // <envoy_v3_api_field_extensions.transport_sockets.tls.v3.CertificateValidationContext.verify_certificate_hash>` and
   // :ref:`verify_certificate_spki
-  // <envoy_api_field_extensions.transport_sockets.tls.v3.CertificateValidationContext.verify_certificate_spki>` are specified,
+  // <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_api_field_extensions.transport_sockets.tls.v3.CertificateValidationContext.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
@@ -324,32 +508,45 @@ message CertificateValidationContext {
   //
   // When both:
   // :ref:`verify_certificate_hash
-  // <envoy_api_field_extensions.transport_sockets.tls.v3.CertificateValidationContext.verify_certificate_hash>` and
+  // <envoy_v3_api_field_extensions.transport_sockets.tls.v3.CertificateValidationContext.verify_certificate_hash>` and
   // :ref:`verify_certificate_spki
-  // <envoy_api_field_extensions.transport_sockets.tls.v3.CertificateValidationContext.verify_certificate_spki>` are specified,
+  // <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_api_msg_type.matcher.v3.StringMatcher>`.
+  // 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_subject_alt_names:
-  //    exact: "api.example.com"
+  //  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_api_field_extensions.transport_sockets.tls.v3.CertificateValidationContext.trusted_ca>`.
-  repeated type.matcher.v3.StringMatcher match_subject_alt_names = 9;
+  //   <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;
@@ -362,7 +559,14 @@ message CertificateValidationContext {
   // 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.
+  // 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.
@@ -371,4 +575,23 @@ message CertificateValidationContext {
   // 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
index f7c849c0334..94660e2da9f 100644
--- 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
@@ -14,6 +14,7 @@ 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]
@@ -21,8 +22,13 @@ option (udpa.annotations.file_status).package_version_status = ACTIVE;
 message GenericSecret {
   option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.auth.GenericSecret";
 
-  // Secret of generic type and is available to filters.
+  // 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 {
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
index 2c5a8bf21d3..d656c66b5d0 100644
--- 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
@@ -2,6 +2,7 @@ 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";
@@ -9,7 +10,7 @@ import "envoy/extensions/transport_sockets/tls/v3/secret.proto";
 import "google/protobuf/duration.proto";
 import "google/protobuf/wrappers.proto";
 
-import "udpa/annotations/migrate.proto";
+import "envoy/annotations/deprecation.proto";
 import "udpa/annotations/status.proto";
 import "udpa/annotations/versioning.proto";
 import "validate/validate.proto";
@@ -17,12 +18,14 @@ 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";
@@ -31,14 +34,32 @@ message UpstreamTlsContext {
   //
   // .. attention::
   //
-  //   Server certificate verification is not enabled by default. Configure
-  //   :ref:`trusted_ca<envoy_api_field_extensions.transport_sockets.tls.v3.CertificateValidationContext.trusted_ca>` to enable
-  //   verification.
+  //   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::
@@ -47,36 +68,38 @@ message UpstreamTlsContext {
   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 store for the purpose of session resumption.
+  // 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: 9]
+// [#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 an OCSP response is absent
-    // or expired, the associated certificate will be used for
-    // connections without an OCSP staple.
+    // OCSP responses are optional. If absent or expired, the certificate is used without stapling.
     LENIENT_STAPLING = 0;
 
-    // OCSP responses are optional. If an OCSP response is absent,
-    // the associated certificate will be used without an
-    // OCSP staple. If a response is provided but is expired,
-    // the associated certificate will not be used for
-    // subsequent connections. If no suitable certificate is found,
-    // the connection is rejected.
+    // 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. Configuration will fail if
-    // a certificate is provided without an OCSP response. If a
-    // response expires, the associated certificate will not be
-    // used connections. If no suitable certificate is found, the
-    // connection is rejected.
+    // 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;
   }
 
@@ -101,36 +124,78 @@ message DownstreamTlsContext {
     // 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_api_field_extensions.transport_sockets.tls.v3.DownstreamTlsContext.session_ticket_keys>`
-    // or :ref:`session_ticket_keys_sds_secret_config <envoy_api_field_extensions.transport_sockets.tls.v3.DownstreamTlsContext.session_ticket_keys_sds_secret_config>`.
+    // 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 specified, session_timeout will change maximum lifetime (in seconds) of TLS session
-  // Currently this value is used as a hint to `TLS session ticket lifetime (for TLSv1.2)
-  // <https://tools.ietf.org/html/rfc5077#section-5.6>`
-  // only seconds could be specified (fractional seconds are going to be ignored).
+  // 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 {}
   }];
 
-  // Config for whether to use certificates if they do not have
-  // an accompanying OCSP response or if the response expires at runtime.
-  // Defaults to LENIENT_STAPLING
+  // 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: 14]
+// [#next-free-field: 17]
 message CommonTlsContext {
   option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.auth.CommonTlsContext";
 
-  // Config for Certificate provider to get certificates. This provider should allow certificates to be
-  // fetched/refreshed over the network asynchronously with respect to the TLS handshake.
+  // 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.
@@ -151,6 +216,11 @@ message CommonTlsContext {
 
   // 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
@@ -179,26 +249,20 @@ message CommonTlsContext {
 
     // 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.
-    // Only one of validation_context_sds_secret_config, validation_context_certificate_provider,
-    // or validation_context_certificate_provider_instance may be used.
-    SdsSecretConfig validation_context_sds_secret_config = 2 [
-      (validate.rules).message = {required: true},
-      (udpa.annotations.field_migrate).oneof_promotion = "dynamic_validation_context"
-    ];
+    SdsSecretConfig validation_context_sds_secret_config = 2
+        [(validate.rules).message = {required: true}];
 
-    // Certificate provider for fetching validation context.
-    // Only one of validation_context_sds_secret_config, validation_context_certificate_provider,
-    // or validation_context_certificate_provider_instance may be used.
+    // 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
-        [(udpa.annotations.field_migrate).oneof_promotion = "dynamic_validation_context"];
+        [deprecated = true, (envoy.annotations.deprecated_at_minor_version) = "3.0"];
 
-    // Certificate provider instance for fetching validation context.
-    // Only one of validation_context_sds_secret_config, validation_context_certificate_provider,
-    // or validation_context_certificate_provider_instance may be used.
+    // 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
-        [(udpa.annotations.field_migrate).oneof_promotion = "dynamic_validation_context"];
+        [deprecated = true, (envoy.annotations.deprecated_at_minor_version) = "3.0"];
   }
 
   reserved 5;
@@ -206,26 +270,48 @@ message CommonTlsContext {
   // 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.
+  // same context to allow both RSA and ECDSA certificates and support SNI-based selection.
   //
-  // Only a single TLS certificate is supported in client contexts. In server contexts, the first
-  // RSA certificate is used for clients that only support RSA and the first ECDSA certificate is
-  // used for clients that support ECDSA.
+  // 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.
-  repeated SdsSecretConfig tls_certificate_sds_secret_configs = 6
-      [(validate.rules).repeated = {max_items: 1}];
+  //
+  // 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.
+  // [#extension-category: envoy.tls.certificate_selectors]
+  config.core.v3.TypedExtensionConfig custom_tls_certificate_selector = 16;
 
   // Certificate provider for fetching TLS certificates.
   // [#not-implemented-hide:]
-  CertificateProvider tls_certificate_certificate_provider = 9;
+  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;
+  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.
@@ -235,28 +321,34 @@ message CommonTlsContext {
     // fetched/refreshed over the network asynchronously with respect to the TLS handshake.
     SdsSecretConfig validation_context_sds_secret_config = 7;
 
-    // Combined certificate validation context holds a default CertificateValidationContext
-    // and SDS config. When SDS server returns dynamic CertificateValidationContext, both dynamic
-    // and default CertificateValidationContext are merged into a new CertificateValidationContext
-    // for validation. This merge is done by Message::MergeFrom(), so dynamic
-    // CertificateValidationContext overwrites singular fields in default
-    // CertificateValidationContext, and concatenates repeated fields to default
-    // CertificateValidationContext, and logical OR is applied to boolean fields.
+    // 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;
+    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;
+    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_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.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.
@@ -268,4 +360,7 @@ message CommonTlsContext {
   // 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..520a4ff4f31
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/service/auth/v3/external_auth.proto
@@ -0,0 +1,157 @@
+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``.
+// [#next-free-field: 6]
+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;
+
+    // Supplies http attributes for an error response. This is used when the authorization
+    // service encounters an internal error and wants to return custom headers and body to the
+    // downstream client. When ``error_response`` is set, the ext_authz filter increments the
+    // ``ext_authz_error`` stat and respects the :ref:`failure_mode_allow
+    // <envoy_v3_api_field_extensions.filters.http.ext_authz.v3.ExtAuthz.failure_mode_allow>`
+    // configuration. The HTTP status code, headers, and body are taken from the
+    // :ref:`DeniedHttpResponse <envoy_v3_api_msg_service.auth.v3.DeniedHttpResponse>` message.
+    // If the status field is not set, Envoy sends the status code configured via
+    // :ref:`status_on_error <envoy_v3_api_field_extensions.filters.http.ext_authz.v3.ExtAuthz.status_on_error>`,
+    // which defaults to ``403 Forbidden``.
+    DeniedHttpResponse error_response = 5;
+  }
+
+  // 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/v2/ads.proto b/xds/third_party/envoy/src/main/proto/envoy/service/discovery/v2/ads.proto
deleted file mode 100644
index d70e0cdc8e1..00000000000
--- a/xds/third_party/envoy/src/main/proto/envoy/service/discovery/v2/ads.proto
+++ /dev/null
@@ -1,42 +0,0 @@
-syntax = "proto3";
-
-package envoy.service.discovery.v2;
-
-import "envoy/api/v2/discovery.proto";
-
-import "udpa/annotations/status.proto";
-
-option java_package = "io.envoyproxy.envoy.service.discovery.v2";
-option java_outer_classname = "AdsProto";
-option java_multiple_files = true;
-option java_generic_services = true;
-option (udpa.annotations.file_status).package_version_status = FROZEN;
-
-// [#protodoc-title: Aggregated Discovery Service (ADS)]
-
-// [#not-implemented-hide:] 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/lyft/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 api.v2.DiscoveryRequest)
-      returns (stream api.v2.DiscoveryResponse) {
-  }
-
-  rpc DeltaAggregatedResources(stream api.v2.DeltaDiscoveryRequest)
-      returns (stream api.v2.DeltaDiscoveryResponse) {
-  }
-}
-
-// [#not-implemented-hide:] Not configuration. Workaround c++ protobuf issue with importing
-// services: https://github.com/google/protobuf/issues/4221
-message AdsDummy {
-}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/service/discovery/v2/sds.proto b/xds/third_party/envoy/src/main/proto/envoy/service/discovery/v2/sds.proto
deleted file mode 100644
index 4d01d475c59..00000000000
--- a/xds/third_party/envoy/src/main/proto/envoy/service/discovery/v2/sds.proto
+++ /dev/null
@@ -1,41 +0,0 @@
-syntax = "proto3";
-
-package envoy.service.discovery.v2;
-
-import "envoy/api/v2/discovery.proto";
-
-import "google/api/annotations.proto";
-
-import "envoy/annotations/resource.proto";
-import "udpa/annotations/migrate.proto";
-import "udpa/annotations/status.proto";
-
-option java_package = "io.envoyproxy.envoy.service.discovery.v2";
-option java_outer_classname = "SdsProto";
-option java_multiple_files = true;
-option java_generic_services = true;
-option (udpa.annotations.file_migrate).move_to_package = "envoy.service.secret.v3";
-option (udpa.annotations.file_status).package_version_status = FROZEN;
-
-// [#protodoc-title: Secret Discovery Service (SDS)]
-
-service SecretDiscoveryService {
-  option (envoy.annotations.resource).type = "envoy.api.v2.auth.Secret";
-
-  rpc DeltaSecrets(stream api.v2.DeltaDiscoveryRequest)
-      returns (stream api.v2.DeltaDiscoveryResponse) {
-  }
-
-  rpc StreamSecrets(stream api.v2.DiscoveryRequest) returns (stream api.v2.DiscoveryResponse) {
-  }
-
-  rpc FetchSecrets(api.v2.DiscoveryRequest) returns (api.v2.DiscoveryResponse) {
-    option (google.api.http).post = "/v2/discovery:secrets";
-    option (google.api.http).body = "*";
-  }
-}
-
-// [#not-implemented-hide:] Not configuration. Workaround c++ protobuf issue with importing
-// services: https://github.com/google/protobuf/issues/4221
-message SdsDummy {
-}
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
index 03021559ab6..50f2af4fe48 100644
--- 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
@@ -10,17 +10,17 @@ 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 java_generic_services = 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)]
 
-// [#not-implemented-hide:] Discovery services for endpoints, clusters, routes,
+// 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/lyft/envoy-api#apis for a description of the role of
+// 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
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
index 4a2547df39f..e1ce827a48f 100644
--- 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
@@ -10,26 +10,60 @@ 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: 7]
+// [#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
+  // 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
+  // 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;
 
@@ -38,33 +72,48 @@ message DiscoveryRequest {
 
   // 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
+  // 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.
+  // 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
+  // ``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 1) this is a non-persistent-stream xDS such as HTTP,
-  // or 2) the client has not yet accepted an update in this xDS stream (unlike
-  // delta, where it is populated only for new explicit ACKs).
+  // 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_api_msg_service.discovery.v3.DiscoveryResponse>`
-  // failed to update configuration. The *message* field in *error_details* provides the Envoy
+  // 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: 7]
+// [#next-free-field: 8]
 message DiscoveryResponse {
   option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.DiscoveryResponse";
 
@@ -77,35 +126,46 @@ message DiscoveryResponse {
   // [#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-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.
+  //
+  //   * 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
+  //
+  // * ``--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).
+  // 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
+  // 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
+  // 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
+  // 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
@@ -121,26 +181,29 @@ message DiscoveryResponse {
 // 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
+// ``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: [1] informing the server of what resources the
-// client has gained/lost interest in (using resource_names_subscribe and
-// resource_names_unsubscribe), or [2] (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
+// ``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.
+// 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:
+// 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: 8]
+// 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";
 
@@ -148,30 +211,31 @@ message DeltaDiscoveryRequest {
   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*.
+  // ``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
+  // 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
+  // *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.
+  // .. 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.
+  // 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;
@@ -179,29 +243,52 @@ message DeltaDiscoveryRequest {
   // 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: [1] in the very first stream of a session, since the client will
-  // not yet have any resources,  [2] 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.)
+  // 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.
+  // 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_api_msg_service.discovery.v3.DiscoveryResponse>`
-  // failed to update configuration. The *message* field in *error_details*
+  // 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: 8]
+// [#next-free-field: 10]
 message DeltaDiscoveryResponse {
   option (udpa.annotations.versioning).previous_message_type =
       "envoy.api.v2.DeltaDiscoveryResponse";
@@ -210,29 +297,92 @@ message DeltaDiscoveryResponse {
   string system_version_info = 1;
 
   // The response resources. These are typed resources, whose types must match
-  // the type_url field.
+  // 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.
+  // Must be consistent with the ``type_url`` in the Any within 'resources' if 'resources' is non-empty.
   string type_url = 4;
 
-  // Resources names of resources that have be deleted and to be removed from the xDS Client.
+  // 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;
 
-  // The nonce provides a way for DeltaDiscoveryRequests to uniquely
-  // reference a DeltaDiscoveryResponse when (N)ACKing. The nonce is required.
+  // 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;
 }
 
-// [#next-free-field: 8]
+// 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";
 
@@ -240,14 +390,24 @@ message Resource {
   // [#not-implemented-hide:]
   message CacheControl {
     // If true, xDS proxies may not cache this resource.
-    // Note that 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.
+    //
+    // .. 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;
 
@@ -264,7 +424,7 @@ message Resource {
   // 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
+  // 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
@@ -276,4 +436,8 @@ message Resource {
   // 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/v2/lrs.proto b/xds/third_party/envoy/src/main/proto/envoy/service/load_stats/v2/lrs.proto
deleted file mode 100644
index 7ab87c2dfb0..00000000000
--- a/xds/third_party/envoy/src/main/proto/envoy/service/load_stats/v2/lrs.proto
+++ /dev/null
@@ -1,88 +0,0 @@
-syntax = "proto3";
-
-package envoy.service.load_stats.v2;
-
-import "envoy/api/v2/core/base.proto";
-import "envoy/api/v2/endpoint/load_report.proto";
-
-import "google/protobuf/duration.proto";
-
-import "udpa/annotations/status.proto";
-
-option java_package = "io.envoyproxy.envoy.service.load_stats.v2";
-option java_outer_classname = "LrsProto";
-option java_multiple_files = true;
-option java_generic_services = true;
-option (udpa.annotations.file_status).package_version_status = FROZEN;
-
-// [#protodoc-title: 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.
-// [#not-implemented-hide:] Not configuration. TBD how to doc proto APIs.
-message LoadStatsRequest {
-  // Node identifier for Envoy instance.
-  api.v2.core.Node node = 1;
-
-  // A list of load stats to report.
-  repeated api.v2.endpoint.ClusterStats cluster_stats = 2;
-}
-
-// The management server sends envoy a LoadStatsResponse with all clusters it
-// is interested in learning load stats about.
-// [#not-implemented-hide:] Not configuration. TBD how to doc proto APIs.
-message 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_api_field_core.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/load_stats/v3/lrs.proto b/xds/third_party/envoy/src/main/proto/envoy/service/load_stats/v3/lrs.proto
index ca8377e1ca6..37410628c8c 100644
--- 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
@@ -13,17 +13,17 @@ 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 java_generic_services = 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)]
+// [#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_api_msg_service.load_stats.v3.LoadStatsResponse>` to a node it is
+// :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_api_msg_service.load_stats.v3.LoadStatsRequest>`. This is done periodically
-// based on the :ref:`load reporting interval <envoy_api_field_service.load_stats.v3.LoadStatsResponse.load_reporting_interval>`
+// :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 {
@@ -78,25 +78,25 @@ message LoadStatsResponse {
       "envoy.service.load_stats.v2.LoadStatsResponse";
 
   // Clusters to report stats for.
-  // Not populated if *send_all_clusters* is true.
+  // 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_api_field_config.core.v3.Node.client_features>` field will honor this field.
+  // :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
+  // 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
+  // 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.proto b/xds/third_party/envoy/src/main/proto/envoy/type/http.proto
deleted file mode 100644
index c1c787411fa..00000000000
--- a/xds/third_party/envoy/src/main/proto/envoy/type/http.proto
+++ /dev/null
@@ -1,23 +0,0 @@
-syntax = "proto3";
-
-package envoy.type;
-
-import "udpa/annotations/status.proto";
-
-option java_package = "io.envoyproxy.envoy.type";
-option java_outer_classname = "HttpProto";
-option java_multiple_files = true;
-option (udpa.annotations.file_status).package_version_status = FROZEN;
-
-// [#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/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/metadata.proto b/xds/third_party/envoy/src/main/proto/envoy/type/matcher/metadata.proto
deleted file mode 100644
index ed58d04adb0..00000000000
--- a/xds/third_party/envoy/src/main/proto/envoy/type/matcher/metadata.proto
+++ /dev/null
@@ -1,98 +0,0 @@
-syntax = "proto3";
-
-package envoy.type.matcher;
-
-import "envoy/type/matcher/value.proto";
-
-import "udpa/annotations/status.proto";
-import "validate/validate.proto";
-
-option java_package = "io.envoyproxy.envoy.type.matcher";
-option java_outer_classname = "MetadataProto";
-option java_multiple_files = true;
-option (udpa.annotations.file_status).package_version_status = FROZEN;
-
-// [#protodoc-title: Metadata matcher]
-
-// MetadataMatcher provides a general interface to check if a given value is matched in
-// :ref:`Metadata <envoy_api_msg_core.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_api_msg_config.rbac.v2.Permission>` and :ref:`Principal
-// <envoy_api_msg_config.rbac.v2.Principal>`.
-
-// [#next-major-version: MetadataMatcher should use StructMatcher]
-message 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 {
-    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}];
-}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/type/matcher/number.proto b/xds/third_party/envoy/src/main/proto/envoy/type/matcher/number.proto
deleted file mode 100644
index e488f16a4a0..00000000000
--- a/xds/third_party/envoy/src/main/proto/envoy/type/matcher/number.proto
+++ /dev/null
@@ -1,29 +0,0 @@
-syntax = "proto3";
-
-package envoy.type.matcher;
-
-import "envoy/type/range.proto";
-
-import "udpa/annotations/status.proto";
-import "validate/validate.proto";
-
-option java_package = "io.envoyproxy.envoy.type.matcher";
-option java_outer_classname = "NumberProto";
-option java_multiple_files = true;
-option (udpa.annotations.file_status).package_version_status = FROZEN;
-
-// [#protodoc-title: Number matcher]
-
-// Specifies the way to match a double value.
-message 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).
-    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/path.proto b/xds/third_party/envoy/src/main/proto/envoy/type/matcher/path.proto
deleted file mode 100644
index 860a1c69f18..00000000000
--- a/xds/third_party/envoy/src/main/proto/envoy/type/matcher/path.proto
+++ /dev/null
@@ -1,27 +0,0 @@
-syntax = "proto3";
-
-package envoy.type.matcher;
-
-import "envoy/type/matcher/string.proto";
-
-import "udpa/annotations/status.proto";
-import "validate/validate.proto";
-
-option java_package = "io.envoyproxy.envoy.type.matcher";
-option java_outer_classname = "PathProto";
-option java_multiple_files = true;
-option (udpa.annotations.file_status).package_version_status = FROZEN;
-
-// [#protodoc-title: Path matcher]
-
-// Specifies the way to match a path on HTTP request.
-message 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/regex.proto b/xds/third_party/envoy/src/main/proto/envoy/type/matcher/regex.proto
deleted file mode 100644
index 6c499235bbe..00000000000
--- a/xds/third_party/envoy/src/main/proto/envoy/type/matcher/regex.proto
+++ /dev/null
@@ -1,78 +0,0 @@
-syntax = "proto3";
-
-package envoy.type.matcher;
-
-import "google/protobuf/wrappers.proto";
-
-import "udpa/annotations/status.proto";
-import "validate/validate.proto";
-
-option java_package = "io.envoyproxy.envoy.type.matcher";
-option java_outer_classname = "RegexProto";
-option java_multiple_files = true;
-option (udpa.annotations.file_status).package_version_status = FROZEN;
-
-// [#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 {
-    // 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.
-    google.protobuf.UInt32Value max_program_size = 1 [deprecated = true];
-  }
-
-  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}];
-}
-
-// Describes how to match a string and then produce a new string using a regular
-// expression and a substitution string.
-message 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;
-
-  // 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;
-}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/type/matcher/string.proto b/xds/third_party/envoy/src/main/proto/envoy/type/matcher/string.proto
deleted file mode 100644
index 499eaf21775..00000000000
--- a/xds/third_party/envoy/src/main/proto/envoy/type/matcher/string.proto
+++ /dev/null
@@ -1,79 +0,0 @@
-syntax = "proto3";
-
-package envoy.type.matcher;
-
-import "envoy/type/matcher/regex.proto";
-
-import "envoy/annotations/deprecation.proto";
-import "udpa/annotations/status.proto";
-import "validate/validate.proto";
-
-option java_package = "io.envoyproxy.envoy.type.matcher";
-option java_outer_classname = "StringProto";
-option java_multiple_files = true;
-option (udpa.annotations.file_status).package_version_status = FROZEN;
-
-// [#protodoc-title: String matcher]
-
-// Specifies the way to match a string.
-// [#next-free-field: 7]
-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.
-    // The regex grammar is defined `here
-    // <https://en.cppreference.com/w/cpp/regex/ecmascript>`_.
-    //
-    // Examples:
-    //
-    // * The regex ``\d{3}`` matches the value *123*
-    // * The regex ``\d{3}`` does not match the value *1234*
-    // * The regex ``\d{3}`` does not match the value *123.456*
-    //
-    // .. attention::
-    //   This field has been deprecated in favor of `safe_regex` as it is not safe for use with
-    //   untrusted input in all cases.
-    string regex = 4 [
-      deprecated = true,
-      (validate.rules).string = {max_bytes: 1024},
-      (envoy.annotations.disallowed_by_default) = true
-    ];
-
-    // The input string must match the regular expression specified here.
-    RegexMatcher safe_regex = 5 [(validate.rules).message = {required: true}];
-  }
-
-  // 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/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
index a7184ee9805..30abde97c09 100644
--- 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
@@ -11,15 +11,16 @@ 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_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.
+// ``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:
+// For example, for the following ``Metadata``:
 //
 // .. code-block:: yaml
 //
@@ -40,8 +41,8 @@ option (udpa.annotations.file_status).package_version_status = ACTIVE;
 //                      - 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.
+// 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
 //
@@ -54,7 +55,7 @@ option (udpa.annotations.file_status).package_version_status = ACTIVE;
 //      string_match:
 //        prefix: pr
 //
-// The following MetadataMatcher is matched as the code will match one of the string values in the
+// 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
@@ -69,18 +70,20 @@ option (udpa.annotations.file_status).package_version_status = ACTIVE;
 //          string_match:
 //            exact: m
 //
-// An example use of MetadataMatcher is specifying additional metadata in envoy.filters.http.rbac to
+// 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_api_msg_config.rbac.v3.Permission>` and :ref:`Principal
-// <envoy_api_msg_config.rbac.v3.Principal>`.
+// <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.
+  // 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";
@@ -88,17 +91,20 @@ message MetadataMatcher {
     oneof segment {
       option (validate.required) = true;
 
-      // If specified, use the key to retrieve the value in a Struct.
+      // 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.
+  // 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.
+  // 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.
+  // 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
index 2379efdcbd2..99681c989ca 100644
--- 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
@@ -11,6 +11,7 @@ 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]
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
index f5913c460c4..10b3970ff84 100644
--- 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
@@ -4,6 +4,7 @@ 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";
@@ -11,6 +12,7 @@ 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]
@@ -23,14 +25,14 @@ message RegexMatcher {
   // 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
+  // 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).
+  // 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
+  // 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 =
@@ -43,17 +45,24 @@ message RegexMatcher {
     //
     // This field is deprecated; regexp validation should be performed on the management server
     // instead of being done by each individual client.
-    google.protobuf.UInt32Value max_program_size = 1 [deprecated = true];
+    //
+    // .. 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 {
-    option (validate.required) = true;
-
     // Google's RE2 regex engine.
-    GoogleRE2 google_re2 = 1 [(validate.rules).message = {required: true}];
+    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 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}];
 }
 
@@ -83,5 +92,6 @@ message RegexMatchAndSubstitute {
   // 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;
+  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
index 78e1572bf8c..56d39565ca5 100644
--- 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
@@ -4,6 +4,8 @@ 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";
@@ -11,12 +13,13 @@ 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: 8]
+// [#next-free-field: 9]
 message StringMatcher {
   option (udpa.annotations.versioning).previous_message_type = "envoy.type.matcher.StringMatcher";
 
@@ -31,40 +34,54 @@ message StringMatcher {
     //
     // Examples:
     //
-    // * *abc* only matches the value *abc*.
+    // * ``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.
+    //
+    // .. note::
+    //
+    //  Empty prefix match is not allowed, please use ``safe_regex`` instead.
     //
     // Examples:
     //
-    // * *abc* matches the value *abc.xyz*
+    // * ``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.
+    //
+    // .. note::
+    //
+    //  Empty suffix match is not allowed, please use ``safe_regex`` instead.
     //
     // Examples:
     //
-    // * *abc* matches the value *xyz.abc*
+    // * ``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.
+    //
+    // .. note::
+    //
+    //  Empty contains match is not allowed, please use ``safe_regex`` instead.
     //
     // Examples:
     //
-    // * *abc* matches the value *xyz.abc.def*
+    // * ``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.
+  // 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;
 }
 
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
index 040332273ba..8d65c457ccc 100644
--- 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
@@ -12,13 +12,14 @@ 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 ProtobufWkt::Value. Primitive values and ListValue are supported.
+// 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: 7]
+// [#next-free-field: 8]
 message ValueMatcher {
   option (udpa.annotations.versioning).previous_message_type = "envoy.type.matcher.ValueMatcher";
 
@@ -55,6 +56,9 @@ message ValueMatcher {
     // 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;
   }
 }
 
@@ -69,3 +73,8 @@ message ListMatcher {
     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/matcher/value.proto b/xds/third_party/envoy/src/main/proto/envoy/type/matcher/value.proto
deleted file mode 100644
index aaecd14e8ec..00000000000
--- a/xds/third_party/envoy/src/main/proto/envoy/type/matcher/value.proto
+++ /dev/null
@@ -1,64 +0,0 @@
-syntax = "proto3";
-
-package envoy.type.matcher;
-
-import "envoy/type/matcher/number.proto";
-import "envoy/type/matcher/string.proto";
-
-import "udpa/annotations/status.proto";
-import "validate/validate.proto";
-
-option java_package = "io.envoyproxy.envoy.type.matcher";
-option java_outer_classname = "ValueProto";
-option java_multiple_files = true;
-option (udpa.annotations.file_status).package_version_status = FROZEN;
-
-// [#protodoc-title: Value matcher]
-
-// Specifies the way to match a ProtobufWkt::Value. Primitive values and ListValue are supported.
-// StructValue is not supported and is always not matched.
-// [#next-free-field: 7]
-message ValueMatcher {
-  // NullMatch is an empty message to specify a null value.
-  message 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;
-  }
-}
-
-// Specifies the way to match a list value.
-message 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;
-  }
-}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/type/metadata/v2/metadata.proto b/xds/third_party/envoy/src/main/proto/envoy/type/metadata/v2/metadata.proto
deleted file mode 100644
index 43a1a7ca927..00000000000
--- a/xds/third_party/envoy/src/main/proto/envoy/type/metadata/v2/metadata.proto
+++ /dev/null
@@ -1,99 +0,0 @@
-syntax = "proto3";
-
-package envoy.type.metadata.v2;
-
-import "udpa/annotations/migrate.proto";
-import "udpa/annotations/status.proto";
-import "validate/validate.proto";
-
-option java_package = "io.envoyproxy.envoy.type.metadata.v2";
-option java_outer_classname = "MetadataProto";
-option java_multiple_files = true;
-option (udpa.annotations.file_migrate).move_to_package = "envoy.type.metadata.v3";
-option (udpa.annotations.file_status).package_version_status = FROZEN;
-
-// [#protodoc-title: Metadata]
-
-// MetadataKey provides a general interface using `key` and `path` to retrieve value from
-// :ref:`Metadata <envoy_api_msg_core.Metadata>`.
-//
-// For example, for the following Metadata:
-//
-// .. code-block:: yaml
-//
-//    filter_metadata:
-//      envoy.xxx:
-//        prop:
-//          foo: bar
-//          xyz:
-//            hello: envoy
-//
-// The following MetadataKey will retrieve a string value "bar" from the Metadata.
-//
-// .. code-block:: yaml
-//
-//    key: envoy.xxx
-//    path:
-//    - key: prop
-//    - key: foo
-//
-message MetadataKey {
-  // Specifies the segment in a path to retrieve value from Metadata.
-  // Currently it is only supported to specify the key, i.e. field name, as one segment of a path.
-  message 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_bytes: 1}];
-    }
-  }
-
-  // The key name of Metadata to retrieve the Struct from the metadata.
-  // Typically, it represents a builtin subsystem or custom extension.
-  string key = 1 [(validate.rules).string = {min_bytes: 1}];
-
-  // The path to retrieve the Value from the Struct. It can be a prefix or a full path,
-  // e.g. ``[prop, xyz]`` for a struct or ``[prop, foo]`` for a string in the example,
-  // which depends on the particular scenario.
-  //
-  // Note: Due to that only the key type segment is supported, the path can not specify a list
-  // unless the list is the last segment.
-  repeated PathSegment path = 2 [(validate.rules).repeated = {min_items: 1}];
-}
-
-// Describes what kind of metadata.
-message MetadataKind {
-  // Represents dynamic metadata associated with the request.
-  message Request {
-  }
-
-  // Represents metadata from :ref:`the route<envoy_api_field_route.Route.metadata>`.
-  message Route {
-  }
-
-  // Represents metadata from :ref:`the upstream cluster<envoy_api_field_Cluster.metadata>`.
-  message Cluster {
-  }
-
-  // Represents metadata from :ref:`the upstream
-  // host<envoy_api_field_endpoint.LbEndpoint.metadata>`.
-  message 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/metadata/v3/metadata.proto b/xds/third_party/envoy/src/main/proto/envoy/type/metadata/v3/metadata.proto
index b971d8debbe..d131635bf9f 100644
--- 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
@@ -9,14 +9,15 @@ 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 general interface using `key` and `path` to retrieve value from
-// :ref:`Metadata <envoy_api_msg_config.core.v3.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, for the following Metadata:
+// For example, consider the following Metadata:
 //
 // .. code-block:: yaml
 //
@@ -27,7 +28,7 @@ option (udpa.annotations.file_status).package_version_status = ACTIVE;
 //          xyz:
 //            hello: envoy
 //
-// The following MetadataKey will retrieve a string value "bar" from the Metadata.
+// The following MetadataKey would retrieve the string value "bar" from the Metadata:
 //
 // .. code-block:: yaml
 //
@@ -39,8 +40,8 @@ option (udpa.annotations.file_status).package_version_status = ACTIVE;
 message MetadataKey {
   option (udpa.annotations.versioning).previous_message_type = "envoy.type.metadata.v2.MetadataKey";
 
-  // Specifies the segment in a path to retrieve value from Metadata.
-  // Currently it is only supported to specify the key, i.e. field name, as one segment of a path.
+  // 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";
@@ -48,25 +49,27 @@ message MetadataKey {
     oneof segment {
       option (validate.required) = true;
 
-      // If specified, use the key to retrieve the value in a Struct.
+      // 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 Metadata to retrieve the Struct from the metadata.
-  // Typically, it represents a builtin subsystem or custom extension.
+  // 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 to retrieve the Value from the Struct. It can be a prefix or a full path,
-  // e.g. ``[prop, xyz]`` for a struct or ``[prop, foo]`` for a string in the example,
-  // which depends on the particular scenario.
+  // 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: Due to that only the key type segment is supported, the path can not specify a list
-  // unless the list is the last segment.
+  // .. 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 what kind of metadata.
+// Describes different types of metadata sources.
 message MetadataKind {
   option (udpa.annotations.versioning).previous_message_type =
       "envoy.type.metadata.v2.MetadataKind";
@@ -77,20 +80,20 @@ message MetadataKind {
         "envoy.type.metadata.v2.MetadataKind.Request";
   }
 
-  // Represents metadata from :ref:`the route<envoy_api_field_config.route.v3.Route.metadata>`.
+  // 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_api_field_config.cluster.v3.Cluster.metadata>`.
+  // 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_api_field_config.endpoint.v3.LbEndpoint.metadata>`.
+  // 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";
diff --git a/xds/third_party/envoy/src/main/proto/envoy/type/percent.proto b/xds/third_party/envoy/src/main/proto/envoy/type/percent.proto
deleted file mode 100644
index fc41a26662f..00000000000
--- a/xds/third_party/envoy/src/main/proto/envoy/type/percent.proto
+++ /dev/null
@@ -1,51 +0,0 @@
-syntax = "proto3";
-
-package envoy.type;
-
-import "udpa/annotations/status.proto";
-import "validate/validate.proto";
-
-option java_package = "io.envoyproxy.envoy.type";
-option java_outer_classname = "PercentProto";
-option java_multiple_files = true;
-option (udpa.annotations.file_status).package_version_status = FROZEN;
-
-// [#protodoc-title: Percent]
-
-// Identifies a percentage, in the range [0.0, 100.0].
-message 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 {
-  // 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/range.proto b/xds/third_party/envoy/src/main/proto/envoy/type/range.proto
deleted file mode 100644
index 79aaa81975c..00000000000
--- a/xds/third_party/envoy/src/main/proto/envoy/type/range.proto
+++ /dev/null
@@ -1,42 +0,0 @@
-syntax = "proto3";
-
-package envoy.type;
-
-import "udpa/annotations/status.proto";
-
-option java_package = "io.envoyproxy.envoy.type";
-option java_outer_classname = "RangeProto";
-option java_multiple_files = true;
-option (udpa.annotations.file_status).package_version_status = FROZEN;
-
-// [#protodoc-title: Range]
-
-// Specifies the int64 start and end of the range using half-open interval semantics [start,
-// end).
-message 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 {
-  // 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 {
-  // 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/semantic_version.proto b/xds/third_party/envoy/src/main/proto/envoy/type/semantic_version.proto
deleted file mode 100644
index 80fe016bfa1..00000000000
--- a/xds/third_party/envoy/src/main/proto/envoy/type/semantic_version.proto
+++ /dev/null
@@ -1,23 +0,0 @@
-syntax = "proto3";
-
-package envoy.type;
-
-import "udpa/annotations/status.proto";
-
-option java_package = "io.envoyproxy.envoy.type";
-option java_outer_classname = "SemanticVersionProto";
-option java_multiple_files = true;
-option (udpa.annotations.file_status).package_version_status = FROZEN;
-
-// [#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 {
-  uint32 major_number = 1;
-
-  uint32 minor_number = 2;
-
-  uint32 patch = 3;
-}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/type/tracing/v2/custom_tag.proto b/xds/third_party/envoy/src/main/proto/envoy/type/tracing/v2/custom_tag.proto
deleted file mode 100644
index 7506ae88612..00000000000
--- a/xds/third_party/envoy/src/main/proto/envoy/type/tracing/v2/custom_tag.proto
+++ /dev/null
@@ -1,86 +0,0 @@
-syntax = "proto3";
-
-package envoy.type.tracing.v2;
-
-import "envoy/type/metadata/v2/metadata.proto";
-
-import "udpa/annotations/status.proto";
-import "validate/validate.proto";
-
-option java_package = "io.envoyproxy.envoy.type.tracing.v2";
-option java_outer_classname = "CustomTagProto";
-option java_multiple_files = true;
-option (udpa.annotations.file_status).package_version_status = FROZEN;
-
-// [#protodoc-title: Custom Tag]
-
-// Describes custom tags for the active span.
-// [#next-free-field: 6]
-message CustomTag {
-  // Literal type custom tag with static value for the tag value.
-  message Literal {
-    // Static literal value to populate the tag value.
-    string value = 1 [(validate.rules).string = {min_bytes: 1}];
-  }
-
-  // Environment type custom tag with environment name and default value.
-  message Environment {
-    // Environment variable name to obtain the value to populate the tag value.
-    string name = 1 [(validate.rules).string = {min_bytes: 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 {
-    // Header name to obtain the value to populate the tag value.
-    string name = 1
-        [(validate.rules).string = {min_bytes: 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_api_msg_type.metadata.v2.MetadataKey>` to retrieve the protobuf value
-  // from :ref:`Metadata <envoy_api_msg_core.Metadata>`, and populate the tag value with
-  // `the canonical JSON <https://developers.google.com/protocol-buffers/docs/proto3#json>`_
-  // representation of it.
-  message Metadata {
-    // Specify what kind of metadata to obtain tag value from.
-    metadata.v2.MetadataKind kind = 1;
-
-    // Metadata key to define the path to retrieve the tag value.
-    metadata.v2.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_bytes: 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/tracing/v3/custom_tag.proto b/xds/third_party/envoy/src/main/proto/envoy/type/tracing/v3/custom_tag.proto
index bcebe5779ba..cdb42a43507 100644
--- 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
@@ -11,12 +11,13 @@ 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]
+// [#next-free-field: 7]
 message CustomTag {
   option (udpa.annotations.versioning).previous_message_type = "envoy.type.tracing.v2.CustomTag";
 
@@ -59,8 +60,8 @@ message CustomTag {
   }
 
   // Metadata type custom tag using
-  // :ref:`MetadataKey <envoy_api_msg_type.metadata.v3.MetadataKey>` to retrieve the protobuf value
-  // from :ref:`Metadata <envoy_api_msg_config.core.v3.Metadata>`, and populate the tag value with
+  // :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 {
@@ -97,5 +98,12 @@ message CustomTag {
 
     // A custom tag to obtain tag value from the metadata.
     Metadata metadata = 5;
+
+    // Custom tag value.
+    //
+    // The same :ref:`format specifier <config_access_log_format>` as used for
+    // :ref:`HTTP access logging <config_access_log>` applies here, however
+    // unknown specifier values are replaced with the empty string instead of ``-``.
+    string value = 6;
   }
 }
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
index fec15d11f87..a1a5a04fc87 100644
--- 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
@@ -7,6 +7,7 @@ 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]
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
index 3a89a3f44fd..e041ecddc78 100644
--- 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
@@ -9,6 +9,7 @@ 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]
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
index de1d55b09a2..3b1af814858 100644
--- 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
@@ -8,6 +8,7 @@ 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]
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
index a4126336f03..e032b4cd22d 100644
--- 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
@@ -8,9 +8,10 @@ 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]
+// [#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
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/import.sh b/xds/third_party/googleapis/import.sh
index e83536564e1..683b8cec952 100755
--- a/xds/third_party/googleapis/import.sh
+++ b/xds/third_party/googleapis/import.sh
@@ -13,14 +13,13 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-# Update VERSION then in this directory run ./import.sh
+# Update VERSION then execute this script
 
 set -e
-BRANCH=master
-VERSION=ca1372c6d7bcb199638ebfdb40d2b2660bab7b88
-GIT_REPO="https://github.com/googleapis/googleapis.git"
-GIT_BASE_DIR=googleapis
-SOURCE_PROTO_BASE_DIR=googleapis
+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=(
@@ -30,18 +29,12 @@ google/api/expr/v1alpha1/syntax.proto
 
 pushd `git rev-parse --show-toplevel`/xds/third_party/googleapis
 
-# clone the googleapis github repo in a tmp directory
+# put the repo in a tmp directory
 tmpdir="$(mktemp -d)"
 trap "rm -rf ${tmpdir}" EXIT
+curl -Ls "${DOWNLOAD_URL}" | tar xz -C "${tmpdir}"
 
-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
+cp -p "${tmpdir}/${DOWNLOAD_BASE_DIR}/LICENSE" LICENSE
 
 rm -rf "${TARGET_PROTO_BASE_DIR}"
 mkdir -p "${TARGET_PROTO_BASE_DIR}"
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
index e6333b07380..930dc4f0090 100644
--- 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
@@ -1,4 +1,4 @@
-// Copyright 2020 Google LLC
+// 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.
@@ -58,6 +58,15 @@ message CheckedExpr {
   // 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;
@@ -228,15 +237,14 @@ message Decl {
   }
 
   // Function declaration specifies one or more overloads which indicate the
-  // function's parameter types and return type, and may optionally specify a
-  // function definition in terms of CEL expressions.
+  // 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.
+    // 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
@@ -248,11 +256,13 @@ message Decl {
       // 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`.
+      // 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.
+      // 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
@@ -275,7 +285,7 @@ message Decl {
       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, ...)`.
+      // or a function call-style `f(x, ...)`.
       //
       // For methods, the first parameter declaration, `params[0]` is the
       // expected type of the target receiver.
@@ -294,9 +304,11 @@ message Decl {
   // 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].
+  // 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.
@@ -321,7 +333,8 @@ message Reference {
   // 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].
+  // 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
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
index 3f7652f163a..8219ba68924 100644
--- 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
@@ -1,4 +1,4 @@
-// Copyright 2020 Google LLC
+// 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.
@@ -99,11 +99,19 @@ message Expr {
 
   // A list creation expression.
   //
-  // Lists may either be homogenous, e.g. `[1, 2, 3]`, or heterogenous, e.g.
+  // 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.
@@ -129,7 +137,14 @@ message Expr {
       }
 
       // 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
@@ -287,15 +302,16 @@ message SourceInfo {
   // `acme/app/AnvilPolicy.cel`.
   string location = 2;
 
-  // Monotonically increasing list of character offsets where newlines appear.
+  // 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 character offset
-  // within source.
+  // 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
@@ -314,7 +330,7 @@ message SourcePosition {
   // The soucre location name (e.g. file name).
   string location = 1;
 
-  // The character offset.
+  // The UTF-8 code unit offset.
   int32 offset = 2;
 
   // The 1-based index of the starting line in the source text
diff --git a/xds/third_party/istio/import.sh b/xds/third_party/istio/import.sh
deleted file mode 100755
index b31725083ea..00000000000
--- a/xds/third_party/istio/import.sh
+++ /dev/null
@@ -1,58 +0,0 @@
-#!/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
-
-VERSION=e0ce39487b4806bdd9062b2c0d0cae0bebbbac7b
-GIT_REPO="https://github.com/istio/istio.git"
-GIT_BASE_DIR=istio
-SOURCE_PROTO_BASE_DIR=istio
-TARGET_PROTO_BASE_DIR=src/main/proto
-# Sorted alphabetically.
-FILES=(
-security/proto/providers/google/meshca.proto
-)
-
-pushd `git rev-parse --show-toplevel`/xds/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/xds/third_party/istio/src/main/proto/security/proto/providers/google/meshca.proto b/xds/third_party/istio/src/main/proto/security/proto/providers/google/meshca.proto
deleted file mode 100644
index c02b7f58287..00000000000
--- a/xds/third_party/istio/src/main/proto/security/proto/providers/google/meshca.proto
+++ /dev/null
@@ -1,51 +0,0 @@
-// Copyright 2019 Istio 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.
-
-syntax = "proto3";
-
-package google.security.meshca.v1;
-
-import "google/protobuf/duration.proto";
-
-option java_multiple_files = true;
-option java_outer_classname = "MeshCaProto";
-option java_package = "com.google.security.meshca.v1";
-
-// Certificate request message.
-message MeshCertificateRequest {
-  // The request ID must be a valid UUID with the exception that zero UUID is
-  // not supported (00000000-0000-0000-0000-000000000000).
-  string request_id = 1;
-  // PEM-encoded certificate request.
-  string csr = 2;
-  // Optional: requested certificate validity period.
-  google.protobuf.Duration validity = 3;
-  // Reserved 4
-}
-
-// Certificate response message.
-message MeshCertificateResponse {
-  // PEM-encoded certificate chain.
-  // Leaf cert is element '0'. Root cert is element 'n'.
-  repeated string cert_chain = 1;
-}
-
-// Service for managing certificates issued by the CSM CA.
-service MeshCertificateService {
-  // Using provided CSR, returns a signed certificate that represents a GCP
-  // service account identity.
-  rpc CreateCertificate(MeshCertificateRequest)
-    returns (MeshCertificateResponse) {
-  }
-}
diff --git a/xds/third_party/protoc-gen-validate/import.sh b/xds/third_party/protoc-gen-validate/import.sh
index 62b6158b600..64c92b16c20 100755
--- a/xds/third_party/protoc-gen-validate/import.sh
+++ b/xds/third_party/protoc-gen-validate/import.sh
@@ -13,33 +13,31 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-# Update GIT_ORIGIN_REV_ID then in this directory run ./import.sh
+# Update VERSION then execute this script
 
 set -e
-BRANCH=master
-# import GIT_ORIGIN_REV_ID from one of the google internal CLs
-GIT_ORIGIN_REV_ID=ab56c3dd1cf9b516b62c5087e1ec1471bd63631e
-GIT_REPO="https://github.com/envoyproxy/protoc-gen-validate.git"
-GIT_BASE_DIR=protoc-gen-validate
-SOURCE_PROTO_BASE_DIR=protoc-gen-validate
+# 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
 )
 
-# clone the protoc-gen-validate github repo in a tmp directory
+pushd `git rev-parse --show-toplevel`/xds/third_party/protoc-gen-validate
+
+# put the repo in a tmp directory
 tmpdir="$(mktemp -d)"
-pushd "${tmpdir}"
-rm -rf "$GIT_BASE_DIR"
-git clone -b $BRANCH $GIT_REPO
-cd "$GIT_BASE_DIR"
-git checkout $GIT_ORIGIN_REV_ID
-popd
+trap "rm -rf ${tmpdir}" EXIT
+curl -Ls "${DOWNLOAD_URL}" | tar xz -C "${tmpdir}"
 
-cp -p "${tmpdir}/${GIT_BASE_DIR}/LICENSE" LICENSE
-cp -p "${tmpdir}/${GIT_BASE_DIR}/NOTICE" NOTICE
+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}"
 
@@ -51,4 +49,4 @@ do
 done
 popd
 
-rm -rf "$tmpdir"
+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
index 7767f0aab92..705d382aac4 100644
--- 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
@@ -13,6 +13,8 @@ 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
@@ -93,6 +95,10 @@ message FloatRules {
     // 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
@@ -125,6 +131,10 @@ message DoubleRules {
     // 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
@@ -157,6 +167,10 @@ message Int32Rules {
     // 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
@@ -189,6 +203,10 @@ message Int64Rules {
     // 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
@@ -221,6 +239,10 @@ message UInt32Rules {
     // 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
@@ -253,6 +275,10 @@ message UInt64Rules {
     // 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
@@ -285,6 +311,10 @@ message SInt32Rules {
     // 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
@@ -317,6 +347,10 @@ message SInt64Rules {
     // 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
@@ -349,6 +383,10 @@ message Fixed32Rules {
     // 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
@@ -381,6 +419,10 @@ message Fixed64Rules {
     // 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
@@ -413,6 +455,10 @@ message SFixed32Rules {
     // 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
@@ -445,6 +491,10 @@ message SFixed64Rules {
     // 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
@@ -474,7 +524,6 @@ message StringRules {
     optional uint64 max_len = 3;
 
     // LenBytes specifies that this field must be the specified number of bytes
-    // at a minimum
     optional uint64 len_bytes = 20;
 
     // MinBytes specifies that this field must be the specified number of bytes
@@ -564,6 +613,10 @@ message StringRules {
   // 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.
@@ -633,6 +686,10 @@ message BytesRules {
         // 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
@@ -683,6 +740,10 @@ message RepeatedRules {
     // 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
@@ -706,6 +767,10 @@ message MapRules {
     // 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
diff --git a/xds/third_party/udpa/import.sh b/xds/third_party/udpa/import.sh
deleted file mode 100755
index b96e4ea6da6..00000000000
--- a/xds/third_party/udpa/import.sh
+++ /dev/null
@@ -1,70 +0,0 @@
-#!/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=main
-# import VERSION from one of the google internal CLs
-VERSION=5459f2c994033b0afed7e4a70ac7e90c90c1ffee
-GIT_REPO="https://github.com/cncf/udpa.git"
-GIT_BASE_DIR=udpa
-SOURCE_PROTO_BASE_DIR=udpa
-TARGET_PROTO_BASE_DIR=src/main/proto
-# Sorted alphabetically.
-FILES=(
-udpa/annotations/migrate.proto
-udpa/annotations/security.proto
-udpa/annotations/sensitive.proto
-udpa/annotations/status.proto
-udpa/annotations/versioning.proto
-udpa/data/orca/v1/orca_load_report.proto
-udpa/service/orca/v1/orca.proto
-udpa/type/v1/typed_struct.proto
-xds/core/v3/authority.proto
-xds/core/v3/collection_entry.proto
-xds/core/v3/context_params.proto
-xds/core/v3/resource_locator.proto
-xds/core/v3/resource_name.proto
-)
-
-pushd `git rev-parse --show-toplevel`/xds/third_party/udpa
-
-# clone the udpa 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/xds/third_party/udpa/src/main/proto/udpa/annotations/migrate.proto b/xds/third_party/udpa/src/main/proto/udpa/annotations/migrate.proto
deleted file mode 100644
index 1c42a6404dc..00000000000
--- a/xds/third_party/udpa/src/main/proto/udpa/annotations/migrate.proto
+++ /dev/null
@@ -1,49 +0,0 @@
-syntax = "proto3";
-
-package udpa.annotations;
-
-import "google/protobuf/descriptor.proto";
-
-// 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/udpa/src/main/proto/udpa/annotations/security.proto b/xds/third_party/udpa/src/main/proto/udpa/annotations/security.proto
deleted file mode 100644
index 7191fe30c82..00000000000
--- a/xds/third_party/udpa/src/main/proto/udpa/annotations/security.proto
+++ /dev/null
@@ -1,31 +0,0 @@
-syntax = "proto3";
-
-package udpa.annotations;
-
-import "udpa/annotations/status.proto";
-
-import "google/protobuf/any.proto";
-import "google/protobuf/descriptor.proto";
-
-import "validate/validate.proto";
-
-// 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/udpa/src/main/proto/udpa/annotations/sensitive.proto b/xds/third_party/udpa/src/main/proto/udpa/annotations/sensitive.proto
deleted file mode 100644
index 8dc921f24b5..00000000000
--- a/xds/third_party/udpa/src/main/proto/udpa/annotations/sensitive.proto
+++ /dev/null
@@ -1,14 +0,0 @@
-syntax = "proto3";
-
-package udpa.annotations;
-
-import "google/protobuf/descriptor.proto";
-
-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/udpa/src/main/proto/udpa/annotations/status.proto b/xds/third_party/udpa/src/main/proto/udpa/annotations/status.proto
deleted file mode 100644
index 9832ffd3a2f..00000000000
--- a/xds/third_party/udpa/src/main/proto/udpa/annotations/status.proto
+++ /dev/null
@@ -1,34 +0,0 @@
-syntax = "proto3";
-
-package udpa.annotations;
-
-import "google/protobuf/descriptor.proto";
-
-// 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/udpa/src/main/proto/udpa/annotations/versioning.proto b/xds/third_party/udpa/src/main/proto/udpa/annotations/versioning.proto
deleted file mode 100644
index 16f6dc30cad..00000000000
--- a/xds/third_party/udpa/src/main/proto/udpa/annotations/versioning.proto
+++ /dev/null
@@ -1,17 +0,0 @@
-syntax = "proto3";
-
-package udpa.annotations;
-
-import "google/protobuf/descriptor.proto";
-
-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/udpa/src/main/proto/udpa/data/orca/v1/orca_load_report.proto b/xds/third_party/udpa/src/main/proto/udpa/data/orca/v1/orca_load_report.proto
deleted file mode 100644
index 3105b094724..00000000000
--- a/xds/third_party/udpa/src/main/proto/udpa/data/orca/v1/orca_load_report.proto
+++ /dev/null
@@ -1,35 +0,0 @@
-syntax = "proto3";
-
-package udpa.data.orca.v1;
-
-option java_outer_classname = "OrcaLoadReportProto";
-option java_multiple_files = true;
-option java_package = "com.github.udpa.udpa.data.orca.v1";
-
-import "validate/validate.proto";
-
-// See section `ORCA load report format` of the design document in
-// :ref:`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.
-  double cpu_utilization = 1 [(validate.rules).double.gte = 0, (validate.rules).double.lte = 1];
-
-  // 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.
-  uint64 rps = 3;
-
-  // 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];
-}
diff --git a/xds/third_party/udpa/src/main/proto/udpa/type/v1/typed_struct.proto b/xds/third_party/udpa/src/main/proto/udpa/type/v1/typed_struct.proto
deleted file mode 100644
index e46a2cb5757..00000000000
--- a/xds/third_party/udpa/src/main/proto/udpa/type/v1/typed_struct.proto
+++ /dev/null
@@ -1,42 +0,0 @@
-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";
-
-import "validate/validate.proto";
-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/udpa/src/main/proto/xds/core/v3/authority.proto b/xds/third_party/udpa/src/main/proto/xds/core/v3/authority.proto
deleted file mode 100644
index 49daf4b8cb6..00000000000
--- a/xds/third_party/udpa/src/main/proto/xds/core/v3/authority.proto
+++ /dev/null
@@ -1,21 +0,0 @@
-syntax = "proto3";
-
-package xds.core.v3;
-
-import "udpa/annotations/status.proto";
-
-import "validate/validate.proto";
-
-option java_outer_classname = "AuthorityProto";
-option java_multiple_files = true;
-option java_package = "com.github.udpa.xds.core.v3";
-
-option (udpa.annotations.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/udpa/LICENSE b/xds/third_party/xds/LICENSE
similarity index 100%
rename from xds/third_party/udpa/LICENSE
rename to xds/third_party/xds/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/udpa/src/main/proto/xds/core/v3/collection_entry.proto b/xds/third_party/xds/src/main/proto/xds/core/v3/collection_entry.proto
similarity index 76%
rename from xds/third_party/udpa/src/main/proto/xds/core/v3/collection_entry.proto
rename to xds/third_party/xds/src/main/proto/xds/core/v3/collection_entry.proto
index 4ece240ca3e..c844d614e4f 100644
--- a/xds/third_party/udpa/src/main/proto/xds/core/v3/collection_entry.proto
+++ b/xds/third_party/xds/src/main/proto/xds/core/v3/collection_entry.proto
@@ -4,30 +4,33 @@ package xds.core.v3;
 
 import "google/protobuf/any.proto";
 
-import "udpa/annotations/status.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.udpa.xds.core.v3";
+option java_package = "com.github.xds.core.v3";
+option go_package = "github.com/cncf/xds/go/xds/core/v3";
 
-option (udpa.annotations.file_status).work_in_progress = true;
+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:
 //
-// message <T>Collection {
-//   repeated CollectionEntry resources = 1;
-// }
+// .. 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
-    // [a-zA-Z0-9_-\./]+ (TODO(htuch): turn this into a PGV constraint once
+    // 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_\\-\\.~:]+$"];
diff --git a/xds/third_party/udpa/src/main/proto/xds/core/v3/context_params.proto b/xds/third_party/xds/src/main/proto/xds/core/v3/context_params.proto
similarity index 76%
rename from xds/third_party/udpa/src/main/proto/xds/core/v3/context_params.proto
rename to xds/third_party/xds/src/main/proto/xds/core/v3/context_params.proto
index 8f27c1ca7e5..a42c7a85960 100644
--- a/xds/third_party/udpa/src/main/proto/xds/core/v3/context_params.proto
+++ b/xds/third_party/xds/src/main/proto/xds/core/v3/context_params.proto
@@ -2,18 +2,20 @@ syntax = "proto3";
 
 package xds.core.v3;
 
-import "udpa/annotations/status.proto";
+import "xds/annotations/v3/status.proto";
 
 option java_outer_classname = "ContextParamsProto";
 option java_multiple_files = true;
-option java_package = "com.github.udpa.xds.core.v3";
+option java_package = "com.github.xds.core.v3";
+option go_package = "github.com/cncf/xds/go/xds/core/v3";
 
-option (udpa.annotations.file_status).work_in_progress = true;
+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 {
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/udpa/src/main/proto/xds/core/v3/resource_locator.proto b/xds/third_party/xds/src/main/proto/xds/core/v3/resource_locator.proto
similarity index 95%
rename from xds/third_party/udpa/src/main/proto/xds/core/v3/resource_locator.proto
rename to xds/third_party/xds/src/main/proto/xds/core/v3/resource_locator.proto
index d7334394ae2..9b40d52fc43 100644
--- a/xds/third_party/udpa/src/main/proto/xds/core/v3/resource_locator.proto
+++ b/xds/third_party/xds/src/main/proto/xds/core/v3/resource_locator.proto
@@ -2,16 +2,17 @@ syntax = "proto3";
 
 package xds.core.v3;
 
-import "udpa/annotations/status.proto";
+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.udpa.xds.core.v3";
+option java_package = "com.github.xds.core.v3";
+option go_package = "github.com/cncf/xds/go/xds/core/v3";
 
-option (udpa.annotations.file_status).work_in_progress = true;
+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.
diff --git a/xds/third_party/udpa/src/main/proto/xds/core/v3/resource_name.proto b/xds/third_party/xds/src/main/proto/xds/core/v3/resource_name.proto
similarity index 86%
rename from xds/third_party/udpa/src/main/proto/xds/core/v3/resource_name.proto
rename to xds/third_party/xds/src/main/proto/xds/core/v3/resource_name.proto
index 103c7de8640..0f3d9974079 100644
--- a/xds/third_party/udpa/src/main/proto/xds/core/v3/resource_name.proto
+++ b/xds/third_party/xds/src/main/proto/xds/core/v3/resource_name.proto
@@ -2,16 +2,17 @@ syntax = "proto3";
 
 package xds.core.v3;
 
-import "udpa/annotations/status.proto";
+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.udpa.xds.core.v3";
+option java_package = "com.github.xds.core.v3";
+option go_package = "github.com/cncf/xds/go/xds/core/v3";
 
-option (udpa.annotations.file_status).work_in_progress = true;
+option (xds.annotations.v3.file_status).work_in_progress = true;
 
 // xDS resource name. This has a canonical xdstp:// URI representation:
 //
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/udpa/src/main/proto/udpa/service/orca/v1/orca.proto b/xds/third_party/xds/src/main/proto/xds/service/orca/v3/orca.proto
similarity index 81%
rename from xds/third_party/udpa/src/main/proto/udpa/service/orca/v1/orca.proto
rename to xds/third_party/xds/src/main/proto/xds/service/orca/v3/orca.proto
index d48cccfeacb..03126cdcaa6 100644
--- a/xds/third_party/udpa/src/main/proto/udpa/service/orca/v1/orca.proto
+++ b/xds/third_party/xds/src/main/proto/xds/service/orca/v3/orca.proto
@@ -1,17 +1,16 @@
 syntax = "proto3";
 
-package udpa.service.orca.v1;
+package xds.service.orca.v3;
 
 option java_outer_classname = "OrcaProto";
 option java_multiple_files = true;
-option java_package = "com.github.udpa.udpa.service.orca.v1";
+option java_package = "com.github.xds.service.orca.v3";
+option go_package = "github.com/cncf/xds/go/xds/service/orca/v3";
 
-import "udpa/data/orca/v1/orca_load_report.proto";
+import "xds/data/orca/v3/orca_load_report.proto";
 
 import "google/protobuf/duration.proto";
 
-import "validate/validate.proto";
-
 // See section `Out-of-band (OOB) reporting` of the design document in
 // :ref:`https://github.com/envoyproxy/envoy/issues/6614`.
 
@@ -24,7 +23,7 @@ import "validate/validate.proto";
 // 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 udpa.data.orca.v1.OrcaLoadReport);
+  rpc StreamCoreMetrics(OrcaLoadReportRequest) returns (stream xds.data.orca.v3.OrcaLoadReport);
 }
 
 message OrcaLoadReportRequest {
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/test/java/io/grpc/xds/XxHash64Test.java b/xds/third_party/zero-allocation-hashing/test/java/io/grpc/xds/XxHash64Test.java
index d66c8cf9d97..10219a2f72e 100644
--- 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
@@ -136,7 +136,7 @@ private static void testNegativePrimitives(XxHash64 f, int len) {
         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((char) -1));
+        assertEquals("char hash", twoByteExpected, f.hashChar(Character.MAX_VALUE));
         assertEquals("int hash", fourByteExpected, f.hashInt(-1));
         assertEquals("long hash", eightByteExpected, f.hashLong(-1L));
       }