grpc 1.8.7 → 1.9.0.pre1

data/src/core/ext/transport/chttp2/transport/stream_lists.cc

@@ -183,6 +183,7 @@ void grpc_chttp2_list_remove_waiting_for_concurrency(grpc_chttp2_transport* t,
 
 void grpc_chttp2_list_add_stalled_by_transport(grpc_chttp2_transport* t,
                                                grpc_chttp2_stream* s) {
+  GPR_ASSERT(t->flow_control->flow_control_enabled());
   stream_list_add(t, s, GRPC_CHTTP2_LIST_STALLED_BY_TRANSPORT);
 }
 
@@ -198,6 +199,7 @@ void grpc_chttp2_list_remove_stalled_by_transport(grpc_chttp2_transport* t,
 
 void grpc_chttp2_list_add_stalled_by_stream(grpc_chttp2_transport* t,
                                             grpc_chttp2_stream* s) {
+  GPR_ASSERT(t->flow_control->flow_control_enabled());
   stream_list_add(t, s, GRPC_CHTTP2_LIST_STALLED_BY_STREAM);
 }
 

data/src/core/ext/transport/chttp2/transport/stream_map.h

@@ -23,10 +23,6 @@
 
 #include <stddef.h>
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 /* Data structure to map a uint32_t to a data object (represented by a void*)
 
    Represented as a sorted array of keys, and a corresponding array of values.
@@ -69,8 +65,4 @@ void grpc_chttp2_stream_map_for_each(grpc_chttp2_stream_map* map,
                                                void* value),
                                      void* user_data);
 
-#ifdef __cplusplus
-}
-#endif
-
 #endif /* GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_STREAM_MAP_H */

data/src/core/ext/transport/chttp2/transport/varint.h

@@ -21,10 +21,6 @@
 
 #include <grpc/support/port_platform.h>
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 /* Helpers for hpack varint encoding */
 
 /* length of a value that needs varint tail encoding (it's bigger than can be
@@ -61,8 +57,4 @@ void grpc_chttp2_hpack_write_varint_tail(uint32_t tail_value, uint8_t* target,
     }                                                                         \
   } while (0)
 
-#ifdef __cplusplus
-}
-#endif
-
 #endif /* GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_VARINT_H */

data/src/core/ext/transport/chttp2/transport/writing.cc

@@ -33,17 +33,15 @@ static void add_to_write_list(grpc_chttp2_write_cb** list,
   *list = cb;
 }
 
-static void finish_write_cb(grpc_exec_ctx* exec_ctx, grpc_chttp2_transport* t,
-                            grpc_chttp2_stream* s, grpc_chttp2_write_cb* cb,
-                            grpc_error* error) {
-  grpc_chttp2_complete_closure_step(exec_ctx, t, s, &cb->closure, error,
+static void finish_write_cb(grpc_chttp2_transport* t, grpc_chttp2_stream* s,
+                            grpc_chttp2_write_cb* cb, grpc_error* error) {
+  grpc_chttp2_complete_closure_step(t, s, &cb->closure, error,
                                     "finish_write_cb");
   cb->next = t->write_cb_pool;
   t->write_cb_pool = cb;
 }
 
-static void maybe_initiate_ping(grpc_exec_ctx* exec_ctx,
-                                grpc_chttp2_transport* t) {
+static void maybe_initiate_ping(grpc_chttp2_transport* t) {
   grpc_chttp2_ping_queue* pq = &t->ping_queue;
   if (grpc_closure_list_empty(pq->lists[GRPC_CHTTP2_PCL_NEXT])) {
     /* no ping needed: wait */
@@ -68,7 +66,7 @@ static void maybe_initiate_ping(grpc_exec_ctx* exec_ctx,
     }
     return;
   }
-  grpc_millis now = grpc_exec_ctx_now(exec_ctx);
+  grpc_millis now = grpc_core::ExecCtx::Get()->Now();
 
   grpc_millis next_allowed_ping_interval =
       (t->keepalive_permit_without_calls == 0 &&
@@ -90,20 +88,20 @@ static void maybe_initiate_ping(grpc_exec_ctx* exec_ctx,
     }
     if (!t->ping_state.is_delayed_ping_timer_set) {
       t->ping_state.is_delayed_ping_timer_set = true;
-      grpc_timer_init(exec_ctx, &t->ping_state.delayed_ping_timer,
-                      next_allowed_ping, &t->retry_initiate_ping_locked);
+      grpc_timer_init(&t->ping_state.delayed_ping_timer, next_allowed_ping,
+                      &t->retry_initiate_ping_locked);
     }
     return;
   }
 
   pq->inflight_id = t->ping_ctr;
   t->ping_ctr++;
-  GRPC_CLOSURE_LIST_SCHED(exec_ctx, &pq->lists[GRPC_CHTTP2_PCL_INITIATE]);
+  GRPC_CLOSURE_LIST_SCHED(&pq->lists[GRPC_CHTTP2_PCL_INITIATE]);
   grpc_closure_list_move(&pq->lists[GRPC_CHTTP2_PCL_NEXT],
                          &pq->lists[GRPC_CHTTP2_PCL_INFLIGHT]);
   grpc_slice_buffer_add(&t->outbuf,
                         grpc_chttp2_ping_create(false, pq->inflight_id));
-  GRPC_STATS_INC_HTTP2_PINGS_SENT(exec_ctx);
+  GRPC_STATS_INC_HTTP2_PINGS_SENT();
   t->ping_state.last_ping_sent_time = now;
   if (grpc_http_trace.enabled() || grpc_bdp_estimator_trace.enabled()) {
     gpr_log(GPR_DEBUG, "%s: Ping sent [%p]: %d/%d",
@@ -115,10 +113,9 @@ static void maybe_initiate_ping(grpc_exec_ctx* exec_ctx,
       (t->ping_state.pings_before_data_required != 0);
 }
 
-static bool update_list(grpc_exec_ctx* exec_ctx, grpc_chttp2_transport* t,
-                        grpc_chttp2_stream* s, int64_t send_bytes,
-                        grpc_chttp2_write_cb** list, int64_t* ctr,
-                        grpc_error* error) {
+static bool update_list(grpc_chttp2_transport* t, grpc_chttp2_stream* s,
+                        int64_t send_bytes, grpc_chttp2_write_cb** list,
+                        int64_t* ctr, grpc_error* error) {
   bool sched_any = false;
   grpc_chttp2_write_cb* cb = *list;
   *list = nullptr;
@@ -127,7 +124,7 @@ static bool update_list(grpc_exec_ctx* exec_ctx, grpc_chttp2_transport* t,
     grpc_chttp2_write_cb* next = cb->next;
     if (cb->call_at_byte <= *ctr) {
       sched_any = true;
-      finish_write_cb(exec_ctx, t, s, cb, GRPC_ERROR_REF(error));
+      finish_write_cb(t, s, cb, GRPC_ERROR_REF(error));
     } else {
       add_to_write_list(list, cb);
     }
@@ -141,10 +138,11 @@ static void report_stall(grpc_chttp2_transport* t, grpc_chttp2_stream* s,
                          const char* staller) {
   gpr_log(
       GPR_DEBUG,
-      "%s:%p stream %d stalled by %s [fc:pending=%" PRIdPTR ":flowed=%" PRId64
+      "%s:%p stream %d stalled by %s [fc:pending=%" PRIdPTR
+      ":pending-compressed=%" PRIdPTR ":flowed=%" PRId64
       ":peer_initwin=%d:t_win=%" PRId64 ":s_win=%d:s_delta=%" PRId64 "]",
       t->peer_string, t, s->id, staller, s->flow_controlled_buffer.length,
-      s->flow_controlled_bytes_flowed,
+      s->compressed_data_buffer.length, s->flow_controlled_bytes_flowed,
       t->settings[GRPC_ACKED_SETTINGS]
                  [GRPC_CHTTP2_SETTINGS_INITIAL_WINDOW_SIZE],
       t->flow_control->remote_window(),
@@ -180,22 +178,22 @@ class StreamWriteContext;
 
 class WriteContext {
  public:
-  WriteContext(grpc_exec_ctx* exec_ctx, grpc_chttp2_transport* t) : t_(t) {
-    GRPC_STATS_INC_HTTP2_WRITES_BEGUN(exec_ctx);
+  WriteContext(grpc_chttp2_transport* t) : t_(t) {
+    GRPC_STATS_INC_HTTP2_WRITES_BEGUN();
     GPR_TIMER_BEGIN("grpc_chttp2_begin_write", 0);
   }
 
   // TODO(ctiller): make this the destructor
-  void FlushStats(grpc_exec_ctx* exec_ctx) {
+  void FlushStats() {
     GRPC_STATS_INC_HTTP2_SEND_INITIAL_METADATA_PER_WRITE(
-        exec_ctx, initial_metadata_writes_);
-    GRPC_STATS_INC_HTTP2_SEND_MESSAGE_PER_WRITE(exec_ctx, message_writes_);
+        initial_metadata_writes_);
+    GRPC_STATS_INC_HTTP2_SEND_MESSAGE_PER_WRITE(message_writes_);
     GRPC_STATS_INC_HTTP2_SEND_TRAILING_METADATA_PER_WRITE(
-        exec_ctx, trailing_metadata_writes_);
-    GRPC_STATS_INC_HTTP2_SEND_FLOWCTL_PER_WRITE(exec_ctx, flow_control_writes_);
+        trailing_metadata_writes_);
+    GRPC_STATS_INC_HTTP2_SEND_FLOWCTL_PER_WRITE(flow_control_writes_);
   }
 
-  void FlushSettings(grpc_exec_ctx* exec_ctx) {
+  void FlushSettings() {
     if (t_->dirtied_local_settings && !t_->sent_local_settings) {
       grpc_slice_buffer_add(
           &t_->outbuf, grpc_chttp2_settings_create(
@@ -205,17 +203,17 @@ class WriteContext {
       t_->force_send_settings = false;
       t_->dirtied_local_settings = false;
       t_->sent_local_settings = true;
-      GRPC_STATS_INC_HTTP2_SETTINGS_WRITES(exec_ctx);
+      GRPC_STATS_INC_HTTP2_SETTINGS_WRITES();
     }
   }
 
-  void FlushQueuedBuffers(grpc_exec_ctx* exec_ctx) {
+  void FlushQueuedBuffers() {
     /* simple writes are queued to qbuf, and flushed here */
     grpc_slice_buffer_move_into(&t_->qbuf, &t_->outbuf);
     GPR_ASSERT(t_->qbuf.count == 0);
   }
 
-  void FlushWindowUpdates(grpc_exec_ctx* exec_ctx) {
+  void FlushWindowUpdates() {
     uint32_t transport_announce =
         t_->flow_control->MaybeSendUpdate(t_->outbuf.count > 0);
     if (transport_announce) {
@@ -235,7 +233,7 @@ class WriteContext {
     t_->ping_ack_count = 0;
   }
 
-  void EnactHpackSettings(grpc_exec_ctx* exec_ctx) {
+  void EnactHpackSettings() {
     grpc_chttp2_hpack_compressor_set_max_table_size(
         &t_->hpack_compressor,
         t_->settings[GRPC_PEER_SETTINGS]
@@ -375,8 +373,8 @@ class DataSendContext {
 
   bool is_last_frame() const { return is_last_frame_; }
 
-  void CallCallbacks(grpc_exec_ctx* exec_ctx) {
-    if (update_list(exec_ctx, t_, s_,
+  void CallCallbacks() {
+    if (update_list(t_, s_,
                     (int64_t)(s_->sending_bytes - sending_bytes_before_),
                     &s_->on_flow_controlled_cbs,
                     &s_->flow_controlled_bytes_flowed, GRPC_ERROR_NONE)) {
@@ -404,7 +402,7 @@ class StreamWriteContext {
                       s->flow_control->announced_window_delta())));
   }
 
-  void FlushInitialMetadata(grpc_exec_ctx* exec_ctx) {
+  void FlushInitialMetadata() {
     /* send initial metadata if it's available */
     if (s_->sent_initial_metadata) return;
     if (s_->send_initial_metadata == nullptr) return;
@@ -431,7 +429,7 @@ class StreamWriteContext {
                       [GRPC_CHTTP2_SETTINGS_MAX_FRAME_SIZE],  // max_frame_size
           &s_->stats.outgoing                                 // stats
       };
-      grpc_chttp2_encode_header(exec_ctx, &t_->hpack_compressor, nullptr, 0,
+      grpc_chttp2_encode_header(&t_->hpack_compressor, nullptr, 0,
                                 s_->send_initial_metadata, &hopt, &t_->outbuf);
       write_context_->ResetPingRecvClock();
       write_context_->IncInitialMetadataWrites();
@@ -441,11 +439,11 @@ class StreamWriteContext {
     s_->sent_initial_metadata = true;
     write_context_->NoteScheduledResults();
     grpc_chttp2_complete_closure_step(
-        exec_ctx, t_, s_, &s_->send_initial_metadata_finished, GRPC_ERROR_NONE,
+        t_, s_, &s_->send_initial_metadata_finished, GRPC_ERROR_NONE,
         "send_initial_metadata_finished");
   }
 
-  void FlushWindowUpdates(grpc_exec_ctx* exec_ctx) {
+  void FlushWindowUpdates() {
     /* send any window updates */
     const uint32_t stream_announce = s_->flow_control->MaybeSendUpdate();
     if (stream_announce == 0) return;
@@ -457,7 +455,7 @@ class StreamWriteContext {
     write_context_->IncWindowUpdateWrites();
   }
 
-  void FlushData(grpc_exec_ctx* exec_ctx) {
+  void FlushData() {
     if (!s_->sent_initial_metadata) return;
 
     if (s_->flow_controlled_buffer.length == 0 &&
@@ -489,9 +487,9 @@ class StreamWriteContext {
     }
     write_context_->ResetPingRecvClock();
     if (data_send_context.is_last_frame()) {
-      SentLastFrame(exec_ctx);
+      SentLastFrame();
     }
-    data_send_context.CallCallbacks(exec_ctx);
+    data_send_context.CallCallbacks();
     stream_became_writable_ = true;
     if (s_->flow_controlled_buffer.length > 0 ||
         s_->compressed_data_buffer.length > 0) {
@@ -501,7 +499,7 @@ class StreamWriteContext {
     write_context_->IncMessageWrites();
   }
 
-  void FlushTrailingMetadata(grpc_exec_ctx* exec_ctx) {
+  void FlushTrailingMetadata() {
     if (!s_->sent_initial_metadata) return;
 
     if (s_->send_trailing_metadata == nullptr) return;
@@ -522,18 +520,18 @@ class StreamWriteContext {
 
           t_->settings[GRPC_PEER_SETTINGS][GRPC_CHTTP2_SETTINGS_MAX_FRAME_SIZE],
           &s_->stats.outgoing};
-      grpc_chttp2_encode_header(exec_ctx, &t_->hpack_compressor,
+      grpc_chttp2_encode_header(&t_->hpack_compressor,
                                 extra_headers_for_trailing_metadata_,
                                 num_extra_headers_for_trailing_metadata_,
                                 s_->send_trailing_metadata, &hopt, &t_->outbuf);
     }
     write_context_->IncTrailingMetadataWrites();
     write_context_->ResetPingRecvClock();
-    SentLastFrame(exec_ctx);
+    SentLastFrame();
 
     write_context_->NoteScheduledResults();
     grpc_chttp2_complete_closure_step(
-        exec_ctx, t_, s_, &s_->send_trailing_metadata_finished, GRPC_ERROR_NONE,
+        t_, s_, &s_->send_trailing_metadata_finished, GRPC_ERROR_NONE,
         "send_trailing_metadata_finished");
   }
 
@@ -557,7 +555,7 @@ class StreamWriteContext {
     }
   }
 
-  void SentLastFrame(grpc_exec_ctx* exec_ctx) {
+  void SentLastFrame() {
     s_->send_trailing_metadata = nullptr;
     s_->sent_trailing_metadata = true;
 
@@ -566,7 +564,7 @@ class StreamWriteContext {
           &t_->outbuf, grpc_chttp2_rst_stream_create(
                            s_->id, GRPC_HTTP2_NO_ERROR, &s_->stats.outgoing));
     }
-    grpc_chttp2_mark_stream_closed(exec_ctx, t_, s_, !t_->is_client, true,
+    grpc_chttp2_mark_stream_closed(t_, s_, !t_->is_client, true,
                                    GRPC_ERROR_NONE);
   }
 
@@ -580,12 +578,12 @@ class StreamWriteContext {
 }  // namespace
 
 grpc_chttp2_begin_write_result grpc_chttp2_begin_write(
-    grpc_exec_ctx* exec_ctx, grpc_chttp2_transport* t) {
-  WriteContext ctx(exec_ctx, t);
-  ctx.FlushSettings(exec_ctx);
+    grpc_chttp2_transport* t) {
+  WriteContext ctx(t);
+  ctx.FlushSettings();
   ctx.FlushPingAcks();
-  ctx.FlushQueuedBuffers(exec_ctx);
-  ctx.EnactHpackSettings(exec_ctx);
+  ctx.FlushQueuedBuffers();
+  ctx.EnactHpackSettings();
 
   if (t->flow_control->remote_window() > 0) {
     ctx.UpdateStreamsNoLongerStalled();
@@ -595,47 +593,45 @@ grpc_chttp2_begin_write_result grpc_chttp2_begin_write(
      (according to available window sizes) and add to the output buffer */
   while (grpc_chttp2_stream* s = ctx.NextStream()) {
     StreamWriteContext stream_ctx(&ctx, s);
-    stream_ctx.FlushInitialMetadata(exec_ctx);
-    stream_ctx.FlushWindowUpdates(exec_ctx);
-    stream_ctx.FlushData(exec_ctx);
-    stream_ctx.FlushTrailingMetadata(exec_ctx);
+    stream_ctx.FlushInitialMetadata();
+    stream_ctx.FlushWindowUpdates();
+    stream_ctx.FlushData();
+    stream_ctx.FlushTrailingMetadata();
 
     if (stream_ctx.stream_became_writable()) {
       if (!grpc_chttp2_list_add_writing_stream(t, s)) {
         /* already in writing list: drop ref */
-        GRPC_CHTTP2_STREAM_UNREF(exec_ctx, s, "chttp2_writing:already_writing");
+        GRPC_CHTTP2_STREAM_UNREF(s, "chttp2_writing:already_writing");
       } else {
         /* ref will be dropped at end of write */
       }
     } else {
-      GRPC_CHTTP2_STREAM_UNREF(exec_ctx, s, "chttp2_writing:no_write");
+      GRPC_CHTTP2_STREAM_UNREF(s, "chttp2_writing:no_write");
     }
   }
 
-  ctx.FlushWindowUpdates(exec_ctx);
+  ctx.FlushWindowUpdates();
 
-  maybe_initiate_ping(exec_ctx, t);
+  maybe_initiate_ping(t);
 
   GPR_TIMER_END("grpc_chttp2_begin_write", 0);
 
   return ctx.Result();
 }
 
-void grpc_chttp2_end_write(grpc_exec_ctx* exec_ctx, grpc_chttp2_transport* t,
-                           grpc_error* error) {
+void grpc_chttp2_end_write(grpc_chttp2_transport* t, grpc_error* error) {
   GPR_TIMER_BEGIN("grpc_chttp2_end_write", 0);
   grpc_chttp2_stream* s;
 
   while (grpc_chttp2_list_pop_writing_stream(t, &s)) {
     if (s->sending_bytes != 0) {
-      update_list(exec_ctx, t, s, (int64_t)s->sending_bytes,
-                  &s->on_write_finished_cbs, &s->flow_controlled_bytes_written,
-                  GRPC_ERROR_REF(error));
+      update_list(t, s, (int64_t)s->sending_bytes, &s->on_write_finished_cbs,
+                  &s->flow_controlled_bytes_written, GRPC_ERROR_REF(error));
       s->sending_bytes = 0;
     }
-    GRPC_CHTTP2_STREAM_UNREF(exec_ctx, s, "chttp2_writing:end");
+    GRPC_CHTTP2_STREAM_UNREF(s, "chttp2_writing:end");
   }
-  grpc_slice_buffer_reset_and_unref_internal(exec_ctx, &t->outbuf);
+  grpc_slice_buffer_reset_and_unref_internal(&t->outbuf);
   GRPC_ERROR_UNREF(error);
   GPR_TIMER_END("grpc_chttp2_end_write", 0);
 }

data/src/core/ext/transport/inproc/inproc_plugin.cc

@@ -21,8 +21,6 @@
 
 grpc_core::TraceFlag grpc_inproc_trace(false, "inproc");
 
-extern "C" void grpc_inproc_plugin_init(void) { grpc_inproc_transport_init(); }
+void grpc_inproc_plugin_init(void) { grpc_inproc_transport_init(); }
 
-extern "C" void grpc_inproc_plugin_shutdown(void) {
-  grpc_inproc_transport_shutdown();
-}
+void grpc_inproc_plugin_shutdown(void) { grpc_inproc_transport_shutdown(); }

data/src/core/ext/transport/inproc/inproc_transport.cc

@@ -54,8 +54,8 @@ typedef struct inproc_transport {
   gpr_refcount refs;
   bool is_client;
   grpc_connectivity_state_tracker connectivity;
-  void (*accept_stream_cb)(grpc_exec_ctx* exec_ctx, void* user_data,
-                           grpc_transport* transport, const void* server_data);
+  void (*accept_stream_cb)(void* user_data, grpc_transport* transport,
+                           const void* server_data);
   void* accept_stream_data;
   bool is_closed;
   struct inproc_transport* other_side;
@@ -118,39 +118,36 @@ typedef struct inproc_stream {
 } inproc_stream;
 
 static grpc_closure do_nothing_closure;
-static bool cancel_stream_locked(grpc_exec_ctx* exec_ctx, inproc_stream* s,
-                                 grpc_error* error);
-static void op_state_machine(grpc_exec_ctx* exec_ctx, void* arg,
-                             grpc_error* error);
+static bool cancel_stream_locked(inproc_stream* s, grpc_error* error);
+static void op_state_machine(void* arg, grpc_error* error);
 
 static void ref_transport(inproc_transport* t) {
   INPROC_LOG(GPR_DEBUG, "ref_transport %p", t);
   gpr_ref(&t->refs);
 }
 
-static void really_destroy_transport(grpc_exec_ctx* exec_ctx,
-                                     inproc_transport* t) {
+static void really_destroy_transport(inproc_transport* t) {
   INPROC_LOG(GPR_DEBUG, "really_destroy_transport %p", t);
-  grpc_connectivity_state_destroy(exec_ctx, &t->connectivity);
+  grpc_connectivity_state_destroy(&t->connectivity);
   if (gpr_unref(&t->mu->refs)) {
     gpr_free(t->mu);
   }
   gpr_free(t);
 }
 
-static void unref_transport(grpc_exec_ctx* exec_ctx, inproc_transport* t) {
+static void unref_transport(inproc_transport* t) {
   INPROC_LOG(GPR_DEBUG, "unref_transport %p", t);
   if (gpr_unref(&t->refs)) {
-    really_destroy_transport(exec_ctx, t);
+    really_destroy_transport(t);
   }
 }
 
 #ifndef NDEBUG
 #define STREAM_REF(refs, reason) grpc_stream_ref(refs, reason)
-#define STREAM_UNREF(e, refs, reason) grpc_stream_unref(e, refs, reason)
+#define STREAM_UNREF(refs, reason) grpc_stream_unref(refs, reason)
 #else
 #define STREAM_REF(refs, reason) grpc_stream_ref(refs)
-#define STREAM_UNREF(e, refs, reason) grpc_stream_unref(e, refs)
+#define STREAM_UNREF(refs, reason) grpc_stream_unref(refs)
 #endif
 
 static void ref_stream(inproc_stream* s, const char* reason) {
@@ -158,13 +155,12 @@ static void ref_stream(inproc_stream* s, const char* reason) {
   STREAM_REF(s->refs, reason);
 }
 
-static void unref_stream(grpc_exec_ctx* exec_ctx, inproc_stream* s,
-                         const char* reason) {
+static void unref_stream(inproc_stream* s, const char* reason) {
   INPROC_LOG(GPR_DEBUG, "unref_stream %p %s", s, reason);
-  STREAM_UNREF(exec_ctx, s->refs, reason);
+  STREAM_UNREF(s->refs, reason);
 }
 
-static void really_destroy_stream(grpc_exec_ctx* exec_ctx, inproc_stream* s) {
+static void really_destroy_stream(inproc_stream* s) {
   INPROC_LOG(GPR_DEBUG, "really_destroy_stream %p", s);
 
   GRPC_ERROR_UNREF(s->write_buffer_cancel_error);
@@ -172,13 +168,13 @@ static void really_destroy_stream(grpc_exec_ctx* exec_ctx, inproc_stream* s) {
   GRPC_ERROR_UNREF(s->cancel_other_error);
 
   if (s->recv_inited) {
-    grpc_slice_buffer_destroy_internal(exec_ctx, &s->recv_message);
+    grpc_slice_buffer_destroy_internal(&s->recv_message);
   }
 
-  unref_transport(exec_ctx, s->t);
+  unref_transport(s->t);
 
   if (s->closure_at_destroy) {
-    GRPC_CLOSURE_SCHED(exec_ctx, s->closure_at_destroy, GRPC_ERROR_NONE);
+    GRPC_CLOSURE_SCHED(s->closure_at_destroy, GRPC_ERROR_NONE);
   }
 }
 
@@ -195,7 +191,7 @@ static void log_metadata(const grpc_metadata_batch* md_batch, bool is_client,
   }
 }
 
-static grpc_error* fill_in_metadata(grpc_exec_ctx* exec_ctx, inproc_stream* s,
+static grpc_error* fill_in_metadata(inproc_stream* s,
                                     const grpc_metadata_batch* metadata,
                                     uint32_t flags, grpc_metadata_batch* out_md,
                                     uint32_t* outflags, bool* markfilled) {
@@ -214,18 +210,18 @@ static grpc_error* fill_in_metadata(grpc_exec_ctx* exec_ctx, inproc_stream* s,
        (elem != nullptr) && (error == GRPC_ERROR_NONE); elem = elem->next) {
     grpc_linked_mdelem* nelem =
         (grpc_linked_mdelem*)gpr_arena_alloc(s->arena, sizeof(*nelem));
-    nelem->md = grpc_mdelem_from_slices(
-        exec_ctx, grpc_slice_intern(GRPC_MDKEY(elem->md)),
-        grpc_slice_intern(GRPC_MDVALUE(elem->md)));
+    nelem->md =
+        grpc_mdelem_from_slices(grpc_slice_intern(GRPC_MDKEY(elem->md)),
+                                grpc_slice_intern(GRPC_MDVALUE(elem->md)));
 
-    error = grpc_metadata_batch_link_tail(exec_ctx, out_md, nelem);
+    error = grpc_metadata_batch_link_tail(out_md, nelem);
   }
   return error;
 }
 
-static int init_stream(grpc_exec_ctx* exec_ctx, grpc_transport* gt,
-                       grpc_stream* gs, grpc_stream_refcount* refcount,
-                       const void* server_data, gpr_arena* arena) {
+static int init_stream(grpc_transport* gt, grpc_stream* gs,
+                       grpc_stream_refcount* refcount, const void* server_data,
+                       gpr_arena* arena) {
   INPROC_LOG(GPR_DEBUG, "init_stream %p %p %p", gt, gs, server_data);
   inproc_transport* t = (inproc_transport*)gt;
   inproc_stream* s = (inproc_stream*)gs;
@@ -285,8 +281,7 @@ static int init_stream(grpc_exec_ctx* exec_ctx, grpc_transport* gt,
                                               // side to avoid destruction
     INPROC_LOG(GPR_DEBUG, "calling accept stream cb %p %p",
                st->accept_stream_cb, st->accept_stream_data);
-    (*st->accept_stream_cb)(exec_ctx, st->accept_stream_data, &st->base,
-                            (void*)s);
+    (*st->accept_stream_cb)(st->accept_stream_data, &st->base, (void*)s);
   } else {
     // This is the server-side and is being called through accept_stream_cb
     inproc_stream* cs = (inproc_stream*)server_data;
@@ -301,19 +296,19 @@ static int init_stream(grpc_exec_ctx* exec_ctx, grpc_transport* gt,
     // Now transfer from the other side's write_buffer if any to the to_read
     // buffer
     if (cs->write_buffer_initial_md_filled) {
-      fill_in_metadata(exec_ctx, s, &cs->write_buffer_initial_md,
+      fill_in_metadata(s, &cs->write_buffer_initial_md,
                        cs->write_buffer_initial_md_flags,
                        &s->to_read_initial_md, &s->to_read_initial_md_flags,
                        &s->to_read_initial_md_filled);
       s->deadline = GPR_MIN(s->deadline, cs->write_buffer_deadline);
-      grpc_metadata_batch_clear(exec_ctx, &cs->write_buffer_initial_md);
+      grpc_metadata_batch_clear(&cs->write_buffer_initial_md);
       cs->write_buffer_initial_md_filled = false;
     }
     if (cs->write_buffer_trailing_md_filled) {
-      fill_in_metadata(exec_ctx, s, &cs->write_buffer_trailing_md, 0,
+      fill_in_metadata(s, &cs->write_buffer_trailing_md, 0,
                        &s->to_read_trailing_md, nullptr,
                        &s->to_read_trailing_md_filled);
-      grpc_metadata_batch_clear(exec_ctx, &cs->write_buffer_trailing_md);
+      grpc_metadata_batch_clear(&cs->write_buffer_trailing_md);
       cs->write_buffer_trailing_md_filled = false;
     }
     if (cs->write_buffer_cancel_error != GRPC_ERROR_NONE) {
@@ -326,11 +321,11 @@ static int init_stream(grpc_exec_ctx* exec_ctx, grpc_transport* gt,
   return 0;  // return value is not important
 }
 
-static void close_stream_locked(grpc_exec_ctx* exec_ctx, inproc_stream* s) {
+static void close_stream_locked(inproc_stream* s) {
   if (!s->closed) {
     // Release the metadata that we would have written out
-    grpc_metadata_batch_destroy(exec_ctx, &s->write_buffer_initial_md);
-    grpc_metadata_batch_destroy(exec_ctx, &s->write_buffer_trailing_md);
+    grpc_metadata_batch_destroy(&s->write_buffer_initial_md);
+    grpc_metadata_batch_destroy(&s->write_buffer_trailing_md);
 
     if (s->listed) {
       inproc_stream* p = s->stream_list_prev;
@@ -344,22 +339,21 @@ static void close_stream_locked(grpc_exec_ctx* exec_ctx, inproc_stream* s) {
         n->stream_list_prev = p;
       }
       s->listed = false;
-      unref_stream(exec_ctx, s, "close_stream:list");
+      unref_stream(s, "close_stream:list");
     }
     s->closed = true;
-    unref_stream(exec_ctx, s, "close_stream:closing");
+    unref_stream(s, "close_stream:closing");
   }
 }
 
 // This function means that we are done talking/listening to the other side
-static void close_other_side_locked(grpc_exec_ctx* exec_ctx, inproc_stream* s,
-                                    const char* reason) {
+static void close_other_side_locked(inproc_stream* s, const char* reason) {
   if (s->other_side != nullptr) {
     // First release the metadata that came from the other side's arena
-    grpc_metadata_batch_destroy(exec_ctx, &s->to_read_initial_md);
-    grpc_metadata_batch_destroy(exec_ctx, &s->to_read_trailing_md);
+    grpc_metadata_batch_destroy(&s->to_read_initial_md);
+    grpc_metadata_batch_destroy(&s->to_read_trailing_md);
 
-    unref_stream(exec_ctx, s->other_side, reason);
+    unref_stream(s->other_side, reason);
     s->other_side_closed = true;
     s->other_side = nullptr;
   } else if (!s->other_side_closed) {
@@ -371,8 +365,7 @@ static void close_other_side_locked(grpc_exec_ctx* exec_ctx, inproc_stream* s,
 // this stream_op_batch is only one of the pending operations for this
 // stream. This is called when one of the pending operations for the stream
 // is done and about to be NULLed out
-static void complete_if_batch_end_locked(grpc_exec_ctx* exec_ctx,
-                                         inproc_stream* s, grpc_error* error,
+static void complete_if_batch_end_locked(inproc_stream* s, grpc_error* error,
                                          grpc_transport_stream_op_batch* op,
                                          const char* msg) {
   int is_sm = (int)(op == s->send_message_op);
@@ -383,22 +376,20 @@ static void complete_if_batch_end_locked(grpc_exec_ctx* exec_ctx,
 
   if ((is_sm + is_stm + is_rim + is_rm + is_rtm) == 1) {
     INPROC_LOG(GPR_DEBUG, "%s %p %p %p", msg, s, op, error);
-    GRPC_CLOSURE_SCHED(exec_ctx, op->on_complete, GRPC_ERROR_REF(error));
+    GRPC_CLOSURE_SCHED(op->on_complete, GRPC_ERROR_REF(error));
   }
 }
 
-static void maybe_schedule_op_closure_locked(grpc_exec_ctx* exec_ctx,
-                                             inproc_stream* s,
+static void maybe_schedule_op_closure_locked(inproc_stream* s,
                                              grpc_error* error) {
   if (s && s->ops_needed && !s->op_closure_scheduled) {
-    GRPC_CLOSURE_SCHED(exec_ctx, &s->op_closure, GRPC_ERROR_REF(error));
+    GRPC_CLOSURE_SCHED(&s->op_closure, GRPC_ERROR_REF(error));
     s->op_closure_scheduled = true;
     s->ops_needed = false;
   }
 }
 
-static void fail_helper_locked(grpc_exec_ctx* exec_ctx, inproc_stream* s,
-                               grpc_error* error) {
+static void fail_helper_locked(inproc_stream* s, grpc_error* error) {
   INPROC_LOG(GPR_DEBUG, "op_state_machine %p fail_helper", s);
   // If we're failing this side, we need to make sure that
   // we also send or have already sent trailing metadata
@@ -415,14 +406,14 @@ static void fail_helper_locked(grpc_exec_ctx* exec_ctx, inproc_stream* s,
                                     : &other->to_read_trailing_md;
     bool* destfilled = (other == nullptr) ? &s->write_buffer_trailing_md_filled
                                           : &other->to_read_trailing_md_filled;
-    fill_in_metadata(exec_ctx, s, &fake_md, 0, dest, nullptr, destfilled);
-    grpc_metadata_batch_destroy(exec_ctx, &fake_md);
+    fill_in_metadata(s, &fake_md, 0, dest, nullptr, destfilled);
+    grpc_metadata_batch_destroy(&fake_md);
 
     if (other != nullptr) {
       if (other->cancel_other_error == GRPC_ERROR_NONE) {
         other->cancel_other_error = GRPC_ERROR_REF(error);
       }
-      maybe_schedule_op_closure_locked(exec_ctx, other, error);
+      maybe_schedule_op_closure_locked(other, error);
     } else if (s->write_buffer_cancel_error == GRPC_ERROR_NONE) {
       s->write_buffer_cancel_error = GRPC_ERROR_REF(error);
     }
@@ -436,39 +427,44 @@ static void fail_helper_locked(grpc_exec_ctx* exec_ctx, inproc_stream* s,
       grpc_metadata_batch_init(&fake_md);
       grpc_linked_mdelem* path_md =
           (grpc_linked_mdelem*)gpr_arena_alloc(s->arena, sizeof(*path_md));
-      path_md->md =
-          grpc_mdelem_from_slices(exec_ctx, g_fake_path_key, g_fake_path_value);
-      GPR_ASSERT(grpc_metadata_batch_link_tail(exec_ctx, &fake_md, path_md) ==
+      path_md->md = grpc_mdelem_from_slices(g_fake_path_key, g_fake_path_value);
+      GPR_ASSERT(grpc_metadata_batch_link_tail(&fake_md, path_md) ==
                  GRPC_ERROR_NONE);
       grpc_linked_mdelem* auth_md =
           (grpc_linked_mdelem*)gpr_arena_alloc(s->arena, sizeof(*auth_md));
-      auth_md->md =
-          grpc_mdelem_from_slices(exec_ctx, g_fake_auth_key, g_fake_auth_value);
-      GPR_ASSERT(grpc_metadata_batch_link_tail(exec_ctx, &fake_md, auth_md) ==
+      auth_md->md = grpc_mdelem_from_slices(g_fake_auth_key, g_fake_auth_value);
+      GPR_ASSERT(grpc_metadata_batch_link_tail(&fake_md, auth_md) ==
                  GRPC_ERROR_NONE);
 
       fill_in_metadata(
-          exec_ctx, s, &fake_md, 0,
+          s, &fake_md, 0,
           s->recv_initial_md_op->payload->recv_initial_metadata
               .recv_initial_metadata,
           s->recv_initial_md_op->payload->recv_initial_metadata.recv_flags,
           nullptr);
-      grpc_metadata_batch_destroy(exec_ctx, &fake_md);
+      grpc_metadata_batch_destroy(&fake_md);
       err = GRPC_ERROR_NONE;
     } else {
       err = GRPC_ERROR_REF(error);
     }
+    if (s->recv_initial_md_op->payload->recv_initial_metadata
+            .trailing_metadata_available != nullptr) {
+      // Set to true unconditionally, because we're failing the call, so even
+      // if we haven't actually seen the send_trailing_metadata op from the
+      // other side, we're going to return trailing metadata anyway.
+      *s->recv_initial_md_op->payload->recv_initial_metadata
+           .trailing_metadata_available = true;
+    }
     INPROC_LOG(GPR_DEBUG,
                "fail_helper %p scheduling initial-metadata-ready %p %p", s,
                error, err);
-    GRPC_CLOSURE_SCHED(exec_ctx,
-                       s->recv_initial_md_op->payload->recv_initial_metadata
+    GRPC_CLOSURE_SCHED(s->recv_initial_md_op->payload->recv_initial_metadata
                            .recv_initial_metadata_ready,
                        err);
     // Last use of err so no need to REF and then UNREF it
 
     complete_if_batch_end_locked(
-        exec_ctx, s, error, s->recv_initial_md_op,
+        s, error, s->recv_initial_md_op,
         "fail_helper scheduling recv-initial-metadata-on-complete");
     s->recv_initial_md_op = nullptr;
   }
@@ -476,22 +472,22 @@ static void fail_helper_locked(grpc_exec_ctx* exec_ctx, inproc_stream* s,
     INPROC_LOG(GPR_DEBUG, "fail_helper %p scheduling message-ready %p", s,
                error);
     GRPC_CLOSURE_SCHED(
-        exec_ctx, s->recv_message_op->payload->recv_message.recv_message_ready,
+        s->recv_message_op->payload->recv_message.recv_message_ready,
         GRPC_ERROR_REF(error));
     complete_if_batch_end_locked(
-        exec_ctx, s, error, s->recv_message_op,
+        s, error, s->recv_message_op,
         "fail_helper scheduling recv-message-on-complete");
     s->recv_message_op = nullptr;
   }
   if (s->send_message_op) {
     complete_if_batch_end_locked(
-        exec_ctx, s, error, s->send_message_op,
+        s, error, s->send_message_op,
         "fail_helper scheduling send-message-on-complete");
     s->send_message_op = nullptr;
   }
   if (s->send_trailing_md_op) {
     complete_if_batch_end_locked(
-        exec_ctx, s, error, s->send_trailing_md_op,
+        s, error, s->send_trailing_md_op,
         "fail_helper scheduling send-trailng-md-on-complete");
     s->send_trailing_md_op = nullptr;
   }
@@ -500,23 +496,22 @@ static void fail_helper_locked(grpc_exec_ctx* exec_ctx, inproc_stream* s,
                "fail_helper %p scheduling trailing-md-on-complete %p", s,
                error);
     complete_if_batch_end_locked(
-        exec_ctx, s, error, s->recv_trailing_md_op,
+        s, error, s->recv_trailing_md_op,
         "fail_helper scheduling recv-trailing-metadata-on-complete");
     s->recv_trailing_md_op = nullptr;
   }
-  close_other_side_locked(exec_ctx, s, "fail_helper:other_side");
-  close_stream_locked(exec_ctx, s);
+  close_other_side_locked(s, "fail_helper:other_side");
+  close_stream_locked(s);
 
   GRPC_ERROR_UNREF(error);
 }
 
-static void message_transfer_locked(grpc_exec_ctx* exec_ctx,
-                                    inproc_stream* sender,
+static void message_transfer_locked(inproc_stream* sender,
                                     inproc_stream* receiver) {
   size_t remaining =
       sender->send_message_op->payload->send_message.send_message->length;
   if (receiver->recv_inited) {
-    grpc_slice_buffer_destroy_internal(exec_ctx, &receiver->recv_message);
+    grpc_slice_buffer_destroy_internal(&receiver->recv_message);
   }
   grpc_slice_buffer_init(&receiver->recv_message);
   receiver->recv_inited = true;
@@ -524,13 +519,13 @@ static void message_transfer_locked(grpc_exec_ctx* exec_ctx,
     grpc_slice message_slice;
     grpc_closure unused;
     GPR_ASSERT(grpc_byte_stream_next(
-        exec_ctx, sender->send_message_op->payload->send_message.send_message,
-        SIZE_MAX, &unused));
+        sender->send_message_op->payload->send_message.send_message, SIZE_MAX,
+        &unused));
     grpc_error* error = grpc_byte_stream_pull(
-        exec_ctx, sender->send_message_op->payload->send_message.send_message,
+        sender->send_message_op->payload->send_message.send_message,
         &message_slice);
     if (error != GRPC_ERROR_NONE) {
-      cancel_stream_locked(exec_ctx, sender, GRPC_ERROR_REF(error));
+      cancel_stream_locked(sender, GRPC_ERROR_REF(error));
       break;
     }
     GPR_ASSERT(error == GRPC_ERROR_NONE);
@@ -545,22 +540,20 @@ static void message_transfer_locked(grpc_exec_ctx* exec_ctx,
   INPROC_LOG(GPR_DEBUG, "message_transfer_locked %p scheduling message-ready",
              receiver);
   GRPC_CLOSURE_SCHED(
-      exec_ctx,
       receiver->recv_message_op->payload->recv_message.recv_message_ready,
       GRPC_ERROR_NONE);
   complete_if_batch_end_locked(
-      exec_ctx, sender, GRPC_ERROR_NONE, sender->send_message_op,
+      sender, GRPC_ERROR_NONE, sender->send_message_op,
       "message_transfer scheduling sender on_complete");
   complete_if_batch_end_locked(
-      exec_ctx, receiver, GRPC_ERROR_NONE, receiver->recv_message_op,
+      receiver, GRPC_ERROR_NONE, receiver->recv_message_op,
       "message_transfer scheduling receiver on_complete");
 
   receiver->recv_message_op = nullptr;
   sender->send_message_op = nullptr;
 }
 
-static void op_state_machine(grpc_exec_ctx* exec_ctx, void* arg,
-                             grpc_error* error) {
+static void op_state_machine(void* arg, grpc_error* error) {
   // This function gets called when we have contents in the unprocessed reads
   // Get what we want based on our ops wanted
   // Schedule our appropriate closures
@@ -581,26 +574,26 @@ static void op_state_machine(grpc_exec_ctx* exec_ctx, void* arg,
   inproc_stream* other = s->other_side;
 
   if (s->cancel_self_error != GRPC_ERROR_NONE) {
-    fail_helper_locked(exec_ctx, s, GRPC_ERROR_REF(s->cancel_self_error));
+    fail_helper_locked(s, GRPC_ERROR_REF(s->cancel_self_error));
     goto done;
   } else if (s->cancel_other_error != GRPC_ERROR_NONE) {
-    fail_helper_locked(exec_ctx, s, GRPC_ERROR_REF(s->cancel_other_error));
+    fail_helper_locked(s, GRPC_ERROR_REF(s->cancel_other_error));
     goto done;
   } else if (error != GRPC_ERROR_NONE) {
-    fail_helper_locked(exec_ctx, s, GRPC_ERROR_REF(error));
+    fail_helper_locked(s, GRPC_ERROR_REF(error));
     goto done;
   }
 
   if (s->send_message_op && other) {
     if (other->recv_message_op) {
-      message_transfer_locked(exec_ctx, s, other);
-      maybe_schedule_op_closure_locked(exec_ctx, other, GRPC_ERROR_NONE);
+      message_transfer_locked(s, other);
+      maybe_schedule_op_closure_locked(other, GRPC_ERROR_NONE);
     } else if (!s->t->is_client &&
                (s->trailing_md_sent || other->recv_trailing_md_op)) {
       // A server send will never be matched if the client is waiting
       // for trailing metadata already
       complete_if_batch_end_locked(
-          exec_ctx, s, GRPC_ERROR_NONE, s->send_message_op,
+          s, GRPC_ERROR_NONE, s->send_message_op,
           "op_state_machine scheduling send-message-on-complete");
       s->send_message_op = nullptr;
     }
@@ -622,11 +615,11 @@ static void op_state_machine(grpc_exec_ctx* exec_ctx, void* arg,
       // The buffer is already in use; that's an error!
       INPROC_LOG(GPR_DEBUG, "Extra trailing metadata %p", s);
       new_err = GRPC_ERROR_CREATE_FROM_STATIC_STRING("Extra trailing metadata");
-      fail_helper_locked(exec_ctx, s, GRPC_ERROR_REF(new_err));
+      fail_helper_locked(s, GRPC_ERROR_REF(new_err));
       goto done;
     } else {
       if (!other || !other->closed) {
-        fill_in_metadata(exec_ctx, s,
+        fill_in_metadata(s,
                          s->send_trailing_md_op->payload->send_trailing_metadata
                              .send_trailing_metadata,
                          0, dest, nullptr, destfilled);
@@ -635,15 +628,15 @@ static void op_state_machine(grpc_exec_ctx* exec_ctx, void* arg,
       if (!s->t->is_client && s->trailing_md_recvd && s->recv_trailing_md_op) {
         INPROC_LOG(GPR_DEBUG,
                    "op_state_machine %p scheduling trailing-md-on-complete", s);
-        GRPC_CLOSURE_SCHED(exec_ctx, s->recv_trailing_md_op->on_complete,
+        GRPC_CLOSURE_SCHED(s->recv_trailing_md_op->on_complete,
                            GRPC_ERROR_NONE);
         s->recv_trailing_md_op = nullptr;
         needs_close = true;
       }
     }
-    maybe_schedule_op_closure_locked(exec_ctx, other, GRPC_ERROR_NONE);
+    maybe_schedule_op_closure_locked(other, GRPC_ERROR_NONE);
     complete_if_batch_end_locked(
-        exec_ctx, s, GRPC_ERROR_NONE, s->send_trailing_md_op,
+        s, GRPC_ERROR_NONE, s->send_trailing_md_op,
         "op_state_machine scheduling send-trailing-metadata-on-complete");
     s->send_trailing_md_op = nullptr;
   }
@@ -656,31 +649,36 @@ static void op_state_machine(grpc_exec_ctx* exec_ctx, void* arg,
           "op_state_machine %p scheduling on_complete errors for already "
           "recvd initial md %p",
           s, new_err);
-      fail_helper_locked(exec_ctx, s, GRPC_ERROR_REF(new_err));
+      fail_helper_locked(s, GRPC_ERROR_REF(new_err));
       goto done;
     }
 
     if (s->to_read_initial_md_filled) {
       s->initial_md_recvd = true;
       new_err = fill_in_metadata(
-          exec_ctx, s, &s->to_read_initial_md, s->to_read_initial_md_flags,
+          s, &s->to_read_initial_md, s->to_read_initial_md_flags,
           s->recv_initial_md_op->payload->recv_initial_metadata
               .recv_initial_metadata,
           s->recv_initial_md_op->payload->recv_initial_metadata.recv_flags,
           nullptr);
       s->recv_initial_md_op->payload->recv_initial_metadata
           .recv_initial_metadata->deadline = s->deadline;
-      grpc_metadata_batch_clear(exec_ctx, &s->to_read_initial_md);
+      if (s->recv_initial_md_op->payload->recv_initial_metadata
+              .trailing_metadata_available != nullptr) {
+        *s->recv_initial_md_op->payload->recv_initial_metadata
+             .trailing_metadata_available =
+            (other != nullptr && other->send_trailing_md_op != nullptr);
+      }
+      grpc_metadata_batch_clear(&s->to_read_initial_md);
       s->to_read_initial_md_filled = false;
       INPROC_LOG(GPR_DEBUG,
                  "op_state_machine %p scheduling initial-metadata-ready %p", s,
                  new_err);
-      GRPC_CLOSURE_SCHED(exec_ctx,
-                         s->recv_initial_md_op->payload->recv_initial_metadata
+      GRPC_CLOSURE_SCHED(s->recv_initial_md_op->payload->recv_initial_metadata
                              .recv_initial_metadata_ready,
                          GRPC_ERROR_REF(new_err));
       complete_if_batch_end_locked(
-          exec_ctx, s, new_err, s->recv_initial_md_op,
+          s, new_err, s->recv_initial_md_op,
           "op_state_machine scheduling recv-initial-metadata-on-complete");
       s->recv_initial_md_op = nullptr;
 
@@ -688,20 +686,20 @@ static void op_state_machine(grpc_exec_ctx* exec_ctx, void* arg,
         INPROC_LOG(GPR_DEBUG,
                    "op_state_machine %p scheduling on_complete errors2 %p", s,
                    new_err);
-        fail_helper_locked(exec_ctx, s, GRPC_ERROR_REF(new_err));
+        fail_helper_locked(s, GRPC_ERROR_REF(new_err));
         goto done;
       }
     }
   }
   if (s->recv_message_op) {
     if (other && other->send_message_op) {
-      message_transfer_locked(exec_ctx, other, s);
-      maybe_schedule_op_closure_locked(exec_ctx, other, GRPC_ERROR_NONE);
+      message_transfer_locked(other, s);
+      maybe_schedule_op_closure_locked(other, GRPC_ERROR_NONE);
     }
   }
   if (s->recv_trailing_md_op && s->t->is_client && other &&
       other->send_message_op) {
-    maybe_schedule_op_closure_locked(exec_ctx, other, GRPC_ERROR_NONE);
+    maybe_schedule_op_closure_locked(other, GRPC_ERROR_NONE);
   }
   if (s->to_read_trailing_md_filled) {
     if (s->trailing_md_recvd) {
@@ -712,7 +710,7 @@ static void op_state_machine(grpc_exec_ctx* exec_ctx, void* arg,
           "op_state_machine %p scheduling on_complete errors for already "
           "recvd trailing md %p",
           s, new_err);
-      fail_helper_locked(exec_ctx, s, GRPC_ERROR_REF(new_err));
+      fail_helper_locked(s, GRPC_ERROR_REF(new_err));
       goto done;
     }
     if (s->recv_message_op != nullptr) {
@@ -720,11 +718,10 @@ static void op_state_machine(grpc_exec_ctx* exec_ctx, void* arg,
       // satisfied
       INPROC_LOG(GPR_DEBUG, "op_state_machine %p scheduling message-ready", s);
       GRPC_CLOSURE_SCHED(
-          exec_ctx,
           s->recv_message_op->payload->recv_message.recv_message_ready,
           GRPC_ERROR_NONE);
       complete_if_batch_end_locked(
-          exec_ctx, s, new_err, s->recv_message_op,
+          s, new_err, s->recv_message_op,
           "op_state_machine scheduling recv-message-on-complete");
       s->recv_message_op = nullptr;
     }
@@ -732,7 +729,7 @@ static void op_state_machine(grpc_exec_ctx* exec_ctx, void* arg,
       // Nothing further will try to receive from this stream, so finish off
       // any outstanding send_message op
       complete_if_batch_end_locked(
-          exec_ctx, s, new_err, s->send_message_op,
+          s, new_err, s->send_message_op,
           "op_state_machine scheduling send-message-on-complete");
       s->send_message_op = nullptr;
     }
@@ -740,11 +737,11 @@ static void op_state_machine(grpc_exec_ctx* exec_ctx, void* arg,
       // We wanted trailing metadata and we got it
       s->trailing_md_recvd = true;
       new_err =
-          fill_in_metadata(exec_ctx, s, &s->to_read_trailing_md, 0,
+          fill_in_metadata(s, &s->to_read_trailing_md, 0,
                            s->recv_trailing_md_op->payload
                                ->recv_trailing_metadata.recv_trailing_metadata,
                            nullptr, nullptr);
-      grpc_metadata_batch_clear(exec_ctx, &s->to_read_trailing_md);
+      grpc_metadata_batch_clear(&s->to_read_trailing_md);
       s->to_read_trailing_md_filled = false;
 
       // We should schedule the recv_trailing_md_op completion if
@@ -756,7 +753,7 @@ static void op_state_machine(grpc_exec_ctx* exec_ctx, void* arg,
         INPROC_LOG(GPR_DEBUG,
                    "op_state_machine %p scheduling trailing-md-on-complete %p",
                    s, new_err);
-        GRPC_CLOSURE_SCHED(exec_ctx, s->recv_trailing_md_op->on_complete,
+        GRPC_CLOSURE_SCHED(s->recv_trailing_md_op->on_complete,
                            GRPC_ERROR_REF(new_err));
         s->recv_trailing_md_op = nullptr;
         needs_close = true;
@@ -777,10 +774,10 @@ static void op_state_machine(grpc_exec_ctx* exec_ctx, void* arg,
     // recv_message_op
     INPROC_LOG(GPR_DEBUG, "op_state_machine %p scheduling message-ready", s);
     GRPC_CLOSURE_SCHED(
-        exec_ctx, s->recv_message_op->payload->recv_message.recv_message_ready,
+        s->recv_message_op->payload->recv_message.recv_message_ready,
         GRPC_ERROR_NONE);
     complete_if_batch_end_locked(
-        exec_ctx, s, new_err, s->recv_message_op,
+        s, new_err, s->recv_message_op,
         "op_state_machine scheduling recv-message-on-complete");
     s->recv_message_op = nullptr;
   }
@@ -789,7 +786,7 @@ static void op_state_machine(grpc_exec_ctx* exec_ctx, void* arg,
     // Nothing further will try to receive from this stream, so finish off
     // any outstanding send_message op
     complete_if_batch_end_locked(
-        exec_ctx, s, new_err, s->send_message_op,
+        s, new_err, s->send_message_op,
         "op_state_machine scheduling send-message-on-complete");
     s->send_message_op = nullptr;
   }
@@ -805,22 +802,21 @@ static void op_state_machine(grpc_exec_ctx* exec_ctx, void* arg,
   }
 done:
   if (needs_close) {
-    close_other_side_locked(exec_ctx, s, "op_state_machine");
-    close_stream_locked(exec_ctx, s);
+    close_other_side_locked(s, "op_state_machine");
+    close_stream_locked(s);
   }
   gpr_mu_unlock(mu);
   GRPC_ERROR_UNREF(new_err);
 }
 
-static bool cancel_stream_locked(grpc_exec_ctx* exec_ctx, inproc_stream* s,
-                                 grpc_error* error) {
+static bool cancel_stream_locked(inproc_stream* s, grpc_error* error) {
   bool ret = false;  // was the cancel accepted
   INPROC_LOG(GPR_DEBUG, "cancel_stream %p with %s", s,
              grpc_error_string(error));
   if (s->cancel_self_error == GRPC_ERROR_NONE) {
     ret = true;
     s->cancel_self_error = GRPC_ERROR_REF(error);
-    maybe_schedule_op_closure_locked(exec_ctx, s, s->cancel_self_error);
+    maybe_schedule_op_closure_locked(s, s->cancel_self_error);
     // Send trailing md to the other side indicating cancellation, even if we
     // already have
     s->trailing_md_sent = true;
@@ -834,15 +830,14 @@ static bool cancel_stream_locked(grpc_exec_ctx* exec_ctx, inproc_stream* s,
                                     : &other->to_read_trailing_md;
     bool* destfilled = (other == nullptr) ? &s->write_buffer_trailing_md_filled
                                           : &other->to_read_trailing_md_filled;
-    fill_in_metadata(exec_ctx, s, &cancel_md, 0, dest, nullptr, destfilled);
-    grpc_metadata_batch_destroy(exec_ctx, &cancel_md);
+    fill_in_metadata(s, &cancel_md, 0, dest, nullptr, destfilled);
+    grpc_metadata_batch_destroy(&cancel_md);
 
     if (other != nullptr) {
       if (other->cancel_other_error == GRPC_ERROR_NONE) {
         other->cancel_other_error = GRPC_ERROR_REF(s->cancel_self_error);
       }
-      maybe_schedule_op_closure_locked(exec_ctx, other,
-                                       other->cancel_other_error);
+      maybe_schedule_op_closure_locked(other, other->cancel_other_error);
     } else if (s->write_buffer_cancel_error == GRPC_ERROR_NONE) {
       s->write_buffer_cancel_error = GRPC_ERROR_REF(s->cancel_self_error);
     }
@@ -852,21 +847,20 @@ static bool cancel_stream_locked(grpc_exec_ctx* exec_ctx, inproc_stream* s,
     // md, now's the chance
     if (!s->t->is_client && s->trailing_md_recvd && s->recv_trailing_md_op) {
       complete_if_batch_end_locked(
-          exec_ctx, s, s->cancel_self_error, s->recv_trailing_md_op,
+          s, s->cancel_self_error, s->recv_trailing_md_op,
           "cancel_stream scheduling trailing-md-on-complete");
       s->recv_trailing_md_op = nullptr;
     }
   }
 
-  close_other_side_locked(exec_ctx, s, "cancel_stream:other_side");
-  close_stream_locked(exec_ctx, s);
+  close_other_side_locked(s, "cancel_stream:other_side");
+  close_stream_locked(s);
 
   GRPC_ERROR_UNREF(error);
   return ret;
 }
 
-static void perform_stream_op(grpc_exec_ctx* exec_ctx, grpc_transport* gt,
-                              grpc_stream* gs,
+static void perform_stream_op(grpc_transport* gt, grpc_stream* gs,
                               grpc_transport_stream_op_batch* op) {
   INPROC_LOG(GPR_DEBUG, "perform_stream_op %p %p %p", gt, gs, op);
   inproc_stream* s = (inproc_stream*)gs;
@@ -892,7 +886,7 @@ static void perform_stream_op(grpc_exec_ctx* exec_ctx, grpc_transport* gt,
   if (op->cancel_stream) {
     // Call cancel_stream_locked without ref'ing the cancel_error because
     // this function is responsible to make sure that that field gets unref'ed
-    cancel_stream_locked(exec_ctx, s, op->payload->cancel_stream.cancel_error);
+    cancel_stream_locked(s, op->payload->cancel_stream.cancel_error);
     // this op can complete without an error
   } else if (s->cancel_self_error != GRPC_ERROR_NONE) {
     // already self-canceled so still give it an error
@@ -932,8 +926,7 @@ static void perform_stream_op(grpc_exec_ctx* exec_ctx, grpc_transport* gt,
       } else {
         if (!other || !other->closed) {
           fill_in_metadata(
-              exec_ctx, s,
-              op->payload->send_initial_metadata.send_initial_metadata,
+              s, op->payload->send_initial_metadata.send_initial_metadata,
               op->payload->send_initial_metadata.send_initial_metadata_flags,
               dest, destflags, destfilled);
         }
@@ -945,7 +938,7 @@ static void perform_stream_op(grpc_exec_ctx* exec_ctx, grpc_transport* gt,
           s->initial_md_sent = true;
         }
       }
-      maybe_schedule_op_closure_locked(exec_ctx, other, error);
+      maybe_schedule_op_closure_locked(other, error);
     }
   }
 
@@ -985,7 +978,7 @@ static void perform_stream_op(grpc_exec_ctx* exec_ctx, grpc_transport* gt,
         (op->recv_message && other && (other->send_message_op != nullptr)) ||
         (s->to_read_trailing_md_filled || s->trailing_md_recvd)) {
       if (!s->op_closure_scheduled) {
-        GRPC_CLOSURE_SCHED(exec_ctx, &s->op_closure, GRPC_ERROR_NONE);
+        GRPC_CLOSURE_SCHED(&s->op_closure, GRPC_ERROR_NONE);
         s->op_closure_scheduled = true;
       }
     } else {
@@ -995,12 +988,20 @@ static void perform_stream_op(grpc_exec_ctx* exec_ctx, grpc_transport* gt,
     if (error != GRPC_ERROR_NONE) {
       // Schedule op's closures that we didn't push to op state machine
       if (op->recv_initial_metadata) {
+        if (op->payload->recv_initial_metadata.trailing_metadata_available !=
+            nullptr) {
+          // Set to true unconditionally, because we're failing the call, so
+          // even if we haven't actually seen the send_trailing_metadata op
+          // from the other side, we're going to return trailing metadata
+          // anyway.
+          *op->payload->recv_initial_metadata.trailing_metadata_available =
+              true;
+        }
         INPROC_LOG(
             GPR_DEBUG,
             "perform_stream_op error %p scheduling initial-metadata-ready %p",
             s, error);
         GRPC_CLOSURE_SCHED(
-            exec_ctx,
             op->payload->recv_initial_metadata.recv_initial_metadata_ready,
             GRPC_ERROR_REF(error));
       }
@@ -1009,28 +1010,26 @@ static void perform_stream_op(grpc_exec_ctx* exec_ctx, grpc_transport* gt,
             GPR_DEBUG,
             "perform_stream_op error %p scheduling recv message-ready %p", s,
             error);
-        GRPC_CLOSURE_SCHED(exec_ctx,
-                           op->payload->recv_message.recv_message_ready,
+        GRPC_CLOSURE_SCHED(op->payload->recv_message.recv_message_ready,
                            GRPC_ERROR_REF(error));
       }
     }
     INPROC_LOG(GPR_DEBUG, "perform_stream_op %p scheduling on_complete %p", s,
                error);
-    GRPC_CLOSURE_SCHED(exec_ctx, on_complete, GRPC_ERROR_REF(error));
+    GRPC_CLOSURE_SCHED(on_complete, GRPC_ERROR_REF(error));
   }
   if (needs_close) {
-    close_other_side_locked(exec_ctx, s, "perform_stream_op:other_side");
-    close_stream_locked(exec_ctx, s);
+    close_other_side_locked(s, "perform_stream_op:other_side");
+    close_stream_locked(s);
   }
   gpr_mu_unlock(mu);
   GRPC_ERROR_UNREF(error);
 }
 
-static void close_transport_locked(grpc_exec_ctx* exec_ctx,
-                                   inproc_transport* t) {
+static void close_transport_locked(inproc_transport* t) {
   INPROC_LOG(GPR_DEBUG, "close_transport %p %d", t, t->is_closed);
   grpc_connectivity_state_set(
-      exec_ctx, &t->connectivity, GRPC_CHANNEL_SHUTDOWN,
+      &t->connectivity, GRPC_CHANNEL_SHUTDOWN,
       GRPC_ERROR_CREATE_FROM_STATIC_STRING("Closing transport."),
       "close transport");
   if (!t->is_closed) {
@@ -1039,7 +1038,7 @@ static void close_transport_locked(grpc_exec_ctx* exec_ctx,
     while (t->stream_list != nullptr) {
       // cancel_stream_locked also adjusts stream list
       cancel_stream_locked(
-          exec_ctx, t->stream_list,
+          t->stream_list,
           grpc_error_set_int(
               GRPC_ERROR_CREATE_FROM_STATIC_STRING("Transport closed"),
               GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_UNAVAILABLE));
@@ -1047,14 +1046,13 @@ static void close_transport_locked(grpc_exec_ctx* exec_ctx,
   }
 }
 
-static void perform_transport_op(grpc_exec_ctx* exec_ctx, grpc_transport* gt,
-                                 grpc_transport_op* op) {
+static void perform_transport_op(grpc_transport* gt, grpc_transport_op* op) {
   inproc_transport* t = (inproc_transport*)gt;
   INPROC_LOG(GPR_DEBUG, "perform_transport_op %p %p", t, op);
   gpr_mu_lock(&t->mu->mu);
   if (op->on_connectivity_state_change) {
     grpc_connectivity_state_notify_on_state_change(
-        exec_ctx, &t->connectivity, op->connectivity_state,
+        &t->connectivity, op->connectivity_state,
         op->on_connectivity_state_change);
   }
   if (op->set_accept_stream) {
@@ -1062,7 +1060,7 @@ static void perform_transport_op(grpc_exec_ctx* exec_ctx, grpc_transport* gt,
     t->accept_stream_data = op->set_accept_stream_user_data;
   }
   if (op->on_consumed) {
-    GRPC_CLOSURE_SCHED(exec_ctx, op->on_consumed, GRPC_ERROR_NONE);
+    GRPC_CLOSURE_SCHED(op->on_consumed, GRPC_ERROR_NONE);
   }
 
   bool do_close = false;
@@ -1076,71 +1074,67 @@ static void perform_transport_op(grpc_exec_ctx* exec_ctx, grpc_transport* gt,
   }
 
   if (do_close) {
-    close_transport_locked(exec_ctx, t);
+    close_transport_locked(t);
   }
   gpr_mu_unlock(&t->mu->mu);
 }
 
-static void destroy_stream(grpc_exec_ctx* exec_ctx, grpc_transport* gt,
-                           grpc_stream* gs,
+static void destroy_stream(grpc_transport* gt, grpc_stream* gs,
                            grpc_closure* then_schedule_closure) {
   INPROC_LOG(GPR_DEBUG, "destroy_stream %p %p", gs, then_schedule_closure);
   inproc_stream* s = (inproc_stream*)gs;
   s->closure_at_destroy = then_schedule_closure;
-  really_destroy_stream(exec_ctx, s);
+  really_destroy_stream(s);
 }
 
-static void destroy_transport(grpc_exec_ctx* exec_ctx, grpc_transport* gt) {
+static void destroy_transport(grpc_transport* gt) {
   inproc_transport* t = (inproc_transport*)gt;
   INPROC_LOG(GPR_DEBUG, "destroy_transport %p", t);
   gpr_mu_lock(&t->mu->mu);
-  close_transport_locked(exec_ctx, t);
+  close_transport_locked(t);
   gpr_mu_unlock(&t->mu->mu);
-  unref_transport(exec_ctx, t->other_side);
-  unref_transport(exec_ctx, t);
+  unref_transport(t->other_side);
+  unref_transport(t);
 }
 
 /*******************************************************************************
  * INTEGRATION GLUE
  */
 
-static void set_pollset(grpc_exec_ctx* exec_ctx, grpc_transport* gt,
-                        grpc_stream* gs, grpc_pollset* pollset) {
+static void set_pollset(grpc_transport* gt, grpc_stream* gs,
+                        grpc_pollset* pollset) {
   // Nothing to do here
 }
 
-static void set_pollset_set(grpc_exec_ctx* exec_ctx, grpc_transport* gt,
-                            grpc_stream* gs, grpc_pollset_set* pollset_set) {
+static void set_pollset_set(grpc_transport* gt, grpc_stream* gs,
+                            grpc_pollset_set* pollset_set) {
   // Nothing to do here
 }
 
-static grpc_endpoint* get_endpoint(grpc_exec_ctx* exec_ctx, grpc_transport* t) {
-  return nullptr;
-}
+static grpc_endpoint* get_endpoint(grpc_transport* t) { return nullptr; }
 
 /*******************************************************************************
  * GLOBAL INIT AND DESTROY
  */
-static void do_nothing(grpc_exec_ctx* exec_ctx, void* arg, grpc_error* error) {}
+static void do_nothing(void* arg, grpc_error* error) {}
 
 void grpc_inproc_transport_init(void) {
-  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+  grpc_core::ExecCtx exec_ctx;
   GRPC_CLOSURE_INIT(&do_nothing_closure, do_nothing, nullptr,
                     grpc_schedule_on_exec_ctx);
   g_empty_slice = grpc_slice_from_static_buffer(nullptr, 0);
 
   grpc_slice key_tmp = grpc_slice_from_static_string(":path");
   g_fake_path_key = grpc_slice_intern(key_tmp);
-  grpc_slice_unref_internal(&exec_ctx, key_tmp);
+  grpc_slice_unref_internal(key_tmp);
 
   g_fake_path_value = grpc_slice_from_static_string("/");
 
   grpc_slice auth_tmp = grpc_slice_from_static_string(":authority");
   g_fake_auth_key = grpc_slice_intern(auth_tmp);
-  grpc_slice_unref_internal(&exec_ctx, auth_tmp);
+  grpc_slice_unref_internal(auth_tmp);
 
   g_fake_auth_value = grpc_slice_from_static_string("inproc-fail");
-  grpc_exec_ctx_finish(&exec_ctx);
 }
 
 static const grpc_transport_vtable inproc_vtable = {
@@ -1152,8 +1146,7 @@ static const grpc_transport_vtable inproc_vtable = {
 /*******************************************************************************
  * Main inproc transport functions
  */
-static void inproc_transports_create(grpc_exec_ctx* exec_ctx,
-                                     grpc_transport** server_transport,
+static void inproc_transports_create(grpc_transport** server_transport,
                                      const grpc_channel_args* server_args,
                                      grpc_transport** client_transport,
                                      const grpc_channel_args* client_args) {
@@ -1190,7 +1183,7 @@ grpc_channel* grpc_inproc_channel_create(grpc_server* server,
   GRPC_API_TRACE("grpc_inproc_channel_create(server=%p, args=%p)", 2,
                  (server, args));
 
-  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+  grpc_core::ExecCtx exec_ctx;
 
   const grpc_channel_args* server_args = grpc_server_get_channel_args(server);
 
@@ -1205,30 +1198,26 @@ grpc_channel* grpc_inproc_channel_create(grpc_server* server,
 
   grpc_transport* server_transport;
   grpc_transport* client_transport;
-  inproc_transports_create(&exec_ctx, &server_transport, server_args,
-                           &client_transport, client_args);
+  inproc_transports_create(&server_transport, server_args, &client_transport,
+                           client_args);
 
-  grpc_server_setup_transport(&exec_ctx, server, server_transport, nullptr,
-                              server_args);
-  grpc_channel* channel =
-      grpc_channel_create(&exec_ctx, "inproc", client_args,
-                          GRPC_CLIENT_DIRECT_CHANNEL, client_transport);
+  grpc_server_setup_transport(server, server_transport, nullptr, server_args);
+  grpc_channel* channel = grpc_channel_create(
+      "inproc", client_args, GRPC_CLIENT_DIRECT_CHANNEL, client_transport);
 
   // Free up created channel args
-  grpc_channel_args_destroy(&exec_ctx, client_args);
+  grpc_channel_args_destroy(client_args);
 
   // Now finish scheduled operations
-  grpc_exec_ctx_finish(&exec_ctx);
 
   return channel;
 }
 
 void grpc_inproc_transport_shutdown(void) {
-  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_slice_unref_internal(&exec_ctx, g_empty_slice);
-  grpc_slice_unref_internal(&exec_ctx, g_fake_path_key);
-  grpc_slice_unref_internal(&exec_ctx, g_fake_path_value);
-  grpc_slice_unref_internal(&exec_ctx, g_fake_auth_key);
-  grpc_slice_unref_internal(&exec_ctx, g_fake_auth_value);
-  grpc_exec_ctx_finish(&exec_ctx);
+  grpc_core::ExecCtx exec_ctx;
+  grpc_slice_unref_internal(g_empty_slice);
+  grpc_slice_unref_internal(g_fake_path_key);
+  grpc_slice_unref_internal(g_fake_path_value);
+  grpc_slice_unref_internal(g_fake_auth_key);
+  grpc_slice_unref_internal(g_fake_auth_value);
 }