Merge branch 'master' of https://github.com/grpc/grpc into server_creds_auth_md_processor

43 files changed, 929 insertions, 106 deletions

diff --git a/test/core/end2end/dualstack_socket_test.c b/test/core/end2end/dualstack_socket_test.c
index c98baeffda..48a88be525 100644
--- a/test/core/end2end/dualstack_socket_test.c
+++ b/test/core/end2end/dualstack_socket_test.c
@@ -131,8 +131,8 @@ void test_connect(const char *server_host, const char *client_host, int port,
   }
 
   /* Send a trivial request. */
-  c = grpc_channel_create_call(client, cq, "/foo", "foo.test.google.fr",
-                               deadline);
+  c = grpc_channel_create_call(client, NULL, GRPC_PROPAGATE_DEFAULTS, cq,
+                               "/foo", "foo.test.google.fr", deadline);
   GPR_ASSERT(c);
 
   op = ops;
diff --git a/test/core/end2end/fixtures/chttp2_fullstack_compression.c b/test/core/end2end/fixtures/chttp2_fullstack_compression.c
index 0ee24c01b5..a75075d1d4 100644
--- a/test/core/end2end/fixtures/chttp2_fullstack_compression.c
+++ b/test/core/end2end/fixtures/chttp2_fullstack_compression.c
@@ -53,8 +53,8 @@
 
 typedef struct fullstack_compression_fixture_data {
   char *localaddr;
-  grpc_channel_args* client_args_compression;
-  grpc_channel_args* server_args_compression;
+  grpc_channel_args *client_args_compression;
+  grpc_channel_args *server_args_compression;
 } fullstack_compression_fixture_data;
 
 static grpc_end2end_test_fixture chttp2_create_fixture_fullstack_compression(
@@ -75,7 +75,7 @@ static grpc_end2end_test_fixture chttp2_create_fixture_fullstack_compression(
 }
 
 void chttp2_init_client_fullstack_compression(grpc_end2end_test_fixture *f,
-                                  grpc_channel_args *client_args) {
+                                              grpc_channel_args *client_args) {
   fullstack_compression_fixture_data *ffd = f->fixture_data;
   if (ffd->client_args_compression != NULL) {
     grpc_channel_args_destroy(ffd->client_args_compression);
@@ -87,7 +87,7 @@ void chttp2_init_client_fullstack_compression(grpc_end2end_test_fixture *f,
 }
 
 void chttp2_init_server_fullstack_compression(grpc_end2end_test_fixture *f,
-                                  grpc_channel_args *server_args) {
+                                              grpc_channel_args *server_args) {
   fullstack_compression_fixture_data *ffd = f->fixture_data;
   if (ffd->server_args_compression != NULL) {
     grpc_channel_args_destroy(ffd->server_args_compression);
diff --git a/test/core/end2end/fixtures/chttp2_fullstack_with_proxy.c b/test/core/end2end/fixtures/chttp2_fullstack_with_proxy.c
new file mode 100644
index 0000000000..248cc7d6e7
--- /dev/null
+++ b/test/core/end2end/fixtures/chttp2_fullstack_with_proxy.c
@@ -0,0 +1,132 @@
+/*
+ *
+ * Copyright 2015, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "test/core/end2end/end2end_tests.h"
+
+#include <string.h>
+
+#include "src/core/channel/client_channel.h"
+#include "src/core/channel/connected_channel.h"
+#include "src/core/channel/http_server_filter.h"
+#include "src/core/surface/channel.h"
+#include "src/core/surface/server.h"
+#include "src/core/transport/chttp2_transport.h"
+#include <grpc/support/alloc.h>
+#include <grpc/support/host_port.h>
+#include <grpc/support/log.h>
+#include <grpc/support/sync.h>
+#include <grpc/support/thd.h>
+#include <grpc/support/useful.h>
+#include "test/core/end2end/fixtures/proxy.h"
+#include "test/core/util/port.h"
+#include "test/core/util/test_config.h"
+
+typedef struct fullstack_fixture_data {
+  grpc_end2end_proxy *proxy;
+} fullstack_fixture_data;
+
+static grpc_server *create_proxy_server(const char *port) {
+  grpc_server *s = grpc_server_create(NULL);
+  GPR_ASSERT(grpc_server_add_insecure_http2_port(s, port));
+  return s;
+}
+
+static grpc_channel *create_proxy_client(const char *target) {
+  return grpc_insecure_channel_create(target, NULL);
+}
+
+static const grpc_end2end_proxy_def proxy_def = {create_proxy_server,
+                                                 create_proxy_client};
+
+static grpc_end2end_test_fixture chttp2_create_fixture_fullstack(
+    grpc_channel_args *client_args, grpc_channel_args *server_args) {
+  grpc_end2end_test_fixture f;
+  fullstack_fixture_data *ffd = gpr_malloc(sizeof(fullstack_fixture_data));
+  memset(&f, 0, sizeof(f));
+
+  ffd->proxy = grpc_end2end_proxy_create(&proxy_def);
+
+  f.fixture_data = ffd;
+  f.cq = grpc_completion_queue_create();
+
+  return f;
+}
+
+void chttp2_init_client_fullstack(grpc_end2end_test_fixture *f,
+                                  grpc_channel_args *client_args) {
+  fullstack_fixture_data *ffd = f->fixture_data;
+  f->client = grpc_insecure_channel_create(
+      grpc_end2end_proxy_get_client_target(ffd->proxy), client_args);
+  GPR_ASSERT(f->client);
+}
+
+void chttp2_init_server_fullstack(grpc_end2end_test_fixture *f,
+                                  grpc_channel_args *server_args) {
+  fullstack_fixture_data *ffd = f->fixture_data;
+  if (f->server) {
+    grpc_server_destroy(f->server);
+  }
+  f->server = grpc_server_create(server_args);
+  grpc_server_register_completion_queue(f->server, f->cq);
+  GPR_ASSERT(grpc_server_add_insecure_http2_port(
+      f->server, grpc_end2end_proxy_get_server_port(ffd->proxy)));
+  grpc_server_start(f->server);
+}
+
+void chttp2_tear_down_fullstack(grpc_end2end_test_fixture *f) {
+  fullstack_fixture_data *ffd = f->fixture_data;
+  grpc_end2end_proxy_destroy(ffd->proxy);
+  gpr_free(ffd);
+}
+
+/* All test configurations */
+static grpc_end2end_test_config configs[] = {
+    {"chttp2/fullstack+proxy", FEATURE_MASK_SUPPORTS_DELAYED_CONNECTION,
+     chttp2_create_fixture_fullstack, chttp2_init_client_fullstack,
+     chttp2_init_server_fullstack, chttp2_tear_down_fullstack},
+};
+
+int main(int argc, char **argv) {
+  size_t i;
+
+  grpc_test_init(argc, argv);
+  grpc_init();
+
+  for (i = 0; i < sizeof(configs) / sizeof(*configs); i++) {
+    grpc_end2end_tests(configs[i]);
+  }
+
+  grpc_shutdown();
+
+  return 0;
+}
diff --git a/test/core/end2end/fixtures/chttp2_simple_ssl_fullstack_with_proxy.c b/test/core/end2end/fixtures/chttp2_simple_ssl_fullstack_with_proxy.c
new file mode 100644
index 0000000000..46a64de6c5
--- /dev/null
+++ b/test/core/end2end/fixtures/chttp2_simple_ssl_fullstack_with_proxy.c
@@ -0,0 +1,193 @@
+/*
+ *
+ * Copyright 2015, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "test/core/end2end/end2end_tests.h"
+
+#include <stdio.h>
+#include <string.h>
+
+#include "src/core/channel/channel_args.h"
+#include "src/core/security/credentials.h"
+#include "src/core/support/env.h"
+#include "src/core/support/file.h"
+#include "src/core/support/string.h"
+#include <grpc/support/alloc.h>
+#include <grpc/support/host_port.h>
+#include <grpc/support/log.h>
+#include "test/core/end2end/data/ssl_test_data.h"
+#include "test/core/end2end/fixtures/proxy.h"
+#include "test/core/util/test_config.h"
+#include "test/core/util/port.h"
+
+typedef struct fullstack_secure_fixture_data {
+  grpc_end2end_proxy *proxy;
+} fullstack_secure_fixture_data;
+
+static grpc_server *create_proxy_server(const char *port) {
+  grpc_server *s = grpc_server_create(NULL);
+  grpc_ssl_pem_key_cert_pair pem_cert_key_pair = {test_server1_key,
+                                                  test_server1_cert};
+  grpc_server_credentials *ssl_creds =
+      grpc_ssl_server_credentials_create(NULL, &pem_cert_key_pair, 1, 0);
+  GPR_ASSERT(grpc_server_add_secure_http2_port(s, port, ssl_creds));
+  grpc_server_credentials_release(ssl_creds);
+  return s;
+}
+
+static grpc_channel *create_proxy_client(const char *target) {
+  grpc_channel *channel;
+  grpc_credentials *ssl_creds = grpc_ssl_credentials_create(NULL, NULL);
+  grpc_arg ssl_name_override = {GRPC_ARG_STRING,
+                                GRPC_SSL_TARGET_NAME_OVERRIDE_ARG,
+                                {"foo.test.google.fr"}};
+  grpc_channel_args client_args;
+  client_args.num_args = 1;
+  client_args.args = &ssl_name_override;
+  channel = grpc_secure_channel_create(ssl_creds, target, &client_args);
+  grpc_credentials_release(ssl_creds);
+  return channel;
+}
+
+static const grpc_end2end_proxy_def proxy_def = {create_proxy_server,
+                                                 create_proxy_client};
+
+static grpc_end2end_test_fixture chttp2_create_fixture_secure_fullstack(
+    grpc_channel_args *client_args, grpc_channel_args *server_args) {
+  grpc_end2end_test_fixture f;
+  fullstack_secure_fixture_data *ffd =
+      gpr_malloc(sizeof(fullstack_secure_fixture_data));
+  memset(&f, 0, sizeof(f));
+
+  ffd->proxy = grpc_end2end_proxy_create(&proxy_def);
+
+  f.fixture_data = ffd;
+  f.cq = grpc_completion_queue_create();
+
+  return f;
+}
+
+static void chttp2_init_client_secure_fullstack(grpc_end2end_test_fixture *f,
+                                                grpc_channel_args *client_args,
+                                                grpc_credentials *creds) {
+  fullstack_secure_fixture_data *ffd = f->fixture_data;
+  f->client = grpc_secure_channel_create(
+      creds, grpc_end2end_proxy_get_client_target(ffd->proxy), client_args);
+  GPR_ASSERT(f->client != NULL);
+  grpc_credentials_release(creds);
+}
+
+static void chttp2_init_server_secure_fullstack(
+    grpc_end2end_test_fixture *f, grpc_channel_args *server_args,
+    grpc_server_credentials *server_creds) {
+  fullstack_secure_fixture_data *ffd = f->fixture_data;
+  if (f->server) {
+    grpc_server_destroy(f->server);
+  }
+  f->server = grpc_server_create(server_args);
+  grpc_server_register_completion_queue(f->server, f->cq);
+  GPR_ASSERT(grpc_server_add_secure_http2_port(
+      f->server, grpc_end2end_proxy_get_server_port(ffd->proxy), server_creds));
+  grpc_server_credentials_release(server_creds);
+  grpc_server_start(f->server);
+}
+
+void chttp2_tear_down_secure_fullstack(grpc_end2end_test_fixture *f) {
+  fullstack_secure_fixture_data *ffd = f->fixture_data;
+  grpc_end2end_proxy_destroy(ffd->proxy);
+  gpr_free(ffd);
+}
+
+static void chttp2_init_client_simple_ssl_secure_fullstack(
+    grpc_end2end_test_fixture *f, grpc_channel_args *client_args) {
+  grpc_credentials *ssl_creds = grpc_ssl_credentials_create(NULL, NULL);
+  grpc_arg ssl_name_override = {GRPC_ARG_STRING,
+                                GRPC_SSL_TARGET_NAME_OVERRIDE_ARG,
+                                {"foo.test.google.fr"}};
+  grpc_channel_args *new_client_args =
+      grpc_channel_args_copy_and_add(client_args, &ssl_name_override, 1);
+  chttp2_init_client_secure_fullstack(f, new_client_args, ssl_creds);
+  grpc_channel_args_destroy(new_client_args);
+}
+
+static void chttp2_init_server_simple_ssl_secure_fullstack(
+    grpc_end2end_test_fixture *f, grpc_channel_args *server_args) {
+  grpc_ssl_pem_key_cert_pair pem_cert_key_pair = {test_server1_key,
+                                                  test_server1_cert};
+  grpc_server_credentials *ssl_creds =
+      grpc_ssl_server_credentials_create(NULL, &pem_cert_key_pair, 1, 0);
+  chttp2_init_server_secure_fullstack(f, server_args, ssl_creds);
+}
+
+/* All test configurations */
+
+static grpc_end2end_test_config configs[] = {
+    {"chttp2/simple_ssl_fullstack",
+     FEATURE_MASK_SUPPORTS_DELAYED_CONNECTION |
+         FEATURE_MASK_SUPPORTS_HOSTNAME_VERIFICATION |
+         FEATURE_MASK_SUPPORTS_PER_CALL_CREDENTIALS,
+     chttp2_create_fixture_secure_fullstack,
+     chttp2_init_client_simple_ssl_secure_fullstack,
+     chttp2_init_server_simple_ssl_secure_fullstack,
+     chttp2_tear_down_secure_fullstack},
+};
+
+int main(int argc, char **argv) {
+  size_t i;
+  FILE *roots_file;
+  size_t roots_size = strlen(test_root_cert);
+  char *roots_filename;
+
+  grpc_test_init(argc, argv);
+
+  /* Set the SSL roots env var. */
+  roots_file = gpr_tmpfile("chttp2_simple_ssl_fullstack_test", &roots_filename);
+  GPR_ASSERT(roots_filename != NULL);
+  GPR_ASSERT(roots_file != NULL);
+  GPR_ASSERT(fwrite(test_root_cert, 1, roots_size, roots_file) == roots_size);
+  fclose(roots_file);
+  gpr_setenv(GRPC_DEFAULT_SSL_ROOTS_FILE_PATH_ENV_VAR, roots_filename);
+
+  grpc_init();
+
+  for (i = 0; i < sizeof(configs) / sizeof(*configs); i++) {
+    grpc_end2end_tests(configs[i]);
+  }
+
+  grpc_shutdown();
+
+  /* Cleanup. */
+  remove(roots_filename);
+  gpr_free(roots_filename);
+
+  return 0;
+}
diff --git a/test/core/end2end/fixtures/chttp2_socket_pair_with_grpc_trace.c b/test/core/end2end/fixtures/chttp2_socket_pair_with_grpc_trace.c
index c59628b959..6d2361b783 100644
--- a/test/core/end2end/fixtures/chttp2_socket_pair_with_grpc_trace.c
+++ b/test/core/end2end/fixtures/chttp2_socket_pair_with_grpc_trace.c
@@ -148,6 +148,7 @@ int main(int argc, char **argv) {
   /* force tracing on, with a value to force many
      code paths in trace.c to be taken */
   gpr_setenv("GRPC_TRACE", "doesnt-exist,http,all");
+  g_fixture_slowdown_factor = 10.0;
 
   grpc_test_init(argc, argv);
   grpc_init();
diff --git a/test/core/end2end/fixtures/proxy.c b/test/core/end2end/fixtures/proxy.c
new file mode 100644
index 0000000000..e4f6263334
--- /dev/null
+++ b/test/core/end2end/fixtures/proxy.c
@@ -0,0 +1,430 @@
+/*
+ *
+ * Copyright 2015, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "test/core/end2end/fixtures/proxy.h"
+
+#include <string.h>
+
+#include <grpc/support/alloc.h>
+#include <grpc/support/host_port.h>
+#include <grpc/support/log.h>
+#include <grpc/support/sync.h>
+#include <grpc/support/thd.h>
+#include <grpc/support/useful.h>
+
+#include "test/core/util/port.h"
+
+struct grpc_end2end_proxy {
+  gpr_thd_id thd;
+  char *proxy_port;
+  char *server_port;
+  grpc_completion_queue *cq;
+  grpc_server *server;
+  grpc_channel *client;
+
+  int shutdown;
+
+  /* requested call */
+  grpc_call *new_call;
+  grpc_call_details new_call_details;
+  grpc_metadata_array new_call_metadata;
+};
+
+typedef struct {
+  void (*func)(void *arg, int success);
+  void *arg;
+} closure;
+
+typedef struct {
+  gpr_refcount refs;
+  grpc_end2end_proxy *proxy;
+
+  grpc_call *c2p;
+  grpc_call *p2s;
+
+  grpc_metadata_array c2p_initial_metadata;
+  grpc_metadata_array p2s_initial_metadata;
+
+  grpc_byte_buffer *c2p_msg;
+  grpc_byte_buffer *p2s_msg;
+
+  grpc_metadata_array p2s_trailing_metadata;
+  grpc_status_code p2s_status;
+  char *p2s_status_details;
+  size_t p2s_status_details_capacity;
+
+  int c2p_server_cancelled;
+} proxy_call;
+
+static void thread_main(void *arg);
+static void request_call(grpc_end2end_proxy *proxy);
+
+grpc_end2end_proxy *grpc_end2end_proxy_create(
+    const grpc_end2end_proxy_def *def) {
+  gpr_thd_options opt = gpr_thd_options_default();
+  int proxy_port = grpc_pick_unused_port_or_die();
+  int server_port = grpc_pick_unused_port_or_die();
+
+  grpc_end2end_proxy *proxy = gpr_malloc(sizeof(*proxy));
+  memset(proxy, 0, sizeof(*proxy));
+
+  gpr_join_host_port(&proxy->proxy_port, "localhost", proxy_port);
+  gpr_join_host_port(&proxy->server_port, "localhost", server_port);
+  proxy->cq = grpc_completion_queue_create();
+  proxy->server = def->create_server(proxy->proxy_port);
+  proxy->client = def->create_client(proxy->server_port);
+
+  grpc_server_register_completion_queue(proxy->server, proxy->cq);
+  grpc_server_start(proxy->server);
+
+  gpr_thd_options_set_joinable(&opt);
+  GPR_ASSERT(gpr_thd_new(&proxy->thd, thread_main, proxy, &opt));
+
+  request_call(proxy);
+
+  return proxy;
+}
+
+static closure *new_closure(void (*func)(void *arg, int success), void *arg) {
+  closure *cl = gpr_malloc(sizeof(*cl));
+  cl->func = func;
+  cl->arg = arg;
+  return cl;
+}
+
+static void shutdown_complete(void *arg, int success) {
+  grpc_end2end_proxy *proxy = arg;
+  proxy->shutdown = 1;
+  grpc_completion_queue_shutdown(proxy->cq);
+}
+
+void grpc_end2end_proxy_destroy(grpc_end2end_proxy *proxy) {
+  grpc_server_shutdown_and_notify(proxy->server, proxy->cq,
+                                  new_closure(shutdown_complete, proxy));
+  gpr_thd_join(proxy->thd);
+  gpr_free(proxy->proxy_port);
+  gpr_free(proxy->server_port);
+  grpc_server_destroy(proxy->server);
+  grpc_channel_destroy(proxy->client);
+  grpc_completion_queue_destroy(proxy->cq);
+  grpc_call_details_destroy(&proxy->new_call_details);
+  gpr_free(proxy);
+}
+
+static void unrefpc(proxy_call *pc, const char *reason) {
+  gpr_log(GPR_DEBUG, "unref %p: %s %d -> %d", pc, reason, pc->refs.count,
+          pc->refs.count - 1);
+  if (gpr_unref(&pc->refs)) {
+    grpc_call_destroy(pc->c2p);
+    grpc_call_destroy(pc->p2s);
+    grpc_metadata_array_destroy(&pc->c2p_initial_metadata);
+    grpc_metadata_array_destroy(&pc->p2s_initial_metadata);
+    grpc_metadata_array_destroy(&pc->p2s_trailing_metadata);
+    gpr_free(pc->p2s_status_details);
+    gpr_free(pc);
+  }
+}
+
+static void refpc(proxy_call *pc, const char *reason) {
+  gpr_log(GPR_DEBUG, "ref %p: %s %d -> %d", pc, reason, pc->refs.count,
+          pc->refs.count + 1);
+  gpr_ref(&pc->refs);
+}
+
+static void on_c2p_sent_initial_metadata(void *arg, int success) {
+  proxy_call *pc = arg;
+  unrefpc(pc, "on_c2p_sent_initial_metadata");
+}
+
+static void on_p2s_recv_initial_metadata(void *arg, int success) {
+  proxy_call *pc = arg;
+  grpc_op op;
+  grpc_call_error err;
+
+  if (!pc->proxy->shutdown) {
+    op.op = GRPC_OP_SEND_INITIAL_METADATA;
+    op.flags = 0;
+    op.data.send_initial_metadata.count = pc->p2s_initial_metadata.count;
+    op.data.send_initial_metadata.metadata = pc->p2s_initial_metadata.metadata;
+    refpc(pc, "on_c2p_sent_initial_metadata");
+    err = grpc_call_start_batch(pc->c2p, &op, 1,
+                                new_closure(on_c2p_sent_initial_metadata, pc));
+    GPR_ASSERT(err == GRPC_CALL_OK);
+  }
+
+  unrefpc(pc, "on_p2s_recv_initial_metadata");
+}
+
+static void on_p2s_sent_initial_metadata(void *arg, int success) {
+  proxy_call *pc = arg;
+  unrefpc(pc, "on_p2s_sent_initial_metadata");
+}
+
+static void on_c2p_recv_msg(void *arg, int success);
+
+static void on_p2s_sent_message(void *arg, int success) {
+  proxy_call *pc = arg;
+  grpc_op op;
+  grpc_call_error err;
+
+  grpc_byte_buffer_destroy(pc->c2p_msg);
+  if (!pc->proxy->shutdown && success) {
+    op.op = GRPC_OP_RECV_MESSAGE;
+    op.flags = 0;
+    op.data.recv_message = &pc->c2p_msg;
+    refpc(pc, "on_c2p_recv_msg");
+    err = grpc_call_start_batch(pc->c2p, &op, 1,
+                                new_closure(on_c2p_recv_msg, pc));
+    GPR_ASSERT(err == GRPC_CALL_OK);
+  }
+
+  unrefpc(pc, "on_p2s_sent_message");
+}
+
+static void on_p2s_sent_close(void *arg, int success) {
+  proxy_call *pc = arg;
+  unrefpc(pc, "on_p2s_sent_close");
+}
+
+static void on_c2p_recv_msg(void *arg, int success) {
+  proxy_call *pc = arg;
+  grpc_op op;
+  grpc_call_error err;
+
+  if (!pc->proxy->shutdown && success) {
+    if (pc->c2p_msg != NULL) {
+      op.op = GRPC_OP_SEND_MESSAGE;
+      op.flags = 0;
+      op.data.send_message = pc->c2p_msg;
+      refpc(pc, "on_p2s_sent_message");
+      err = grpc_call_start_batch(pc->p2s, &op, 1,
+                                  new_closure(on_p2s_sent_message, pc));
+      GPR_ASSERT(err == GRPC_CALL_OK);
+    } else {
+      op.op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
+      op.flags = 0;
+      refpc(pc, "on_p2s_sent_close");
+      err = grpc_call_start_batch(pc->p2s, &op, 1,
+                                  new_closure(on_p2s_sent_close, pc));
+      GPR_ASSERT(err == GRPC_CALL_OK);
+    }
+  }
+
+  unrefpc(pc, "on_c2p_recv_msg");
+}
+
+static void on_p2s_recv_msg(void *arg, int success);
+
+static void on_c2p_sent_message(void *arg, int success) {
+  proxy_call *pc = arg;
+  grpc_op op;
+  grpc_call_error err;
+
+  grpc_byte_buffer_destroy(pc->p2s_msg);
+  if (!pc->proxy->shutdown && success) {
+    op.op = GRPC_OP_RECV_MESSAGE;
+    op.flags = 0;
+    op.data.recv_message = &pc->p2s_msg;
+    refpc(pc, "on_p2s_recv_msg");
+    err = grpc_call_start_batch(pc->p2s, &op, 1,
+                                new_closure(on_p2s_recv_msg, pc));
+    GPR_ASSERT(err == GRPC_CALL_OK);
+  }
+
+  unrefpc(pc, "on_c2p_sent_message");
+}
+
+static void on_p2s_recv_msg(void *arg, int success) {
+  proxy_call *pc = arg;
+  grpc_op op;
+  grpc_call_error err;
+
+  if (!pc->proxy->shutdown && success && pc->p2s_msg) {
+    op.op = GRPC_OP_SEND_MESSAGE;
+    op.flags = 0;
+    op.data.send_message = pc->p2s_msg;
+    refpc(pc, "on_c2p_sent_message");
+    err = grpc_call_start_batch(pc->c2p, &op, 1,
+                                new_closure(on_c2p_sent_message, pc));
+    GPR_ASSERT(err == GRPC_CALL_OK);
+  }
+  unrefpc(pc, "on_p2s_recv_msg");
+}
+
+static void on_c2p_sent_status(void *arg, int success) {
+  proxy_call *pc = arg;
+  unrefpc(pc, "on_c2p_sent_status");
+}
+
+static void on_p2s_status(void *arg, int success) {
+  proxy_call *pc = arg;
+  grpc_op op;
+  grpc_call_error err;
+
+  if (!pc->proxy->shutdown) {
+    GPR_ASSERT(success);
+    op.op = GRPC_OP_SEND_STATUS_FROM_SERVER;
+    op.flags = 0;
+    op.data.send_status_from_server.trailing_metadata_count =
+        pc->p2s_trailing_metadata.count;
+    op.data.send_status_from_server.trailing_metadata =
+        pc->p2s_trailing_metadata.metadata;
+    op.data.send_status_from_server.status = pc->p2s_status;
+    op.data.send_status_from_server.status_details = pc->p2s_status_details;
+    refpc(pc, "on_c2p_sent_status");
+    err = grpc_call_start_batch(pc->c2p, &op, 1,
+                                new_closure(on_c2p_sent_status, pc));
+    GPR_ASSERT(err == GRPC_CALL_OK);
+  }
+
+  unrefpc(pc, "on_p2s_status");
+}
+
+static void on_c2p_closed(void *arg, int success) {
+  proxy_call *pc = arg;
+  unrefpc(pc, "on_c2p_closed");
+}
+
+static void on_new_call(void *arg, int success) {
+  grpc_end2end_proxy *proxy = arg;
+  grpc_call_error err;
+
+  if (success) {
+    grpc_op op;
+    proxy_call *pc = gpr_malloc(sizeof(*pc));
+    memset(pc, 0, sizeof(*pc));
+    pc->proxy = proxy;
+    GPR_SWAP(grpc_metadata_array, pc->c2p_initial_metadata,
+             proxy->new_call_metadata);
+    pc->c2p = proxy->new_call;
+    pc->p2s = grpc_channel_create_call(
+        proxy->client, pc->c2p, GRPC_PROPAGATE_DEFAULTS, proxy->cq,
+        proxy->new_call_details.method, proxy->new_call_details.host,
+        proxy->new_call_details.deadline);
+    gpr_ref_init(&pc->refs, 1);
+
+    op.flags = 0;
+
+    op.op = GRPC_OP_RECV_INITIAL_METADATA;
+    op.data.recv_initial_metadata = &pc->p2s_initial_metadata;
+    refpc(pc, "on_p2s_recv_initial_metadata");
+    err = grpc_call_start_batch(pc->p2s, &op, 1,
+                                new_closure(on_p2s_recv_initial_metadata, pc));
+    GPR_ASSERT(err == GRPC_CALL_OK);
+
+    op.op = GRPC_OP_SEND_INITIAL_METADATA;
+    op.data.send_initial_metadata.count = pc->c2p_initial_metadata.count;
+    op.data.send_initial_metadata.metadata = pc->c2p_initial_metadata.metadata;
+    refpc(pc, "on_p2s_sent_initial_metadata");
+    err = grpc_call_start_batch(pc->p2s, &op, 1,
+                                new_closure(on_p2s_sent_initial_metadata, pc));
+    GPR_ASSERT(err == GRPC_CALL_OK);
+
+    op.op = GRPC_OP_RECV_MESSAGE;
+    op.data.recv_message = &pc->c2p_msg;
+    refpc(pc, "on_c2p_recv_msg");
+    err = grpc_call_start_batch(pc->c2p, &op, 1,
+                                new_closure(on_c2p_recv_msg, pc));
+    GPR_ASSERT(err == GRPC_CALL_OK);
+
+    op.op = GRPC_OP_RECV_MESSAGE;
+    op.data.recv_message = &pc->p2s_msg;
+    refpc(pc, "on_p2s_recv_msg");
+    err = grpc_call_start_batch(pc->p2s, &op, 1,
+                                new_closure(on_p2s_recv_msg, pc));
+    GPR_ASSERT(err == GRPC_CALL_OK);
+
+    op.op = GRPC_OP_RECV_STATUS_ON_CLIENT;
+    op.data.recv_status_on_client.trailing_metadata =
+        &pc->p2s_trailing_metadata;
+    op.data.recv_status_on_client.status = &pc->p2s_status;
+    op.data.recv_status_on_client.status_details = &pc->p2s_status_details;
+    op.data.recv_status_on_client.status_details_capacity =
+        &pc->p2s_status_details_capacity;
+    refpc(pc, "on_p2s_status");
+    err =
+        grpc_call_start_batch(pc->p2s, &op, 1, new_closure(on_p2s_status, pc));
+    GPR_ASSERT(err == GRPC_CALL_OK);
+
+    op.op = GRPC_OP_RECV_CLOSE_ON_SERVER;
+    op.data.recv_close_on_server.cancelled = &pc->c2p_server_cancelled;
+    refpc(pc, "on_c2p_closed");
+    err =
+        grpc_call_start_batch(pc->c2p, &op, 1, new_closure(on_c2p_closed, pc));
+    GPR_ASSERT(err == GRPC_CALL_OK);
+
+    request_call(proxy);
+
+    unrefpc(pc, "init");
+  } else {
+    GPR_ASSERT(proxy->new_call == NULL);
+  }
+}
+
+static void request_call(grpc_end2end_proxy *proxy) {
+  proxy->new_call = NULL;
+  GPR_ASSERT(GRPC_CALL_OK == grpc_server_request_call(
+                                 proxy->server, &proxy->new_call,
+                                 &proxy->new_call_details,
+                                 &proxy->new_call_metadata, proxy->cq,
+                                 proxy->cq, new_closure(on_new_call, proxy)));
+}
+
+static void thread_main(void *arg) {
+  grpc_end2end_proxy *proxy = arg;
+  closure *cl;
+  for (;;) {
+    grpc_event ev = grpc_completion_queue_next(
+        proxy->cq, gpr_inf_future(GPR_CLOCK_MONOTONIC));
+    switch (ev.type) {
+      case GRPC_QUEUE_TIMEOUT:
+        gpr_log(GPR_ERROR, "Should never reach here");
+        abort();
+      case GRPC_QUEUE_SHUTDOWN:
+        return;
+      case GRPC_OP_COMPLETE:
+        cl = ev.tag;
+        cl->func(cl->arg, ev.success);
+        gpr_free(cl);
+        break;
+    }
+  }
+}
+
+const char *grpc_end2end_proxy_get_client_target(grpc_end2end_proxy *proxy) {
+  return proxy->proxy_port;
+}
+
+const char *grpc_end2end_proxy_get_server_port(grpc_end2end_proxy *proxy) {
+  return proxy->server_port;
+}
diff --git a/test/core/end2end/fixtures/proxy.h b/test/core/end2end/fixtures/proxy.h
new file mode 100644
index 0000000000..c1cf01d39a
--- /dev/null
+++ b/test/core/end2end/fixtures/proxy.h
@@ -0,0 +1,55 @@
+/*
+ *
+ * Copyright 2015, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef GRPC_TEST_CORE_END2END_FIXTURES_PROXY_H
+#define GRPC_TEST_CORE_END2END_FIXTURES_PROXY_H
+
+#include <grpc/grpc.h>
+
+/* proxy service for _with_proxy fixtures */
+
+typedef struct grpc_end2end_proxy grpc_end2end_proxy;
+
+typedef struct grpc_end2end_proxy_def {
+  grpc_server *(*create_server)(const char *port);
+  grpc_channel *(*create_client)(const char *target);
+} grpc_end2end_proxy_def;
+
+grpc_end2end_proxy *grpc_end2end_proxy_create(
+    const grpc_end2end_proxy_def *def);
+void grpc_end2end_proxy_destroy(grpc_end2end_proxy *proxy);
+
+const char *grpc_end2end_proxy_get_client_target(grpc_end2end_proxy *proxy);
+const char *grpc_end2end_proxy_get_server_port(grpc_end2end_proxy *proxy);
+
+#endif /* GRPC_TEST_CORE_END2END_FIXTURES_PROXY_H */
diff --git a/test/core/end2end/gen_build_json.py b/test/core/end2end/gen_build_json.py
index 43ab09f57d..d1138abd78 100755
--- a/test/core/end2end/gen_build_json.py
+++ b/test/core/end2end/gen_build_json.py
@@ -36,30 +36,33 @@ import simplejson
 import collections
 
 
-FixtureOptions = collections.namedtuple('FixtureOptions', 'fullstack dns_resolver secure platforms')
-default_unsecure_fixture_options = FixtureOptions(True, True, False, ['windows', 'posix'])
-socketpair_unsecure_fixture_options = FixtureOptions(False, False, False, ['windows', 'posix'])
-default_secure_fixture_options = FixtureOptions(True, True, True, ['windows', 'posix'])
+FixtureOptions = collections.namedtuple('FixtureOptions', 'fullstack includes_proxy dns_resolver secure platforms')
+default_unsecure_fixture_options = FixtureOptions(True, False, True, False, ['windows', 'linux', 'mac', 'posix'])
+socketpair_unsecure_fixture_options = default_unsecure_fixture_options._replace(fullstack=False, dns_resolver=False)
+default_secure_fixture_options = default_unsecure_fixture_options._replace(secure=True)
+uds_fixture_options = default_unsecure_fixture_options._replace(dns_resolver=False, platforms=['linux', 'mac', 'posix'])
 
 # maps fixture name to whether it requires the security library
 END2END_FIXTURES = {
     'chttp2_fake_security': default_secure_fixture_options,
-    'chttp2_fullstack_compression': default_unsecure_fixture_options,
     'chttp2_fullstack': default_unsecure_fixture_options,
-    'chttp2_fullstack_uds_posix': FixtureOptions(True, False, False, ['posix']),
-    'chttp2_fullstack_uds_posix_with_poll': FixtureOptions(True, False, False, ['posix']),
-    'chttp2_fullstack_with_poll': FixtureOptions(True, True, False, ['posix']),
+    'chttp2_fullstack_compression': default_unsecure_fixture_options,
+    'chttp2_fullstack_uds_posix': uds_fixture_options,
+    'chttp2_fullstack_uds_posix_with_poll': uds_fixture_options._replace(platforms=['linux']),
+    'chttp2_fullstack_with_poll': default_unsecure_fixture_options._replace(platforms=['linux']),
+    'chttp2_fullstack_with_proxy': default_unsecure_fixture_options._replace(includes_proxy=True),
     'chttp2_simple_ssl_fullstack': default_secure_fixture_options,
-    'chttp2_simple_ssl_fullstack_with_poll': FixtureOptions(True, True, True, ['posix']),
+    'chttp2_simple_ssl_fullstack_with_poll': default_secure_fixture_options._replace(platforms=['linux']),
+    'chttp2_simple_ssl_fullstack_with_proxy': default_secure_fixture_options._replace(includes_proxy=True),
     'chttp2_simple_ssl_with_oauth2_fullstack': default_secure_fixture_options,
-    'chttp2_socket_pair_one_byte_at_a_time': socketpair_unsecure_fixture_options,
     'chttp2_socket_pair': socketpair_unsecure_fixture_options,
+    'chttp2_socket_pair_one_byte_at_a_time': socketpair_unsecure_fixture_options,
     'chttp2_socket_pair_with_grpc_trace': socketpair_unsecure_fixture_options,
 }
 
-TestOptions = collections.namedtuple('TestOptions', 'needs_fullstack needs_dns flaky secure')
-default_test_options = TestOptions(False, False, False, False)
-connectivity_test_options = TestOptions(True, False, False, False)
+TestOptions = collections.namedtuple('TestOptions', 'needs_fullstack needs_dns proxyable flaky secure')
+default_test_options = TestOptions(False, False, True, False, False)
+connectivity_test_options = default_test_options._replace(needs_fullstack=True)
 
 # maps test names to options
 END2END_TESTS = {
@@ -70,26 +73,26 @@ END2END_TESTS = {
     'cancel_before_invoke': default_test_options,
     'cancel_in_a_vacuum': default_test_options,
     'census_simple_request': default_test_options,
-    'channel_connectivity': connectivity_test_options,
-    'default_host': TestOptions(True, True, False, False),
+    'channel_connectivity': connectivity_test_options._replace(proxyable=False),
+    'default_host': default_test_options._replace(needs_fullstack=True, needs_dns=True),
     'disappearing_server': connectivity_test_options,
     'early_server_shutdown_finishes_inflight_calls': default_test_options,
     'early_server_shutdown_finishes_tags': default_test_options,
     'empty_batch': default_test_options,
     'graceful_server_shutdown': default_test_options,
     'invoke_large_request': default_test_options,
-    'max_concurrent_streams': default_test_options,
+    'max_concurrent_streams': default_test_options._replace(proxyable=False),
     'max_message_length': default_test_options,
     'no_op': default_test_options,
     'ping_pong_streaming': default_test_options,
     'registered_call': default_test_options,
     'request_response_with_binary_metadata_and_payload': default_test_options,
     'request_response_with_metadata_and_payload': default_test_options,
-    'request_response_with_payload_and_call_creds': TestOptions(needs_fullstack=False, needs_dns=False, flaky=False, secure=True),
+    'request_response_with_payload_and_call_creds': default_test_options._replace(secure=True),
     'request_response_with_payload': default_test_options,
     'request_response_with_trailing_metadata_and_payload': default_test_options,
-    'request_with_compressed_payload': default_test_options,
-    'request_with_flags': default_test_options,
+    'request_with_compressed_payload': default_test_options._replace(proxyable=False),
+    'request_with_flags': default_test_options._replace(proxyable=False),
     'request_with_large_metadata': default_test_options,
     'request_with_payload': default_test_options,
     'server_finishes_request': default_test_options,
@@ -106,6 +109,9 @@ def compatible(f, t):
   if END2END_TESTS[t].needs_dns:
     if not END2END_FIXTURES[f].dns_resolver:
       return False
+  if not END2END_TESTS[t].proxyable:
+    if END2END_FIXTURES[f].includes_proxy:
+      return False
   return True
 
 
@@ -132,7 +138,7 @@ def main():
               'language': 'c',
               'secure': 'check' if END2END_FIXTURES[f].secure else 'no',
               'src': ['test/core/end2end/fixtures/%s.c' % f],
-              'platforms': [ 'posix' ] if f.endswith('_posix') else END2END_FIXTURES[f].platforms,
+              'platforms': [ 'linux', 'mac', 'posix' ] if f.endswith('_posix') else END2END_FIXTURES[f].platforms,
               'deps': sec_deps if END2END_FIXTURES[f].secure else unsec_deps,
               'headers': ['test/core/end2end/end2end_tests.h'],
           }
diff --git a/test/core/end2end/no_server_test.c b/test/core/end2end/no_server_test.c
index 6f1133c009..6a5e12325d 100644
--- a/test/core/end2end/no_server_test.c
+++ b/test/core/end2end/no_server_test.c
@@ -62,7 +62,8 @@ int main(int argc, char **argv) {
 
   /* create a call, channel to a non existant server */
   chan = grpc_insecure_channel_create("nonexistant:54321", NULL);
-  call = grpc_channel_create_call(chan, cq, "/Foo", "nonexistant", deadline);
+  call = grpc_channel_create_call(chan, NULL, GRPC_PROPAGATE_DEFAULTS, cq,
+                                  "/Foo", "nonexistant", deadline);
 
   op = ops;
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
diff --git a/test/core/end2end/tests/bad_hostname.c b/test/core/end2end/tests/bad_hostname.c
index 2509ea06a0..198ba46cd2 100644
--- a/test/core/end2end/tests/bad_hostname.c
+++ b/test/core/end2end/tests/bad_hostname.c
@@ -113,8 +113,8 @@ static void simple_request_body(grpc_end2end_test_fixture f) {
   char *details = NULL;
   size_t details_capacity = 0;
 
-  c = grpc_channel_create_call(f.client, f.cq, "/foo", "slartibartfast.local",
-                               deadline);
+  c = grpc_channel_create_call(f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+                               "/foo", "slartibartfast.local", deadline);
   GPR_ASSERT(c);
 
   grpc_metadata_array_init(&initial_metadata_recv);
diff --git a/test/core/end2end/tests/cancel_after_accept.c b/test/core/end2end/tests/cancel_after_accept.c
index 1cc6b2d147..2e166b8412 100644
--- a/test/core/end2end/tests/cancel_after_accept.c
+++ b/test/core/end2end/tests/cancel_after_accept.c
@@ -126,8 +126,8 @@ static void test_cancel_after_accept(grpc_end2end_test_config config,
       grpc_raw_byte_buffer_create(&response_payload_slice, 1);
   int was_cancelled = 2;
 
-  c = grpc_channel_create_call(f.client, f.cq, "/foo", "foo.test.google.fr",
-                               deadline);
+  c = grpc_channel_create_call(f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+                               "/foo", "foo.test.google.fr", deadline);
   GPR_ASSERT(c);
 
   grpc_metadata_array_init(&initial_metadata_recv);
@@ -192,8 +192,7 @@ static void test_cancel_after_accept(grpc_end2end_test_config config,
   cq_expect_completion(cqv, tag(1), 1);
   cq_verify(cqv);
 
-  GPR_ASSERT(status == mode.expect_status);
-  GPR_ASSERT(0 == strcmp(details, mode.expect_details));
+  GPR_ASSERT(status == mode.expect_status || status == GRPC_STATUS_INTERNAL);
   GPR_ASSERT(was_cancelled == 1);
 
   grpc_metadata_array_destroy(&initial_metadata_recv);
diff --git a/test/core/end2end/tests/cancel_after_accept_and_writes_closed.c b/test/core/end2end/tests/cancel_after_accept_and_writes_closed.c
index 015d437543..171c1874cc 100644
--- a/test/core/end2end/tests/cancel_after_accept_and_writes_closed.c
+++ b/test/core/end2end/tests/cancel_after_accept_and_writes_closed.c
@@ -126,8 +126,8 @@ static void test_cancel_after_accept_and_writes_closed(
       grpc_raw_byte_buffer_create(&response_payload_slice, 1);
   int was_cancelled = 2;
 
-  c = grpc_channel_create_call(f.client, f.cq, "/foo", "foo.test.google.fr",
-                               deadline);
+  c = grpc_channel_create_call(f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+                               "/foo", "foo.test.google.fr", deadline);
   GPR_ASSERT(c);
 
   grpc_metadata_array_init(&initial_metadata_recv);
@@ -195,8 +195,7 @@ static void test_cancel_after_accept_and_writes_closed(
   cq_expect_completion(cqv, tag(1), 1);
   cq_verify(cqv);
 
-  GPR_ASSERT(status == mode.expect_status);
-  GPR_ASSERT(0 == strcmp(details, mode.expect_details));
+  GPR_ASSERT(status == mode.expect_status || status == GRPC_STATUS_INTERNAL);
   GPR_ASSERT(was_cancelled == 1);
 
   grpc_metadata_array_destroy(&initial_metadata_recv);
diff --git a/test/core/end2end/tests/cancel_after_invoke.c b/test/core/end2end/tests/cancel_after_invoke.c
index 414ec706ce..186cd44a43 100644
--- a/test/core/end2end/tests/cancel_after_invoke.c
+++ b/test/core/end2end/tests/cancel_after_invoke.c
@@ -121,8 +121,8 @@ static void test_cancel_after_invoke(grpc_end2end_test_config config,
   grpc_byte_buffer *request_payload =
       grpc_raw_byte_buffer_create(&request_payload_slice, 1);
 
-  c = grpc_channel_create_call(f.client, f.cq, "/foo", "foo.test.google.fr",
-                               deadline);
+  c = grpc_channel_create_call(f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+                               "/foo", "foo.test.google.fr", deadline);
   GPR_ASSERT(c);
 
   grpc_metadata_array_init(&initial_metadata_recv);
@@ -164,8 +164,7 @@ static void test_cancel_after_invoke(grpc_end2end_test_config config,
   cq_expect_completion(cqv, tag(1), 1);
   cq_verify(cqv);
 
-  GPR_ASSERT(status == mode.expect_status);
-  GPR_ASSERT(0 == strcmp(details, mode.expect_details));
+  GPR_ASSERT(status == mode.expect_status || status == GRPC_STATUS_INTERNAL);
 
   grpc_metadata_array_destroy(&initial_metadata_recv);
   grpc_metadata_array_destroy(&trailing_metadata_recv);
diff --git a/test/core/end2end/tests/cancel_before_invoke.c b/test/core/end2end/tests/cancel_before_invoke.c
index 3cfe56eca2..b511908b4f 100644
--- a/test/core/end2end/tests/cancel_before_invoke.c
+++ b/test/core/end2end/tests/cancel_before_invoke.c
@@ -119,8 +119,8 @@ static void test_cancel_before_invoke(grpc_end2end_test_config config,
   grpc_byte_buffer *request_payload =
       grpc_raw_byte_buffer_create(&request_payload_slice, 1);
 
-  c = grpc_channel_create_call(f.client, f.cq, "/foo", "foo.test.google.fr",
-                               deadline);
+  c = grpc_channel_create_call(f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+                               "/foo", "foo.test.google.fr", deadline);
   GPR_ASSERT(c);
 
   GPR_ASSERT(GRPC_CALL_OK == grpc_call_cancel(c));
diff --git a/test/core/end2end/tests/cancel_in_a_vacuum.c b/test/core/end2end/tests/cancel_in_a_vacuum.c
index 8bffc3f4d3..7645410184 100644
--- a/test/core/end2end/tests/cancel_in_a_vacuum.c
+++ b/test/core/end2end/tests/cancel_in_a_vacuum.c
@@ -107,8 +107,8 @@ static void test_cancel_in_a_vacuum(grpc_end2end_test_config config,
   gpr_timespec deadline = five_seconds_time();
   cq_verifier *v_client = cq_verifier_create(f.cq);
 
-  c = grpc_channel_create_call(f.client, f.cq, "/foo", "foo.test.google.fr",
-                               deadline);
+  c = grpc_channel_create_call(f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+                               "/foo", "foo.test.google.fr", deadline);
   GPR_ASSERT(c);
 
   GPR_ASSERT(GRPC_CALL_OK == mode.initiate_cancel(c));
diff --git a/test/core/end2end/tests/census_simple_request.c b/test/core/end2end/tests/census_simple_request.c
index b414755cd1..2142dde921 100644
--- a/test/core/end2end/tests/census_simple_request.c
+++ b/test/core/end2end/tests/census_simple_request.c
@@ -111,8 +111,8 @@ static void test_body(grpc_end2end_test_fixture f) {
   size_t details_capacity = 0;
   int was_cancelled = 2;
 
-  c = grpc_channel_create_call(f.client, f.cq, "/foo",
-                               "foo.test.google.fr:1234", deadline);
+  c = grpc_channel_create_call(f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+                               "/foo", "foo.test.google.fr:1234", deadline);
   GPR_ASSERT(c);
 
   grpc_metadata_array_init(&initial_metadata_recv);
diff --git a/test/core/end2end/tests/default_host.c b/test/core/end2end/tests/default_host.c
index 63ef4bcd35..920449f4fa 100644
--- a/test/core/end2end/tests/default_host.c
+++ b/test/core/end2end/tests/default_host.c
@@ -116,7 +116,8 @@ static void simple_request_body(grpc_end2end_test_fixture f) {
   int was_cancelled = 2;
   char *peer;
 
-  c = grpc_channel_create_call(f.client, f.cq, "/foo", NULL, deadline);
+  c = grpc_channel_create_call(f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+                               "/foo", NULL, deadline);
   GPR_ASSERT(c);
 
   peer = grpc_call_get_peer(c);
diff --git a/test/core/end2end/tests/disappearing_server.c b/test/core/end2end/tests/disappearing_server.c
index a5fd74ee9a..94bed336e8 100644
--- a/test/core/end2end/tests/disappearing_server.c
+++ b/test/core/end2end/tests/disappearing_server.c
@@ -97,8 +97,8 @@ static void do_request_and_shutdown_server(grpc_end2end_test_fixture *f,
   size_t details_capacity = 0;
   int was_cancelled = 2;
 
-  c = grpc_channel_create_call(f->client, f->cq, "/foo",
-                               "foo.test.google.fr:1234", deadline);
+  c = grpc_channel_create_call(f->client, NULL, GRPC_PROPAGATE_DEFAULTS, f->cq,
+                               "/foo", "foo.test.google.fr:1234", deadline);
   GPR_ASSERT(c);
 
   grpc_metadata_array_init(&initial_metadata_recv);
diff --git a/test/core/end2end/tests/early_server_shutdown_finishes_inflight_calls.c b/test/core/end2end/tests/early_server_shutdown_finishes_inflight_calls.c
index adc59b4e94..36cbe8067b 100644
--- a/test/core/end2end/tests/early_server_shutdown_finishes_inflight_calls.c
+++ b/test/core/end2end/tests/early_server_shutdown_finishes_inflight_calls.c
@@ -105,8 +105,8 @@ static void test_early_server_shutdown_finishes_inflight_calls(
   size_t details_capacity = 0;
   int was_cancelled = 2;
 
-  c = grpc_channel_create_call(f.client, f.cq, "/foo", "foo.test.google.fr",
-                               deadline);
+  c = grpc_channel_create_call(f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+                               "/foo", "foo.test.google.fr", deadline);
   GPR_ASSERT(c);
 
   grpc_metadata_array_init(&initial_metadata_recv);
diff --git a/test/core/end2end/tests/empty_batch.c b/test/core/end2end/tests/empty_batch.c
index db8458d3d9..138c6b07c5 100644
--- a/test/core/end2end/tests/empty_batch.c
+++ b/test/core/end2end/tests/empty_batch.c
@@ -105,8 +105,8 @@ static void empty_batch_body(grpc_end2end_test_fixture f) {
   cq_verifier *cqv = cq_verifier_create(f.cq);
   grpc_op *op = NULL;
 
-  c = grpc_channel_create_call(f.client, f.cq, "/foo", "foo.test.google.fr",
-                               deadline);
+  c = grpc_channel_create_call(f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+                               "/foo", "foo.test.google.fr", deadline);
   GPR_ASSERT(c);
 
   GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_batch(c, op, 0, tag(1)));
diff --git a/test/core/end2end/tests/graceful_server_shutdown.c b/test/core/end2end/tests/graceful_server_shutdown.c
index 8c1889add9..23efa0304f 100644
--- a/test/core/end2end/tests/graceful_server_shutdown.c
+++ b/test/core/end2end/tests/graceful_server_shutdown.c
@@ -112,8 +112,8 @@ static void test_early_server_shutdown_finishes_inflight_calls(
   size_t details_capacity = 0;
   int was_cancelled = 2;
 
-  c = grpc_channel_create_call(f.client, f.cq, "/foo", "foo.test.google.fr",
-                               deadline);
+  c = grpc_channel_create_call(f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+                               "/foo", "foo.test.google.fr", deadline);
   GPR_ASSERT(c);
 
   grpc_metadata_array_init(&initial_metadata_recv);
diff --git a/test/core/end2end/tests/invoke_large_request.c b/test/core/end2end/tests/invoke_large_request.c
index 744a9ada57..e32645e2ba 100644
--- a/test/core/end2end/tests/invoke_large_request.c
+++ b/test/core/end2end/tests/invoke_large_request.c
@@ -128,8 +128,8 @@ static void test_invoke_large_request(grpc_end2end_test_config config) {
   size_t details_capacity = 0;
   int was_cancelled = 2;
 
-  c = grpc_channel_create_call(f.client, f.cq, "/foo", "foo.test.google.fr",
-                               deadline);
+  c = grpc_channel_create_call(f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+                               "/foo", "foo.test.google.fr", deadline);
   GPR_ASSERT(c);
 
   grpc_metadata_array_init(&initial_metadata_recv);
diff --git a/test/core/end2end/tests/max_concurrent_streams.c b/test/core/end2end/tests/max_concurrent_streams.c
index 1204c070af..049c028835 100644
--- a/test/core/end2end/tests/max_concurrent_streams.c
+++ b/test/core/end2end/tests/max_concurrent_streams.c
@@ -113,8 +113,8 @@ static void simple_request_body(grpc_end2end_test_fixture f) {
   size_t details_capacity = 0;
   int was_cancelled = 2;
 
-  c = grpc_channel_create_call(f.client, f.cq, "/foo",
-                               "foo.test.google.fr:1234", deadline);
+  c = grpc_channel_create_call(f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+                               "/foo", "foo.test.google.fr:1234", deadline);
   GPR_ASSERT(c);
 
   grpc_metadata_array_init(&initial_metadata_recv);
@@ -244,11 +244,11 @@ static void test_max_concurrent_streams(grpc_end2end_test_config config) {
   /* start two requests - ensuring that the second is not accepted until
      the first completes */
   deadline = n_seconds_time(1000);
-  c1 = grpc_channel_create_call(f.client, f.cq, "/alpha",
-                                "foo.test.google.fr:1234", deadline);
+  c1 = grpc_channel_create_call(f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+                                "/alpha", "foo.test.google.fr:1234", deadline);
   GPR_ASSERT(c1);
-  c2 = grpc_channel_create_call(f.client, f.cq, "/beta",
-                                "foo.test.google.fr:1234", deadline);
+  c2 = grpc_channel_create_call(f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+                                "/beta", "foo.test.google.fr:1234", deadline);
   GPR_ASSERT(c2);
 
   GPR_ASSERT(GRPC_CALL_OK == grpc_server_request_call(
diff --git a/test/core/end2end/tests/max_message_length.c b/test/core/end2end/tests/max_message_length.c
index ea59a9385f..feea49c68f 100644
--- a/test/core/end2end/tests/max_message_length.c
+++ b/test/core/end2end/tests/max_message_length.c
@@ -128,8 +128,8 @@ static void test_max_message_length(grpc_end2end_test_config config) {
   f = begin_test(config, "test_max_message_length", NULL, &server_args);
   cqv = cq_verifier_create(f.cq);
 
-  c = grpc_channel_create_call(f.client, f.cq, "/foo",
-                               "foo.test.google.fr:1234",
+  c = grpc_channel_create_call(f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+                               "/foo", "foo.test.google.fr:1234",
                                gpr_inf_future(GPR_CLOCK_REALTIME));
   GPR_ASSERT(c);
 
diff --git a/test/core/end2end/tests/ping_pong_streaming.c b/test/core/end2end/tests/ping_pong_streaming.c
index 8a3ec96212..0ae611b518 100644
--- a/test/core/end2end/tests/ping_pong_streaming.c
+++ b/test/core/end2end/tests/ping_pong_streaming.c
@@ -124,8 +124,8 @@ static void test_pingpong_streaming(grpc_end2end_test_config config,
   gpr_slice request_payload_slice = gpr_slice_from_copied_string("hello world");
   gpr_slice response_payload_slice = gpr_slice_from_copied_string("hello you");
 
-  c = grpc_channel_create_call(f.client, f.cq, "/foo",
-                               "foo.test.google.fr:1234", deadline);
+  c = grpc_channel_create_call(f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+                               "/foo", "foo.test.google.fr:1234", deadline);
   GPR_ASSERT(c);
 
   grpc_metadata_array_init(&initial_metadata_recv);
diff --git a/test/core/end2end/tests/registered_call.c b/test/core/end2end/tests/registered_call.c
index f44fd3a224..ffc4cd40a0 100644
--- a/test/core/end2end/tests/registered_call.c
+++ b/test/core/end2end/tests/registered_call.c
@@ -115,7 +115,8 @@ static void simple_request_body(grpc_end2end_test_fixture f, void *rc) {
   size_t details_capacity = 0;
   int was_cancelled = 2;
 
-  c = grpc_channel_create_registered_call(f.client, f.cq, rc, deadline);
+  c = grpc_channel_create_registered_call(
+      f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq, rc, deadline);
   GPR_ASSERT(c);
 
   grpc_metadata_array_init(&initial_metadata_recv);
diff --git a/test/core/end2end/tests/request_response_with_binary_metadata_and_payload.c b/test/core/end2end/tests/request_response_with_binary_metadata_and_payload.c
index 8b8a11babe..600642e6a7 100644
--- a/test/core/end2end/tests/request_response_with_binary_metadata_and_payload.c
+++ b/test/core/end2end/tests/request_response_with_binary_metadata_and_payload.c
@@ -143,8 +143,8 @@ static void test_request_response_with_metadata_and_payload(
   size_t details_capacity = 0;
   int was_cancelled = 2;
 
-  c = grpc_channel_create_call(f.client, f.cq, "/foo", "foo.test.google.fr",
-                               deadline);
+  c = grpc_channel_create_call(f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+                               "/foo", "foo.test.google.fr", deadline);
   GPR_ASSERT(c);
 
   grpc_metadata_array_init(&initial_metadata_recv);
diff --git a/test/core/end2end/tests/request_response_with_metadata_and_payload.c b/test/core/end2end/tests/request_response_with_metadata_and_payload.c
index 9821d7852f..7e8cce10f4 100644
--- a/test/core/end2end/tests/request_response_with_metadata_and_payload.c
+++ b/test/core/end2end/tests/request_response_with_metadata_and_payload.c
@@ -129,8 +129,8 @@ static void test_request_response_with_metadata_and_payload(
   size_t details_capacity = 0;
   int was_cancelled = 2;
 
-  c = grpc_channel_create_call(f.client, f.cq, "/foo", "foo.test.google.fr",
-                               deadline);
+  c = grpc_channel_create_call(f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+                               "/foo", "foo.test.google.fr", deadline);
   GPR_ASSERT(c);
 
   grpc_metadata_array_init(&initial_metadata_recv);
diff --git a/test/core/end2end/tests/request_response_with_payload.c b/test/core/end2end/tests/request_response_with_payload.c
index 38d3432f94..55323895fb 100644
--- a/test/core/end2end/tests/request_response_with_payload.c
+++ b/test/core/end2end/tests/request_response_with_payload.c
@@ -121,8 +121,8 @@ static void request_response_with_payload(grpc_end2end_test_fixture f) {
   size_t details_capacity = 0;
   int was_cancelled = 2;
 
-  c = grpc_channel_create_call(f.client, f.cq, "/foo", "foo.test.google.fr",
-                               deadline);
+  c = grpc_channel_create_call(f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+                               "/foo", "foo.test.google.fr", deadline);
   GPR_ASSERT(c);
 
   grpc_metadata_array_init(&initial_metadata_recv);
diff --git a/test/core/end2end/tests/request_response_with_payload_and_call_creds.c b/test/core/end2end/tests/request_response_with_payload_and_call_creds.c
index b4ccaf8216..0ea7b30fc5 100644
--- a/test/core/end2end/tests/request_response_with_payload_and_call_creds.c
+++ b/test/core/end2end/tests/request_response_with_payload_and_call_creds.c
@@ -138,8 +138,8 @@ static void test_call_creds_failure(grpc_end2end_test_config config) {
   grpc_end2end_test_fixture f =
       begin_test(config, "test_call_creds_failure", 0);
   gpr_timespec deadline = five_seconds_time();
-  c = grpc_channel_create_call(f.client, f.cq, "/foo", "foo.test.google.fr",
-                               deadline);
+  c = grpc_channel_create_call(f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+                               "/foo", "foo.test.google.fr", deadline);
   GPR_ASSERT(c);
 
   /* Try with credentials unfit to be set on a call (channel creds). */
@@ -186,8 +186,8 @@ static void request_response_with_payload_and_call_creds(
   f = begin_test(config, test_name, 0);
   cqv = cq_verifier_create(f.cq);
 
-  c = grpc_channel_create_call(f.client, f.cq, "/foo", "foo.test.google.fr",
-                               deadline);
+  c = grpc_channel_create_call(f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+                               "/foo", "foo.test.google.fr", deadline);
   GPR_ASSERT(c);
   creds = grpc_iam_credentials_create(iam_token, iam_selector);
   GPR_ASSERT(creds != NULL);
diff --git a/test/core/end2end/tests/request_response_with_trailing_metadata_and_payload.c b/test/core/end2end/tests/request_response_with_trailing_metadata_and_payload.c
index a5c0851d05..26be4ef643 100644
--- a/test/core/end2end/tests/request_response_with_trailing_metadata_and_payload.c
+++ b/test/core/end2end/tests/request_response_with_trailing_metadata_and_payload.c
@@ -131,8 +131,8 @@ static void test_request_response_with_metadata_and_payload(
   size_t details_capacity = 0;
   int was_cancelled = 2;
 
-  c = grpc_channel_create_call(f.client, f.cq, "/foo", "foo.test.google.fr",
-                               deadline);
+  c = grpc_channel_create_call(f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+                               "/foo", "foo.test.google.fr", deadline);
   GPR_ASSERT(c);
 
   grpc_metadata_array_init(&initial_metadata_recv);
diff --git a/test/core/end2end/tests/request_with_compressed_payload.c b/test/core/end2end/tests/request_with_compressed_payload.c
index 2599f796d2..5f7d83cb06 100644
--- a/test/core/end2end/tests/request_with_compressed_payload.c
+++ b/test/core/end2end/tests/request_with_compressed_payload.c
@@ -141,8 +141,8 @@ static void request_with_payload_template(
   f = begin_test(config, test_name, client_args, server_args);
   cqv = cq_verifier_create(f.cq);
 
-  c = grpc_channel_create_call(f.client, f.cq, "/foo",
-                               "foo.test.google.fr", deadline);
+  c = grpc_channel_create_call(f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+                               "/foo", "foo.test.google.fr", deadline);
   GPR_ASSERT(c);
 
   grpc_metadata_array_init(&initial_metadata_recv);
diff --git a/test/core/end2end/tests/request_with_flags.c b/test/core/end2end/tests/request_with_flags.c
index 0bfedca0ab..37c4825c8b 100644
--- a/test/core/end2end/tests/request_with_flags.c
+++ b/test/core/end2end/tests/request_with_flags.c
@@ -121,8 +121,8 @@ static void test_invoke_request_with_flags(
   size_t details_capacity = 0;
   grpc_call_error expectation;
 
-  c = grpc_channel_create_call(f.client, f.cq, "/foo", "foo.test.google.fr",
-                               deadline);
+  c = grpc_channel_create_call(f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+                               "/foo", "foo.test.google.fr", deadline);
   GPR_ASSERT(c);
 
   grpc_metadata_array_init(&initial_metadata_recv);
diff --git a/test/core/end2end/tests/request_with_large_metadata.c b/test/core/end2end/tests/request_with_large_metadata.c
index ad34c69774..9ea8273ab0 100644
--- a/test/core/end2end/tests/request_with_large_metadata.c
+++ b/test/core/end2end/tests/request_with_large_metadata.c
@@ -122,8 +122,8 @@ static void test_request_with_large_metadata(grpc_end2end_test_config config) {
   int was_cancelled = 2;
   const int large_size = 64 * 1024;
 
-  c = grpc_channel_create_call(f.client, f.cq, "/foo", "foo.test.google.fr",
-                               deadline);
+  c = grpc_channel_create_call(f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+                               "/foo", "foo.test.google.fr", deadline);
   GPR_ASSERT(c);
 
   meta.key = "key";
diff --git a/test/core/end2end/tests/request_with_payload.c b/test/core/end2end/tests/request_with_payload.c
index 8db6457830..6b5f173f01 100644
--- a/test/core/end2end/tests/request_with_payload.c
+++ b/test/core/end2end/tests/request_with_payload.c
@@ -120,8 +120,8 @@ static void test_invoke_request_with_payload(grpc_end2end_test_config config) {
   size_t details_capacity = 0;
   int was_cancelled = 2;
 
-  c = grpc_channel_create_call(f.client, f.cq, "/foo", "foo.test.google.fr",
-                               deadline);
+  c = grpc_channel_create_call(f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+                               "/foo", "foo.test.google.fr", deadline);
   GPR_ASSERT(c);
 
   grpc_metadata_array_init(&initial_metadata_recv);
diff --git a/test/core/end2end/tests/server_finishes_request.c b/test/core/end2end/tests/server_finishes_request.c
index 062a59aca2..661c099d93 100644
--- a/test/core/end2end/tests/server_finishes_request.c
+++ b/test/core/end2end/tests/server_finishes_request.c
@@ -115,8 +115,8 @@ static void simple_request_body(grpc_end2end_test_fixture f) {
   size_t details_capacity = 0;
   int was_cancelled = 2;
 
-  c = grpc_channel_create_call(f.client, f.cq, "/foo",
-                               "foo.test.google.fr:1234", deadline);
+  c = grpc_channel_create_call(f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+                               "/foo", "foo.test.google.fr:1234", deadline);
   GPR_ASSERT(c);
 
   grpc_metadata_array_init(&initial_metadata_recv);
diff --git a/test/core/end2end/tests/simple_delayed_request.c b/test/core/end2end/tests/simple_delayed_request.c
index 034e974256..82d2bf9657 100644
--- a/test/core/end2end/tests/simple_delayed_request.c
+++ b/test/core/end2end/tests/simple_delayed_request.c
@@ -107,8 +107,8 @@ static void simple_delayed_request_body(grpc_end2end_test_config config,
 
   config.init_client(f, client_args);
 
-  c = grpc_channel_create_call(f->client, f->cq, "/foo", "foo.test.google.fr",
-                               deadline);
+  c = grpc_channel_create_call(f->client, NULL, GRPC_PROPAGATE_DEFAULTS, f->cq,
+                               "/foo", "foo.test.google.fr", deadline);
   GPR_ASSERT(c);
 
   grpc_metadata_array_init(&initial_metadata_recv);
diff --git a/test/core/end2end/tests/simple_request.c b/test/core/end2end/tests/simple_request.c
index ca783afccd..d60a63e682 100644
--- a/test/core/end2end/tests/simple_request.c
+++ b/test/core/end2end/tests/simple_request.c
@@ -116,8 +116,8 @@ static void simple_request_body(grpc_end2end_test_fixture f) {
   int was_cancelled = 2;
   char *peer;
 
-  c = grpc_channel_create_call(f.client, f.cq, "/foo",
-                               "foo.test.google.fr:1234", deadline);
+  c = grpc_channel_create_call(f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+                               "/foo", "foo.test.google.fr:1234", deadline);
   GPR_ASSERT(c);
 
   peer = grpc_call_get_peer(c);
diff --git a/test/core/end2end/tests/simple_request_with_high_initial_sequence_number.c b/test/core/end2end/tests/simple_request_with_high_initial_sequence_number.c
index 2cd638cbb9..2244e22416 100644
--- a/test/core/end2end/tests/simple_request_with_high_initial_sequence_number.c
+++ b/test/core/end2end/tests/simple_request_with_high_initial_sequence_number.c
@@ -115,8 +115,8 @@ static void simple_request_body(grpc_end2end_test_fixture f) {
   size_t details_capacity = 0;
   int was_cancelled = 2;
 
-  c = grpc_channel_create_call(f.client, f.cq, "/foo",
-                               "foo.test.google.fr:1234", deadline);
+  c = grpc_channel_create_call(f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
+                               "/foo", "foo.test.google.fr:1234", deadline);
   GPR_ASSERT(c);
 
   grpc_metadata_array_init(&initial_metadata_recv);
diff --git a/test/core/fling/client.c b/test/core/fling/client.c
index 5647a16101..17b737c9dd 100644
--- a/test/core/fling/client.c
+++ b/test/core/fling/client.c
@@ -89,9 +89,9 @@ static void init_ping_pong_request(void) {
 }
 
 static void step_ping_pong_request(void) {
-  call =
-      grpc_channel_create_call(channel, cq, "/Reflector/reflectUnary",
-                               "localhost", gpr_inf_future(GPR_CLOCK_REALTIME));
+  call = grpc_channel_create_call(channel, NULL, GRPC_PROPAGATE_DEFAULTS, cq,
+                                  "/Reflector/reflectUnary", "localhost",
+                                  gpr_inf_future(GPR_CLOCK_REALTIME));
   GPR_ASSERT(GRPC_CALL_OK ==
              grpc_call_start_batch(call, ops, op - ops, (void *)1));
   grpc_completion_queue_next(cq, gpr_inf_future(GPR_CLOCK_REALTIME));
@@ -101,9 +101,9 @@ static void step_ping_pong_request(void) {
 }
 
 static void init_ping_pong_stream(void) {
-  call =
-      grpc_channel_create_call(channel, cq, "/Reflector/reflectStream",
-                               "localhost", gpr_inf_future(GPR_CLOCK_REALTIME));
+  call = grpc_channel_create_call(channel, NULL, GRPC_PROPAGATE_DEFAULTS, cq,
+                                  "/Reflector/reflectStream", "localhost",
+                                  gpr_inf_future(GPR_CLOCK_REALTIME));
   stream_init_op.op = GRPC_OP_SEND_INITIAL_METADATA;
   stream_init_op.data.send_initial_metadata.count = 0;
   GPR_ASSERT(GRPC_CALL_OK ==
diff --git a/test/core/surface/lame_client_test.c b/test/core/surface/lame_client_test.c
index 3a7a3a36ee..5e6c9ae15c 100644
--- a/test/core/surface/lame_client_test.c
+++ b/test/core/surface/lame_client_test.c
@@ -60,7 +60,8 @@ int main(int argc, char **argv) {
   chan = grpc_lame_client_channel_create("lampoon:national");
   GPR_ASSERT(chan);
   cq = grpc_completion_queue_create();
-  call = grpc_channel_create_call(chan, cq, "/Foo", "anywhere",
+  call = grpc_channel_create_call(chan, NULL, GRPC_PROPAGATE_DEFAULTS, cq,
+                                  "/Foo", "anywhere",
                                   GRPC_TIMEOUT_SECONDS_TO_DEADLINE(100));
   GPR_ASSERT(call);
   cqv = cq_verifier_create(cq);
diff --git a/test/core/util/test_config.c b/test/core/util/test_config.c
index 225658f5e2..cadf88a7c6 100644
--- a/test/core/util/test_config.c
+++ b/test/core/util/test_config.c
@@ -38,6 +38,8 @@
 #include <stdlib.h>
 #include <signal.h>
 
+double g_fixture_slowdown_factor = 1.0;
+
 #if GPR_GETPID_IN_UNISTD_H
 #include <unistd.h>
 static int seed(void) { return getpid(); }
diff --git a/test/core/util/test_config.h b/test/core/util/test_config.h
index 7028ade7b2..b2cc40bb47 100644
--- a/test/core/util/test_config.h
+++ b/test/core/util/test_config.h
@@ -48,8 +48,11 @@ extern "C" {
 #define GRPC_TEST_SLOWDOWN_MACHINE_FACTOR 1.0
 #endif
 
-#define GRPC_TEST_SLOWDOWN_FACTOR \
-  (GRPC_TEST_SLOWDOWN_BUILD_FACTOR * GRPC_TEST_SLOWDOWN_MACHINE_FACTOR)
+extern double g_fixture_slowdown_factor;
+
+#define GRPC_TEST_SLOWDOWN_FACTOR                                        \
+  (GRPC_TEST_SLOWDOWN_BUILD_FACTOR * GRPC_TEST_SLOWDOWN_MACHINE_FACTOR * \
+   g_fixture_slowdown_factor)
 
 #define GRPC_TIMEOUT_SECONDS_TO_DEADLINE(x)                                \
   gpr_time_add(gpr_now(GPR_CLOCK_MONOTONIC),                               \