grpc 1.21.0 → 1.32.0

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

@@ -27,8 +27,10 @@
 #include "src/core/lib/transport/transport.h"
 
 extern grpc_core::TraceFlag grpc_http_trace;
+extern grpc_core::TraceFlag grpc_keepalive_trace;
 extern grpc_core::TraceFlag grpc_trace_http2_stream_state;
 extern grpc_core::DebugOnlyTraceFlag grpc_trace_chttp2_refcount;
+extern grpc_core::DebugOnlyTraceFlag grpc_trace_chttp2_hpack_parser;
 
 extern bool g_flow_control_enabled;
 

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

@@ -33,7 +33,7 @@ void ContextList::Append(ContextList** head, grpc_chttp2_stream* s) {
     return;
   }
   /* Create a new element in the list and add it at the front */
-  ContextList* elem = grpc_core::New<ContextList>();
+  ContextList* elem = new ContextList();
   elem->trace_context_ = get_copied_context_fn_g(s->context);
   elem->byte_offset_ = s->byte_counter;
   elem->next_ = *head;
@@ -46,12 +46,14 @@ void ContextList::Execute(void* arg, grpc_core::Timestamps* ts,
   ContextList* to_be_freed;
   while (head != nullptr) {
     if (write_timestamps_callback_g) {
-      ts->byte_offset = static_cast<uint32_t>(head->byte_offset_);
+      if (ts) {
+        ts->byte_offset = static_cast<uint32_t>(head->byte_offset_);
+      }
       write_timestamps_callback_g(head->trace_context_, ts, error);
     }
     to_be_freed = head;
     head = head->next_;
-    grpc_core::Delete(to_be_freed);
+    delete to_be_freed;
   }
 }
 

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

@@ -25,9 +25,12 @@
 #include <math.h>
 #include <string.h>
 
+#include <string>
+
+#include "absl/strings/str_format.h"
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
-#include <grpc/support/string_util.h>
 
 #include "src/core/ext/transport/chttp2/transport/internal.h"
 #include "src/core/lib/gpr/string.h"
@@ -43,27 +46,23 @@ static constexpr const int kTracePadding = 30;
 static constexpr const uint32_t kMaxWindowUpdateSize = (1u << 31) - 1;
 
 static char* fmt_int64_diff_str(int64_t old_val, int64_t new_val) {
-  char* str;
+  std::string str;
   if (old_val != new_val) {
-    gpr_asprintf(&str, "%" PRId64 " -> %" PRId64 "", old_val, new_val);
+    str = absl::StrFormat("%" PRId64 " -> %" PRId64 "", old_val, new_val);
   } else {
-    gpr_asprintf(&str, "%" PRId64 "", old_val);
+    str = absl::StrFormat("%" PRId64 "", old_val);
   }
-  char* str_lp = gpr_leftpad(str, ' ', kTracePadding);
-  gpr_free(str);
-  return str_lp;
+  return gpr_leftpad(str.c_str(), ' ', kTracePadding);
 }
 
 static char* fmt_uint32_diff_str(uint32_t old_val, uint32_t new_val) {
-  char* str;
+  std::string str;
   if (old_val != new_val) {
-    gpr_asprintf(&str, "%" PRIu32 " -> %" PRIu32 "", old_val, new_val);
+    str = absl::StrFormat("%" PRIu32 " -> %" PRIu32 "", old_val, new_val);
   } else {
-    gpr_asprintf(&str, "%" PRIu32 "", old_val);
+    str = absl::StrFormat("%" PRIu32 "", old_val);
   }
-  char* str_lp = gpr_leftpad(str, ' ', kTracePadding);
-  gpr_free(str);
-  return str_lp;
+  return gpr_leftpad(str.c_str(), ' ', kTracePadding);
 }
 }  // namespace
 
@@ -176,7 +175,7 @@ TransportFlowControl::TransportFlowControl(const grpc_chttp2_transport* t,
                                            bool enable_bdp_probe)
     : t_(t),
       enable_bdp_probe_(enable_bdp_probe),
-      bdp_estimator_(t->peer_string),
+      bdp_estimator_(t->peer_string.c_str()),
       pid_controller_(grpc_core::PidController::Args()
                           .set_gain_p(4)
                           .set_gain_i(8)
@@ -204,13 +203,11 @@ uint32_t TransportFlowControl::MaybeSendUpdate(bool writing_anyway) {
 grpc_error* TransportFlowControl::ValidateRecvData(
     int64_t incoming_frame_size) {
   if (incoming_frame_size > announced_window_) {
-    char* msg;
-    gpr_asprintf(&msg,
-                 "frame of size %" PRId64 " overflows local window of %" PRId64,
-                 incoming_frame_size, announced_window_);
-    grpc_error* err = GRPC_ERROR_CREATE_FROM_COPIED_STRING(msg);
-    gpr_free(msg);
-    return err;
+    return GRPC_ERROR_CREATE_FROM_COPIED_STRING(
+        absl::StrFormat("frame of size %" PRId64
+                        " overflows local window of %" PRId64,
+                        incoming_frame_size, announced_window_)
+            .c_str());
   }
   return GRPC_ERROR_NONE;
 }
@@ -248,13 +245,11 @@ grpc_error* StreamFlowControl::RecvData(int64_t incoming_frame_size) {
               "See (for example) https://github.com/netty/netty/issues/6520.",
               incoming_frame_size, acked_stream_window, sent_stream_window);
     } else {
-      char* msg;
-      gpr_asprintf(
-          &msg, "frame of size %" PRId64 " overflows local window of %" PRId64,
-          incoming_frame_size, acked_stream_window);
-      grpc_error* err = GRPC_ERROR_CREATE_FROM_COPIED_STRING(msg);
-      gpr_free(msg);
-      return err;
+      return GRPC_ERROR_CREATE_FROM_COPIED_STRING(
+          absl::StrFormat("frame of size %" PRId64
+                          " overflows local window of %" PRId64,
+                          incoming_frame_size, acked_stream_window)
+              .c_str());
     }
   }
 
@@ -284,8 +279,8 @@ void StreamFlowControl::IncomingByteStreamUpdate(size_t max_size_hint,
                                  [GRPC_CHTTP2_SETTINGS_INITIAL_WINDOW_SIZE];
 
   /* clamp max recv hint to an allowable size */
-  if (max_size_hint >= UINT32_MAX - sent_init_window) {
-    max_recv_bytes = UINT32_MAX - sent_init_window;
+  if (max_size_hint >= kMaxWindowUpdateSize - sent_init_window) {
+    max_recv_bytes = kMaxWindowUpdateSize - sent_init_window;
   } else {
     max_recv_bytes = static_cast<uint32_t>(max_size_hint);
   }
@@ -298,7 +293,7 @@ void StreamFlowControl::IncomingByteStreamUpdate(size_t max_size_hint,
   }
 
   /* add some small lookahead to keep pipelines flowing */
-  GPR_ASSERT(max_recv_bytes <= UINT32_MAX - sent_init_window);
+  GPR_DEBUG_ASSERT(max_recv_bytes <= kMaxWindowUpdateSize - sent_init_window);
   if (local_window_delta_ < max_recv_bytes) {
     uint32_t add_max_recv_bytes =
         static_cast<uint32_t>(max_recv_bytes - local_window_delta_);

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

@@ -25,7 +25,6 @@
 
 #include "src/core/ext/transport/chttp2/transport/http2_settings.h"
 #include "src/core/lib/gpr/useful.h"
-#include "src/core/lib/gprpp/abstract.h"
 #include "src/core/lib/gprpp/manual_constructor.h"
 #include "src/core/lib/transport/bdp_estimator.h"
 #include "src/core/lib/transport/pid_controller.h"
@@ -141,8 +140,7 @@ class FlowControlTrace {
 };
 
 // Fat interface with all methods a flow control implementation needs to
-// support. gRPC C Core does not support pure virtual functions, so instead
-// we abort in any methods which require implementation in the base class.
+// support.
 class TransportFlowControlBase {
  public:
   TransportFlowControlBase() {}
@@ -150,30 +148,30 @@ class TransportFlowControlBase {
 
   // Is flow control enabled? This is needed in other codepaths like the checks
   // in parsing and in writing.
-  virtual bool flow_control_enabled() const { abort(); }
+  virtual bool flow_control_enabled() const = 0;
 
   // Called to check if the transport needs to send a WINDOW_UPDATE frame
-  virtual uint32_t MaybeSendUpdate(bool writing_anyway) { abort(); }
+  virtual uint32_t MaybeSendUpdate(bool /* writing_anyway */) = 0;
 
   // Using the protected members, returns and Action to be taken by the
   // tranport.
-  virtual FlowControlAction MakeAction() { abort(); }
+  virtual FlowControlAction MakeAction() = 0;
 
   // Using the protected members, returns and Action to be taken by the
   // tranport. Also checks for updates to our BDP estimate and acts
   // accordingly.
-  virtual FlowControlAction PeriodicUpdate() { abort(); }
+  virtual FlowControlAction PeriodicUpdate() = 0;
 
   // Called to do bookkeeping when a stream owned by this transport sends
   // data on the wire
-  virtual void StreamSentData(int64_t size) { abort(); }
+  virtual void StreamSentData(int64_t /* size */) = 0;
 
   // Called to do bookkeeping when a stream owned by this transport receives
   // data from the wire. Also does error checking for frame size.
-  virtual grpc_error* RecvData(int64_t incoming_frame_size) { abort(); }
+  virtual grpc_error* RecvData(int64_t /* incoming_frame_size */) = 0;
 
   // Called to do bookkeeping when we receive a WINDOW_UPDATE frame.
-  virtual void RecvUpdate(uint32_t size) { abort(); }
+  virtual void RecvUpdate(uint32_t /* size */) = 0;
 
   // Returns the BdpEstimator held by this object. Caller is responsible for
   // checking for nullptr. TODO(ncteisen): consider fully encapsulating all
@@ -189,8 +187,6 @@ class TransportFlowControlBase {
   // factor
   virtual void TestOnlyForceHugeWindow() {}
 
-  GRPC_ABSTRACT_BASE_CLASS
-
  protected:
   friend class ::grpc::testing::TrickledCHTTP2;
   int64_t remote_window_ = kDefaultWindow;
@@ -210,14 +206,14 @@ class TransportFlowControlDisabled final : public TransportFlowControlBase {
   bool flow_control_enabled() const override { return false; }
 
   // Never do anything.
-  uint32_t MaybeSendUpdate(bool writing_anyway) override { return 0; }
+  uint32_t MaybeSendUpdate(bool /* writing_anyway */) override { return 0; }
   FlowControlAction MakeAction() override { return FlowControlAction(); }
   FlowControlAction PeriodicUpdate() override { return FlowControlAction(); }
-  void StreamSentData(int64_t size) override {}
-  grpc_error* RecvData(int64_t incoming_frame_size) override {
+  void StreamSentData(int64_t /* size */) override {}
+  grpc_error* RecvData(int64_t /* incoming_frame_size */) override {
     return GRPC_ERROR_NONE;
   }
-  void RecvUpdate(uint32_t size) override {}
+  void RecvUpdate(uint32_t /* size */) override {}
 };
 
 // Implementation of flow control that abides to HTTP/2 spec and attempts
@@ -283,16 +279,12 @@ class TransportFlowControl final : public TransportFlowControlBase {
   void PreUpdateAnnouncedWindowOverIncomingWindow(int64_t delta) {
     if (delta > 0) {
       announced_stream_total_over_incoming_window_ -= delta;
-    } else {
-      announced_stream_total_under_incoming_window_ += -delta;
     }
   }
 
   void PostUpdateAnnouncedWindowOverIncomingWindow(int64_t delta) {
     if (delta > 0) {
       announced_stream_total_over_incoming_window_ += delta;
-    } else {
-      announced_stream_total_under_incoming_window_ -= -delta;
     }
   }
 
@@ -328,7 +320,6 @@ class TransportFlowControl final : public TransportFlowControlBase {
       we want to adjust incoming_window such that:
       incoming_window = total_over - max(bdp - total_under, 0) */
   int64_t announced_stream_total_over_incoming_window_ = 0;
-  int64_t announced_stream_total_under_incoming_window_ = 0;
 
   /** should we probe bdp? */
   const bool enable_bdp_probe_;
@@ -342,37 +333,38 @@ class TransportFlowControl final : public TransportFlowControlBase {
 };
 
 // Fat interface with all methods a stream flow control implementation needs
-// to support. gRPC C Core does not support pure virtual functions, so instead
-// we abort in any methods which require implementation in the base class.
+// to support.
 class StreamFlowControlBase {
  public:
   StreamFlowControlBase() {}
   virtual ~StreamFlowControlBase() {}
 
   // Updates an action using the protected members.
-  virtual FlowControlAction UpdateAction(FlowControlAction action) { abort(); }
+  virtual FlowControlAction UpdateAction(FlowControlAction /* action */) {
+    abort();
+  }
 
   // Using the protected members, returns an Action for this stream to be
   // taken by the tranport.
-  virtual FlowControlAction MakeAction() { abort(); }
+  virtual FlowControlAction MakeAction() = 0;
 
   // Bookkeeping for when data is sent on this stream.
-  virtual void SentData(int64_t outgoing_frame_size) { abort(); }
+  virtual void SentData(int64_t /* outgoing_frame_size */) = 0;
 
   // Bookkeeping and error checking for when data is received by this stream.
-  virtual grpc_error* RecvData(int64_t incoming_frame_size) { abort(); }
+  virtual grpc_error* RecvData(int64_t /* incoming_frame_size */) = 0;
 
   // Called to check if this stream needs to send a WINDOW_UPDATE frame.
-  virtual uint32_t MaybeSendUpdate() { abort(); }
+  virtual uint32_t MaybeSendUpdate() = 0;
 
   // Bookkeeping for receiving a WINDOW_UPDATE from for this stream.
-  virtual void RecvUpdate(uint32_t size) { abort(); }
+  virtual void RecvUpdate(uint32_t /* size */) = 0;
 
   // Bookkeeping for when a call pulls bytes out of the transport. At this
   // point we consider the data 'used' and can thus let out peer know we are
   // ready for more data.
-  virtual void IncomingByteStreamUpdate(size_t max_size_hint,
-                                        size_t have_already) {
+  virtual void IncomingByteStreamUpdate(size_t /* max_size_hint */,
+                                        size_t /* have_already */) {
     abort();
   }
 
@@ -385,8 +377,6 @@ class StreamFlowControlBase {
   int64_t local_window_delta() { return local_window_delta_; }
   int64_t announced_window_delta() { return announced_window_delta_; }
 
-  GRPC_ABSTRACT_BASE_CLASS
-
  protected:
   friend class ::grpc::testing::TrickledCHTTP2;
   int64_t remote_window_delta_ = 0;
@@ -404,14 +394,14 @@ class StreamFlowControlDisabled : public StreamFlowControlBase {
     return action;
   }
   FlowControlAction MakeAction() override { return FlowControlAction(); }
-  void SentData(int64_t outgoing_frame_size) override {}
-  grpc_error* RecvData(int64_t incoming_frame_size) override {
+  void SentData(int64_t /* outgoing_frame_size */) override {}
+  grpc_error* RecvData(int64_t /* incoming_frame_size */) override {
     return GRPC_ERROR_NONE;
   }
   uint32_t MaybeSendUpdate() override { return 0; }
-  void RecvUpdate(uint32_t size) override {}
-  void IncomingByteStreamUpdate(size_t max_size_hint,
-                                size_t have_already) override {}
+  void RecvUpdate(uint32_t /* size */) override {}
+  void IncomingByteStreamUpdate(size_t /* max_size_hint */,
+                                size_t /* have_already */) override {}
 };
 
 // Implementation of flow control that abides to HTTP/2 spec and attempts

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

@@ -22,9 +22,10 @@
 
 #include <string.h>
 
+#include "absl/strings/str_format.h"
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
-#include <grpc/support/string_util.h>
 #include "src/core/ext/transport/chttp2/transport/internal.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gprpp/memory.h"
@@ -40,18 +41,14 @@ grpc_chttp2_data_parser::~grpc_chttp2_data_parser() {
   GRPC_ERROR_UNREF(error);
 }
 
-grpc_error* grpc_chttp2_data_parser_begin_frame(grpc_chttp2_data_parser* parser,
-                                                uint8_t flags,
-                                                uint32_t stream_id,
-                                                grpc_chttp2_stream* s) {
+grpc_error* grpc_chttp2_data_parser_begin_frame(
+    grpc_chttp2_data_parser* /*parser*/, uint8_t flags, uint32_t stream_id,
+    grpc_chttp2_stream* s) {
   if (flags & ~GRPC_CHTTP2_DATA_FLAG_END_STREAM) {
-    char* msg;
-    gpr_asprintf(&msg, "unsupported data flags: 0x%02x", flags);
-    grpc_error* err = grpc_error_set_int(
-        GRPC_ERROR_CREATE_FROM_COPIED_STRING(msg), GRPC_ERROR_INT_STREAM_ID,
-        static_cast<intptr_t>(stream_id));
-    gpr_free(msg);
-    return err;
+    return grpc_error_set_int(
+        GRPC_ERROR_CREATE_FROM_COPIED_STRING(
+            absl::StrFormat("unsupported data flags: 0x%02x", flags).c_str()),
+        GRPC_ERROR_INT_STREAM_ID, static_cast<intptr_t>(stream_id));
   }
 
   if (flags & GRPC_CHTTP2_DATA_FLAG_END_STREAM) {
@@ -104,23 +101,21 @@ grpc_error* grpc_deframe_unprocessed_incoming_frames(
     uint8_t* end = nullptr;
     uint8_t* cur = nullptr;
 
-    grpc_slice slice = grpc_slice_buffer_take_first(slices);
-
-    beg = GRPC_SLICE_START_PTR(slice);
-    end = GRPC_SLICE_END_PTR(slice);
+    grpc_slice* slice = grpc_slice_buffer_peek_first(slices);
+    beg = GRPC_SLICE_START_PTR(*slice);
+    end = GRPC_SLICE_END_PTR(*slice);
     cur = beg;
     uint32_t message_flags;
-    char* msg;
 
     if (cur == end) {
-      grpc_slice_unref_internal(slice);
+      grpc_slice_buffer_remove_first(slices);
       continue;
     }
 
     switch (p->state) {
       case GRPC_CHTTP2_DATA_ERROR:
         p->state = GRPC_CHTTP2_DATA_ERROR;
-        grpc_slice_unref_internal(slice);
+        grpc_slice_buffer_remove_first(slices);
         return GRPC_ERROR_REF(p->error);
       case GRPC_CHTTP2_DATA_FH_0:
         s->stats.incoming.framing_bytes++;
@@ -133,24 +128,24 @@ grpc_error* grpc_deframe_unprocessed_incoming_frames(
             p->is_frame_compressed = true; /* GPR_TRUE */
             break;
           default:
-            gpr_asprintf(&msg, "Bad GRPC frame type 0x%02x", p->frame_type);
-            p->error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(msg);
+            p->error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(
+                absl::StrFormat("Bad GRPC frame type 0x%02x", p->frame_type)
+                    .c_str());
             p->error = grpc_error_set_int(p->error, GRPC_ERROR_INT_STREAM_ID,
                                           static_cast<intptr_t>(s->id));
-            gpr_free(msg);
-            msg = grpc_dump_slice(slice, GPR_DUMP_HEX | GPR_DUMP_ASCII);
-            p->error = grpc_error_set_str(p->error, GRPC_ERROR_STR_RAW_BYTES,
-                                          grpc_slice_from_copied_string(msg));
-            gpr_free(msg);
+            p->error = grpc_error_set_str(
+                p->error, GRPC_ERROR_STR_RAW_BYTES,
+                grpc_slice_from_moved_string(grpc_core::UniquePtr<char>(
+                    grpc_dump_slice(*slice, GPR_DUMP_HEX | GPR_DUMP_ASCII))));
             p->error =
                 grpc_error_set_int(p->error, GRPC_ERROR_INT_OFFSET, cur - beg);
             p->state = GRPC_CHTTP2_DATA_ERROR;
-            grpc_slice_unref_internal(slice);
+            grpc_slice_buffer_remove_first(slices);
             return GRPC_ERROR_REF(p->error);
         }
         if (++cur == end) {
           p->state = GRPC_CHTTP2_DATA_FH_1;
-          grpc_slice_unref_internal(slice);
+          grpc_slice_buffer_remove_first(slices);
           continue;
         }
       /* fallthrough */
@@ -159,7 +154,7 @@ grpc_error* grpc_deframe_unprocessed_incoming_frames(
         p->frame_size = (static_cast<uint32_t>(*cur)) << 24;
         if (++cur == end) {
           p->state = GRPC_CHTTP2_DATA_FH_2;
-          grpc_slice_unref_internal(slice);
+          grpc_slice_buffer_remove_first(slices);
           continue;
         }
       /* fallthrough */
@@ -168,7 +163,7 @@ grpc_error* grpc_deframe_unprocessed_incoming_frames(
         p->frame_size |= (static_cast<uint32_t>(*cur)) << 16;
         if (++cur == end) {
           p->state = GRPC_CHTTP2_DATA_FH_3;
-          grpc_slice_unref_internal(slice);
+          grpc_slice_buffer_remove_first(slices);
           continue;
         }
       /* fallthrough */
@@ -177,7 +172,7 @@ grpc_error* grpc_deframe_unprocessed_incoming_frames(
         p->frame_size |= (static_cast<uint32_t>(*cur)) << 8;
         if (++cur == end) {
           p->state = GRPC_CHTTP2_DATA_FH_4;
-          grpc_slice_unref_internal(slice);
+          grpc_slice_buffer_remove_first(slices);
           continue;
         }
       /* fallthrough */
@@ -195,7 +190,7 @@ grpc_error* grpc_deframe_unprocessed_incoming_frames(
         if (p->is_frame_compressed) {
           message_flags |= GRPC_WRITE_INTERNAL_COMPRESS;
         }
-        p->parsing_frame = grpc_core::New<grpc_core::Chttp2IncomingByteStream>(
+        p->parsing_frame = new grpc_core::Chttp2IncomingByteStream(
             t, s, p->frame_size, message_flags);
         stream_out->reset(p->parsing_frame);
         if (p->parsing_frame->remaining_bytes() == 0) {
@@ -204,19 +199,18 @@ grpc_error* grpc_deframe_unprocessed_incoming_frames(
           p->state = GRPC_CHTTP2_DATA_FH_0;
         }
         s->pending_byte_stream = true;
-
         if (cur != end) {
-          grpc_slice_buffer_undo_take_first(
-              slices, grpc_slice_sub(slice, static_cast<size_t>(cur - beg),
-                                     static_cast<size_t>(end - beg)));
+          grpc_slice_buffer_sub_first(slices, static_cast<size_t>(cur - beg),
+                                      static_cast<size_t>(end - beg));
+        } else {
+          grpc_slice_buffer_remove_first(slices);
         }
-        grpc_slice_unref_internal(slice);
         return GRPC_ERROR_NONE;
       case GRPC_CHTTP2_DATA_FRAME: {
         GPR_ASSERT(p->parsing_frame != nullptr);
         GPR_ASSERT(slice_out != nullptr);
         if (cur == end) {
-          grpc_slice_unref_internal(slice);
+          grpc_slice_buffer_remove_first(slices);
           continue;
         }
         uint32_t remaining = static_cast<uint32_t>(end - cur);
@@ -224,32 +218,32 @@ grpc_error* grpc_deframe_unprocessed_incoming_frames(
           s->stats.incoming.data_bytes += remaining;
           if (GRPC_ERROR_NONE !=
               (error = p->parsing_frame->Push(
-                   grpc_slice_sub(slice, static_cast<size_t>(cur - beg),
+                   grpc_slice_sub(*slice, static_cast<size_t>(cur - beg),
                                   static_cast<size_t>(end - beg)),
                    slice_out))) {
-            grpc_slice_unref_internal(slice);
+            grpc_slice_buffer_remove_first(slices);
             return error;
           }
           if (GRPC_ERROR_NONE !=
               (error = p->parsing_frame->Finished(GRPC_ERROR_NONE, true))) {
-            grpc_slice_unref_internal(slice);
+            grpc_slice_buffer_remove_first(slices);
             return error;
           }
           p->parsing_frame = nullptr;
           p->state = GRPC_CHTTP2_DATA_FH_0;
-          grpc_slice_unref_internal(slice);
+          grpc_slice_buffer_remove_first(slices);
           return GRPC_ERROR_NONE;
         } else if (remaining < p->frame_size) {
           s->stats.incoming.data_bytes += remaining;
           if (GRPC_ERROR_NONE !=
               (error = p->parsing_frame->Push(
-                   grpc_slice_sub(slice, static_cast<size_t>(cur - beg),
+                   grpc_slice_sub(*slice, static_cast<size_t>(cur - beg),
                                   static_cast<size_t>(end - beg)),
                    slice_out))) {
             return error;
           }
           p->frame_size -= remaining;
-          grpc_slice_unref_internal(slice);
+          grpc_slice_buffer_remove_first(slices);
           return GRPC_ERROR_NONE;
         } else {
           GPR_ASSERT(remaining > p->frame_size);
@@ -257,34 +251,31 @@ grpc_error* grpc_deframe_unprocessed_incoming_frames(
           if (GRPC_ERROR_NONE !=
               p->parsing_frame->Push(
                   grpc_slice_sub(
-                      slice, static_cast<size_t>(cur - beg),
+                      *slice, static_cast<size_t>(cur - beg),
                       static_cast<size_t>(cur + p->frame_size - beg)),
                   slice_out)) {
-            grpc_slice_unref_internal(slice);
+            grpc_slice_buffer_remove_first(slices);
             return error;
           }
           if (GRPC_ERROR_NONE !=
               (error = p->parsing_frame->Finished(GRPC_ERROR_NONE, true))) {
-            grpc_slice_unref_internal(slice);
+            grpc_slice_buffer_remove_first(slices);
             return error;
           }
           p->parsing_frame = nullptr;
           p->state = GRPC_CHTTP2_DATA_FH_0;
           cur += p->frame_size;
-          grpc_slice_buffer_undo_take_first(
-              slices, grpc_slice_sub(slice, static_cast<size_t>(cur - beg),
-                                     static_cast<size_t>(end - beg)));
-          grpc_slice_unref_internal(slice);
+          grpc_slice_buffer_sub_first(slices, static_cast<size_t>(cur - beg),
+                                      static_cast<size_t>(end - beg));
           return GRPC_ERROR_NONE;
         }
       }
     }
   }
-
   return GRPC_ERROR_NONE;
 }
 
-grpc_error* grpc_chttp2_data_parser_parse(void* parser,
+grpc_error* grpc_chttp2_data_parser_parse(void* /*parser*/,
                                           grpc_chttp2_transport* t,
                                           grpc_chttp2_stream* s,
                                           const grpc_slice& slice,
@@ -297,7 +288,7 @@ grpc_error* grpc_chttp2_data_parser_parse(void* parser,
     GPR_ASSERT(s->frame_storage.length == 0);
     grpc_slice_ref_internal(slice);
     grpc_slice_buffer_add(&s->unprocessed_incoming_frames_buffer, slice);
-    GRPC_CLOSURE_SCHED(s->on_next, GRPC_ERROR_NONE);
+    grpc_core::ExecCtx::Run(DEBUG_LOCATION, s->on_next, GRPC_ERROR_NONE);
     s->on_next = nullptr;
     s->unprocessed_incoming_frames_decompressed = false;
   } else {