Merge branch 'master' into gpr_review3

50 files changed, 817 insertions, 577 deletions

diff --git a/src/compiler/cpp_generator.cc b/src/compiler/cpp_generator.cc
index f35bfd9ab9..3a15a601cb 100644
--- a/src/compiler/cpp_generator.cc
+++ b/src/compiler/cpp_generator.cc
@@ -64,16 +64,15 @@ T* array_end(T (&array)[N]) {
 
 void PrintIncludes(grpc_generator::Printer* printer,
                    const std::vector<grpc::string>& headers,
-                   const Parameters& params) {
+                   bool use_system_headers, const grpc::string& search_path) {
   std::map<grpc::string, grpc::string> vars;
 
-  vars["l"] = params.use_system_headers ? '<' : '"';
-  vars["r"] = params.use_system_headers ? '>' : '"';
+  vars["l"] = use_system_headers ? '<' : '"';
+  vars["r"] = use_system_headers ? '>' : '"';
 
-  auto& s = params.grpc_search_path;
-  if (!s.empty()) {
-    vars["l"] += s;
-    if (s[s.size() - 1] != '/') {
+  if (!search_path.empty()) {
+    vars["l"] += search_path;
+    if (search_path[search_path.size() - 1] != '/') {
       vars["l"] += '/';
     }
   }
@@ -124,6 +123,10 @@ grpc::string GetHeaderIncludes(grpc_generator::File* file,
     auto printer = file->CreatePrinter(&output);
     std::map<grpc::string, grpc::string> vars;
 
+    if (!params.additional_header_includes.empty()) {
+      PrintIncludes(printer.get(), params.additional_header_includes, false,
+                    "");
+    }
     static const char* headers_strs[] = {
         "grpc++/impl/codegen/async_stream.h",
         "grpc++/impl/codegen/async_unary_call.h",
@@ -135,7 +138,8 @@ grpc::string GetHeaderIncludes(grpc_generator::File* file,
         "grpc++/impl/codegen/stub_options.h",
         "grpc++/impl/codegen/sync_stream.h"};
     std::vector<grpc::string> headers(headers_strs, array_end(headers_strs));
-    PrintIncludes(printer.get(), headers, params);
+    PrintIncludes(printer.get(), headers, params.use_system_headers,
+                  params.grpc_search_path);
     printer->Print(vars, "\n");
     printer->Print(vars, "namespace grpc {\n");
     printer->Print(vars, "class CompletionQueue;\n");
@@ -1153,7 +1157,8 @@ grpc::string GetSourceIncludes(grpc_generator::File* file,
         "grpc++/impl/codegen/service_type.h",
         "grpc++/impl/codegen/sync_stream.h"};
     std::vector<grpc::string> headers(headers_strs, array_end(headers_strs));
-    PrintIncludes(printer.get(), headers, params);
+    PrintIncludes(printer.get(), headers, params.use_system_headers,
+                  params.grpc_search_path);
 
     if (!file->package().empty()) {
       std::vector<grpc::string> parts = file->package_parts();
@@ -1570,20 +1575,19 @@ grpc::string GetMockIncludes(grpc_generator::File* file,
         "grpc++/impl/codegen/sync_stream.h",
     };
     std::vector<grpc::string> headers(headers_strs, array_end(headers_strs));
-    PrintIncludes(printer.get(), headers, params);
+    PrintIncludes(printer.get(), headers, params.use_system_headers,
+                  params.grpc_search_path);
 
     std::vector<grpc::string> gmock_header;
     if (params.gmock_search_path.empty()) {
       gmock_header.push_back("gmock/gmock.h");
-      PrintIncludes(printer.get(), gmock_header, params);
+      PrintIncludes(printer.get(), gmock_header, params.use_system_headers,
+                    params.grpc_search_path);
     } else {
       gmock_header.push_back("gmock.h");
-      // Copy a params to generate gmock header.
-      Parameters gmock_params(params);
       // We use local includes when a gmock_search_path is given
-      gmock_params.use_system_headers = false;
-      gmock_params.grpc_search_path = params.gmock_search_path;
-      PrintIncludes(printer.get(), gmock_header, gmock_params);
+      PrintIncludes(printer.get(), gmock_header, false,
+                    params.gmock_search_path);
     }
 
     if (!file->package().empty()) {
diff --git a/src/compiler/cpp_generator.h b/src/compiler/cpp_generator.h
index 300a27c589..d88ef75c98 100644
--- a/src/compiler/cpp_generator.h
+++ b/src/compiler/cpp_generator.h
@@ -54,6 +54,8 @@ struct Parameters {
   bool generate_mock_code;
   // Google Mock search path, when non-empty, local includes will be used.
   grpc::string gmock_search_path;
+  // *EXPERIMENTAL* Additional include files in grpc.pb.h
+  std::vector<grpc::string> additional_header_includes;
 };
 
 // Return the prologue of the generated header file.
diff --git a/src/compiler/cpp_plugin.cc b/src/compiler/cpp_plugin.cc
index 661282f880..c8ab78863b 100644
--- a/src/compiler/cpp_plugin.cc
+++ b/src/compiler/cpp_plugin.cc
@@ -80,6 +80,9 @@ class CppGrpcGenerator : public grpc::protobuf::compiler::CodeGenerator {
           }
         } else if (param[0] == "gmock_search_path") {
           generator_parameters.gmock_search_path = param[1];
+        } else if (param[0] == "additional_header_includes") {
+          generator_parameters.additional_header_includes =
+              grpc_generator::tokenize(param[1], ":");
         } else {
           *error = grpc::string("Unknown parameter: ") + *parameter_string;
           return false;
diff --git a/src/core/ext/filters/client_channel/client_channel.cc b/src/core/ext/filters/client_channel/client_channel.cc
index 49522ef3e4..6b93644430 100644
--- a/src/core/ext/filters/client_channel/client_channel.cc
+++ b/src/core/ext/filters/client_channel/client_channel.cc
@@ -1095,6 +1095,7 @@ static void pick_callback_done_locked(void* arg, grpc_error* error) {
             chand, calld);
   }
   async_pick_done_locked(elem, GRPC_ERROR_REF(error));
+  GRPC_CALL_STACK_UNREF(calld->owning_call, "pick_callback");
 }
 
 // Takes a ref to chand->lb_policy and calls grpc_lb_policy_pick_locked().
@@ -1134,6 +1135,7 @@ static bool pick_callback_start_locked(grpc_call_element* elem) {
   GRPC_CLOSURE_INIT(&calld->lb_pick_closure, pick_callback_done_locked, elem,
                     grpc_combiner_scheduler(chand->combiner));
   calld->pick.on_complete = &calld->lb_pick_closure;
+  GRPC_CALL_STACK_REF(calld->owning_call, "pick_callback");
   const bool pick_done =
       grpc_lb_policy_pick_locked(chand->lb_policy, &calld->pick);
   if (pick_done) {
@@ -1142,6 +1144,7 @@ static bool pick_callback_start_locked(grpc_call_element* elem) {
       gpr_log(GPR_DEBUG, "chand=%p calld=%p: pick completed synchronously",
               chand, calld);
     }
+    GRPC_CALL_STACK_UNREF(calld->owning_call, "pick_callback");
   } else {
     GRPC_CALL_STACK_REF(calld->owning_call, "pick_callback_cancel");
     grpc_call_combiner_set_notify_on_cancel(
diff --git a/src/core/ext/filters/client_channel/lb_policy/round_robin/round_robin.cc b/src/core/ext/filters/client_channel/lb_policy/round_robin/round_robin.cc
index 24c381a46d..ab6d3e6a03 100644
--- a/src/core/ext/filters/client_channel/lb_policy/round_robin/round_robin.cc
+++ b/src/core/ext/filters/client_channel/lb_policy/round_robin/round_robin.cc
@@ -328,18 +328,11 @@ static void update_lb_connectivity_status_locked(grpc_lb_subchannel_data* sd,
    * 2) RULE: ANY subchannel is CONNECTING => policy is CONNECTING.
    *    CHECK: sd->curr_connectivity_state == CONNECTING.
    *
-   * 3) RULE: ALL subchannels are SHUTDOWN => policy is IDLE (and requests
-   *          re-resolution).
-   *    CHECK: subchannel_list->num_shutdown ==
-   *           subchannel_list->num_subchannels.
-   *
-   * 4) RULE: ALL subchannels are SHUTDOWN or TRANSIENT_FAILURE => policy is
-   *          TRANSIENT_FAILURE.
-   *    CHECK: subchannel_list->num_shutdown +
-   *             subchannel_list->num_transient_failures ==
+   * 3) RULE: ALL subchannels are TRANSIENT_FAILURE => policy is
+   *                                                   TRANSIENT_FAILURE.
+   *    CHECK: subchannel_list->num_transient_failures ==
    *           subchannel_list->num_subchannels.
    */
-  // TODO(juanlishen): For rule 4, we may want to re-resolve instead.
   grpc_lb_subchannel_list* subchannel_list = sd->subchannel_list;
   round_robin_lb_policy* p = (round_robin_lb_policy*)subchannel_list->policy;
   GPR_ASSERT(sd->curr_connectivity_state != GRPC_CHANNEL_IDLE);
@@ -351,22 +344,12 @@ static void update_lb_connectivity_status_locked(grpc_lb_subchannel_data* sd,
     /* 2) CONNECTING */
     grpc_connectivity_state_set(&p->state_tracker, GRPC_CHANNEL_CONNECTING,
                                 GRPC_ERROR_NONE, "rr_connecting");
-  } else if (subchannel_list->num_shutdown ==
+  } else if (subchannel_list->num_transient_failures ==
              subchannel_list->num_subchannels) {
-    /* 3) IDLE and re-resolve */
-    grpc_connectivity_state_set(&p->state_tracker, GRPC_CHANNEL_IDLE,
-                                GRPC_ERROR_NONE,
-                                "rr_exhausted_subchannels+reresolve");
-    p->started_picking = false;
-    grpc_lb_policy_try_reresolve(&p->base, &grpc_lb_round_robin_trace,
-                                 GRPC_ERROR_NONE);
-  } else if (subchannel_list->num_shutdown +
-                 subchannel_list->num_transient_failures ==
-             subchannel_list->num_subchannels) {
-    /* 4) TRANSIENT_FAILURE */
-    grpc_connectivity_state_set(&p->state_tracker,
-                                GRPC_CHANNEL_TRANSIENT_FAILURE,
-                                GRPC_ERROR_REF(error), "rr_transient_failure");
+    /* 3) TRANSIENT_FAILURE */
+    grpc_connectivity_state_set(
+        &p->state_tracker, GRPC_CHANNEL_TRANSIENT_FAILURE,
+        GRPC_ERROR_REF(error), "rr_exhausted_subchannels");
   }
   GRPC_ERROR_UNREF(error);
 }
@@ -387,6 +370,7 @@ static void rr_connectivity_changed_locked(void* arg, grpc_error* error) {
         p->shutdown, sd->subchannel_list->shutting_down,
         grpc_error_string(error));
   }
+  GPR_ASSERT(sd->subchannel != nullptr);
   // If the policy is shutting down, unref and return.
   if (p->shutdown) {
     grpc_lb_subchannel_data_stop_connectivity_watch(sd);
@@ -412,14 +396,19 @@ static void rr_connectivity_changed_locked(void* arg, grpc_error* error) {
   // state (which was set by the connectivity state watcher) to
   // curr_connectivity_state, which is what we use inside of the combiner.
   sd->curr_connectivity_state = sd->pending_connectivity_state_unsafe;
-  // Update state counters and new overall state.
-  update_state_counters_locked(sd);
-  update_lb_connectivity_status_locked(sd, GRPC_ERROR_REF(error));
   // If the sd's new state is TRANSIENT_FAILURE, unref the *connected*
   // subchannel, if any.
   switch (sd->curr_connectivity_state) {
     case GRPC_CHANNEL_TRANSIENT_FAILURE: {
       sd->connected_subchannel.reset();
+      if (grpc_lb_round_robin_trace.enabled()) {
+        gpr_log(GPR_DEBUG,
+                "[RR %p] Subchannel %p has gone into TRANSIENT_FAILURE. "
+                "Requesting re-resolution",
+                p, sd->subchannel);
+      }
+      grpc_lb_policy_try_reresolve(&p->base, &grpc_lb_round_robin_trace,
+                                   GRPC_ERROR_NONE);
       break;
     }
     case GRPC_CHANNEL_READY: {
@@ -442,8 +431,8 @@ static void rr_connectivity_changed_locked(void* arg, grpc_error* error) {
           gpr_log(GPR_DEBUG,
                   "[RR %p] phasing out subchannel list %p (size %lu) in favor "
                   "of %p (size %lu)",
-                  (void*)p, (void*)p->subchannel_list, num_subchannels,
-                  (void*)sd->subchannel_list, num_subchannels);
+                  p, p->subchannel_list, num_subchannels, sd->subchannel_list,
+                  num_subchannels);
         }
         if (p->subchannel_list != nullptr) {
           // dispose of the current subchannel_list
@@ -455,7 +444,8 @@ static void rr_connectivity_changed_locked(void* arg, grpc_error* error) {
       }
       /* at this point we know there's at least one suitable subchannel. Go
        * ahead and pick one and notify the pending suitors in
-       * p->pending_picks. This preemptively replicates rr_pick()'s actions. */
+       * p->pending_picks. This preemptively replicates rr_pick()'s actions.
+       */
       const size_t next_ready_index = get_next_ready_subchannel_index_locked(p);
       GPR_ASSERT(next_ready_index < p->subchannel_list->num_subchannels);
       grpc_lb_subchannel_data* selected =
@@ -488,6 +478,12 @@ static void rr_connectivity_changed_locked(void* arg, grpc_error* error) {
     case GRPC_CHANNEL_CONNECTING:
     case GRPC_CHANNEL_IDLE:;  // fallthrough
   }
+  // Update state counters and new overall state.
+  update_state_counters_locked(sd);
+  // Only update connectivity based on the selected subchannel list.
+  if (sd->subchannel_list == p->subchannel_list) {
+    update_lb_connectivity_status_locked(sd, GRPC_ERROR_REF(error));
+  }
   // Renew notification.
   grpc_lb_subchannel_data_start_connectivity_watch(sd);
 }
@@ -562,6 +558,30 @@ static void rr_update_locked(grpc_lb_policy* policy,
     return;
   }
   if (p->started_picking) {
+    for (size_t i = 0; i < subchannel_list->num_subchannels; ++i) {
+      const grpc_connectivity_state subchannel_state =
+          grpc_subchannel_check_connectivity(
+              subchannel_list->subchannels[i].subchannel, nullptr);
+      // Override the default setting of IDLE for connectivity notification
+      // purposes if the subchannel is already in transient failure. Otherwise
+      // we'd be immediately notified of the IDLE-TRANSIENT_FAILURE
+      // discrepancy, attempt to re-resolve and end up here again.
+      // TODO(roth): As part of C++-ifying the subchannel_list API, design a
+      // better API for notifying the LB policy of subchannel states, which can
+      // be used both for the subchannel's initial state and for subsequent
+      // state changes. This will allow us to handle this more generally instead
+      // of special-casing TRANSIENT_FAILURE (e.g., we can also distribute any
+      // pending picks across all READY subchannels rather than sending them all
+      // to the first one).
+      if (subchannel_state == GRPC_CHANNEL_TRANSIENT_FAILURE) {
+        subchannel_list->subchannels[i].pending_connectivity_state_unsafe =
+            subchannel_list->subchannels[i].curr_connectivity_state =
+                subchannel_list->subchannels[i].prev_connectivity_state =
+                    subchannel_state;
+        --subchannel_list->num_idle;
+        ++subchannel_list->num_transient_failures;
+      }
+    }
     if (p->latest_pending_subchannel_list != nullptr) {
       if (grpc_lb_round_robin_trace.enabled()) {
         gpr_log(GPR_DEBUG,
diff --git a/src/core/ext/filters/client_channel/lb_policy/subchannel_list.cc b/src/core/ext/filters/client_channel/lb_policy/subchannel_list.cc
index fa2ffcc796..75f7ca2d12 100644
--- a/src/core/ext/filters/client_channel/lb_policy/subchannel_list.cc
+++ b/src/core/ext/filters/client_channel/lb_policy/subchannel_list.cc
@@ -54,13 +54,15 @@ void grpc_lb_subchannel_data_unref_subchannel(grpc_lb_subchannel_data* sd,
 void grpc_lb_subchannel_data_start_connectivity_watch(
     grpc_lb_subchannel_data* sd) {
   if (sd->subchannel_list->tracer->enabled()) {
-    gpr_log(GPR_DEBUG,
-            "[%s %p] subchannel list %p index %" PRIuPTR " of %" PRIuPTR
-            " (subchannel %p): requesting connectivity change notification",
-            sd->subchannel_list->tracer->name(), sd->subchannel_list->policy,
-            sd->subchannel_list,
-            (size_t)(sd - sd->subchannel_list->subchannels),
-            sd->subchannel_list->num_subchannels, sd->subchannel);
+    gpr_log(
+        GPR_DEBUG,
+        "[%s %p] subchannel list %p index %" PRIuPTR " of %" PRIuPTR
+        " (subchannel %p): requesting connectivity change "
+        "notification (from %s)",
+        sd->subchannel_list->tracer->name(), sd->subchannel_list->policy,
+        sd->subchannel_list, (size_t)(sd - sd->subchannel_list->subchannels),
+        sd->subchannel_list->num_subchannels, sd->subchannel,
+        grpc_connectivity_state_name(sd->pending_connectivity_state_unsafe));
   }
   sd->connectivity_notification_pending = true;
   grpc_subchannel_notify_on_state_change(
diff --git a/src/core/ext/filters/client_channel/lb_policy/subchannel_list.h b/src/core/ext/filters/client_channel/lb_policy/subchannel_list.h
index 3377605263..91537f3afe 100644
--- a/src/core/ext/filters/client_channel/lb_policy/subchannel_list.h
+++ b/src/core/ext/filters/client_channel/lb_policy/subchannel_list.h
@@ -101,8 +101,6 @@ struct grpc_lb_subchannel_list {
   size_t num_ready;
   /** how many subchannels are in state TRANSIENT_FAILURE */
   size_t num_transient_failures;
-  /** how many subchannels are in state SHUTDOWN */
-  size_t num_shutdown;
   /** how many subchannels are in state IDLE */
   size_t num_idle;
 
diff --git a/src/core/ext/filters/client_channel/resolver/fake/fake_resolver.cc b/src/core/ext/filters/client_channel/resolver/fake/fake_resolver.cc
index eaa5e6ac49..e945d08202 100644
--- a/src/core/ext/filters/client_channel/resolver/fake/fake_resolver.cc
+++ b/src/core/ext/filters/client_channel/resolver/fake/fake_resolver.cc
@@ -47,10 +47,10 @@
 //
 
 typedef struct {
-  // base class -- must be first
+  // Base class -- must be first
   grpc_resolver base;
 
-  // passed-in parameters
+  // Passed-in parameters
   grpc_channel_args* channel_args;
 
   // If not NULL, the next set of resolution results to be returned to
@@ -61,9 +61,16 @@ typedef struct {
   // fake_resolver_channel_saw_error_locked().
   grpc_channel_args* results_upon_error;
 
-  // pending next completion, or NULL
+  // TODO(juanlishen): This can go away once pick_first is changed to not throw
+  // away its subchannels, since that will eliminate its dependence on
+  // channel_saw_error_locked() causing an immediate resolver return.
+  // A copy of the most-recently used resolution results.
+  grpc_channel_args* last_used_results;
+
+  // Pending next completion, or NULL
   grpc_closure* next_completion;
-  // target result address for next completion
+
+  // Target result address for next completion
   grpc_channel_args** target_result;
 } fake_resolver;
 
@@ -71,6 +78,7 @@ static void fake_resolver_destroy(grpc_resolver* gr) {
   fake_resolver* r = (fake_resolver*)gr;
   grpc_channel_args_destroy(r->next_results);
   grpc_channel_args_destroy(r->results_upon_error);
+  grpc_channel_args_destroy(r->last_used_results);
   grpc_channel_args_destroy(r->channel_args);
   gpr_free(r);
 }
@@ -98,9 +106,15 @@ static void fake_resolver_maybe_finish_next_locked(fake_resolver* r) {
 
 static void fake_resolver_channel_saw_error_locked(grpc_resolver* resolver) {
   fake_resolver* r = (fake_resolver*)resolver;
-  if (r->next_results == nullptr && r->results_upon_error != nullptr) {
-    // Pretend we re-resolved.
+  // A resolution must have been returned before an error is seen.
+  GPR_ASSERT(r->last_used_results != nullptr);
+  grpc_channel_args_destroy(r->next_results);
+  if (r->results_upon_error != nullptr) {
     r->next_results = grpc_channel_args_copy(r->results_upon_error);
+  } else {
+    // If results_upon_error is unavailable, re-resolve with the most-recently
+    // used results to avoid a no-op re-resolution.
+    r->next_results = grpc_channel_args_copy(r->last_used_results);
   }
   fake_resolver_maybe_finish_next_locked(r);
 }
@@ -149,35 +163,56 @@ void grpc_fake_resolver_response_generator_unref(
 typedef struct set_response_closure_arg {
   grpc_closure set_response_closure;
   grpc_fake_resolver_response_generator* generator;
-  grpc_channel_args* next_response;
+  grpc_channel_args* response;
+  bool upon_error;
 } set_response_closure_arg;
 
-static void set_response_closure_fn(void* arg, grpc_error* error) {
+static void set_response_closure_locked(void* arg, grpc_error* error) {
   set_response_closure_arg* closure_arg = (set_response_closure_arg*)arg;
   grpc_fake_resolver_response_generator* generator = closure_arg->generator;
   fake_resolver* r = generator->resolver;
-  if (r->next_results != nullptr) {
+  if (!closure_arg->upon_error) {
     grpc_channel_args_destroy(r->next_results);
-  }
-  r->next_results = closure_arg->next_response;
-  if (r->results_upon_error != nullptr) {
+    r->next_results = closure_arg->response;
+    grpc_channel_args_destroy(r->last_used_results);
+    r->last_used_results = grpc_channel_args_copy(closure_arg->response);
+    fake_resolver_maybe_finish_next_locked(r);
+  } else {
     grpc_channel_args_destroy(r->results_upon_error);
+    r->results_upon_error = closure_arg->response;
   }
-  r->results_upon_error = grpc_channel_args_copy(closure_arg->next_response);
   gpr_free(closure_arg);
-  fake_resolver_maybe_finish_next_locked(r);
 }
 
 void grpc_fake_resolver_response_generator_set_response(
     grpc_fake_resolver_response_generator* generator,
-    grpc_channel_args* next_response) {
+    grpc_channel_args* response) {
+  GPR_ASSERT(generator->resolver != nullptr);
+  GPR_ASSERT(response != nullptr);
+  set_response_closure_arg* closure_arg =
+      (set_response_closure_arg*)gpr_zalloc(sizeof(*closure_arg));
+  closure_arg->generator = generator;
+  closure_arg->response = grpc_channel_args_copy(response);
+  closure_arg->upon_error = false;
+  GRPC_CLOSURE_SCHED(GRPC_CLOSURE_INIT(&closure_arg->set_response_closure,
+                                       set_response_closure_locked, closure_arg,
+                                       grpc_combiner_scheduler(
+                                           generator->resolver->base.combiner)),
+                     GRPC_ERROR_NONE);
+}
+
+void grpc_fake_resolver_response_generator_set_response_upon_error(
+    grpc_fake_resolver_response_generator* generator,
+    grpc_channel_args* response) {
   GPR_ASSERT(generator->resolver != nullptr);
   set_response_closure_arg* closure_arg =
       (set_response_closure_arg*)gpr_zalloc(sizeof(*closure_arg));
   closure_arg->generator = generator;
-  closure_arg->next_response = grpc_channel_args_copy(next_response);
+  closure_arg->response =
+      response != nullptr ? grpc_channel_args_copy(response) : nullptr;
+  closure_arg->upon_error = true;
   GRPC_CLOSURE_SCHED(GRPC_CLOSURE_INIT(&closure_arg->set_response_closure,
-                                       set_response_closure_fn, closure_arg,
+                                       set_response_closure_locked, closure_arg,
                                        grpc_combiner_scheduler(
                                            generator->resolver->base.combiner)),
                      GRPC_ERROR_NONE);
diff --git a/src/core/ext/filters/client_channel/resolver/fake/fake_resolver.h b/src/core/ext/filters/client_channel/resolver/fake/fake_resolver.h
index a8977e5980..94f9a8e6ca 100644
--- a/src/core/ext/filters/client_channel/resolver/fake/fake_resolver.h
+++ b/src/core/ext/filters/client_channel/resolver/fake/fake_resolver.h
@@ -36,11 +36,20 @@ typedef struct grpc_fake_resolver_response_generator
 grpc_fake_resolver_response_generator*
 grpc_fake_resolver_response_generator_create();
 
-// Instruct the fake resolver associated with the \a response_generator instance
-// to trigger a new resolution for \a uri and \a args.
+// Set next response of the fake resolver associated with the \a
+// response_generator instance and trigger a new resolution.
 void grpc_fake_resolver_response_generator_set_response(
     grpc_fake_resolver_response_generator* generator,
-    grpc_channel_args* next_response);
+    grpc_channel_args* response);
+
+// Set results_upon_error of the fake resolver associated with the \a
+// response_generator instance. When fake_resolver_channel_saw_error_locked() is
+// called, results_upon_error will be returned as long as it's non-NULL,
+// otherwise the last value set by
+// grpc_fake_resolver_response_generator_set_response() will be returned.
+void grpc_fake_resolver_response_generator_set_response_upon_error(
+    grpc_fake_resolver_response_generator* generator,
+    grpc_channel_args* response);
 
 // Return a \a grpc_arg for a \a grpc_fake_resolver_response_generator instance.
 grpc_arg grpc_fake_resolver_response_generator_arg(
diff --git a/src/core/ext/filters/client_channel/subchannel.cc b/src/core/ext/filters/client_channel/subchannel.cc
index dc1beee165..6bf710c948 100644
--- a/src/core/ext/filters/client_channel/subchannel.cc
+++ b/src/core/ext/filters/client_channel/subchannel.cc
@@ -738,8 +738,9 @@ grpc_arg grpc_create_subchannel_address_arg(const grpc_resolved_address* addr) {
 }
 
 namespace grpc_core {
+
 ConnectedSubchannel::ConnectedSubchannel(grpc_channel_stack* channel_stack)
-    : grpc_core::RefCountedWithTracing(&grpc_trace_stream_refcount),
+    : RefCountedWithTracing<ConnectedSubchannel>(&grpc_trace_stream_refcount),
       channel_stack_(channel_stack) {}
 
 ConnectedSubchannel::~ConnectedSubchannel() {
@@ -774,7 +775,9 @@ grpc_error* ConnectedSubchannel::CreateCall(const CallArgs& args,
       args.arena,
       sizeof(grpc_subchannel_call) + channel_stack_->call_stack_size);
   grpc_call_stack* callstk = SUBCHANNEL_CALL_TO_CALL_STACK(*call);
-  Ref(DEBUG_LOCATION, "subchannel_call");
+  RefCountedPtr<ConnectedSubchannel> connection =
+      Ref(DEBUG_LOCATION, "subchannel_call");
+  connection.release();  // Ref is passed to the grpc_subchannel_call object.
   (*call)->connection = this;
   const grpc_call_element_args call_args = {
       callstk,           /* call_stack */
@@ -796,4 +799,5 @@ grpc_error* ConnectedSubchannel::CreateCall(const CallArgs& args,
   grpc_call_stack_set_pollset_or_pollset_set(callstk, args.pollent);
   return GRPC_ERROR_NONE;
 }
+
 }  // namespace grpc_core
diff --git a/src/core/ext/filters/client_channel/subchannel.h b/src/core/ext/filters/client_channel/subchannel.h
index b7593ec911..d2b45ae9c8 100644
--- a/src/core/ext/filters/client_channel/subchannel.h
+++ b/src/core/ext/filters/client_channel/subchannel.h
@@ -68,7 +68,8 @@ typedef struct grpc_subchannel_key grpc_subchannel_key;
 #endif
 
 namespace grpc_core {
-class ConnectedSubchannel : public grpc_core::RefCountedWithTracing {
+
+class ConnectedSubchannel : public RefCountedWithTracing<ConnectedSubchannel> {
  public:
   struct CallArgs {
     grpc_polling_entity* pollent;
@@ -93,6 +94,7 @@ class ConnectedSubchannel : public grpc_core::RefCountedWithTracing {
  private:
   grpc_channel_stack* channel_stack_;
 };
+
 }  // namespace grpc_core
 
 grpc_subchannel* grpc_subchannel_ref(
diff --git a/src/core/ext/filters/max_age/max_age_filter.cc b/src/core/ext/filters/max_age/max_age_filter.cc
index 7b86e4cd6c..a3f9780f3f 100644
--- a/src/core/ext/filters/max_age/max_age_filter.cc
+++ b/src/core/ext/filters/max_age/max_age_filter.cc
@@ -37,6 +37,12 @@
 #define MAX_CONNECTION_IDLE_INTEGER_OPTIONS \
   { DEFAULT_MAX_CONNECTION_IDLE_MS, 1, INT_MAX }
 
+/* States for idle_state in channel_data */
+#define MAX_IDLE_STATE_INIT ((gpr_atm)0)
+#define MAX_IDLE_STATE_SEEN_EXIT_IDLE ((gpr_atm)1)
+#define MAX_IDLE_STATE_SEEN_ENTER_IDLE ((gpr_atm)2)
+#define MAX_IDLE_STATE_TIMER_SET ((gpr_atm)3)
+
 namespace {
 struct channel_data {
   /* We take a reference to the channel stack for the timer callback */
@@ -64,7 +70,7 @@ struct channel_data {
   grpc_millis max_connection_age_grace;
   /* Closure to run when the channel's idle duration reaches max_connection_idle
      and should be closed gracefully */
-  grpc_closure close_max_idle_channel;
+  grpc_closure max_idle_timer_cb;
   /* Closure to run when the channel reaches its max age and should be closed
      gracefully */
   grpc_closure close_max_age_channel;
@@ -85,26 +91,117 @@ struct channel_data {
   grpc_connectivity_state connectivity_state;
   /* Number of active calls */
   gpr_atm call_count;
+  /* TODO(zyc): C++lize this state machine */
+  /* 'idle_state' holds the states of max_idle_timer and channel idleness.
+      It can contain one of the following values:
+     +--------------------------------+----------------+---------+
+     |           idle_state           | max_idle_timer | channel |
+     +--------------------------------+----------------+---------+
+     | MAX_IDLE_STATE_INIT            | unset          | busy    |
+     | MAX_IDLE_STATE_TIMER_SET       | set, valid     | idle    |
+     | MAX_IDLE_STATE_SEEN_EXIT_IDLE  | set, invalid   | busy    |
+     | MAX_IDLE_STATE_SEEN_ENTER_IDLE | set, invalid   | idle    |
+     +--------------------------------+----------------+---------+
+
+     MAX_IDLE_STATE_INIT: The initial and final state of 'idle_state'. The
+     channel has 1 or 1+ active calls, and the the timer is not set. Note that
+     we may put a virtual call to hold this state at channel initialization or
+     shutdown, so that the channel won't enter other states.
+
+     MAX_IDLE_STATE_TIMER_SET: The state after the timer is set and no calls
+     have arrived after the timer is set. The channel must have 0 active call in
+     this state. If the timer is fired in this state, we will close the channel
+     due to idleness.
+
+     MAX_IDLE_STATE_SEEN_EXIT_IDLE: The state after the timer is set and at
+     least one call has arrived after the timer is set. The channel must have 1
+     or 1+ active calls in this state. If the timer is fired in this state, we
+     won't reschudle it.
+
+     MAX_IDLE_STATE_SEEN_ENTER_IDLE: The state after the timer is set and the at
+     least one call has arrived after the timer is set, BUT the channel
+     currently has 1 or 1+ active calls. If the timer is fired in this state, we
+     will reschudle it.
+
+     max_idle_timer will not be cancelled (unless the channel is shutting down).
+     If the timer callback is called when the max_idle_timer is valid (i.e.
+     idle_state is MAX_IDLE_STATE_TIMER_SET), the channel will be closed due to
+     idleness, otherwise the channel won't be changed.
+
+     State transitions:
+         MAX_IDLE_STATE_INIT <-------3------ MAX_IDLE_STATE_SEEN_EXIT_IDLE
+              ^    |                              ^     ^    |
+              |    |                              |     |    |
+              1    2     +-----------4------------+     6    7
+              |    |     |                              |    |
+              |    v     |                              |    v
+       MAX_IDLE_STATE_TIMER_SET <----5------ MAX_IDLE_STATE_SEEN_ENTER_IDLE
+
+     For 1, 3, 5 :  See max_idle_timer_cb() function
+     For 2, 7    :  See decrease_call_count() function
+     For 4, 6    :  See increase_call_count() function */
+  gpr_atm idle_state;
+  /* Time when the channel finished its last outstanding call, in grpc_millis */
+  gpr_atm last_enter_idle_time_millis;
 };
 }  // namespace
 
 /* Increase the nubmer of active calls. Before the increasement, if there are no
    calls, the max_idle_timer should be cancelled. */
 static void increase_call_count(channel_data* chand) {
+  /* Exit idle */
   if (gpr_atm_full_fetch_add(&chand->call_count, 1) == 0) {
-    grpc_timer_cancel(&chand->max_idle_timer);
+    while (true) {
+      gpr_atm idle_state = gpr_atm_acq_load(&chand->idle_state);
+      switch (idle_state) {
+        case MAX_IDLE_STATE_TIMER_SET:
+          /* max_idle_timer_cb may have already set idle_state to
+             MAX_IDLE_STATE_INIT, in this case, we don't need to set it to
+             MAX_IDLE_STATE_SEEN_EXIT_IDLE */
+          gpr_atm_rel_cas(&chand->idle_state, MAX_IDLE_STATE_TIMER_SET,
+                          MAX_IDLE_STATE_SEEN_EXIT_IDLE);
+          return;
+        case MAX_IDLE_STATE_SEEN_ENTER_IDLE:
+          gpr_atm_rel_store(&chand->idle_state, MAX_IDLE_STATE_SEEN_EXIT_IDLE);
+          return;
+        default:
+          /* try again */
+          break;
+      }
+    }
   }
 }
 
 /* Decrease the nubmer of active calls. After the decrement, if there are no
    calls, the max_idle_timer should be started. */
 static void decrease_call_count(channel_data* chand) {
+  /* Enter idle */
   if (gpr_atm_full_fetch_add(&chand->call_count, -1) == 1) {
-    GRPC_CHANNEL_STACK_REF(chand->channel_stack, "max_age max_idle_timer");
-    grpc_timer_init(
-        &chand->max_idle_timer,
-        grpc_core::ExecCtx::Get()->Now() + chand->max_connection_idle,
-        &chand->close_max_idle_channel);
+    gpr_atm_no_barrier_store(&chand->last_enter_idle_time_millis,
+                             (gpr_atm)grpc_core::ExecCtx::Get()->Now());
+    while (true) {
+      gpr_atm idle_state = gpr_atm_acq_load(&chand->idle_state);
+      switch (idle_state) {
+        case MAX_IDLE_STATE_INIT:
+          GRPC_CHANNEL_STACK_REF(chand->channel_stack,
+                                 "max_age max_idle_timer");
+          grpc_timer_init(
+              &chand->max_idle_timer,
+              grpc_core::ExecCtx::Get()->Now() + chand->max_connection_idle,
+              &chand->max_idle_timer_cb);
+          gpr_atm_rel_store(&chand->idle_state, MAX_IDLE_STATE_TIMER_SET);
+          return;
+        case MAX_IDLE_STATE_SEEN_EXIT_IDLE:
+          if (gpr_atm_rel_cas(&chand->idle_state, MAX_IDLE_STATE_SEEN_EXIT_IDLE,
+                              MAX_IDLE_STATE_SEEN_ENTER_IDLE)) {
+            return;
+          }
+          break;
+        default:
+          /* try again */
+          break;
+      }
+    }
   }
 }
 
@@ -152,20 +249,58 @@ static void start_max_age_grace_timer_after_goaway_op(void* arg,
                            "max_age start_max_age_grace_timer_after_goaway_op");
 }
 
-static void close_max_idle_channel(void* arg, grpc_error* error) {
+static void close_max_idle_channel(channel_data* chand) {
+  /* Prevent the max idle timer from being set again */
+  gpr_atm_no_barrier_fetch_add(&chand->call_count, 1);
+  grpc_transport_op* op = grpc_make_transport_op(nullptr);
+  op->goaway_error =
+      grpc_error_set_int(GRPC_ERROR_CREATE_FROM_STATIC_STRING("max_idle"),
+                         GRPC_ERROR_INT_HTTP2_ERROR, GRPC_HTTP2_NO_ERROR);
+  grpc_channel_element* elem =
+      grpc_channel_stack_element(chand->channel_stack, 0);
+  elem->filter->start_transport_op(elem, op);
+}
+
+static void max_idle_timer_cb(void* arg, grpc_error* error) {
   channel_data* chand = (channel_data*)arg;
   if (error == GRPC_ERROR_NONE) {
-    /* Prevent the max idle timer from being set again */
-    gpr_atm_no_barrier_fetch_add(&chand->call_count, 1);
-    grpc_transport_op* op = grpc_make_transport_op(nullptr);
-    op->goaway_error =
-        grpc_error_set_int(GRPC_ERROR_CREATE_FROM_STATIC_STRING("max_idle"),
-                           GRPC_ERROR_INT_HTTP2_ERROR, GRPC_HTTP2_NO_ERROR);
-    grpc_channel_element* elem =
-        grpc_channel_stack_element(chand->channel_stack, 0);
-    elem->filter->start_transport_op(elem, op);
-  } else if (error != GRPC_ERROR_CANCELLED) {
-    GRPC_LOG_IF_ERROR("close_max_idle_channel", error);
+    bool try_again = true;
+    while (try_again) {
+      gpr_atm idle_state = gpr_atm_acq_load(&chand->idle_state);
+      switch (idle_state) {
+        case MAX_IDLE_STATE_TIMER_SET:
+          close_max_idle_channel(chand);
+          /* This MAX_IDLE_STATE_INIT is a final state, we don't have to check
+           * if idle_state has been changed */
+          gpr_atm_rel_store(&chand->idle_state, MAX_IDLE_STATE_INIT);
+          try_again = false;
+          break;
+        case MAX_IDLE_STATE_SEEN_EXIT_IDLE:
+          if (gpr_atm_rel_cas(&chand->idle_state, MAX_IDLE_STATE_SEEN_EXIT_IDLE,
+                              MAX_IDLE_STATE_INIT)) {
+            try_again = false;
+          }
+          break;
+        case MAX_IDLE_STATE_SEEN_ENTER_IDLE:
+          GRPC_CHANNEL_STACK_REF(chand->channel_stack,
+                                 "max_age max_idle_timer");
+          grpc_timer_init(&chand->max_idle_timer,
+                          (grpc_millis)gpr_atm_no_barrier_load(
+                              &chand->last_enter_idle_time_millis) +
+                              chand->max_connection_idle,
+                          &chand->max_idle_timer_cb);
+          /* idle_state may have already been set to
+             MAX_IDLE_STATE_SEEN_EXIT_IDLE by increase_call_count(), in this
+             case, we don't need to set it to MAX_IDLE_STATE_TIMER_SET */
+          gpr_atm_rel_cas(&chand->idle_state, MAX_IDLE_STATE_SEEN_ENTER_IDLE,
+                          MAX_IDLE_STATE_TIMER_SET);
+          try_again = false;
+          break;
+        default:
+          /* try again */
+          break;
+      }
+    }
   }
   GRPC_CHANNEL_STACK_UNREF(chand->channel_stack, "max_age max_idle_timer");
 }
@@ -288,6 +423,9 @@ static grpc_error* init_channel_elem(grpc_channel_element* elem,
   chand->max_connection_idle = DEFAULT_MAX_CONNECTION_IDLE_MS == INT_MAX
                                    ? GRPC_MILLIS_INF_FUTURE
                                    : DEFAULT_MAX_CONNECTION_IDLE_MS;
+  chand->idle_state = MAX_IDLE_STATE_INIT;
+  gpr_atm_no_barrier_store(&chand->last_enter_idle_time_millis,
+                           GRPC_MILLIS_INF_PAST);
   for (size_t i = 0; i < args->channel_args->num_args; ++i) {
     if (0 == strcmp(args->channel_args->args[i].key,
                     GRPC_ARG_MAX_CONNECTION_AGE_MS)) {
@@ -311,8 +449,8 @@ static grpc_error* init_channel_elem(grpc_channel_element* elem,
           value == INT_MAX ? GRPC_MILLIS_INF_FUTURE : value;
     }
   }
-  GRPC_CLOSURE_INIT(&chand->close_max_idle_channel, close_max_idle_channel,
-                    chand, grpc_schedule_on_exec_ctx);
+  GRPC_CLOSURE_INIT(&chand->max_idle_timer_cb, max_idle_timer_cb, chand,
+                    grpc_schedule_on_exec_ctx);
   GRPC_CLOSURE_INIT(&chand->close_max_age_channel, close_max_age_channel, chand,
                     grpc_schedule_on_exec_ctx);
   GRPC_CLOSURE_INIT(&chand->force_close_max_age_channel,
diff --git a/src/core/lib/compression/compression.cc b/src/core/lib/compression/compression.cc
index 99e6014b23..167e90fd26 100644
--- a/src/core/lib/compression/compression.cc
+++ b/src/core/lib/compression/compression.cc
@@ -29,8 +29,7 @@
 
 int grpc_compression_algorithm_is_message(
     grpc_compression_algorithm algorithm) {
-  return (algorithm >= GRPC_COMPRESS_MESSAGE_DEFLATE &&
-          algorithm <= GRPC_COMPRESS_MESSAGE_GZIP)
+  return (algorithm >= GRPC_COMPRESS_DEFLATE && algorithm <= GRPC_COMPRESS_GZIP)
              ? 1
              : 0;
 }
@@ -44,11 +43,11 @@ int grpc_compression_algorithm_parse(grpc_slice name,
   if (grpc_slice_eq(name, GRPC_MDSTR_IDENTITY)) {
     *algorithm = GRPC_COMPRESS_NONE;
     return 1;
-  } else if (grpc_slice_eq(name, GRPC_MDSTR_MESSAGE_SLASH_DEFLATE)) {
-    *algorithm = GRPC_COMPRESS_MESSAGE_DEFLATE;
+  } else if (grpc_slice_eq(name, GRPC_MDSTR_DEFLATE)) {
+    *algorithm = GRPC_COMPRESS_DEFLATE;
     return 1;
-  } else if (grpc_slice_eq(name, GRPC_MDSTR_MESSAGE_SLASH_GZIP)) {
-    *algorithm = GRPC_COMPRESS_MESSAGE_GZIP;
+  } else if (grpc_slice_eq(name, GRPC_MDSTR_GZIP)) {
+    *algorithm = GRPC_COMPRESS_GZIP;
     return 1;
   } else if (grpc_slice_eq(name, GRPC_MDSTR_STREAM_SLASH_GZIP)) {
     *algorithm = GRPC_COMPRESS_STREAM_GZIP;
@@ -67,11 +66,11 @@ int grpc_compression_algorithm_name(grpc_compression_algorithm algorithm,
     case GRPC_COMPRESS_NONE:
       *name = "identity";
       return 1;
-    case GRPC_COMPRESS_MESSAGE_DEFLATE:
-      *name = "message/deflate";
+    case GRPC_COMPRESS_DEFLATE:
+      *name = "deflate";
       return 1;
-    case GRPC_COMPRESS_MESSAGE_GZIP:
-      *name = "message/gzip";
+    case GRPC_COMPRESS_GZIP:
+      *name = "gzip";
       return 1;
     case GRPC_COMPRESS_STREAM_GZIP:
       *name = "stream/gzip";
@@ -133,10 +132,10 @@ grpc_slice grpc_compression_algorithm_slice(
   switch (algorithm) {
     case GRPC_COMPRESS_NONE:
       return GRPC_MDSTR_IDENTITY;
-    case GRPC_COMPRESS_MESSAGE_DEFLATE:
-      return GRPC_MDSTR_MESSAGE_SLASH_DEFLATE;
-    case GRPC_COMPRESS_MESSAGE_GZIP:
-      return GRPC_MDSTR_MESSAGE_SLASH_GZIP;
+    case GRPC_COMPRESS_DEFLATE:
+      return GRPC_MDSTR_DEFLATE;
+    case GRPC_COMPRESS_GZIP:
+      return GRPC_MDSTR_GZIP;
     case GRPC_COMPRESS_STREAM_GZIP:
       return GRPC_MDSTR_STREAM_SLASH_GZIP;
     case GRPC_COMPRESS_ALGORITHMS_COUNT:
@@ -148,10 +147,8 @@ grpc_slice grpc_compression_algorithm_slice(
 grpc_compression_algorithm grpc_compression_algorithm_from_slice(
     grpc_slice str) {
   if (grpc_slice_eq(str, GRPC_MDSTR_IDENTITY)) return GRPC_COMPRESS_NONE;
-  if (grpc_slice_eq(str, GRPC_MDSTR_MESSAGE_SLASH_DEFLATE))
-    return GRPC_COMPRESS_MESSAGE_DEFLATE;
-  if (grpc_slice_eq(str, GRPC_MDSTR_MESSAGE_SLASH_GZIP))
-    return GRPC_COMPRESS_MESSAGE_GZIP;
+  if (grpc_slice_eq(str, GRPC_MDSTR_DEFLATE)) return GRPC_COMPRESS_DEFLATE;
+  if (grpc_slice_eq(str, GRPC_MDSTR_GZIP)) return GRPC_COMPRESS_GZIP;
   if (grpc_slice_eq(str, GRPC_MDSTR_STREAM_SLASH_GZIP))
     return GRPC_COMPRESS_STREAM_GZIP;
   return GRPC_COMPRESS_ALGORITHMS_COUNT;
@@ -162,9 +159,9 @@ grpc_mdelem grpc_compression_encoding_mdelem(
   switch (algorithm) {
     case GRPC_COMPRESS_NONE:
       return GRPC_MDELEM_GRPC_ENCODING_IDENTITY;
-    case GRPC_COMPRESS_MESSAGE_DEFLATE:
+    case GRPC_COMPRESS_DEFLATE:
       return GRPC_MDELEM_GRPC_ENCODING_DEFLATE;
-    case GRPC_COMPRESS_MESSAGE_GZIP:
+    case GRPC_COMPRESS_GZIP:
       return GRPC_MDELEM_GRPC_ENCODING_GZIP;
     case GRPC_COMPRESS_STREAM_GZIP:
       return GRPC_MDELEM_GRPC_ENCODING_GZIP;
diff --git a/src/core/lib/compression/compression_internal.cc b/src/core/lib/compression/compression_internal.cc
index 263cdf06eb..1b7ead3301 100644
--- a/src/core/lib/compression/compression_internal.cc
+++ b/src/core/lib/compression/compression_internal.cc
@@ -80,9 +80,9 @@ grpc_message_compression_algorithm
 grpc_compression_algorithm_to_message_compression_algorithm(
     grpc_compression_algorithm algo) {
   switch (algo) {
-    case GRPC_COMPRESS_MESSAGE_DEFLATE:
+    case GRPC_COMPRESS_DEFLATE:
       return GRPC_MESSAGE_COMPRESS_DEFLATE;
-    case GRPC_COMPRESS_MESSAGE_GZIP:
+    case GRPC_COMPRESS_GZIP:
       return GRPC_MESSAGE_COMPRESS_GZIP;
     default:
       return GRPC_MESSAGE_COMPRESS_NONE;
@@ -147,10 +147,10 @@ int grpc_compression_algorithm_from_message_stream_compression_algorithm(
         *algorithm = GRPC_COMPRESS_NONE;
         return 1;
       case GRPC_MESSAGE_COMPRESS_DEFLATE:
-        *algorithm = GRPC_COMPRESS_MESSAGE_DEFLATE;
+        *algorithm = GRPC_COMPRESS_DEFLATE;
         return 1;
       case GRPC_MESSAGE_COMPRESS_GZIP:
-        *algorithm = GRPC_COMPRESS_MESSAGE_GZIP;
+        *algorithm = GRPC_COMPRESS_GZIP;
         return 1;
       default:
         *algorithm = GRPC_COMPRESS_NONE;
diff --git a/src/core/lib/compression/compression_ruby.cc b/src/core/lib/compression/compression_ruby.cc
deleted file mode 100644
index 293062f5ed..0000000000
--- a/src/core/lib/compression/compression_ruby.cc
+++ /dev/null
@@ -1,66 +0,0 @@
-/*
- *
- * Copyright 2017 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#include <grpc/compression_ruby.h>
-#include <grpc/support/useful.h>
-
-#include "src/core/lib/surface/api_trace.h"
-#include "src/core/lib/transport/static_metadata.h"
-
-int grpc_compression_algorithm_parse_ruby(
-    grpc_slice name, grpc_compression_algorithm* algorithm) {
-  if (grpc_slice_eq(name, GRPC_MDSTR_IDENTITY)) {
-    *algorithm = GRPC_COMPRESS_NONE;
-    return 1;
-  } else if (grpc_slice_eq(name, GRPC_MDSTR_DEFLATE)) {
-    *algorithm = GRPC_COMPRESS_MESSAGE_DEFLATE;
-    return 1;
-  } else if (grpc_slice_eq(name, GRPC_MDSTR_GZIP)) {
-    *algorithm = GRPC_COMPRESS_MESSAGE_GZIP;
-    return 1;
-  } else if (grpc_slice_eq(name, GRPC_MDSTR_STREAM_SLASH_GZIP)) {
-    *algorithm = GRPC_COMPRESS_STREAM_GZIP;
-    return 1;
-  } else {
-    return 0;
-  }
-  return 0;
-}
-
-int grpc_compression_algorithm_name_ruby(grpc_compression_algorithm algorithm,
-                                         const char** name) {
-  GRPC_API_TRACE("grpc_compression_algorithm_parse(algorithm=%d, name=%p)", 2,
-                 ((int)algorithm, name));
-  switch (algorithm) {
-    case GRPC_COMPRESS_NONE:
-      *name = "identity";
-      return 1;
-    case GRPC_COMPRESS_MESSAGE_DEFLATE:
-      *name = "deflate";
-      return 1;
-    case GRPC_COMPRESS_MESSAGE_GZIP:
-      *name = "gzip";
-      return 1;
-    case GRPC_COMPRESS_STREAM_GZIP:
-      *name = "stream/gzip";
-      return 1;
-    case GRPC_COMPRESS_ALGORITHMS_COUNT:
-      return 0;
-  }
-  return 0;
-}
diff --git a/src/core/lib/gpr/env.h b/src/core/lib/gpr/env.h
index 7f35104be3..b31e20b7d2 100644
--- a/src/core/lib/gpr/env.h
+++ b/src/core/lib/gpr/env.h
@@ -29,7 +29,7 @@
    variable exists). */
 char* gpr_getenv(const char* name);
 
-/* Sets the the environment with the specified name to the specified value. */
+/* Sets the environment with the specified name to the specified value. */
 void gpr_setenv(const char* name, const char* value);
 
 /* This is a version of gpr_getenv that does not produce any output if it has to
diff --git a/src/core/lib/gprpp/orphanable.h b/src/core/lib/gprpp/orphanable.h
index 50199730c9..78d1b01ff8 100644
--- a/src/core/lib/gprpp/orphanable.h
+++ b/src/core/lib/gprpp/orphanable.h
@@ -28,6 +28,7 @@
 #include "src/core/lib/gprpp/abstract.h"
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/memory.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
 
 namespace grpc_core {
 
@@ -69,6 +70,7 @@ inline OrphanablePtr<T> MakeOrphanable(Args&&... args) {
 }
 
 // A type of Orphanable with internal ref-counting.
+template <typename Child>
 class InternallyRefCounted : public Orphanable {
  public:
   // Not copyable nor movable.
@@ -78,10 +80,20 @@ class InternallyRefCounted : public Orphanable {
   GRPC_ABSTRACT_BASE_CLASS
 
  protected:
+  // Allow Delete() to access destructor.
+  template <typename T>
+  friend void Delete(T*);
+
+  // Allow RefCountedPtr<> to access Unref() and IncrementRefCount().
+  friend class RefCountedPtr<Child>;
+
   InternallyRefCounted() { gpr_ref_init(&refs_, 1); }
   virtual ~InternallyRefCounted() {}
 
-  void Ref() { gpr_ref(&refs_); }
+  RefCountedPtr<Child> Ref() GRPC_MUST_USE_RESULT {
+    IncrementRefCount();
+    return RefCountedPtr<Child>(static_cast<Child*>(this));
+  }
 
   void Unref() {
     if (gpr_unref(&refs_)) {
@@ -89,11 +101,9 @@ class InternallyRefCounted : public Orphanable {
     }
   }
 
-  // Allow Delete() to access destructor.
-  template <typename T>
-  friend void Delete(T*);
-
  private:
+  void IncrementRefCount() { gpr_ref(&refs_); }
+
   gpr_refcount refs_;
 };
 
@@ -103,6 +113,7 @@ class InternallyRefCounted : public Orphanable {
 // pointers and legacy code that is manually calling Ref() and Unref().
 // Once all of our code is converted to idiomatic C++, we may be able to
 // eliminate this class.
+template <typename Child>
 class InternallyRefCountedWithTracing : public Orphanable {
  public:
   // Not copyable nor movable.
@@ -118,6 +129,9 @@ class InternallyRefCountedWithTracing : public Orphanable {
   template <typename T>
   friend void Delete(T*);
 
+  // Allow RefCountedPtr<> to access Unref() and IncrementRefCount().
+  friend class RefCountedPtr<Child>;
+
   InternallyRefCountedWithTracing()
       : InternallyRefCountedWithTracing(static_cast<TraceFlag*>(nullptr)) {}
 
@@ -133,18 +147,27 @@ class InternallyRefCountedWithTracing : public Orphanable {
 
   virtual ~InternallyRefCountedWithTracing() {}
 
-  void Ref() { gpr_ref(&refs_); }
+  RefCountedPtr<Child> Ref() GRPC_MUST_USE_RESULT {
+    IncrementRefCount();
+    return RefCountedPtr<Child>(static_cast<Child*>(this));
+  }
 
-  void Ref(const DebugLocation& location, const char* reason) {
+  RefCountedPtr<Child> Ref(const DebugLocation& location,
+                           const char* reason) GRPC_MUST_USE_RESULT {
     if (location.Log() && trace_flag_ != nullptr && trace_flag_->enabled()) {
       gpr_atm old_refs = gpr_atm_no_barrier_load(&refs_.count);
       gpr_log(GPR_DEBUG, "%s:%p %s:%d ref %" PRIdPTR " -> %" PRIdPTR " %s",
               trace_flag_->name(), this, location.file(), location.line(),
               old_refs, old_refs + 1, reason);
     }
-    Ref();
+    return Ref();
   }
 
+  // TODO(roth): Once all of our code is converted to C++ and can use
+  // RefCountedPtr<> instead of manual ref-counting, make the Unref() methods
+  // private, since they will only be used by RefCountedPtr<>, which is a
+  // friend of this class.
+
   void Unref() {
     if (gpr_unref(&refs_)) {
       Delete(this);
@@ -162,6 +185,8 @@ class InternallyRefCountedWithTracing : public Orphanable {
   }
 
  private:
+  void IncrementRefCount() { gpr_ref(&refs_); }
+
   TraceFlag* trace_flag_ = nullptr;
   gpr_refcount refs_;
 };
diff --git a/src/core/lib/gprpp/ref_counted.h b/src/core/lib/gprpp/ref_counted.h
index c68118a71a..ab589fc01a 100644
--- a/src/core/lib/gprpp/ref_counted.h
+++ b/src/core/lib/gprpp/ref_counted.h
@@ -26,16 +26,28 @@
 #include "src/core/lib/gprpp/abstract.h"
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/memory.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
 
 namespace grpc_core {
 
 // A base class for reference-counted objects.
 // New objects should be created via New() and start with a refcount of 1.
 // When the refcount reaches 0, the object will be deleted via Delete().
+//
+// This will commonly be used by CRTP (curiously-recurring template pattern)
+// e.g., class MyClass : public RefCounted<MyClass>
+template <typename Child>
 class RefCounted {
  public:
-  void Ref() { gpr_ref(&refs_); }
+  RefCountedPtr<Child> Ref() GRPC_MUST_USE_RESULT {
+    IncrementRefCount();
+    return RefCountedPtr<Child>(static_cast<Child*>(this));
+  }
 
+  // TODO(roth): Once all of our code is converted to C++ and can use
+  // RefCountedPtr<> instead of manual ref-counting, make this method
+  // private, since it will only be used by RefCountedPtr<>, which is a
+  // friend of this class.
   void Unref() {
     if (gpr_unref(&refs_)) {
       Delete(this);
@@ -58,6 +70,11 @@ class RefCounted {
   virtual ~RefCounted() {}
 
  private:
+  // Allow RefCountedPtr<> to access IncrementRefCount().
+  friend class RefCountedPtr<Child>;
+
+  void IncrementRefCount() { gpr_ref(&refs_); }
+
   gpr_refcount refs_;
 };
 
@@ -67,20 +84,30 @@ class RefCounted {
 // pointers and legacy code that is manually calling Ref() and Unref().
 // Once all of our code is converted to idiomatic C++, we may be able to
 // eliminate this class.
+template <typename Child>
 class RefCountedWithTracing {
  public:
-  void Ref() { gpr_ref(&refs_); }
+  RefCountedPtr<Child> Ref() GRPC_MUST_USE_RESULT {
+    IncrementRefCount();
+    return RefCountedPtr<Child>(static_cast<Child*>(this));
+  }
 
-  void Ref(const DebugLocation& location, const char* reason) {
+  RefCountedPtr<Child> Ref(const DebugLocation& location,
+                           const char* reason) GRPC_MUST_USE_RESULT {
     if (location.Log() && trace_flag_ != nullptr && trace_flag_->enabled()) {
       gpr_atm old_refs = gpr_atm_no_barrier_load(&refs_.count);
       gpr_log(GPR_DEBUG, "%s:%p %s:%d ref %" PRIdPTR " -> %" PRIdPTR " %s",
               trace_flag_->name(), this, location.file(), location.line(),
               old_refs, old_refs + 1, reason);
     }
-    Ref();
+    return Ref();
   }
 
+  // TODO(roth): Once all of our code is converted to C++ and can use
+  // RefCountedPtr<> instead of manual ref-counting, make the Unref() methods
+  // private, since they will only be used by RefCountedPtr<>, which is a
+  // friend of this class.
+
   void Unref() {
     if (gpr_unref(&refs_)) {
       Delete(this);
@@ -124,6 +151,11 @@ class RefCountedWithTracing {
   virtual ~RefCountedWithTracing() {}
 
  private:
+  // Allow RefCountedPtr<> to access IncrementRefCount().
+  friend class RefCountedPtr<Child>;
+
+  void IncrementRefCount() { gpr_ref(&refs_); }
+
   TraceFlag* trace_flag_ = nullptr;
   gpr_refcount refs_;
 };
diff --git a/src/core/lib/gprpp/ref_counted_ptr.h b/src/core/lib/gprpp/ref_counted_ptr.h
index dda0f00d79..f82ba50da3 100644
--- a/src/core/lib/gprpp/ref_counted_ptr.h
+++ b/src/core/lib/gprpp/ref_counted_ptr.h
@@ -25,8 +25,8 @@
 
 namespace grpc_core {
 
-// A smart pointer class for objects that provide Ref() and Unref() methods,
-// such as those provided by the RefCounted base class.
+// A smart pointer class for objects that provide IncrementRefCount() and
+// Unref() methods, such as those provided by the RefCounted base class.
 template <typename T>
 class RefCountedPtr {
  public:
@@ -49,13 +49,13 @@ class RefCountedPtr {
 
   // Copy support.
   RefCountedPtr(const RefCountedPtr& other) {
-    if (other.value_ != nullptr) other.value_->Ref();
+    if (other.value_ != nullptr) other.value_->IncrementRefCount();
     value_ = other.value_;
   }
   RefCountedPtr& operator=(const RefCountedPtr& other) {
     // Note: Order of reffing and unreffing is important here in case value_
     // and other.value_ are the same object.
-    if (other.value_ != nullptr) other.value_->Ref();
+    if (other.value_ != nullptr) other.value_->IncrementRefCount();
     if (value_ != nullptr) value_->Unref();
     value_ = other.value_;
     return *this;
@@ -71,6 +71,16 @@ class RefCountedPtr {
     value_ = value;
   }
 
+  // TODO(roth): This method exists solely as a transition mechanism to allow
+  // us to pass a ref to idiomatic C code that does not use RefCountedPtr<>.
+  // Once all of our code has been converted to idiomatic C++, this
+  // method should go away.
+  T* release() {
+    T* value = value_;
+    value_ = nullptr;
+    return value;
+  }
+
   T* get() const { return value_; }
 
   T& operator*() const { return *value_; }
diff --git a/src/core/lib/iomgr/ev_epollex_linux.cc b/src/core/lib/iomgr/ev_epollex_linux.cc
index 178ebd8977..30c7a89824 100644
--- a/src/core/lib/iomgr/ev_epollex_linux.cc
+++ b/src/core/lib/iomgr/ev_epollex_linux.cc
@@ -57,7 +57,7 @@
 //#define GRPC_EPOLLEX_CREATE_WORKERS_ON_HEAP 1
 
 #define MAX_EPOLL_EVENTS 100
-#define MAX_EPOLL_EVENTS_HANDLED_EACH_POLL_CALL 5
+#define MAX_EPOLL_EVENTS_HANDLED_EACH_POLL_CALL 1
 
 grpc_core::DebugOnlyTraceFlag grpc_trace_pollable_refcount(false,
                                                            "pollable_refcount");
@@ -1452,10 +1452,6 @@ static const grpc_event_engine_vtable vtable = {
 
 const grpc_event_engine_vtable* grpc_init_epollex_linux(
     bool explicitly_requested) {
-  if (!explicitly_requested) {
-    return nullptr;
-  }
-
   if (!grpc_has_wakeup_fd()) {
     gpr_log(GPR_ERROR, "Skipping epollex because of no wakeup fd.");
     return nullptr;
diff --git a/src/core/lib/iomgr/ev_poll_posix.cc b/src/core/lib/iomgr/ev_poll_posix.cc
index ad92a93beb..8ccc256222 100644
--- a/src/core/lib/iomgr/ev_poll_posix.cc
+++ b/src/core/lib/iomgr/ev_poll_posix.cc
@@ -457,16 +457,20 @@ static grpc_error* fd_shutdown_error(grpc_fd* fd) {
   if (!fd->shutdown) {
     return GRPC_ERROR_NONE;
   } else {
-    return GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
-        "FD shutdown", &fd->shutdown_error, 1);
+    return grpc_error_set_int(GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
+                                  "FD shutdown", &fd->shutdown_error, 1),
+                              GRPC_ERROR_INT_GRPC_STATUS,
+                              GRPC_STATUS_UNAVAILABLE);
   }
 }
 
 static void notify_on_locked(grpc_fd* fd, grpc_closure** st,
                              grpc_closure* closure) {
   if (fd->shutdown || gpr_atm_no_barrier_load(&fd->pollhup)) {
-    GRPC_CLOSURE_SCHED(closure,
-                       GRPC_ERROR_CREATE_FROM_STATIC_STRING("FD shutdown"));
+    GRPC_CLOSURE_SCHED(
+        closure, grpc_error_set_int(
+                     GRPC_ERROR_CREATE_FROM_STATIC_STRING("FD shutdown"),
+                     GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_UNAVAILABLE));
   } else if (*st == CLOSURE_NOT_READY) {
     /* not ready ==> switch to a waiting state by setting the closure */
     *st = closure;
diff --git a/src/core/lib/security/transport/client_auth_filter.cc b/src/core/lib/security/transport/client_auth_filter.cc
index 16814d2598..802503c868 100644
--- a/src/core/lib/security/transport/client_auth_filter.cc
+++ b/src/core/lib/security/transport/client_auth_filter.cc
@@ -118,6 +118,7 @@ static void on_credentials_metadata(void* arg, grpc_error* input_error) {
     grpc_transport_stream_op_batch_finish_with_failure(batch, error,
                                                        calld->call_combiner);
   }
+  GRPC_CALL_STACK_UNREF(calld->owning_call, "get_request_metadata");
 }
 
 void grpc_auth_metadata_context_build(
@@ -208,7 +209,7 @@ static void send_security_metadata(grpc_call_element* elem,
       chand->auth_context, &calld->auth_md_context);
 
   GPR_ASSERT(calld->pollent != nullptr);
-
+  GRPC_CALL_STACK_REF(calld->owning_call, "get_request_metadata");
   GRPC_CLOSURE_INIT(&calld->async_result_closure, on_credentials_metadata,
                     batch, grpc_schedule_on_exec_ctx);
   grpc_error* error = GRPC_ERROR_NONE;
@@ -250,6 +251,7 @@ static void on_host_checked(void* arg, grpc_error* error) {
         calld->call_combiner);
     gpr_free(error_msg);
   }
+  GRPC_CALL_STACK_UNREF(calld->owning_call, "check_call_host");
 }
 
 static void cancel_check_call_host(void* arg, grpc_error* error) {
@@ -312,6 +314,7 @@ static void auth_start_transport_stream_op_batch(
     }
     if (calld->have_host) {
       batch->handler_private.extra_arg = elem;
+      GRPC_CALL_STACK_REF(calld->owning_call, "check_call_host");
       GRPC_CLOSURE_INIT(&calld->async_result_closure, on_host_checked, batch,
                         grpc_schedule_on_exec_ctx);
       char* call_host = grpc_slice_to_c_string(calld->host);
diff --git a/src/core/lib/surface/call.cc b/src/core/lib/surface/call.cc
index f2096d8937..b538cc0212 100644
--- a/src/core/lib/surface/call.cc
+++ b/src/core/lib/surface/call.cc
@@ -1032,6 +1032,7 @@ static grpc_stream_compression_algorithm decode_stream_compression(
 static void publish_app_metadata(grpc_call* call, grpc_metadata_batch* b,
                                  int is_trailing) {
   if (b->list.count == 0) return;
+  if (is_trailing && call->buffered_metadata[1] == nullptr) return;
   GPR_TIMER_SCOPE("publish_app_metadata", 0);
   grpc_metadata_array* dest;
   grpc_metadata* mdusr;
diff --git a/src/core/lib/surface/version.cc b/src/core/lib/surface/version.cc
index 153b6e0297..51daad0368 100644
--- a/src/core/lib/surface/version.cc
+++ b/src/core/lib/surface/version.cc
@@ -23,4 +23,4 @@
 
 const char* grpc_version_string(void) { return "6.0.0-dev"; }
 
-const char* grpc_g_stands_for(void) { return "glossy"; }
+const char* grpc_g_stands_for(void) { return "glamorous"; }
diff --git a/src/core/lib/transport/static_metadata.cc b/src/core/lib/transport/static_metadata.cc
index 82ba7ac51a..ebc75724cf 100644
--- a/src/core/lib/transport/static_metadata.cc
+++ b/src/core/lib/transport/static_metadata.cc
@@ -20,7 +20,7 @@
  * To make changes to this file, change
  * tools/codegen/core/gen_static_metadata.py, and then re-run it.
  *
- * See metadata.h for an explanation of the interface here, and metadata.c for
+ * See metadata.h for an explanation of the interface here, and metadata.cc for
  * an explanation of what's going on.
  */
 
@@ -57,53 +57,52 @@ static uint8_t g_bytes[] = {
     112, 111, 110, 115, 101, 95,  109, 101, 115, 115, 97,  103, 101, 95,  98,
     121, 116, 101, 115, 47,  103, 114, 112, 99,  46,  108, 98,  46,  118, 49,
     46,  76,  111, 97,  100, 66,  97,  108, 97,  110, 99,  101, 114, 47,  66,
-    97,  108, 97,  110, 99,  101, 76,  111, 97,  100, 109, 101, 115, 115, 97,
-    103, 101, 47,  100, 101, 102, 108, 97,  116, 101, 109, 101, 115, 115, 97,
-    103, 101, 47,  103, 122, 105, 112, 115, 116, 114, 101, 97,  109, 47,  103,
-    122, 105, 112, 48,  49,  50,  105, 100, 101, 110, 116, 105, 116, 121, 103,
-    122, 105, 112, 100, 101, 102, 108, 97,  116, 101, 116, 114, 97,  105, 108,
-    101, 114, 115, 97,  112, 112, 108, 105, 99,  97,  116, 105, 111, 110, 47,
-    103, 114, 112, 99,  80,  79,  83,  84,  50,  48,  48,  52,  48,  52,  104,
-    116, 116, 112, 104, 116, 116, 112, 115, 103, 114, 112, 99,  71,  69,  84,
-    80,  85,  84,  47,  47,  105, 110, 100, 101, 120, 46,  104, 116, 109, 108,
-    50,  48,  52,  50,  48,  54,  51,  48,  52,  52,  48,  48,  53,  48,  48,
-    97,  99,  99,  101, 112, 116, 45,  99,  104, 97,  114, 115, 101, 116, 103,
-    122, 105, 112, 44,  32,  100, 101, 102, 108, 97,  116, 101, 97,  99,  99,
-    101, 112, 116, 45,  108, 97,  110, 103, 117, 97,  103, 101, 97,  99,  99,
-    101, 112, 116, 45,  114, 97,  110, 103, 101, 115, 97,  99,  99,  101, 112,
-    116, 97,  99,  99,  101, 115, 115, 45,  99,  111, 110, 116, 114, 111, 108,
-    45,  97,  108, 108, 111, 119, 45,  111, 114, 105, 103, 105, 110, 97,  103,
-    101, 97,  108, 108, 111, 119, 97,  117, 116, 104, 111, 114, 105, 122, 97,
-    116, 105, 111, 110, 99,  97,  99,  104, 101, 45,  99,  111, 110, 116, 114,
-    111, 108, 99,  111, 110, 116, 101, 110, 116, 45,  100, 105, 115, 112, 111,
-    115, 105, 116, 105, 111, 110, 99,  111, 110, 116, 101, 110, 116, 45,  108,
-    97,  110, 103, 117, 97,  103, 101, 99,  111, 110, 116, 101, 110, 116, 45,
-    108, 101, 110, 103, 116, 104, 99,  111, 110, 116, 101, 110, 116, 45,  108,
-    111, 99,  97,  116, 105, 111, 110, 99,  111, 110, 116, 101, 110, 116, 45,
-    114, 97,  110, 103, 101, 99,  111, 111, 107, 105, 101, 100, 97,  116, 101,
-    101, 116, 97,  103, 101, 120, 112, 101, 99,  116, 101, 120, 112, 105, 114,
-    101, 115, 102, 114, 111, 109, 105, 102, 45,  109, 97,  116, 99,  104, 105,
-    102, 45,  109, 111, 100, 105, 102, 105, 101, 100, 45,  115, 105, 110, 99,
-    101, 105, 102, 45,  110, 111, 110, 101, 45,  109, 97,  116, 99,  104, 105,
-    102, 45,  114, 97,  110, 103, 101, 105, 102, 45,  117, 110, 109, 111, 100,
-    105, 102, 105, 101, 100, 45,  115, 105, 110, 99,  101, 108, 97,  115, 116,
-    45,  109, 111, 100, 105, 102, 105, 101, 100, 108, 98,  45,  99,  111, 115,
-    116, 45,  98,  105, 110, 108, 105, 110, 107, 108, 111, 99,  97,  116, 105,
-    111, 110, 109, 97,  120, 45,  102, 111, 114, 119, 97,  114, 100, 115, 112,
-    114, 111, 120, 121, 45,  97,  117, 116, 104, 101, 110, 116, 105, 99,  97,
-    116, 101, 112, 114, 111, 120, 121, 45,  97,  117, 116, 104, 111, 114, 105,
-    122, 97,  116, 105, 111, 110, 114, 97,  110, 103, 101, 114, 101, 102, 101,
-    114, 101, 114, 114, 101, 102, 114, 101, 115, 104, 114, 101, 116, 114, 121,
-    45,  97,  102, 116, 101, 114, 115, 101, 114, 118, 101, 114, 115, 101, 116,
-    45,  99,  111, 111, 107, 105, 101, 115, 116, 114, 105, 99,  116, 45,  116,
-    114, 97,  110, 115, 112, 111, 114, 116, 45,  115, 101, 99,  117, 114, 105,
-    116, 121, 116, 114, 97,  110, 115, 102, 101, 114, 45,  101, 110, 99,  111,
-    100, 105, 110, 103, 118, 97,  114, 121, 118, 105, 97,  119, 119, 119, 45,
-    97,  117, 116, 104, 101, 110, 116, 105, 99,  97,  116, 101, 105, 100, 101,
-    110, 116, 105, 116, 121, 44,  100, 101, 102, 108, 97,  116, 101, 105, 100,
-    101, 110, 116, 105, 116, 121, 44,  103, 122, 105, 112, 100, 101, 102, 108,
-    97,  116, 101, 44,  103, 122, 105, 112, 105, 100, 101, 110, 116, 105, 116,
-    121, 44,  100, 101, 102, 108, 97,  116, 101, 44,  103, 122, 105, 112};
+    97,  108, 97,  110, 99,  101, 76,  111, 97,  100, 100, 101, 102, 108, 97,
+    116, 101, 103, 122, 105, 112, 115, 116, 114, 101, 97,  109, 47,  103, 122,
+    105, 112, 48,  49,  50,  105, 100, 101, 110, 116, 105, 116, 121, 116, 114,
+    97,  105, 108, 101, 114, 115, 97,  112, 112, 108, 105, 99,  97,  116, 105,
+    111, 110, 47,  103, 114, 112, 99,  80,  79,  83,  84,  50,  48,  48,  52,
+    48,  52,  104, 116, 116, 112, 104, 116, 116, 112, 115, 103, 114, 112, 99,
+    71,  69,  84,  80,  85,  84,  47,  47,  105, 110, 100, 101, 120, 46,  104,
+    116, 109, 108, 50,  48,  52,  50,  48,  54,  51,  48,  52,  52,  48,  48,
+    53,  48,  48,  97,  99,  99,  101, 112, 116, 45,  99,  104, 97,  114, 115,
+    101, 116, 103, 122, 105, 112, 44,  32,  100, 101, 102, 108, 97,  116, 101,
+    97,  99,  99,  101, 112, 116, 45,  108, 97,  110, 103, 117, 97,  103, 101,
+    97,  99,  99,  101, 112, 116, 45,  114, 97,  110, 103, 101, 115, 97,  99,
+    99,  101, 112, 116, 97,  99,  99,  101, 115, 115, 45,  99,  111, 110, 116,
+    114, 111, 108, 45,  97,  108, 108, 111, 119, 45,  111, 114, 105, 103, 105,
+    110, 97,  103, 101, 97,  108, 108, 111, 119, 97,  117, 116, 104, 111, 114,
+    105, 122, 97,  116, 105, 111, 110, 99,  97,  99,  104, 101, 45,  99,  111,
+    110, 116, 114, 111, 108, 99,  111, 110, 116, 101, 110, 116, 45,  100, 105,
+    115, 112, 111, 115, 105, 116, 105, 111, 110, 99,  111, 110, 116, 101, 110,
+    116, 45,  108, 97,  110, 103, 117, 97,  103, 101, 99,  111, 110, 116, 101,
+    110, 116, 45,  108, 101, 110, 103, 116, 104, 99,  111, 110, 116, 101, 110,
+    116, 45,  108, 111, 99,  97,  116, 105, 111, 110, 99,  111, 110, 116, 101,
+    110, 116, 45,  114, 97,  110, 103, 101, 99,  111, 111, 107, 105, 101, 100,
+    97,  116, 101, 101, 116, 97,  103, 101, 120, 112, 101, 99,  116, 101, 120,
+    112, 105, 114, 101, 115, 102, 114, 111, 109, 105, 102, 45,  109, 97,  116,
+    99,  104, 105, 102, 45,  109, 111, 100, 105, 102, 105, 101, 100, 45,  115,
+    105, 110, 99,  101, 105, 102, 45,  110, 111, 110, 101, 45,  109, 97,  116,
+    99,  104, 105, 102, 45,  114, 97,  110, 103, 101, 105, 102, 45,  117, 110,
+    109, 111, 100, 105, 102, 105, 101, 100, 45,  115, 105, 110, 99,  101, 108,
+    97,  115, 116, 45,  109, 111, 100, 105, 102, 105, 101, 100, 108, 98,  45,
+    99,  111, 115, 116, 45,  98,  105, 110, 108, 105, 110, 107, 108, 111, 99,
+    97,  116, 105, 111, 110, 109, 97,  120, 45,  102, 111, 114, 119, 97,  114,
+    100, 115, 112, 114, 111, 120, 121, 45,  97,  117, 116, 104, 101, 110, 116,
+    105, 99,  97,  116, 101, 112, 114, 111, 120, 121, 45,  97,  117, 116, 104,
+    111, 114, 105, 122, 97,  116, 105, 111, 110, 114, 97,  110, 103, 101, 114,
+    101, 102, 101, 114, 101, 114, 114, 101, 102, 114, 101, 115, 104, 114, 101,
+    116, 114, 121, 45,  97,  102, 116, 101, 114, 115, 101, 114, 118, 101, 114,
+    115, 101, 116, 45,  99,  111, 111, 107, 105, 101, 115, 116, 114, 105, 99,
+    116, 45,  116, 114, 97,  110, 115, 112, 111, 114, 116, 45,  115, 101, 99,
+    117, 114, 105, 116, 121, 116, 114, 97,  110, 115, 102, 101, 114, 45,  101,
+    110, 99,  111, 100, 105, 110, 103, 118, 97,  114, 121, 118, 105, 97,  119,
+    119, 119, 45,  97,  117, 116, 104, 101, 110, 116, 105, 99,  97,  116, 101,
+    105, 100, 101, 110, 116, 105, 116, 121, 44,  100, 101, 102, 108, 97,  116,
+    101, 105, 100, 101, 110, 116, 105, 116, 121, 44,  103, 122, 105, 112, 100,
+    101, 102, 108, 97,  116, 101, 44,  103, 122, 105, 112, 105, 100, 101, 110,
+    116, 105, 116, 121, 44,  100, 101, 102, 108, 97,  116, 101, 44,  103, 122,
+    105, 112};
 
 static void static_ref(void* unused) {}
 static void static_unref(void* unused) {}
@@ -216,8 +215,6 @@ grpc_slice_refcount grpc_static_metadata_refcounts[GRPC_STATIC_MDSTR_COUNT] = {
     {&grpc_static_metadata_vtable, &static_sub_refcnt},
     {&grpc_static_metadata_vtable, &static_sub_refcnt},
     {&grpc_static_metadata_vtable, &static_sub_refcnt},
-    {&grpc_static_metadata_vtable, &static_sub_refcnt},
-    {&grpc_static_metadata_vtable, &static_sub_refcnt},
 };
 
 const grpc_slice grpc_static_slice_table[GRPC_STATIC_MDSTR_COUNT] = {
@@ -250,80 +247,78 @@ const grpc_slice grpc_static_slice_table[GRPC_STATIC_MDSTR_COUNT] = {
     {&grpc_static_metadata_refcounts[26], {{g_bytes + 333, 30}}},
     {&grpc_static_metadata_refcounts[27], {{g_bytes + 363, 31}}},
     {&grpc_static_metadata_refcounts[28], {{g_bytes + 394, 36}}},
-    {&grpc_static_metadata_refcounts[29], {{g_bytes + 430, 15}}},
-    {&grpc_static_metadata_refcounts[30], {{g_bytes + 445, 12}}},
-    {&grpc_static_metadata_refcounts[31], {{g_bytes + 457, 11}}},
-    {&grpc_static_metadata_refcounts[32], {{g_bytes + 468, 1}}},
-    {&grpc_static_metadata_refcounts[33], {{g_bytes + 469, 1}}},
-    {&grpc_static_metadata_refcounts[34], {{g_bytes + 470, 1}}},
-    {&grpc_static_metadata_refcounts[35], {{g_bytes + 471, 8}}},
-    {&grpc_static_metadata_refcounts[36], {{g_bytes + 479, 4}}},
-    {&grpc_static_metadata_refcounts[37], {{g_bytes + 483, 7}}},
-    {&grpc_static_metadata_refcounts[38], {{g_bytes + 490, 8}}},
-    {&grpc_static_metadata_refcounts[39], {{g_bytes + 498, 16}}},
-    {&grpc_static_metadata_refcounts[40], {{g_bytes + 514, 4}}},
-    {&grpc_static_metadata_refcounts[41], {{g_bytes + 518, 3}}},
-    {&grpc_static_metadata_refcounts[42], {{g_bytes + 521, 3}}},
-    {&grpc_static_metadata_refcounts[43], {{g_bytes + 524, 4}}},
-    {&grpc_static_metadata_refcounts[44], {{g_bytes + 528, 5}}},
-    {&grpc_static_metadata_refcounts[45], {{g_bytes + 533, 4}}},
-    {&grpc_static_metadata_refcounts[46], {{g_bytes + 537, 3}}},
-    {&grpc_static_metadata_refcounts[47], {{g_bytes + 540, 3}}},
-    {&grpc_static_metadata_refcounts[48], {{g_bytes + 543, 1}}},
-    {&grpc_static_metadata_refcounts[49], {{g_bytes + 544, 11}}},
-    {&grpc_static_metadata_refcounts[50], {{g_bytes + 555, 3}}},
-    {&grpc_static_metadata_refcounts[51], {{g_bytes + 558, 3}}},
-    {&grpc_static_metadata_refcounts[52], {{g_bytes + 561, 3}}},
-    {&grpc_static_metadata_refcounts[53], {{g_bytes + 564, 3}}},
-    {&grpc_static_metadata_refcounts[54], {{g_bytes + 567, 3}}},
-    {&grpc_static_metadata_refcounts[55], {{g_bytes + 570, 14}}},
-    {&grpc_static_metadata_refcounts[56], {{g_bytes + 584, 13}}},
-    {&grpc_static_metadata_refcounts[57], {{g_bytes + 597, 15}}},
-    {&grpc_static_metadata_refcounts[58], {{g_bytes + 612, 13}}},
-    {&grpc_static_metadata_refcounts[59], {{g_bytes + 625, 6}}},
-    {&grpc_static_metadata_refcounts[60], {{g_bytes + 631, 27}}},
-    {&grpc_static_metadata_refcounts[61], {{g_bytes + 658, 3}}},
-    {&grpc_static_metadata_refcounts[62], {{g_bytes + 661, 5}}},
-    {&grpc_static_metadata_refcounts[63], {{g_bytes + 666, 13}}},
-    {&grpc_static_metadata_refcounts[64], {{g_bytes + 679, 13}}},
-    {&grpc_static_metadata_refcounts[65], {{g_bytes + 692, 19}}},
-    {&grpc_static_metadata_refcounts[66], {{g_bytes + 711, 16}}},
-    {&grpc_static_metadata_refcounts[67], {{g_bytes + 727, 14}}},
-    {&grpc_static_metadata_refcounts[68], {{g_bytes + 741, 16}}},
-    {&grpc_static_metadata_refcounts[69], {{g_bytes + 757, 13}}},
-    {&grpc_static_metadata_refcounts[70], {{g_bytes + 770, 6}}},
-    {&grpc_static_metadata_refcounts[71], {{g_bytes + 776, 4}}},
-    {&grpc_static_metadata_refcounts[72], {{g_bytes + 780, 4}}},
-    {&grpc_static_metadata_refcounts[73], {{g_bytes + 784, 6}}},
-    {&grpc_static_metadata_refcounts[74], {{g_bytes + 790, 7}}},
-    {&grpc_static_metadata_refcounts[75], {{g_bytes + 797, 4}}},
-    {&grpc_static_metadata_refcounts[76], {{g_bytes + 801, 8}}},
-    {&grpc_static_metadata_refcounts[77], {{g_bytes + 809, 17}}},
-    {&grpc_static_metadata_refcounts[78], {{g_bytes + 826, 13}}},
-    {&grpc_static_metadata_refcounts[79], {{g_bytes + 839, 8}}},
-    {&grpc_static_metadata_refcounts[80], {{g_bytes + 847, 19}}},
-    {&grpc_static_metadata_refcounts[81], {{g_bytes + 866, 13}}},
-    {&grpc_static_metadata_refcounts[82], {{g_bytes + 879, 11}}},
-    {&grpc_static_metadata_refcounts[83], {{g_bytes + 890, 4}}},
-    {&grpc_static_metadata_refcounts[84], {{g_bytes + 894, 8}}},
-    {&grpc_static_metadata_refcounts[85], {{g_bytes + 902, 12}}},
-    {&grpc_static_metadata_refcounts[86], {{g_bytes + 914, 18}}},
-    {&grpc_static_metadata_refcounts[87], {{g_bytes + 932, 19}}},
-    {&grpc_static_metadata_refcounts[88], {{g_bytes + 951, 5}}},
-    {&grpc_static_metadata_refcounts[89], {{g_bytes + 956, 7}}},
-    {&grpc_static_metadata_refcounts[90], {{g_bytes + 963, 7}}},
-    {&grpc_static_metadata_refcounts[91], {{g_bytes + 970, 11}}},
-    {&grpc_static_metadata_refcounts[92], {{g_bytes + 981, 6}}},
-    {&grpc_static_metadata_refcounts[93], {{g_bytes + 987, 10}}},
-    {&grpc_static_metadata_refcounts[94], {{g_bytes + 997, 25}}},
-    {&grpc_static_metadata_refcounts[95], {{g_bytes + 1022, 17}}},
-    {&grpc_static_metadata_refcounts[96], {{g_bytes + 1039, 4}}},
-    {&grpc_static_metadata_refcounts[97], {{g_bytes + 1043, 3}}},
-    {&grpc_static_metadata_refcounts[98], {{g_bytes + 1046, 16}}},
-    {&grpc_static_metadata_refcounts[99], {{g_bytes + 1062, 16}}},
-    {&grpc_static_metadata_refcounts[100], {{g_bytes + 1078, 13}}},
-    {&grpc_static_metadata_refcounts[101], {{g_bytes + 1091, 12}}},
-    {&grpc_static_metadata_refcounts[102], {{g_bytes + 1103, 21}}},
+    {&grpc_static_metadata_refcounts[29], {{g_bytes + 430, 7}}},
+    {&grpc_static_metadata_refcounts[30], {{g_bytes + 437, 4}}},
+    {&grpc_static_metadata_refcounts[31], {{g_bytes + 441, 11}}},
+    {&grpc_static_metadata_refcounts[32], {{g_bytes + 452, 1}}},
+    {&grpc_static_metadata_refcounts[33], {{g_bytes + 453, 1}}},
+    {&grpc_static_metadata_refcounts[34], {{g_bytes + 454, 1}}},
+    {&grpc_static_metadata_refcounts[35], {{g_bytes + 455, 8}}},
+    {&grpc_static_metadata_refcounts[36], {{g_bytes + 463, 8}}},
+    {&grpc_static_metadata_refcounts[37], {{g_bytes + 471, 16}}},
+    {&grpc_static_metadata_refcounts[38], {{g_bytes + 487, 4}}},
+    {&grpc_static_metadata_refcounts[39], {{g_bytes + 491, 3}}},
+    {&grpc_static_metadata_refcounts[40], {{g_bytes + 494, 3}}},
+    {&grpc_static_metadata_refcounts[41], {{g_bytes + 497, 4}}},
+    {&grpc_static_metadata_refcounts[42], {{g_bytes + 501, 5}}},
+    {&grpc_static_metadata_refcounts[43], {{g_bytes + 506, 4}}},
+    {&grpc_static_metadata_refcounts[44], {{g_bytes + 510, 3}}},
+    {&grpc_static_metadata_refcounts[45], {{g_bytes + 513, 3}}},
+    {&grpc_static_metadata_refcounts[46], {{g_bytes + 516, 1}}},
+    {&grpc_static_metadata_refcounts[47], {{g_bytes + 517, 11}}},
+    {&grpc_static_metadata_refcounts[48], {{g_bytes + 528, 3}}},
+    {&grpc_static_metadata_refcounts[49], {{g_bytes + 531, 3}}},
+    {&grpc_static_metadata_refcounts[50], {{g_bytes + 534, 3}}},
+    {&grpc_static_metadata_refcounts[51], {{g_bytes + 537, 3}}},
+    {&grpc_static_metadata_refcounts[52], {{g_bytes + 540, 3}}},
+    {&grpc_static_metadata_refcounts[53], {{g_bytes + 543, 14}}},
+    {&grpc_static_metadata_refcounts[54], {{g_bytes + 557, 13}}},
+    {&grpc_static_metadata_refcounts[55], {{g_bytes + 570, 15}}},
+    {&grpc_static_metadata_refcounts[56], {{g_bytes + 585, 13}}},
+    {&grpc_static_metadata_refcounts[57], {{g_bytes + 598, 6}}},
+    {&grpc_static_metadata_refcounts[58], {{g_bytes + 604, 27}}},
+    {&grpc_static_metadata_refcounts[59], {{g_bytes + 631, 3}}},
+    {&grpc_static_metadata_refcounts[60], {{g_bytes + 634, 5}}},
+    {&grpc_static_metadata_refcounts[61], {{g_bytes + 639, 13}}},
+    {&grpc_static_metadata_refcounts[62], {{g_bytes + 652, 13}}},
+    {&grpc_static_metadata_refcounts[63], {{g_bytes + 665, 19}}},
+    {&grpc_static_metadata_refcounts[64], {{g_bytes + 684, 16}}},
+    {&grpc_static_metadata_refcounts[65], {{g_bytes + 700, 14}}},
+    {&grpc_static_metadata_refcounts[66], {{g_bytes + 714, 16}}},
+    {&grpc_static_metadata_refcounts[67], {{g_bytes + 730, 13}}},
+    {&grpc_static_metadata_refcounts[68], {{g_bytes + 743, 6}}},
+    {&grpc_static_metadata_refcounts[69], {{g_bytes + 749, 4}}},
+    {&grpc_static_metadata_refcounts[70], {{g_bytes + 753, 4}}},
+    {&grpc_static_metadata_refcounts[71], {{g_bytes + 757, 6}}},
+    {&grpc_static_metadata_refcounts[72], {{g_bytes + 763, 7}}},
+    {&grpc_static_metadata_refcounts[73], {{g_bytes + 770, 4}}},
+    {&grpc_static_metadata_refcounts[74], {{g_bytes + 774, 8}}},
+    {&grpc_static_metadata_refcounts[75], {{g_bytes + 782, 17}}},
+    {&grpc_static_metadata_refcounts[76], {{g_bytes + 799, 13}}},
+    {&grpc_static_metadata_refcounts[77], {{g_bytes + 812, 8}}},
+    {&grpc_static_metadata_refcounts[78], {{g_bytes + 820, 19}}},
+    {&grpc_static_metadata_refcounts[79], {{g_bytes + 839, 13}}},
+    {&grpc_static_metadata_refcounts[80], {{g_bytes + 852, 11}}},
+    {&grpc_static_metadata_refcounts[81], {{g_bytes + 863, 4}}},
+    {&grpc_static_metadata_refcounts[82], {{g_bytes + 867, 8}}},
+    {&grpc_static_metadata_refcounts[83], {{g_bytes + 875, 12}}},
+    {&grpc_static_metadata_refcounts[84], {{g_bytes + 887, 18}}},
+    {&grpc_static_metadata_refcounts[85], {{g_bytes + 905, 19}}},
+    {&grpc_static_metadata_refcounts[86], {{g_bytes + 924, 5}}},
+    {&grpc_static_metadata_refcounts[87], {{g_bytes + 929, 7}}},
+    {&grpc_static_metadata_refcounts[88], {{g_bytes + 936, 7}}},
+    {&grpc_static_metadata_refcounts[89], {{g_bytes + 943, 11}}},
+    {&grpc_static_metadata_refcounts[90], {{g_bytes + 954, 6}}},
+    {&grpc_static_metadata_refcounts[91], {{g_bytes + 960, 10}}},
+    {&grpc_static_metadata_refcounts[92], {{g_bytes + 970, 25}}},
+    {&grpc_static_metadata_refcounts[93], {{g_bytes + 995, 17}}},
+    {&grpc_static_metadata_refcounts[94], {{g_bytes + 1012, 4}}},
+    {&grpc_static_metadata_refcounts[95], {{g_bytes + 1016, 3}}},
+    {&grpc_static_metadata_refcounts[96], {{g_bytes + 1019, 16}}},
+    {&grpc_static_metadata_refcounts[97], {{g_bytes + 1035, 16}}},
+    {&grpc_static_metadata_refcounts[98], {{g_bytes + 1051, 13}}},
+    {&grpc_static_metadata_refcounts[99], {{g_bytes + 1064, 12}}},
+    {&grpc_static_metadata_refcounts[100], {{g_bytes + 1076, 21}}},
 };
 
 uintptr_t grpc_static_mdelem_user_data[GRPC_STATIC_MDELEM_COUNT] = {
@@ -333,16 +328,16 @@ uintptr_t grpc_static_mdelem_user_data[GRPC_STATIC_MDELEM_COUNT] = {
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 4, 4, 6, 6, 8, 8, 2, 4, 4};
 
 static const int8_t elems_r[] = {
-    11, 9,  -3, 0,  10,  25, -77, 26,  0,   11,  -7,  0,   0,  0,  21, 14, 1,
-    0,  0,  33, 12, 11,  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,  0,  0,
-    0,  0,  0,  0,  -56, 0,  -36, -61, -60, -39, -63, -64, 0,  36, 35, 34, 33,
-    34, 33, 32, 31, 31,  30, 29,  28,  27,  26,  26,  25,  25, 24, 23, 22, 21,
-    20, 19, 22, 21, 20,  19, 18,  17,  16,  15,  14,  13,  12, 12, 11, 0};
+    13, 2,  1,   0,  15,  4,   0,   21,  0,   23,  -3, 0,  0,  0,  10, 19, -4,
+    0,  0,  1,   10, 9,   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,  0,  0,
+    0,  0,  -52, 0,  -55, -36, -57, -58, -58, -58, 0,  40, 39, 38, 37, 36, 35,
+    34, 33, 32,  31, 30,  29,  28,  28,  27,  26,  25, 24, 23, 22, 21, 20, 19,
+    18, 17, 16,  15, 18,  17,  16,  15,  14,  13,  12, 11, 11, 0};
 static uint32_t elems_phash(uint32_t i) {
-  i -= 48;
-  uint32_t x = i % 101;
-  uint32_t y = i / 101;
+  i -= 46;
+  uint32_t x = i % 99;
+  uint32_t y = i / 99;
   uint32_t h = x;
   if (y < GPR_ARRAY_SIZE(elems_r)) {
     uint32_t delta = (uint32_t)elems_r[y];
@@ -352,31 +347,31 @@ static uint32_t elems_phash(uint32_t i) {
 }
 
 static const uint16_t elem_keys[] = {
-    1065, 1066, 1067, 256,  257,  258,  259,  260,  1671,  149,   150,  48,
-    49,   455,  456,  457,  962,  963,  964,  1568, 1683,  1684,  753,  754,
-    1465, 553,  755,  2083, 2186, 5688, 5997, 1580, 1581,  6100,  6306, 6409,
-    6512, 6615, 6718, 6821, 1481, 1704, 6924, 7027, 7130,  7233,  1980, 7336,
-    7439, 7542, 7645, 7748, 7851, 5894, 7954, 8057, 6203,  8160,  8263, 8366,
-    8469, 8572, 8675, 8778, 1129, 1130, 1131, 1132, 8881,  8984,  9087, 9190,
-    9293, 9396, 9499, 9602, 9705, 9808, 9911, 332,  10014, 10117, 0,    0,
-    0,    1748, 0,    0,    0,    0,    0,    0,    0,     0,     0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,     0,     143,  247,
-    248,  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};
+    1039, 1040, 145,  146,  541,  1639, 1045, 250,  251,  252,  253,  254,
+    1646, 46,   47,   1437, 1942, 1651, 445,  446,  447,  739,  740,  741,
+    938,  939,  1538, 2043, 2144, 1451, 944,  5376, 5578, 1545, 5780, 5881,
+    1670, 5982, 1550, 6083, 6184, 6285, 6386, 6487, 6588, 6689, 6790, 6891,
+    6992, 7093, 7194, 7295, 7396, 5679, 7497, 7598, 7699, 7800, 7901, 8002,
+    8103, 8204, 8305, 8406, 8507, 8608, 8709, 8810, 1107, 1108, 1109, 1110,
+    8911, 9012, 9113, 9214, 9315, 9416, 9517, 9618, 1714, 9719, 0,    326,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    241,  242,  0,    0,    0,    0,    0,    0,    139,  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,    0,    0,    0,    0};
 static const uint8_t elem_idxs[] = {
-    76,  79,  77,  19,  20,  21,  22,  23,  25,  15,  16,  17,  18,  11,
-    12,  13,  3,   4,   5,   38,  83,  84,  0,   1,   43,  6,   2,   50,
-    57,  24,  28,  36,  37,  29,  31,  32,  33,  34,  35,  39,  7,   26,
-    40,  41,  42,  44,  72,  45,  46,  47,  48,  49,  51,  27,  52,  53,
-    30,  54,  55,  56,  58,  59,  60,  61,  78,  80,  81,  82,  62,  63,
-    64,  65,  66,  67,  68,  69,  70,  71,  73,  14,  74,  75,  255, 255,
-    255, 85,  255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    255, 255, 255, 255, 255, 255, 255, 255, 8,   9,   10};
+    77,  79,  15,  16,  6,   25,  76,  19,  20,  21,  22,  23,  84,  17,
+    18,  43,  72,  83,  11,  12,  13,  0,   1,   2,   5,   4,   38,  50,
+    57,  7,   3,   24,  27,  37,  29,  30,  26,  31,  36,  32,  33,  34,
+    35,  39,  40,  41,  42,  44,  45,  46,  47,  48,  49,  28,  51,  52,
+    53,  54,  55,  56,  58,  59,  60,  61,  62,  63,  64,  65,  78,  80,
+    81,  82,  66,  67,  68,  69,  70,  71,  73,  74,  85,  75,  255, 14,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    9,   10,  255, 255, 255, 255, 255, 255, 8};
 
 grpc_mdelem grpc_static_mdelem_for_static_strings(int a, int b) {
   if (a == -1 || b == -1) return GRPC_MDNULL;
-  uint32_t k = (uint32_t)(a * 103 + b);
+  uint32_t k = (uint32_t)(a * 101 + b);
   uint32_t h = elems_phash(k);
   return h < GPR_ARRAY_SIZE(elem_keys) && elem_keys[h] == k &&
                  elem_idxs[h] != 255
@@ -387,177 +382,177 @@ grpc_mdelem grpc_static_mdelem_for_static_strings(int a, int b) {
 
 grpc_mdelem_data grpc_static_mdelem_table[GRPC_STATIC_MDELEM_COUNT] = {
     {{&grpc_static_metadata_refcounts[7], {{g_bytes + 50, 11}}},
-     {&grpc_static_metadata_refcounts[32], {{g_bytes + 468, 1}}}},
+     {&grpc_static_metadata_refcounts[32], {{g_bytes + 452, 1}}}},
     {{&grpc_static_metadata_refcounts[7], {{g_bytes + 50, 11}}},
-     {&grpc_static_metadata_refcounts[33], {{g_bytes + 469, 1}}}},
+     {&grpc_static_metadata_refcounts[33], {{g_bytes + 453, 1}}}},
     {{&grpc_static_metadata_refcounts[7], {{g_bytes + 50, 11}}},
-     {&grpc_static_metadata_refcounts[34], {{g_bytes + 470, 1}}}},
+     {&grpc_static_metadata_refcounts[34], {{g_bytes + 454, 1}}}},
     {{&grpc_static_metadata_refcounts[9], {{g_bytes + 77, 13}}},
-     {&grpc_static_metadata_refcounts[35], {{g_bytes + 471, 8}}}},
+     {&grpc_static_metadata_refcounts[35], {{g_bytes + 455, 8}}}},
     {{&grpc_static_metadata_refcounts[9], {{g_bytes + 77, 13}}},
-     {&grpc_static_metadata_refcounts[36], {{g_bytes + 479, 4}}}},
+     {&grpc_static_metadata_refcounts[30], {{g_bytes + 437, 4}}}},
     {{&grpc_static_metadata_refcounts[9], {{g_bytes + 77, 13}}},
-     {&grpc_static_metadata_refcounts[37], {{g_bytes + 483, 7}}}},
+     {&grpc_static_metadata_refcounts[29], {{g_bytes + 430, 7}}}},
     {{&grpc_static_metadata_refcounts[5], {{g_bytes + 36, 2}}},
-     {&grpc_static_metadata_refcounts[38], {{g_bytes + 490, 8}}}},
+     {&grpc_static_metadata_refcounts[36], {{g_bytes + 463, 8}}}},
     {{&grpc_static_metadata_refcounts[14], {{g_bytes + 158, 12}}},
-     {&grpc_static_metadata_refcounts[39], {{g_bytes + 498, 16}}}},
+     {&grpc_static_metadata_refcounts[37], {{g_bytes + 471, 16}}}},
     {{&grpc_static_metadata_refcounts[1], {{g_bytes + 5, 7}}},
-     {&grpc_static_metadata_refcounts[40], {{g_bytes + 514, 4}}}},
+     {&grpc_static_metadata_refcounts[38], {{g_bytes + 487, 4}}}},
     {{&grpc_static_metadata_refcounts[2], {{g_bytes + 12, 7}}},
-     {&grpc_static_metadata_refcounts[41], {{g_bytes + 518, 3}}}},
+     {&grpc_static_metadata_refcounts[39], {{g_bytes + 491, 3}}}},
     {{&grpc_static_metadata_refcounts[2], {{g_bytes + 12, 7}}},
-     {&grpc_static_metadata_refcounts[42], {{g_bytes + 521, 3}}}},
+     {&grpc_static_metadata_refcounts[40], {{g_bytes + 494, 3}}}},
     {{&grpc_static_metadata_refcounts[4], {{g_bytes + 29, 7}}},
-     {&grpc_static_metadata_refcounts[43], {{g_bytes + 524, 4}}}},
+     {&grpc_static_metadata_refcounts[41], {{g_bytes + 497, 4}}}},
     {{&grpc_static_metadata_refcounts[4], {{g_bytes + 29, 7}}},
-     {&grpc_static_metadata_refcounts[44], {{g_bytes + 528, 5}}}},
+     {&grpc_static_metadata_refcounts[42], {{g_bytes + 501, 5}}}},
     {{&grpc_static_metadata_refcounts[4], {{g_bytes + 29, 7}}},
-     {&grpc_static_metadata_refcounts[45], {{g_bytes + 533, 4}}}},
+     {&grpc_static_metadata_refcounts[43], {{g_bytes + 506, 4}}}},
     {{&grpc_static_metadata_refcounts[3], {{g_bytes + 19, 10}}},
      {&grpc_static_metadata_refcounts[23], {{g_bytes + 302, 0}}}},
     {{&grpc_static_metadata_refcounts[1], {{g_bytes + 5, 7}}},
-     {&grpc_static_metadata_refcounts[46], {{g_bytes + 537, 3}}}},
+     {&grpc_static_metadata_refcounts[44], {{g_bytes + 510, 3}}}},
     {{&grpc_static_metadata_refcounts[1], {{g_bytes + 5, 7}}},
-     {&grpc_static_metadata_refcounts[47], {{g_bytes + 540, 3}}}},
+     {&grpc_static_metadata_refcounts[45], {{g_bytes + 513, 3}}}},
     {{&grpc_static_metadata_refcounts[0], {{g_bytes + 0, 5}}},
-     {&grpc_static_metadata_refcounts[48], {{g_bytes + 543, 1}}}},
+     {&grpc_static_metadata_refcounts[46], {{g_bytes + 516, 1}}}},
     {{&grpc_static_metadata_refcounts[0], {{g_bytes + 0, 5}}},
-     {&grpc_static_metadata_refcounts[49], {{g_bytes + 544, 11}}}},
+     {&grpc_static_metadata_refcounts[47], {{g_bytes + 517, 11}}}},
     {{&grpc_static_metadata_refcounts[2], {{g_bytes + 12, 7}}},
-     {&grpc_static_metadata_refcounts[50], {{g_bytes + 555, 3}}}},
+     {&grpc_static_metadata_refcounts[48], {{g_bytes + 528, 3}}}},
     {{&grpc_static_metadata_refcounts[2], {{g_bytes + 12, 7}}},
-     {&grpc_static_metadata_refcounts[51], {{g_bytes + 558, 3}}}},
+     {&grpc_static_metadata_refcounts[49], {{g_bytes + 531, 3}}}},
     {{&grpc_static_metadata_refcounts[2], {{g_bytes + 12, 7}}},
-     {&grpc_static_metadata_refcounts[52], {{g_bytes + 561, 3}}}},
+     {&grpc_static_metadata_refcounts[50], {{g_bytes + 534, 3}}}},
     {{&grpc_static_metadata_refcounts[2], {{g_bytes + 12, 7}}},
-     {&grpc_static_metadata_refcounts[53], {{g_bytes + 564, 3}}}},
+     {&grpc_static_metadata_refcounts[51], {{g_bytes + 537, 3}}}},
     {{&grpc_static_metadata_refcounts[2], {{g_bytes + 12, 7}}},
-     {&grpc_static_metadata_refcounts[54], {{g_bytes + 567, 3}}}},
-    {{&grpc_static_metadata_refcounts[55], {{g_bytes + 570, 14}}},
+     {&grpc_static_metadata_refcounts[52], {{g_bytes + 540, 3}}}},
+    {{&grpc_static_metadata_refcounts[53], {{g_bytes + 543, 14}}},
      {&grpc_static_metadata_refcounts[23], {{g_bytes + 302, 0}}}},
     {{&grpc_static_metadata_refcounts[16], {{g_bytes + 186, 15}}},
      {&grpc_static_metadata_refcounts[23], {{g_bytes + 302, 0}}}},
     {{&grpc_static_metadata_refcounts[16], {{g_bytes + 186, 15}}},
-     {&grpc_static_metadata_refcounts[56], {{g_bytes + 584, 13}}}},
-    {{&grpc_static_metadata_refcounts[57], {{g_bytes + 597, 15}}},
+     {&grpc_static_metadata_refcounts[54], {{g_bytes + 557, 13}}}},
+    {{&grpc_static_metadata_refcounts[55], {{g_bytes + 570, 15}}},
      {&grpc_static_metadata_refcounts[23], {{g_bytes + 302, 0}}}},
-    {{&grpc_static_metadata_refcounts[58], {{g_bytes + 612, 13}}},
+    {{&grpc_static_metadata_refcounts[56], {{g_bytes + 585, 13}}},
      {&grpc_static_metadata_refcounts[23], {{g_bytes + 302, 0}}}},
-    {{&grpc_static_metadata_refcounts[59], {{g_bytes + 625, 6}}},
+    {{&grpc_static_metadata_refcounts[57], {{g_bytes + 598, 6}}},
      {&grpc_static_metadata_refcounts[23], {{g_bytes + 302, 0}}}},
-    {{&grpc_static_metadata_refcounts[60], {{g_bytes + 631, 27}}},
+    {{&grpc_static_metadata_refcounts[58], {{g_bytes + 604, 27}}},
      {&grpc_static_metadata_refcounts[23], {{g_bytes + 302, 0}}}},
-    {{&grpc_static_metadata_refcounts[61], {{g_bytes + 658, 3}}},
+    {{&grpc_static_metadata_refcounts[59], {{g_bytes + 631, 3}}},
      {&grpc_static_metadata_refcounts[23], {{g_bytes + 302, 0}}}},
-    {{&grpc_static_metadata_refcounts[62], {{g_bytes + 661, 5}}},
+    {{&grpc_static_metadata_refcounts[60], {{g_bytes + 634, 5}}},
      {&grpc_static_metadata_refcounts[23], {{g_bytes + 302, 0}}}},
-    {{&grpc_static_metadata_refcounts[63], {{g_bytes + 666, 13}}},
+    {{&grpc_static_metadata_refcounts[61], {{g_bytes + 639, 13}}},
      {&grpc_static_metadata_refcounts[23], {{g_bytes + 302, 0}}}},
-    {{&grpc_static_metadata_refcounts[64], {{g_bytes + 679, 13}}},
+    {{&grpc_static_metadata_refcounts[62], {{g_bytes + 652, 13}}},
      {&grpc_static_metadata_refcounts[23], {{g_bytes + 302, 0}}}},
-    {{&grpc_static_metadata_refcounts[65], {{g_bytes + 692, 19}}},
+    {{&grpc_static_metadata_refcounts[63], {{g_bytes + 665, 19}}},
      {&grpc_static_metadata_refcounts[23], {{g_bytes + 302, 0}}}},
     {{&grpc_static_metadata_refcounts[15], {{g_bytes + 170, 16}}},
-     {&grpc_static_metadata_refcounts[35], {{g_bytes + 471, 8}}}},
+     {&grpc_static_metadata_refcounts[35], {{g_bytes + 455, 8}}}},
     {{&grpc_static_metadata_refcounts[15], {{g_bytes + 170, 16}}},
-     {&grpc_static_metadata_refcounts[36], {{g_bytes + 479, 4}}}},
+     {&grpc_static_metadata_refcounts[30], {{g_bytes + 437, 4}}}},
     {{&grpc_static_metadata_refcounts[15], {{g_bytes + 170, 16}}},
      {&grpc_static_metadata_refcounts[23], {{g_bytes + 302, 0}}}},
-    {{&grpc_static_metadata_refcounts[66], {{g_bytes + 711, 16}}},
+    {{&grpc_static_metadata_refcounts[64], {{g_bytes + 684, 16}}},
      {&grpc_static_metadata_refcounts[23], {{g_bytes + 302, 0}}}},
-    {{&grpc_static_metadata_refcounts[67], {{g_bytes + 727, 14}}},
+    {{&grpc_static_metadata_refcounts[65], {{g_bytes + 700, 14}}},
      {&grpc_static_metadata_refcounts[23], {{g_bytes + 302, 0}}}},
-    {{&grpc_static_metadata_refcounts[68], {{g_bytes + 741, 16}}},
+    {{&grpc_static_metadata_refcounts[66], {{g_bytes + 714, 16}}},
      {&grpc_static_metadata_refcounts[23], {{g_bytes + 302, 0}}}},
-    {{&grpc_static_metadata_refcounts[69], {{g_bytes + 757, 13}}},
+    {{&grpc_static_metadata_refcounts[67], {{g_bytes + 730, 13}}},
      {&grpc_static_metadata_refcounts[23], {{g_bytes + 302, 0}}}},
     {{&grpc_static_metadata_refcounts[14], {{g_bytes + 158, 12}}},
      {&grpc_static_metadata_refcounts[23], {{g_bytes + 302, 0}}}},
-    {{&grpc_static_metadata_refcounts[70], {{g_bytes + 770, 6}}},
+    {{&grpc_static_metadata_refcounts[68], {{g_bytes + 743, 6}}},
      {&grpc_static_metadata_refcounts[23], {{g_bytes + 302, 0}}}},
-    {{&grpc_static_metadata_refcounts[71], {{g_bytes + 776, 4}}},
+    {{&grpc_static_metadata_refcounts[69], {{g_bytes + 749, 4}}},
      {&grpc_static_metadata_refcounts[23], {{g_bytes + 302, 0}}}},
-    {{&grpc_static_metadata_refcounts[72], {{g_bytes + 780, 4}}},
+    {{&grpc_static_metadata_refcounts[70], {{g_bytes + 753, 4}}},
      {&grpc_static_metadata_refcounts[23], {{g_bytes + 302, 0}}}},
-    {{&grpc_static_metadata_refcounts[73], {{g_bytes + 784, 6}}},
+    {{&grpc_static_metadata_refcounts[71], {{g_bytes + 757, 6}}},
      {&grpc_static_metadata_refcounts[23], {{g_bytes + 302, 0}}}},
-    {{&grpc_static_metadata_refcounts[74], {{g_bytes + 790, 7}}},
+    {{&grpc_static_metadata_refcounts[72], {{g_bytes + 763, 7}}},
      {&grpc_static_metadata_refcounts[23], {{g_bytes + 302, 0}}}},
-    {{&grpc_static_metadata_refcounts[75], {{g_bytes + 797, 4}}},
+    {{&grpc_static_metadata_refcounts[73], {{g_bytes + 770, 4}}},
      {&grpc_static_metadata_refcounts[23], {{g_bytes + 302, 0}}}},
     {{&grpc_static_metadata_refcounts[20], {{g_bytes + 278, 4}}},
      {&grpc_static_metadata_refcounts[23], {{g_bytes + 302, 0}}}},
-    {{&grpc_static_metadata_refcounts[76], {{g_bytes + 801, 8}}},
+    {{&grpc_static_metadata_refcounts[74], {{g_bytes + 774, 8}}},
      {&grpc_static_metadata_refcounts[23], {{g_bytes + 302, 0}}}},
-    {{&grpc_static_metadata_refcounts[77], {{g_bytes + 809, 17}}},
+    {{&grpc_static_metadata_refcounts[75], {{g_bytes + 782, 17}}},
      {&grpc_static_metadata_refcounts[23], {{g_bytes + 302, 0}}}},
-    {{&grpc_static_metadata_refcounts[78], {{g_bytes + 826, 13}}},
+    {{&grpc_static_metadata_refcounts[76], {{g_bytes + 799, 13}}},
      {&grpc_static_metadata_refcounts[23], {{g_bytes + 302, 0}}}},
-    {{&grpc_static_metadata_refcounts[79], {{g_bytes + 839, 8}}},
+    {{&grpc_static_metadata_refcounts[77], {{g_bytes + 812, 8}}},
      {&grpc_static_metadata_refcounts[23], {{g_bytes + 302, 0}}}},
-    {{&grpc_static_metadata_refcounts[80], {{g_bytes + 847, 19}}},
+    {{&grpc_static_metadata_refcounts[78], {{g_bytes + 820, 19}}},
      {&grpc_static_metadata_refcounts[23], {{g_bytes + 302, 0}}}},
-    {{&grpc_static_metadata_refcounts[81], {{g_bytes + 866, 13}}},
+    {{&grpc_static_metadata_refcounts[79], {{g_bytes + 839, 13}}},
      {&grpc_static_metadata_refcounts[23], {{g_bytes + 302, 0}}}},
     {{&grpc_static_metadata_refcounts[21], {{g_bytes + 282, 8}}},
      {&grpc_static_metadata_refcounts[23], {{g_bytes + 302, 0}}}},
-    {{&grpc_static_metadata_refcounts[82], {{g_bytes + 879, 11}}},
+    {{&grpc_static_metadata_refcounts[80], {{g_bytes + 852, 11}}},
      {&grpc_static_metadata_refcounts[23], {{g_bytes + 302, 0}}}},
-    {{&grpc_static_metadata_refcounts[83], {{g_bytes + 890, 4}}},
+    {{&grpc_static_metadata_refcounts[81], {{g_bytes + 863, 4}}},
      {&grpc_static_metadata_refcounts[23], {{g_bytes + 302, 0}}}},
-    {{&grpc_static_metadata_refcounts[84], {{g_bytes + 894, 8}}},
+    {{&grpc_static_metadata_refcounts[82], {{g_bytes + 867, 8}}},
      {&grpc_static_metadata_refcounts[23], {{g_bytes + 302, 0}}}},
-    {{&grpc_static_metadata_refcounts[85], {{g_bytes + 902, 12}}},
+    {{&grpc_static_metadata_refcounts[83], {{g_bytes + 875, 12}}},
      {&grpc_static_metadata_refcounts[23], {{g_bytes + 302, 0}}}},
-    {{&grpc_static_metadata_refcounts[86], {{g_bytes + 914, 18}}},
+    {{&grpc_static_metadata_refcounts[84], {{g_bytes + 887, 18}}},
      {&grpc_static_metadata_refcounts[23], {{g_bytes + 302, 0}}}},
-    {{&grpc_static_metadata_refcounts[87], {{g_bytes + 932, 19}}},
+    {{&grpc_static_metadata_refcounts[85], {{g_bytes + 905, 19}}},
      {&grpc_static_metadata_refcounts[23], {{g_bytes + 302, 0}}}},
-    {{&grpc_static_metadata_refcounts[88], {{g_bytes + 951, 5}}},
+    {{&grpc_static_metadata_refcounts[86], {{g_bytes + 924, 5}}},
      {&grpc_static_metadata_refcounts[23], {{g_bytes + 302, 0}}}},
-    {{&grpc_static_metadata_refcounts[89], {{g_bytes + 956, 7}}},
+    {{&grpc_static_metadata_refcounts[87], {{g_bytes + 929, 7}}},
      {&grpc_static_metadata_refcounts[23], {{g_bytes + 302, 0}}}},
-    {{&grpc_static_metadata_refcounts[90], {{g_bytes + 963, 7}}},
+    {{&grpc_static_metadata_refcounts[88], {{g_bytes + 936, 7}}},
      {&grpc_static_metadata_refcounts[23], {{g_bytes + 302, 0}}}},
-    {{&grpc_static_metadata_refcounts[91], {{g_bytes + 970, 11}}},
+    {{&grpc_static_metadata_refcounts[89], {{g_bytes + 943, 11}}},
      {&grpc_static_metadata_refcounts[23], {{g_bytes + 302, 0}}}},
-    {{&grpc_static_metadata_refcounts[92], {{g_bytes + 981, 6}}},
+    {{&grpc_static_metadata_refcounts[90], {{g_bytes + 954, 6}}},
      {&grpc_static_metadata_refcounts[23], {{g_bytes + 302, 0}}}},
-    {{&grpc_static_metadata_refcounts[93], {{g_bytes + 987, 10}}},
+    {{&grpc_static_metadata_refcounts[91], {{g_bytes + 960, 10}}},
      {&grpc_static_metadata_refcounts[23], {{g_bytes + 302, 0}}}},
-    {{&grpc_static_metadata_refcounts[94], {{g_bytes + 997, 25}}},
+    {{&grpc_static_metadata_refcounts[92], {{g_bytes + 970, 25}}},
      {&grpc_static_metadata_refcounts[23], {{g_bytes + 302, 0}}}},
-    {{&grpc_static_metadata_refcounts[95], {{g_bytes + 1022, 17}}},
+    {{&grpc_static_metadata_refcounts[93], {{g_bytes + 995, 17}}},
      {&grpc_static_metadata_refcounts[23], {{g_bytes + 302, 0}}}},
     {{&grpc_static_metadata_refcounts[19], {{g_bytes + 268, 10}}},
      {&grpc_static_metadata_refcounts[23], {{g_bytes + 302, 0}}}},
-    {{&grpc_static_metadata_refcounts[96], {{g_bytes + 1039, 4}}},
+    {{&grpc_static_metadata_refcounts[94], {{g_bytes + 1012, 4}}},
      {&grpc_static_metadata_refcounts[23], {{g_bytes + 302, 0}}}},
-    {{&grpc_static_metadata_refcounts[97], {{g_bytes + 1043, 3}}},
+    {{&grpc_static_metadata_refcounts[95], {{g_bytes + 1016, 3}}},
      {&grpc_static_metadata_refcounts[23], {{g_bytes + 302, 0}}}},
-    {{&grpc_static_metadata_refcounts[98], {{g_bytes + 1046, 16}}},
+    {{&grpc_static_metadata_refcounts[96], {{g_bytes + 1019, 16}}},
      {&grpc_static_metadata_refcounts[23], {{g_bytes + 302, 0}}}},
     {{&grpc_static_metadata_refcounts[10], {{g_bytes + 90, 20}}},
-     {&grpc_static_metadata_refcounts[35], {{g_bytes + 471, 8}}}},
+     {&grpc_static_metadata_refcounts[35], {{g_bytes + 455, 8}}}},
     {{&grpc_static_metadata_refcounts[10], {{g_bytes + 90, 20}}},
-     {&grpc_static_metadata_refcounts[37], {{g_bytes + 483, 7}}}},
+     {&grpc_static_metadata_refcounts[29], {{g_bytes + 430, 7}}}},
     {{&grpc_static_metadata_refcounts[10], {{g_bytes + 90, 20}}},
-     {&grpc_static_metadata_refcounts[99], {{g_bytes + 1062, 16}}}},
+     {&grpc_static_metadata_refcounts[97], {{g_bytes + 1035, 16}}}},
     {{&grpc_static_metadata_refcounts[10], {{g_bytes + 90, 20}}},
-     {&grpc_static_metadata_refcounts[36], {{g_bytes + 479, 4}}}},
+     {&grpc_static_metadata_refcounts[30], {{g_bytes + 437, 4}}}},
     {{&grpc_static_metadata_refcounts[10], {{g_bytes + 90, 20}}},
-     {&grpc_static_metadata_refcounts[100], {{g_bytes + 1078, 13}}}},
+     {&grpc_static_metadata_refcounts[98], {{g_bytes + 1051, 13}}}},
     {{&grpc_static_metadata_refcounts[10], {{g_bytes + 90, 20}}},
-     {&grpc_static_metadata_refcounts[101], {{g_bytes + 1091, 12}}}},
+     {&grpc_static_metadata_refcounts[99], {{g_bytes + 1064, 12}}}},
     {{&grpc_static_metadata_refcounts[10], {{g_bytes + 90, 20}}},
-     {&grpc_static_metadata_refcounts[102], {{g_bytes + 1103, 21}}}},
+     {&grpc_static_metadata_refcounts[100], {{g_bytes + 1076, 21}}}},
     {{&grpc_static_metadata_refcounts[16], {{g_bytes + 186, 15}}},
-     {&grpc_static_metadata_refcounts[35], {{g_bytes + 471, 8}}}},
+     {&grpc_static_metadata_refcounts[35], {{g_bytes + 455, 8}}}},
     {{&grpc_static_metadata_refcounts[16], {{g_bytes + 186, 15}}},
-     {&grpc_static_metadata_refcounts[36], {{g_bytes + 479, 4}}}},
+     {&grpc_static_metadata_refcounts[30], {{g_bytes + 437, 4}}}},
     {{&grpc_static_metadata_refcounts[16], {{g_bytes + 186, 15}}},
-     {&grpc_static_metadata_refcounts[100], {{g_bytes + 1078, 13}}}},
+     {&grpc_static_metadata_refcounts[98], {{g_bytes + 1051, 13}}}},
 };
 bool grpc_static_callout_is_default[GRPC_BATCH_CALLOUTS_COUNT] = {
     true,  // :path
diff --git a/src/core/lib/transport/static_metadata.h b/src/core/lib/transport/static_metadata.h
index 21dc7a3d3f..8ce9b21bc1 100644
--- a/src/core/lib/transport/static_metadata.h
+++ b/src/core/lib/transport/static_metadata.h
@@ -20,7 +20,7 @@
  * To make changes to this file, change
  * tools/codegen/core/gen_static_metadata.py, and then re-run it.
  *
- * See metadata.h for an explanation of the interface here, and metadata.c for
+ * See metadata.h for an explanation of the interface here, and metadata.cc for
  * an explanation of what's going on.
  */
 
@@ -29,7 +29,7 @@
 
 #include "src/core/lib/transport/metadata.h"
 
-#define GRPC_STATIC_MDSTR_COUNT 103
+#define GRPC_STATIC_MDSTR_COUNT 101
 extern const grpc_slice grpc_static_slice_table[GRPC_STATIC_MDSTR_COUNT];
 /* ":path" */
 #define GRPC_MDSTR_PATH (grpc_static_slice_table[0])
@@ -93,10 +93,10 @@ extern const grpc_slice grpc_static_slice_table[GRPC_STATIC_MDSTR_COUNT];
 /* "/grpc.lb.v1.LoadBalancer/BalanceLoad" */
 #define GRPC_MDSTR_SLASH_GRPC_DOT_LB_DOT_V1_DOT_LOADBALANCER_SLASH_BALANCELOAD \
   (grpc_static_slice_table[28])
-/* "message/deflate" */
-#define GRPC_MDSTR_MESSAGE_SLASH_DEFLATE (grpc_static_slice_table[29])
-/* "message/gzip" */
-#define GRPC_MDSTR_MESSAGE_SLASH_GZIP (grpc_static_slice_table[30])
+/* "deflate" */
+#define GRPC_MDSTR_DEFLATE (grpc_static_slice_table[29])
+/* "gzip" */
+#define GRPC_MDSTR_GZIP (grpc_static_slice_table[30])
 /* "stream/gzip" */
 #define GRPC_MDSTR_STREAM_SLASH_GZIP (grpc_static_slice_table[31])
 /* "0" */
@@ -107,141 +107,137 @@ extern const grpc_slice grpc_static_slice_table[GRPC_STATIC_MDSTR_COUNT];
 #define GRPC_MDSTR_2 (grpc_static_slice_table[34])
 /* "identity" */
 #define GRPC_MDSTR_IDENTITY (grpc_static_slice_table[35])
-/* "gzip" */
-#define GRPC_MDSTR_GZIP (grpc_static_slice_table[36])
-/* "deflate" */
-#define GRPC_MDSTR_DEFLATE (grpc_static_slice_table[37])
 /* "trailers" */
-#define GRPC_MDSTR_TRAILERS (grpc_static_slice_table[38])
+#define GRPC_MDSTR_TRAILERS (grpc_static_slice_table[36])
 /* "application/grpc" */
-#define GRPC_MDSTR_APPLICATION_SLASH_GRPC (grpc_static_slice_table[39])
+#define GRPC_MDSTR_APPLICATION_SLASH_GRPC (grpc_static_slice_table[37])
 /* "POST" */
-#define GRPC_MDSTR_POST (grpc_static_slice_table[40])
+#define GRPC_MDSTR_POST (grpc_static_slice_table[38])
 /* "200" */
-#define GRPC_MDSTR_200 (grpc_static_slice_table[41])
+#define GRPC_MDSTR_200 (grpc_static_slice_table[39])
 /* "404" */
-#define GRPC_MDSTR_404 (grpc_static_slice_table[42])
+#define GRPC_MDSTR_404 (grpc_static_slice_table[40])
 /* "http" */
-#define GRPC_MDSTR_HTTP (grpc_static_slice_table[43])
+#define GRPC_MDSTR_HTTP (grpc_static_slice_table[41])
 /* "https" */
-#define GRPC_MDSTR_HTTPS (grpc_static_slice_table[44])
+#define GRPC_MDSTR_HTTPS (grpc_static_slice_table[42])
 /* "grpc" */
-#define GRPC_MDSTR_GRPC (grpc_static_slice_table[45])
+#define GRPC_MDSTR_GRPC (grpc_static_slice_table[43])
 /* "GET" */
-#define GRPC_MDSTR_GET (grpc_static_slice_table[46])
+#define GRPC_MDSTR_GET (grpc_static_slice_table[44])
 /* "PUT" */
-#define GRPC_MDSTR_PUT (grpc_static_slice_table[47])
+#define GRPC_MDSTR_PUT (grpc_static_slice_table[45])
 /* "/" */
-#define GRPC_MDSTR_SLASH (grpc_static_slice_table[48])
+#define GRPC_MDSTR_SLASH (grpc_static_slice_table[46])
 /* "/index.html" */
-#define GRPC_MDSTR_SLASH_INDEX_DOT_HTML (grpc_static_slice_table[49])
+#define GRPC_MDSTR_SLASH_INDEX_DOT_HTML (grpc_static_slice_table[47])
 /* "204" */
-#define GRPC_MDSTR_204 (grpc_static_slice_table[50])
+#define GRPC_MDSTR_204 (grpc_static_slice_table[48])
 /* "206" */
-#define GRPC_MDSTR_206 (grpc_static_slice_table[51])
+#define GRPC_MDSTR_206 (grpc_static_slice_table[49])
 /* "304" */
-#define GRPC_MDSTR_304 (grpc_static_slice_table[52])
+#define GRPC_MDSTR_304 (grpc_static_slice_table[50])
 /* "400" */
-#define GRPC_MDSTR_400 (grpc_static_slice_table[53])
+#define GRPC_MDSTR_400 (grpc_static_slice_table[51])
 /* "500" */
-#define GRPC_MDSTR_500 (grpc_static_slice_table[54])
+#define GRPC_MDSTR_500 (grpc_static_slice_table[52])
 /* "accept-charset" */
-#define GRPC_MDSTR_ACCEPT_CHARSET (grpc_static_slice_table[55])
+#define GRPC_MDSTR_ACCEPT_CHARSET (grpc_static_slice_table[53])
 /* "gzip, deflate" */
-#define GRPC_MDSTR_GZIP_COMMA_DEFLATE (grpc_static_slice_table[56])
+#define GRPC_MDSTR_GZIP_COMMA_DEFLATE (grpc_static_slice_table[54])
 /* "accept-language" */
-#define GRPC_MDSTR_ACCEPT_LANGUAGE (grpc_static_slice_table[57])
+#define GRPC_MDSTR_ACCEPT_LANGUAGE (grpc_static_slice_table[55])
 /* "accept-ranges" */
-#define GRPC_MDSTR_ACCEPT_RANGES (grpc_static_slice_table[58])
+#define GRPC_MDSTR_ACCEPT_RANGES (grpc_static_slice_table[56])
 /* "accept" */
-#define GRPC_MDSTR_ACCEPT (grpc_static_slice_table[59])
+#define GRPC_MDSTR_ACCEPT (grpc_static_slice_table[57])
 /* "access-control-allow-origin" */
-#define GRPC_MDSTR_ACCESS_CONTROL_ALLOW_ORIGIN (grpc_static_slice_table[60])
+#define GRPC_MDSTR_ACCESS_CONTROL_ALLOW_ORIGIN (grpc_static_slice_table[58])
 /* "age" */
-#define GRPC_MDSTR_AGE (grpc_static_slice_table[61])
+#define GRPC_MDSTR_AGE (grpc_static_slice_table[59])
 /* "allow" */
-#define GRPC_MDSTR_ALLOW (grpc_static_slice_table[62])
+#define GRPC_MDSTR_ALLOW (grpc_static_slice_table[60])
 /* "authorization" */
-#define GRPC_MDSTR_AUTHORIZATION (grpc_static_slice_table[63])
+#define GRPC_MDSTR_AUTHORIZATION (grpc_static_slice_table[61])
 /* "cache-control" */
-#define GRPC_MDSTR_CACHE_CONTROL (grpc_static_slice_table[64])
+#define GRPC_MDSTR_CACHE_CONTROL (grpc_static_slice_table[62])
 /* "content-disposition" */
-#define GRPC_MDSTR_CONTENT_DISPOSITION (grpc_static_slice_table[65])
+#define GRPC_MDSTR_CONTENT_DISPOSITION (grpc_static_slice_table[63])
 /* "content-language" */
-#define GRPC_MDSTR_CONTENT_LANGUAGE (grpc_static_slice_table[66])
+#define GRPC_MDSTR_CONTENT_LANGUAGE (grpc_static_slice_table[64])
 /* "content-length" */
-#define GRPC_MDSTR_CONTENT_LENGTH (grpc_static_slice_table[67])
+#define GRPC_MDSTR_CONTENT_LENGTH (grpc_static_slice_table[65])
 /* "content-location" */
-#define GRPC_MDSTR_CONTENT_LOCATION (grpc_static_slice_table[68])
+#define GRPC_MDSTR_CONTENT_LOCATION (grpc_static_slice_table[66])
 /* "content-range" */
-#define GRPC_MDSTR_CONTENT_RANGE (grpc_static_slice_table[69])
+#define GRPC_MDSTR_CONTENT_RANGE (grpc_static_slice_table[67])
 /* "cookie" */
-#define GRPC_MDSTR_COOKIE (grpc_static_slice_table[70])
+#define GRPC_MDSTR_COOKIE (grpc_static_slice_table[68])
 /* "date" */
-#define GRPC_MDSTR_DATE (grpc_static_slice_table[71])
+#define GRPC_MDSTR_DATE (grpc_static_slice_table[69])
 /* "etag" */
-#define GRPC_MDSTR_ETAG (grpc_static_slice_table[72])
+#define GRPC_MDSTR_ETAG (grpc_static_slice_table[70])
 /* "expect" */
-#define GRPC_MDSTR_EXPECT (grpc_static_slice_table[73])
+#define GRPC_MDSTR_EXPECT (grpc_static_slice_table[71])
 /* "expires" */
-#define GRPC_MDSTR_EXPIRES (grpc_static_slice_table[74])
+#define GRPC_MDSTR_EXPIRES (grpc_static_slice_table[72])
 /* "from" */
-#define GRPC_MDSTR_FROM (grpc_static_slice_table[75])
+#define GRPC_MDSTR_FROM (grpc_static_slice_table[73])
 /* "if-match" */
-#define GRPC_MDSTR_IF_MATCH (grpc_static_slice_table[76])
+#define GRPC_MDSTR_IF_MATCH (grpc_static_slice_table[74])
 /* "if-modified-since" */
-#define GRPC_MDSTR_IF_MODIFIED_SINCE (grpc_static_slice_table[77])
+#define GRPC_MDSTR_IF_MODIFIED_SINCE (grpc_static_slice_table[75])
 /* "if-none-match" */
-#define GRPC_MDSTR_IF_NONE_MATCH (grpc_static_slice_table[78])
+#define GRPC_MDSTR_IF_NONE_MATCH (grpc_static_slice_table[76])
 /* "if-range" */
-#define GRPC_MDSTR_IF_RANGE (grpc_static_slice_table[79])
+#define GRPC_MDSTR_IF_RANGE (grpc_static_slice_table[77])
 /* "if-unmodified-since" */
-#define GRPC_MDSTR_IF_UNMODIFIED_SINCE (grpc_static_slice_table[80])
+#define GRPC_MDSTR_IF_UNMODIFIED_SINCE (grpc_static_slice_table[78])
 /* "last-modified" */
-#define GRPC_MDSTR_LAST_MODIFIED (grpc_static_slice_table[81])
+#define GRPC_MDSTR_LAST_MODIFIED (grpc_static_slice_table[79])
 /* "lb-cost-bin" */
-#define GRPC_MDSTR_LB_COST_BIN (grpc_static_slice_table[82])
+#define GRPC_MDSTR_LB_COST_BIN (grpc_static_slice_table[80])
 /* "link" */
-#define GRPC_MDSTR_LINK (grpc_static_slice_table[83])
+#define GRPC_MDSTR_LINK (grpc_static_slice_table[81])
 /* "location" */
-#define GRPC_MDSTR_LOCATION (grpc_static_slice_table[84])
+#define GRPC_MDSTR_LOCATION (grpc_static_slice_table[82])
 /* "max-forwards" */
-#define GRPC_MDSTR_MAX_FORWARDS (grpc_static_slice_table[85])
+#define GRPC_MDSTR_MAX_FORWARDS (grpc_static_slice_table[83])
 /* "proxy-authenticate" */
-#define GRPC_MDSTR_PROXY_AUTHENTICATE (grpc_static_slice_table[86])
+#define GRPC_MDSTR_PROXY_AUTHENTICATE (grpc_static_slice_table[84])
 /* "proxy-authorization" */
-#define GRPC_MDSTR_PROXY_AUTHORIZATION (grpc_static_slice_table[87])
+#define GRPC_MDSTR_PROXY_AUTHORIZATION (grpc_static_slice_table[85])
 /* "range" */
-#define GRPC_MDSTR_RANGE (grpc_static_slice_table[88])
+#define GRPC_MDSTR_RANGE (grpc_static_slice_table[86])
 /* "referer" */
-#define GRPC_MDSTR_REFERER (grpc_static_slice_table[89])
+#define GRPC_MDSTR_REFERER (grpc_static_slice_table[87])
 /* "refresh" */
-#define GRPC_MDSTR_REFRESH (grpc_static_slice_table[90])
+#define GRPC_MDSTR_REFRESH (grpc_static_slice_table[88])
 /* "retry-after" */
-#define GRPC_MDSTR_RETRY_AFTER (grpc_static_slice_table[91])
+#define GRPC_MDSTR_RETRY_AFTER (grpc_static_slice_table[89])
 /* "server" */
-#define GRPC_MDSTR_SERVER (grpc_static_slice_table[92])
+#define GRPC_MDSTR_SERVER (grpc_static_slice_table[90])
 /* "set-cookie" */
-#define GRPC_MDSTR_SET_COOKIE (grpc_static_slice_table[93])
+#define GRPC_MDSTR_SET_COOKIE (grpc_static_slice_table[91])
 /* "strict-transport-security" */
-#define GRPC_MDSTR_STRICT_TRANSPORT_SECURITY (grpc_static_slice_table[94])
+#define GRPC_MDSTR_STRICT_TRANSPORT_SECURITY (grpc_static_slice_table[92])
 /* "transfer-encoding" */
-#define GRPC_MDSTR_TRANSFER_ENCODING (grpc_static_slice_table[95])
+#define GRPC_MDSTR_TRANSFER_ENCODING (grpc_static_slice_table[93])
 /* "vary" */
-#define GRPC_MDSTR_VARY (grpc_static_slice_table[96])
+#define GRPC_MDSTR_VARY (grpc_static_slice_table[94])
 /* "via" */
-#define GRPC_MDSTR_VIA (grpc_static_slice_table[97])
+#define GRPC_MDSTR_VIA (grpc_static_slice_table[95])
 /* "www-authenticate" */
-#define GRPC_MDSTR_WWW_AUTHENTICATE (grpc_static_slice_table[98])
+#define GRPC_MDSTR_WWW_AUTHENTICATE (grpc_static_slice_table[96])
 /* "identity,deflate" */
-#define GRPC_MDSTR_IDENTITY_COMMA_DEFLATE (grpc_static_slice_table[99])
+#define GRPC_MDSTR_IDENTITY_COMMA_DEFLATE (grpc_static_slice_table[97])
 /* "identity,gzip" */
-#define GRPC_MDSTR_IDENTITY_COMMA_GZIP (grpc_static_slice_table[100])
+#define GRPC_MDSTR_IDENTITY_COMMA_GZIP (grpc_static_slice_table[98])
 /* "deflate,gzip" */
-#define GRPC_MDSTR_DEFLATE_COMMA_GZIP (grpc_static_slice_table[101])
+#define GRPC_MDSTR_DEFLATE_COMMA_GZIP (grpc_static_slice_table[99])
 /* "identity,deflate,gzip" */
 #define GRPC_MDSTR_IDENTITY_COMMA_DEFLATE_COMMA_GZIP \
-  (grpc_static_slice_table[102])
+  (grpc_static_slice_table[100])
 
 extern const grpc_slice_refcount_vtable grpc_static_metadata_vtable;
 extern grpc_slice_refcount
@@ -590,5 +586,4 @@ extern const uint8_t grpc_static_accept_stream_encoding_metadata[4];
   (GRPC_MAKE_MDELEM(&grpc_static_mdelem_table                                  \
                         [grpc_static_accept_stream_encoding_metadata[(algs)]], \
                     GRPC_MDELEM_STORAGE_STATIC))
-
 #endif /* GRPC_CORE_LIB_TRANSPORT_STATIC_METADATA_H */
diff --git a/src/core/tsi/alts_transport_security.cc b/src/core/tsi/alts_transport_security.cc
index ddd75cbd02..1654d893d0 100644
--- a/src/core/tsi/alts_transport_security.cc
+++ b/src/core/tsi/alts_transport_security.cc
@@ -26,17 +26,36 @@ alts_shared_resource* alts_get_shared_resource(void) {
   return &g_alts_resource;
 }
 
+static void grpc_tsi_alts_wait_for_cq_drain() {
+  gpr_mu_lock(&g_alts_resource.mu);
+  while (!g_alts_resource.is_cq_drained) {
+    gpr_cv_wait(&g_alts_resource.cv, &g_alts_resource.mu,
+                gpr_inf_future(GPR_CLOCK_REALTIME));
+  }
+  gpr_mu_unlock(&g_alts_resource.mu);
+}
+
+void grpc_tsi_alts_signal_for_cq_destroy() {
+  gpr_mu_lock(&g_alts_resource.mu);
+  g_alts_resource.is_cq_drained = true;
+  gpr_cv_signal(&g_alts_resource.cv);
+  gpr_mu_unlock(&g_alts_resource.mu);
+}
+
 void grpc_tsi_alts_init() {
   memset(&g_alts_resource, 0, sizeof(alts_shared_resource));
   gpr_mu_init(&g_alts_resource.mu);
+  gpr_cv_init(&g_alts_resource.cv);
 }
 
 void grpc_tsi_alts_shutdown() {
-  gpr_mu_destroy(&g_alts_resource.mu);
-  if (g_alts_resource.cq == nullptr) {
-    return;
+  if (g_alts_resource.cq != nullptr) {
+    grpc_completion_queue_shutdown(g_alts_resource.cq);
+    grpc_tsi_alts_wait_for_cq_drain();
+    grpc_completion_queue_destroy(g_alts_resource.cq);
+    grpc_channel_destroy(g_alts_resource.channel);
+    gpr_thd_join(g_alts_resource.thread_id);
   }
-  grpc_completion_queue_destroy(g_alts_resource.cq);
-  grpc_channel_destroy(g_alts_resource.channel);
-  gpr_thd_join(g_alts_resource.thread_id);
+  gpr_cv_destroy(&g_alts_resource.cv);
+  gpr_mu_destroy(&g_alts_resource.mu);
 }
diff --git a/src/core/tsi/alts_transport_security.h b/src/core/tsi/alts_transport_security.h
index c90e31478e..5d693d04af 100644
--- a/src/core/tsi/alts_transport_security.h
+++ b/src/core/tsi/alts_transport_security.h
@@ -28,10 +28,17 @@ typedef struct alts_shared_resource {
   grpc_channel* channel;
   grpc_completion_queue* cq;
   gpr_mu mu;
+  gpr_cv cv;
+  bool is_cq_drained;
 } alts_shared_resource;
 
 /* This method returns the address of alts_shared_resource object shared by all
  *    TSI handshakes. */
 alts_shared_resource* alts_get_shared_resource(void);
 
+/* This method signals the thread that invokes grpc_tsi_alts_shutdown() to
+ * continue with destroying the cq as a part of shutdown process. */
+
+void grpc_tsi_alts_signal_for_cq_destroy(void);
+
 #endif /* GRPC_CORE_TSI_ALTS_TRANSPORT_SECURITY_H */
diff --git a/src/cpp/client/client_context.cc b/src/cpp/client/client_context.cc
index dafa8081e9..5c90838440 100644
--- a/src/cpp/client/client_context.cc
+++ b/src/cpp/client/client_context.cc
@@ -96,6 +96,7 @@ void ClientContext::set_call(grpc_call* call,
 
 void ClientContext::set_compression_algorithm(
     grpc_compression_algorithm algorithm) {
+  compression_algorithm_ = algorithm;
   const char* algorithm_name = nullptr;
   if (!grpc_compression_algorithm_name(algorithm, &algorithm_name)) {
     gpr_log(GPR_ERROR, "Name for compression algorithm '%d' unknown.",
diff --git a/src/cpp/server/server_context.cc b/src/cpp/server/server_context.cc
index f0cbbdb86d..878be1c4b6 100644
--- a/src/cpp/server/server_context.cc
+++ b/src/cpp/server/server_context.cc
@@ -190,6 +190,7 @@ bool ServerContext::IsCancelled() const {
 
 void ServerContext::set_compression_algorithm(
     grpc_compression_algorithm algorithm) {
+  compression_algorithm_ = algorithm;
   const char* algorithm_name = nullptr;
   if (!grpc_compression_algorithm_name(algorithm, &algorithm_name)) {
     gpr_log(GPR_ERROR, "Name for compression algorithm '%d' unknown.",
diff --git a/src/csharp/Grpc.Core/Internal/NativeExtension.cs b/src/csharp/Grpc.Core/Internal/NativeExtension.cs
index 4cbde900d9..e514608c28 100644
--- a/src/csharp/Grpc.Core/Internal/NativeExtension.cs
+++ b/src/csharp/Grpc.Core/Internal/NativeExtension.cs
@@ -39,7 +39,7 @@ namespace Grpc.Core.Internal
         {
             this.nativeMethods = new NativeMethods(Load());
             
-            // Redirect the the native logs as the very first thing after loading the native extension
+            // Redirect the native logs as the very first thing after loading the native extension
             // to make sure we don't lose any logs.
             NativeLogRedirector.Redirect(this.nativeMethods);
 
diff --git a/src/csharp/Grpc.Core/SourceLink.csproj.include b/src/csharp/Grpc.Core/SourceLink.csproj.include
index 02ae79fb89..0ec273f57e 100755
--- a/src/csharp/Grpc.Core/SourceLink.csproj.include
+++ b/src/csharp/Grpc.Core/SourceLink.csproj.include
@@ -13,7 +13,7 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="SourceLink.Embed.AllSourceFiles" Version="2.7.3" PrivateAssets="all" />
+    <PackageReference Include="SourceLink.Create.CommandLine" Version="2.7.6" PrivateAssets="all" />
   </ItemGroup>
 
 </Project>
diff --git a/src/csharp/Grpc.IntegrationTesting/InteropClient.cs b/src/csharp/Grpc.IntegrationTesting/InteropClient.cs
index 10c31c455e..e83a8a7274 100644
--- a/src/csharp/Grpc.IntegrationTesting/InteropClient.cs
+++ b/src/csharp/Grpc.IntegrationTesting/InteropClient.cs
@@ -685,7 +685,7 @@ namespace Grpc.IntegrationTesting
 
         private static Metadata CreateClientCompressionMetadata(bool compressed)
         {
-            var algorithmName = compressed ? "message/gzip" : "identity";
+            var algorithmName = compressed ? "gzip" : "identity";
             return new Metadata
             {
                 { new Metadata.Entry(Metadata.CompressionRequestAlgorithmMetadataKey, algorithmName) }
diff --git a/src/objective-c/GRPCClient/GRPCCall+ChannelArg.m b/src/objective-c/GRPCClient/GRPCCall+ChannelArg.m
index d44e39f551..805e54b890 100644
--- a/src/objective-c/GRPCClient/GRPCCall+ChannelArg.m
+++ b/src/objective-c/GRPCClient/GRPCCall+ChannelArg.m
@@ -46,10 +46,10 @@
       hostConfig.compressAlgorithm = GRPC_COMPRESS_NONE;
       break;
     case GRPCCompressDeflate:
-      hostConfig.compressAlgorithm = GRPC_COMPRESS_MESSAGE_DEFLATE;
+      hostConfig.compressAlgorithm = GRPC_COMPRESS_DEFLATE;
       break;
     case GRPCCompressGzip:
-      hostConfig.compressAlgorithm = GRPC_COMPRESS_MESSAGE_GZIP;
+      hostConfig.compressAlgorithm = GRPC_COMPRESS_GZIP;
       break;
     default:
       NSLog(@"Invalid compression algorithm");
diff --git a/src/objective-c/GRPCClient/private/GRPCHost.m b/src/objective-c/GRPCClient/private/GRPCHost.m
index 665943f181..ceae9607d7 100644
--- a/src/objective-c/GRPCClient/private/GRPCHost.m
+++ b/src/objective-c/GRPCClient/private/GRPCHost.m
@@ -225,8 +225,6 @@ static GRPCConnectivityMonitor *connectivityMonitor = nil;
   if (_responseSizeLimitOverride) {
     args[@GRPC_ARG_MAX_RECEIVE_MESSAGE_LENGTH] = _responseSizeLimitOverride;
   }
-  // Use 10000ms initial backoff time for correct behavior on bad/slow networks  
-  args[@GRPC_ARG_INITIAL_RECONNECT_BACKOFF_MS] = @10000;
 
   if (_compressAlgorithm != GRPC_COMPRESS_NONE) {
     args[@GRPC_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM] =
diff --git a/src/objective-c/ProtoRPC/ProtoMethod.m b/src/objective-c/ProtoRPC/ProtoMethod.m
index 4bef10af0e..ed585acfb9 100644
--- a/src/objective-c/ProtoRPC/ProtoMethod.m
+++ b/src/objective-c/ProtoRPC/ProtoMethod.m
@@ -18,7 +18,10 @@
 
 #import "ProtoMethod.h"
 
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-implementations"
 @implementation ProtoMethod
+#pragma clang diagnostic pop
 - (instancetype)initWithPackage:(NSString *)package
                         service:(NSString *)service
                          method:(NSString *)method {
diff --git a/src/objective-c/ProtoRPC/ProtoRPC.m b/src/objective-c/ProtoRPC/ProtoRPC.m
index 1ecfcc5b0e..20b9d04cd8 100644
--- a/src/objective-c/ProtoRPC/ProtoRPC.m
+++ b/src/objective-c/ProtoRPC/ProtoRPC.m
@@ -42,7 +42,10 @@ static NSError *ErrorForBadProto(id proto, Class expectedClass, NSError *parsing
                          userInfo:info];
 }
 
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-implementations"
 @implementation ProtoRPC {
+#pragma clang diagnostic pop
   id<GRXWriteable> _responseWriteable;
 }
 
diff --git a/src/objective-c/ProtoRPC/ProtoService.m b/src/objective-c/ProtoRPC/ProtoService.m
index be6089f0a4..611cee46bf 100644
--- a/src/objective-c/ProtoRPC/ProtoService.m
+++ b/src/objective-c/ProtoRPC/ProtoService.m
@@ -24,7 +24,10 @@
 #import "ProtoMethod.h"
 #import "ProtoRPC.h"
 
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-implementations"
 @implementation ProtoService {
+#pragma clang diagnostic pop
   NSString *_host;
   NSString *_packageName;
   NSString *_serviceName;
diff --git a/src/objective-c/RxLibrary/GRXConcurrentWriteable.m b/src/objective-c/RxLibrary/GRXConcurrentWriteable.m
index 37bc975f87..c262313496 100644
--- a/src/objective-c/RxLibrary/GRXConcurrentWriteable.m
+++ b/src/objective-c/RxLibrary/GRXConcurrentWriteable.m
@@ -64,21 +64,25 @@
 }
 
 - (void)enqueueSuccessfulCompletion {
+  __weak typeof(self) weakSelf = self;
   dispatch_async(_writeableQueue, ^{
-    BOOL finished = NO;
-    @synchronized (self) {
-      if (!_alreadyFinished) {
-        _alreadyFinished = YES;
-      } else {
-        finished = YES;
+    typeof(self) strongSelf = weakSelf;
+    if (strongSelf) {
+      BOOL finished = NO;
+      @synchronized (self) {
+        if (!strongSelf->_alreadyFinished) {
+          strongSelf->_alreadyFinished = YES;
+        } else {
+          finished = YES;
+        }
+      }
+      if (!finished) {
+        // Cancellation is now impossible. None of the other three blocks can run concurrently with
+        // this one.
+        [self.writeable writesFinishedWithError:nil];
+        // Skip any possible message to the wrapped writeable enqueued after this one.
+        self.writeable = nil;
       }
-    }
-    if (!finished) {
-      // Cancellation is now impossible. None of the other three blocks can run concurrently with
-      // this one.
-      [self.writeable writesFinishedWithError:nil];
-      // Skip any possible message to the wrapped writeable enqueued after this one.
-      self.writeable = nil;
     }
   });
 }
diff --git a/src/python/grpcio/grpc/_cython/_cygrpc/grpc.pxi b/src/python/grpcio/grpc/_cython/_cygrpc/grpc.pxi
index 30253fc20c..a4c0319553 100644
--- a/src/python/grpcio/grpc/_cython/_cygrpc/grpc.pxi
+++ b/src/python/grpcio/grpc/_cython/_cygrpc/grpc.pxi
@@ -557,8 +557,8 @@ cdef extern from "grpc/compression.h":
 
   ctypedef enum grpc_compression_algorithm:
     GRPC_COMPRESS_NONE
-    GRPC_COMPRESS_MESSAGE_DEFLATE
-    GRPC_COMPRESS_MESSAGE_GZIP
+    GRPC_COMPRESS_DEFLATE
+    GRPC_COMPRESS_GZIP
     GRPC_COMPRESS_STREAM_GZIP
     GRPC_COMPRESS_ALGORITHMS_COUNT
 
diff --git a/src/python/grpcio/grpc/_cython/_cygrpc/records.pyx.pxi b/src/python/grpcio/grpc/_cython/_cygrpc/records.pyx.pxi
index 1bcea8d347..ecd991685f 100644
--- a/src/python/grpcio/grpc/_cython/_cygrpc/records.pyx.pxi
+++ b/src/python/grpcio/grpc/_cython/_cygrpc/records.pyx.pxi
@@ -112,8 +112,8 @@ class OperationType:
 
 class CompressionAlgorithm:
   none = GRPC_COMPRESS_NONE
-  deflate = GRPC_COMPRESS_MESSAGE_DEFLATE
-  gzip = GRPC_COMPRESS_MESSAGE_GZIP
+  deflate = GRPC_COMPRESS_DEFLATE
+  gzip = GRPC_COMPRESS_GZIP
 
 
 class CompressionLevel:
diff --git a/src/python/grpcio/grpc_core_dependencies.py b/src/python/grpcio/grpc_core_dependencies.py
index 72776ea807..db7c390a03 100644
--- a/src/python/grpcio/grpc_core_dependencies.py
+++ b/src/python/grpcio/grpc_core_dependencies.py
@@ -67,7 +67,6 @@ CORE_SOURCE_FILES = [
     'src/core/lib/channel/handshaker_registry.cc',
     'src/core/lib/compression/compression.cc',
     'src/core/lib/compression/compression_internal.cc',
-    'src/core/lib/compression/compression_ruby.cc',
     'src/core/lib/compression/message_compress.cc',
     'src/core/lib/compression/stream_compression.cc',
     'src/core/lib/compression/stream_compression_gzip.cc',
diff --git a/src/python/grpcio_tests/tests/unit/_reconnect_test.py b/src/python/grpcio_tests/tests/unit/_reconnect_test.py
index 10aee9fb4f..8acba5a30b 100644
--- a/src/python/grpcio_tests/tests/unit/_reconnect_test.py
+++ b/src/python/grpcio_tests/tests/unit/_reconnect_test.py
@@ -14,6 +14,7 @@
 """Tests that a channel will reconnect if a connection is dropped"""
 
 import socket
+import time
 import unittest
 
 import grpc
@@ -88,6 +89,7 @@ class ReconnectTest(unittest.TestCase):
         multi_callable = channel.unary_unary(_UNARY_UNARY)
         self.assertEqual(_RESPONSE, multi_callable(_REQUEST))
         server.stop(None)
+        time.sleep(1)
         server = grpc.server(server_pool, (handler,))
         server.add_insecure_port('[::]:{}'.format(port))
         server.start()
diff --git a/src/ruby/bin/apis/pubsub_demo.rb b/src/ruby/bin/apis/pubsub_demo.rb
index 6f155650ed..c565771d45 100755
--- a/src/ruby/bin/apis/pubsub_demo.rb
+++ b/src/ruby/bin/apis/pubsub_demo.rb
@@ -193,7 +193,7 @@ end
 Args = Struct.new(:host, :port, :action, :project_id, :topic_name,
                   :sub_name)
 
-# validates the the command line options, returning them as an Arg.
+# validates the command line options, returning them as an Arg.
 def parse_args
   args = Args.new('pubsub-staging.googleapis.com',
                    443, 'list_some_topics', 'stoked-keyword-656')
diff --git a/src/ruby/ext/grpc/rb_channel.c b/src/ruby/ext/grpc/rb_channel.c
index 1d11a53aa7..c56ac21645 100644
--- a/src/ruby/ext/grpc/rb_channel.c
+++ b/src/ruby/ext/grpc/rb_channel.c
@@ -362,8 +362,8 @@ static void wait_for_watch_state_op_complete_unblocking_func(void* arg) {
 
 /* Wait until the channel's connectivity state becomes different from
  * "last_state", or "deadline" expires.
- * Returns true if the the channel's connectivity state becomes
- * different from "last_state" within "deadline".
+ * Returns true if the channel's connectivity state becomes different
+ * from "last_state" within "deadline".
  * Returns false if "deadline" expires before the channel's connectivity
  * state changes from "last_state".
  * */
diff --git a/src/ruby/ext/grpc/rb_compression_options.c b/src/ruby/ext/grpc/rb_compression_options.c
index a7e37099af..e24f20d2f9 100644
--- a/src/ruby/ext/grpc/rb_compression_options.c
+++ b/src/ruby/ext/grpc/rb_compression_options.c
@@ -23,7 +23,6 @@
 #include "rb_grpc_imports.generated.h"
 
 #include <grpc/compression.h>
-#include <grpc/compression_ruby.h>
 #include <grpc/grpc.h>
 #include <grpc/impl/codegen/compression_types.h>
 #include <grpc/impl/codegen/grpc_types.h>
@@ -175,7 +174,7 @@ void grpc_rb_compression_options_algorithm_name_to_value_internal(
   /* Raise an error if the name isn't recognized as a compression algorithm by
    * the algorithm parse function
    * in GRPC core. */
-  if (!grpc_compression_algorithm_parse_ruby(name_slice, algorithm_value)) {
+  if (!grpc_compression_algorithm_parse(name_slice, algorithm_value)) {
     tmp_str = grpc_slice_to_c_string(name_slice);
     rb_raise(rb_eNameError, "Invalid compression algorithm name: %s", tmp_str);
   }
@@ -287,7 +286,7 @@ VALUE grpc_rb_compression_options_algorithm_value_to_name_internal(
     grpc_compression_algorithm internal_value) {
   char* algorithm_name = NULL;
 
-  if (!grpc_compression_algorithm_name_ruby(internal_value, &algorithm_name)) {
+  if (!grpc_compression_algorithm_name(internal_value, &algorithm_name)) {
     rb_raise(rb_eArgError, "Failed to convert algorithm value to name");
   }
 
diff --git a/src/ruby/ext/grpc/rb_grpc_imports.generated.c b/src/ruby/ext/grpc/rb_grpc_imports.generated.c
index dbba16818f..e9c446ef34 100644
--- a/src/ruby/ext/grpc/rb_grpc_imports.generated.c
+++ b/src/ruby/ext/grpc/rb_grpc_imports.generated.c
@@ -31,8 +31,6 @@ grpc_compression_options_init_type grpc_compression_options_init_import;
 grpc_compression_options_enable_algorithm_type grpc_compression_options_enable_algorithm_import;
 grpc_compression_options_disable_algorithm_type grpc_compression_options_disable_algorithm_import;
 grpc_compression_options_is_algorithm_enabled_type grpc_compression_options_is_algorithm_enabled_import;
-grpc_compression_algorithm_parse_ruby_type grpc_compression_algorithm_parse_ruby_import;
-grpc_compression_algorithm_name_ruby_type grpc_compression_algorithm_name_ruby_import;
 grpc_metadata_array_init_type grpc_metadata_array_init_import;
 grpc_metadata_array_destroy_type grpc_metadata_array_destroy_import;
 grpc_call_details_init_type grpc_call_details_init_import;
@@ -286,8 +284,6 @@ void grpc_rb_load_imports(HMODULE library) {
   grpc_compression_options_enable_algorithm_import = (grpc_compression_options_enable_algorithm_type) GetProcAddress(library, "grpc_compression_options_enable_algorithm");
   grpc_compression_options_disable_algorithm_import = (grpc_compression_options_disable_algorithm_type) GetProcAddress(library, "grpc_compression_options_disable_algorithm");
   grpc_compression_options_is_algorithm_enabled_import = (grpc_compression_options_is_algorithm_enabled_type) GetProcAddress(library, "grpc_compression_options_is_algorithm_enabled");
-  grpc_compression_algorithm_parse_ruby_import = (grpc_compression_algorithm_parse_ruby_type) GetProcAddress(library, "grpc_compression_algorithm_parse_ruby");
-  grpc_compression_algorithm_name_ruby_import = (grpc_compression_algorithm_name_ruby_type) GetProcAddress(library, "grpc_compression_algorithm_name_ruby");
   grpc_metadata_array_init_import = (grpc_metadata_array_init_type) GetProcAddress(library, "grpc_metadata_array_init");
   grpc_metadata_array_destroy_import = (grpc_metadata_array_destroy_type) GetProcAddress(library, "grpc_metadata_array_destroy");
   grpc_call_details_init_import = (grpc_call_details_init_type) GetProcAddress(library, "grpc_call_details_init");
diff --git a/src/ruby/ext/grpc/rb_grpc_imports.generated.h b/src/ruby/ext/grpc/rb_grpc_imports.generated.h
index 7c2766f6e6..5c724de089 100644
--- a/src/ruby/ext/grpc/rb_grpc_imports.generated.h
+++ b/src/ruby/ext/grpc/rb_grpc_imports.generated.h
@@ -26,7 +26,6 @@
 #include <windows.h>
 
 #include <grpc/compression.h>
-#include <grpc/compression_ruby.h>
 #include <grpc/grpc.h>
 #include <grpc/grpc_posix.h>
 #include <grpc/grpc_security.h>
@@ -71,12 +70,6 @@ extern grpc_compression_options_disable_algorithm_type grpc_compression_options_
 typedef int(*grpc_compression_options_is_algorithm_enabled_type)(const grpc_compression_options* opts, grpc_compression_algorithm algorithm);
 extern grpc_compression_options_is_algorithm_enabled_type grpc_compression_options_is_algorithm_enabled_import;
 #define grpc_compression_options_is_algorithm_enabled grpc_compression_options_is_algorithm_enabled_import
-typedef int(*grpc_compression_algorithm_parse_ruby_type)(grpc_slice value, grpc_compression_algorithm* algorithm);
-extern grpc_compression_algorithm_parse_ruby_type grpc_compression_algorithm_parse_ruby_import;
-#define grpc_compression_algorithm_parse_ruby grpc_compression_algorithm_parse_ruby_import
-typedef int(*grpc_compression_algorithm_name_ruby_type)(grpc_compression_algorithm algorithm, const char** name);
-extern grpc_compression_algorithm_name_ruby_type grpc_compression_algorithm_name_ruby_import;
-#define grpc_compression_algorithm_name_ruby grpc_compression_algorithm_name_ruby_import
 typedef void(*grpc_metadata_array_init_type)(grpc_metadata_array* array);
 extern grpc_metadata_array_init_type grpc_metadata_array_init_import;
 #define grpc_metadata_array_init grpc_metadata_array_init_import
diff --git a/src/ruby/pb/test/client.rb b/src/ruby/pb/test/client.rb
index a110fec960..63959d9b14 100755
--- a/src/ruby/pb/test/client.rb
+++ b/src/ruby/pb/test/client.rb
@@ -707,7 +707,7 @@ Args = Struct.new(:default_service_account, :host, :host_override,
                   :oauth_scope, :port, :secure, :test_case,
                   :use_test_ca)
 
-# validates the the command line options, returning them as a Hash.
+# validates the command line options, returning them as a Hash.
 def parse_args
   args = Args.new
   args.host_override = 'foo.test.google.fr'
diff --git a/src/ruby/pb/test/server.rb b/src/ruby/pb/test/server.rb
index f3257d3d2d..1c82ba0b9a 100755
--- a/src/ruby/pb/test/server.rb
+++ b/src/ruby/pb/test/server.rb
@@ -211,7 +211,7 @@ class TestTarget < Grpc::Testing::TestService::Service
   end
 end
 
-# validates the the command line options, returning them as a Hash.
+# validates the command line options, returning them as a Hash.
 def parse_options
   options = {
     'port' => nil,