grpc 1.50.0-x86_64-linux → 1.51.0-x86_64-linux

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

@@ -279,7 +279,16 @@ void TransportFlowControl::UpdateSetting(
               grpc_chttp2_settings_parameters[id].max_value);
     if (new_desired_value != *desired_value) {
       *desired_value = new_desired_value;
-      (action->*set)(FlowControlAction::Urgency::QUEUE_UPDATE, *desired_value);
+      // Reaching zero can only happen for initial window size, and if it occurs
+      // we really want to wake up writes and ensure all the queued stream
+      // window updates are flushed, since stream flow control operates
+      // differently at zero window size.
+      FlowControlAction::Urgency urgency =
+          FlowControlAction::Urgency::QUEUE_UPDATE;
+      if (new_desired_value == 0) {
+        urgency = FlowControlAction::Urgency::UPDATE_IMMEDIATELY;
+      }
+      (action->*set)(urgency, *desired_value);
     }
   } else {
     int64_t delta = new_desired_value - *desired_value;
@@ -287,7 +296,8 @@ void TransportFlowControl::UpdateSetting(
     if (delta != 0 &&
         (delta <= -*desired_value / 5 || delta >= *desired_value / 5)) {
       *desired_value = new_desired_value;
-      (action->*set)(FlowControlAction::Urgency::QUEUE_UPDATE, *desired_value);
+      (action->*set)(FlowControlAction::Urgency::QUEUE_UPDATE,
+                     static_cast<uint32_t>(*desired_value));
     }
   }
 }
@@ -362,15 +372,15 @@ FlowControlAction TransportFlowControl::PeriodicUpdate() {
 
 uint32_t StreamFlowControl::MaybeSendUpdate() {
   TransportFlowControl::IncomingUpdateContext tfc_upd(tfc_);
-  const uint32_t announce = DesiredAnnounceSize();
+  const int64_t announce = DesiredAnnounceSize();
   pending_size_ = absl::nullopt;
   tfc_upd.UpdateAnnouncedWindowDelta(&announced_window_delta_, announce);
   GPR_ASSERT(DesiredAnnounceSize() == 0);
   tfc_upd.MakeAction();
-  return announce;
+  return static_cast<uint32_t>(announce);
 }
 
-uint32_t StreamFlowControl::DesiredAnnounceSize() const {
+int64_t StreamFlowControl::DesiredAnnounceSize() const {
   int64_t desired_window_delta = [this]() {
     if (min_progress_size_ == 0) {
       if (pending_size_.has_value() &&
@@ -390,13 +400,34 @@ uint32_t StreamFlowControl::DesiredAnnounceSize() const {
 FlowControlAction StreamFlowControl::UpdateAction(FlowControlAction action) {
   const int64_t desired_announce_size = DesiredAnnounceSize();
   if (desired_announce_size > 0) {
-    if ((min_progress_size_ > 0 && announced_window_delta_ <= 0) ||
-        desired_announce_size >= 8192) {
-      action.set_send_stream_update(
-          FlowControlAction::Urgency::UPDATE_IMMEDIATELY);
-    } else {
-      action.set_send_stream_update(FlowControlAction::Urgency::QUEUE_UPDATE);
+    FlowControlAction::Urgency urgency =
+        FlowControlAction::Urgency::QUEUE_UPDATE;
+    // Size at which we probably want to wake up and write regardless of whether
+    // we *have* to.
+    // Currently set at half the initial window size or 8kb (whichever is
+    // greater). 8kb means we don't send rapidly unnecessarily when the initial
+    // window size is small.
+    const int64_t hurry_up_size =
+        std::max(static_cast<int64_t>(tfc_->sent_init_window()) / 2,
+                 static_cast<int64_t>(8192));
+    if (desired_announce_size > hurry_up_size) {
+      urgency = FlowControlAction::Urgency::UPDATE_IMMEDIATELY;
+    }
+    // min_progress_size_ > 0 means we have a reader ready to read.
+    if (min_progress_size_ > 0) {
+      // If we're into initial window to receive that data we should wake up and
+      // send an update.
+      if (announced_window_delta_ < 0) {
+        urgency = FlowControlAction::Urgency::UPDATE_IMMEDIATELY;
+      } else if (announced_window_delta_ == 0 &&
+                 tfc_->sent_init_window() == 0) {
+        // Special case when initial window size is zero, meaning that
+        // announced_window_delta cannot become negative (it may already be so
+        // however).
+        urgency = FlowControlAction::Urgency::UPDATE_IMMEDIATELY;
+      }
     }
+    action.set_send_stream_update(urgency);
   }
   return action;
 }

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

@@ -236,6 +236,7 @@ class TransportFlowControl final {
   BdpEstimator* bdp_estimator() { return &bdp_estimator_; }
 
   uint32_t acked_init_window() const { return acked_init_window_; }
+  uint32_t sent_init_window() const { return target_initial_window_size_; }
 
   void SetAckedInitialWindow(uint32_t value) { acked_init_window_ = value; }
 
@@ -319,7 +320,7 @@ class StreamFlowControl final {
     absl::Status RecvData(int64_t incoming_frame_size);
 
     // the application is asking for a certain amount of bytes
-    void SetMinProgressSize(uint32_t min_progress_size) {
+    void SetMinProgressSize(int64_t min_progress_size) {
       sfc_->min_progress_size_ = min_progress_size;
     }
 
@@ -356,7 +357,7 @@ class StreamFlowControl final {
 
   int64_t remote_window_delta() const { return remote_window_delta_; }
   int64_t announced_window_delta() const { return announced_window_delta_; }
-  uint32_t min_progress_size() const { return min_progress_size_; }
+  int64_t min_progress_size() const { return min_progress_size_; }
 
  private:
   TransportFlowControl* const tfc_;
@@ -366,7 +367,7 @@ class StreamFlowControl final {
   absl::optional<int64_t> pending_size_;
 
   FlowControlAction UpdateAction(FlowControlAction action);
-  uint32_t DesiredAnnounceSize() const;
+  int64_t DesiredAnnounceSize() const;
 };
 
 class TestOnlyTransportTargetWindowEstimatesMocker {

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

@@ -29,8 +29,9 @@
 #include <grpc/support/log.h>
 
 #include "src/core/ext/transport/chttp2/transport/internal.h"
+#include "src/core/lib/gprpp/status_helper.h"
+#include "src/core/lib/slice/slice.h"
 #include "src/core/lib/slice/slice_buffer.h"
-#include "src/core/lib/slice/slice_refcount.h"
 #include "src/core/lib/transport/transport.h"
 
 absl::Status grpc_chttp2_data_parser_begin_frame(uint8_t flags,
@@ -80,10 +81,10 @@ void grpc_chttp2_encode_data(uint32_t id, grpc_slice_buffer* inbuf,
 }
 
 grpc_core::Poll<grpc_error_handle> grpc_deframe_unprocessed_incoming_frames(
-    grpc_chttp2_stream* s, uint32_t* min_progress_size,
+    grpc_chttp2_stream* s, int64_t* min_progress_size,
     grpc_core::SliceBuffer* stream_out, uint32_t* message_flags) {
   grpc_slice_buffer* slices = &s->frame_storage;
-  grpc_error_handle error = GRPC_ERROR_NONE;
+  grpc_error_handle error;
 
   if (slices->length < 5) {
     if (min_progress_size != nullptr) *min_progress_size = 5 - slices->length;
@@ -103,17 +104,17 @@ grpc_core::Poll<grpc_error_handle> grpc_deframe_unprocessed_incoming_frames(
       }
       break;
     default:
-      error = GRPC_ERROR_CREATE_FROM_CPP_STRING(
+      error = GRPC_ERROR_CREATE(
           absl::StrFormat("Bad GRPC frame type 0x%02x", header[0]));
-      error = grpc_error_set_int(error, GRPC_ERROR_INT_STREAM_ID,
+      error = grpc_error_set_int(error, grpc_core::StatusIntProperty::kStreamId,
                                  static_cast<intptr_t>(s->id));
       return error;
   }
 
-  uint64_t length = (static_cast<uint32_t>(header[1]) << 24) |
-                    (static_cast<uint32_t>(header[2]) << 16) |
-                    (static_cast<uint32_t>(header[3]) << 8) |
-                    static_cast<uint32_t>(header[4]);
+  size_t length = (static_cast<uint32_t>(header[1]) << 24) |
+                  (static_cast<uint32_t>(header[2]) << 16) |
+                  (static_cast<uint32_t>(header[3]) << 8) |
+                  static_cast<uint32_t>(header[4]);
 
   if (slices->length < length + 5) {
     if (min_progress_size != nullptr) {
@@ -131,7 +132,7 @@ grpc_core::Poll<grpc_error_handle> grpc_deframe_unprocessed_incoming_frames(
     grpc_slice_buffer_move_first(slices, length, stream_out->c_slice_buffer());
   }
 
-  return GRPC_ERROR_NONE;
+  return absl::OkStatus();
 }
 
 grpc_error_handle grpc_chttp2_data_parser_parse(void* /*parser*/,
@@ -139,17 +140,17 @@ grpc_error_handle grpc_chttp2_data_parser_parse(void* /*parser*/,
                                                 grpc_chttp2_stream* s,
                                                 const grpc_slice& slice,
                                                 int is_last) {
-  grpc_slice_ref_internal(slice);
+  grpc_core::CSliceRef(slice);
   grpc_slice_buffer_add(&s->frame_storage, slice);
   grpc_chttp2_maybe_complete_recv_message(t, s);
 
   if (is_last && s->received_last_frame) {
     grpc_chttp2_mark_stream_closed(
         t, s, true, false,
-        t->is_client ? GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-                           "Data frame with END_STREAM flag received")
-                     : GRPC_ERROR_NONE);
+        t->is_client
+            ? GRPC_ERROR_CREATE("Data frame with END_STREAM flag received")
+            : absl::OkStatus());
   }
 
-  return GRPC_ERROR_NONE;
+  return absl::OkStatus();
 }

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

@@ -54,7 +54,7 @@ void grpc_chttp2_encode_data(uint32_t id, grpc_slice_buffer* inbuf,
                              grpc_slice_buffer* outbuf);
 
 grpc_core::Poll<grpc_error_handle> grpc_deframe_unprocessed_incoming_frames(
-    grpc_chttp2_stream* s, uint32_t* min_progress_size,
+    grpc_chttp2_stream* s, int64_t* min_progress_size,
     grpc_core::SliceBuffer* stream_out, uint32_t* message_flags);
 
 #endif /* GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_FRAME_DATA_H */

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

@@ -23,6 +23,7 @@
 #include <string.h>
 
 #include "absl/base/attributes.h"
+#include "absl/status/status.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/string_view.h"
 
@@ -43,7 +44,7 @@ void grpc_chttp2_goaway_parser_destroy(grpc_chttp2_goaway_parser* p) {
 grpc_error_handle grpc_chttp2_goaway_parser_begin_frame(
     grpc_chttp2_goaway_parser* p, uint32_t length, uint8_t /*flags*/) {
   if (length < 8) {
-    return GRPC_ERROR_CREATE_FROM_CPP_STRING(
+    return GRPC_ERROR_CREATE(
         absl::StrFormat("goaway frame too short (%d bytes)", length));
   }
 
@@ -52,7 +53,7 @@ grpc_error_handle grpc_chttp2_goaway_parser_begin_frame(
   p->debug_data = static_cast<char*>(gpr_malloc(p->debug_length));
   p->debug_pos = 0;
   p->state = GRPC_CHTTP2_GOAWAY_LSI0;
-  return GRPC_ERROR_NONE;
+  return absl::OkStatus();
 }
 
 grpc_error_handle grpc_chttp2_goaway_parser_parse(void* parser,
@@ -70,7 +71,7 @@ grpc_error_handle grpc_chttp2_goaway_parser_parse(void* parser,
     case GRPC_CHTTP2_GOAWAY_LSI0:
       if (cur == end) {
         p->state = GRPC_CHTTP2_GOAWAY_LSI0;
-        return GRPC_ERROR_NONE;
+        return absl::OkStatus();
       }
       p->last_stream_id = (static_cast<uint32_t>(*cur)) << 24;
       ++cur;
@@ -78,7 +79,7 @@ grpc_error_handle grpc_chttp2_goaway_parser_parse(void* parser,
     case GRPC_CHTTP2_GOAWAY_LSI1:
       if (cur == end) {
         p->state = GRPC_CHTTP2_GOAWAY_LSI1;
-        return GRPC_ERROR_NONE;
+        return absl::OkStatus();
       }
       p->last_stream_id |= (static_cast<uint32_t>(*cur)) << 16;
       ++cur;
@@ -86,7 +87,7 @@ grpc_error_handle grpc_chttp2_goaway_parser_parse(void* parser,
     case GRPC_CHTTP2_GOAWAY_LSI2:
       if (cur == end) {
         p->state = GRPC_CHTTP2_GOAWAY_LSI2;
-        return GRPC_ERROR_NONE;
+        return absl::OkStatus();
       }
       p->last_stream_id |= (static_cast<uint32_t>(*cur)) << 8;
       ++cur;
@@ -94,7 +95,7 @@ grpc_error_handle grpc_chttp2_goaway_parser_parse(void* parser,
     case GRPC_CHTTP2_GOAWAY_LSI3:
       if (cur == end) {
         p->state = GRPC_CHTTP2_GOAWAY_LSI3;
-        return GRPC_ERROR_NONE;
+        return absl::OkStatus();
       }
       p->last_stream_id |= (static_cast<uint32_t>(*cur));
       ++cur;
@@ -102,7 +103,7 @@ grpc_error_handle grpc_chttp2_goaway_parser_parse(void* parser,
     case GRPC_CHTTP2_GOAWAY_ERR0:
       if (cur == end) {
         p->state = GRPC_CHTTP2_GOAWAY_ERR0;
-        return GRPC_ERROR_NONE;
+        return absl::OkStatus();
       }
       p->error_code = (static_cast<uint32_t>(*cur)) << 24;
       ++cur;
@@ -110,7 +111,7 @@ grpc_error_handle grpc_chttp2_goaway_parser_parse(void* parser,
     case GRPC_CHTTP2_GOAWAY_ERR1:
       if (cur == end) {
         p->state = GRPC_CHTTP2_GOAWAY_ERR1;
-        return GRPC_ERROR_NONE;
+        return absl::OkStatus();
       }
       p->error_code |= (static_cast<uint32_t>(*cur)) << 16;
       ++cur;
@@ -118,7 +119,7 @@ grpc_error_handle grpc_chttp2_goaway_parser_parse(void* parser,
     case GRPC_CHTTP2_GOAWAY_ERR2:
       if (cur == end) {
         p->state = GRPC_CHTTP2_GOAWAY_ERR2;
-        return GRPC_ERROR_NONE;
+        return absl::OkStatus();
       }
       p->error_code |= (static_cast<uint32_t>(*cur)) << 8;
       ++cur;
@@ -126,7 +127,7 @@ grpc_error_handle grpc_chttp2_goaway_parser_parse(void* parser,
     case GRPC_CHTTP2_GOAWAY_ERR3:
       if (cur == end) {
         p->state = GRPC_CHTTP2_GOAWAY_ERR3;
-        return GRPC_ERROR_NONE;
+        return absl::OkStatus();
       }
       p->error_code |= (static_cast<uint32_t>(*cur));
       ++cur;
@@ -146,10 +147,9 @@ grpc_error_handle grpc_chttp2_goaway_parser_parse(void* parser,
         gpr_free(p->debug_data);
         p->debug_data = nullptr;
       }
-      return GRPC_ERROR_NONE;
+      return absl::OkStatus();
   }
-  GPR_UNREACHABLE_CODE(
-      return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Should never reach here"));
+  GPR_UNREACHABLE_CODE(return GRPC_ERROR_CREATE("Should never reach here"));
 }
 
 void grpc_chttp2_goaway_append(uint32_t last_stream_id, uint32_t error_code,

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

@@ -24,6 +24,7 @@
 
 #include <algorithm>
 
+#include "absl/status/status.h"
 #include "absl/strings/str_format.h"
 
 #include <grpc/support/alloc.h>
@@ -63,13 +64,13 @@ grpc_slice grpc_chttp2_ping_create(uint8_t ack, uint64_t opaque_8bytes) {
 grpc_error_handle grpc_chttp2_ping_parser_begin_frame(
     grpc_chttp2_ping_parser* parser, uint32_t length, uint8_t flags) {
   if (flags & 0xfe || length != 8) {
-    return GRPC_ERROR_CREATE_FROM_CPP_STRING(
+    return GRPC_ERROR_CREATE(
         absl::StrFormat("invalid ping: length=%d, flags=%02x", length, flags));
   }
   parser->byte = 0;
   parser->is_ack = flags;
   parser->opaque_8bytes = 0;
-  return GRPC_ERROR_NONE;
+  return absl::OkStatus();
 }
 
 grpc_error_handle grpc_chttp2_ping_parser_parse(void* parser,
@@ -128,7 +129,7 @@ grpc_error_handle grpc_chttp2_ping_parser_parse(void* parser,
     }
   }
 
-  return GRPC_ERROR_NONE;
+  return absl::OkStatus();
 }
 
 void grpc_set_disable_ping_ack(bool disable_ping_ack) {

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

@@ -22,6 +22,7 @@
 
 #include <stddef.h>
 
+#include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 
@@ -32,6 +33,7 @@
 #include "src/core/ext/transport/chttp2/transport/hpack_encoder.h"
 #include "src/core/ext/transport/chttp2/transport/internal.h"
 #include "src/core/lib/debug/trace.h"
+#include "src/core/lib/gprpp/status_helper.h"
 #include "src/core/lib/transport/http2_errors.h"
 #include "src/core/lib/transport/metadata_batch.h"
 
@@ -75,11 +77,11 @@ void grpc_chttp2_add_rst_stream_to_next_write(
 grpc_error_handle grpc_chttp2_rst_stream_parser_begin_frame(
     grpc_chttp2_rst_stream_parser* parser, uint32_t length, uint8_t flags) {
   if (length != 4) {
-    return GRPC_ERROR_CREATE_FROM_CPP_STRING(absl::StrFormat(
+    return GRPC_ERROR_CREATE(absl::StrFormat(
         "invalid rst_stream: length=%d, flags=%02x", length, flags));
   }
   parser->byte = 0;
-  return GRPC_ERROR_NONE;
+  return absl::OkStatus();
 }
 
 grpc_error_handle grpc_chttp2_rst_stream_parser_parse(void* parser,
@@ -111,17 +113,18 @@ grpc_error_handle grpc_chttp2_rst_stream_parser_parse(void* parser,
               "[chttp2 transport=%p stream=%p] received RST_STREAM(reason=%d)",
               t, s, reason);
     }
-    grpc_error_handle error = GRPC_ERROR_NONE;
+    grpc_error_handle error;
     if (reason != GRPC_HTTP2_NO_ERROR || s->trailing_metadata_buffer.empty()) {
       error = grpc_error_set_int(
           grpc_error_set_str(
-              GRPC_ERROR_CREATE_FROM_STATIC_STRING("RST_STREAM"),
-              GRPC_ERROR_STR_GRPC_MESSAGE,
+              GRPC_ERROR_CREATE("RST_STREAM"),
+              grpc_core::StatusStrProperty::kGrpcMessage,
               absl::StrCat("Received RST_STREAM with error code ", reason)),
-          GRPC_ERROR_INT_HTTP2_ERROR, static_cast<intptr_t>(reason));
+          grpc_core::StatusIntProperty::kHttp2Error,
+          static_cast<intptr_t>(reason));
     }
     grpc_chttp2_mark_stream_closed(t, s, true, true, error);
   }
 
-  return GRPC_ERROR_NONE;
+  return absl::OkStatus();
 }

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

@@ -25,6 +25,7 @@
 #include <string>
 
 #include "absl/base/attributes.h"
+#include "absl/status/status.h"
 #include "absl/strings/str_format.h"
 
 #include <grpc/slice_buffer.h>
@@ -102,18 +103,15 @@ grpc_error_handle grpc_chttp2_settings_parser_begin_frame(
   if (flags == GRPC_CHTTP2_FLAG_ACK) {
     parser->is_ack = 1;
     if (length != 0) {
-      return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "non-empty settings ack frame received");
+      return GRPC_ERROR_CREATE("non-empty settings ack frame received");
     }
-    return GRPC_ERROR_NONE;
+    return absl::OkStatus();
   } else if (flags != 0) {
-    return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-        "invalid flags on settings frame");
+    return GRPC_ERROR_CREATE("invalid flags on settings frame");
   } else if (length % 6 != 0) {
-    return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-        "settings frames must be a multiple of six bytes");
+    return GRPC_ERROR_CREATE("settings frames must be a multiple of six bytes");
   } else {
-    return GRPC_ERROR_NONE;
+    return absl::OkStatus();
   }
 }
 
@@ -129,7 +127,7 @@ grpc_error_handle grpc_chttp2_settings_parser_parse(void* p,
   grpc_chttp2_setting_id id;
 
   if (parser->is_ack) {
-    return GRPC_ERROR_NONE;
+    return absl::OkStatus();
   }
 
   for (;;) {
@@ -147,11 +145,11 @@ grpc_error_handle grpc_chttp2_settings_parser_parse(void* p,
             if (t->notify_on_receive_settings != nullptr) {
               grpc_core::ExecCtx::Run(DEBUG_LOCATION,
                                       t->notify_on_receive_settings,
-                                      GRPC_ERROR_NONE);
+                                      absl::OkStatus());
               t->notify_on_receive_settings = nullptr;
             }
           }
-          return GRPC_ERROR_NONE;
+          return absl::OkStatus();
         }
         parser->id = static_cast<uint16_t>((static_cast<uint16_t>(*cur)) << 8);
         cur++;
@@ -159,7 +157,7 @@ grpc_error_handle grpc_chttp2_settings_parser_parse(void* p,
       case GRPC_CHTTP2_SPS_ID1:
         if (cur == end) {
           parser->state = GRPC_CHTTP2_SPS_ID1;
-          return GRPC_ERROR_NONE;
+          return absl::OkStatus();
         }
         parser->id = static_cast<uint16_t>(parser->id | (*cur));
         cur++;
@@ -167,7 +165,7 @@ grpc_error_handle grpc_chttp2_settings_parser_parse(void* p,
       case GRPC_CHTTP2_SPS_VAL0:
         if (cur == end) {
           parser->state = GRPC_CHTTP2_SPS_VAL0;
-          return GRPC_ERROR_NONE;
+          return absl::OkStatus();
         }
         parser->value = (static_cast<uint32_t>(*cur)) << 24;
         cur++;
@@ -175,7 +173,7 @@ grpc_error_handle grpc_chttp2_settings_parser_parse(void* p,
       case GRPC_CHTTP2_SPS_VAL1:
         if (cur == end) {
           parser->state = GRPC_CHTTP2_SPS_VAL1;
-          return GRPC_ERROR_NONE;
+          return absl::OkStatus();
         }
         parser->value |= (static_cast<uint32_t>(*cur)) << 16;
         cur++;
@@ -183,7 +181,7 @@ grpc_error_handle grpc_chttp2_settings_parser_parse(void* p,
       case GRPC_CHTTP2_SPS_VAL2:
         if (cur == end) {
           parser->state = GRPC_CHTTP2_SPS_VAL2;
-          return GRPC_ERROR_NONE;
+          return absl::OkStatus();
         }
         parser->value |= (static_cast<uint32_t>(*cur)) << 8;
         cur++;
@@ -191,7 +189,7 @@ grpc_error_handle grpc_chttp2_settings_parser_parse(void* p,
       case GRPC_CHTTP2_SPS_VAL3:
         if (cur == end) {
           parser->state = GRPC_CHTTP2_SPS_VAL3;
-          return GRPC_ERROR_NONE;
+          return absl::OkStatus();
         } else {
           parser->state = GRPC_CHTTP2_SPS_ID0;
         }
@@ -212,7 +210,7 @@ grpc_error_handle grpc_chttp2_settings_parser_parse(void* p,
                     t->last_new_stream_id, sp->error_value,
                     grpc_slice_from_static_string("HTTP2 settings error"),
                     &t->qbuf);
-                return GRPC_ERROR_CREATE_FROM_CPP_STRING(absl::StrFormat(
+                return GRPC_ERROR_CREATE(absl::StrFormat(
                     "invalid value %u passed for %s", parser->value, sp->name));
             }
           }

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

@@ -22,6 +22,7 @@
 
 #include <stddef.h>
 
+#include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 
@@ -59,12 +60,12 @@ grpc_slice grpc_chttp2_window_update_create(
 grpc_error_handle grpc_chttp2_window_update_parser_begin_frame(
     grpc_chttp2_window_update_parser* parser, uint32_t length, uint8_t flags) {
   if (flags || length != 4) {
-    return GRPC_ERROR_CREATE_FROM_CPP_STRING(absl::StrFormat(
+    return GRPC_ERROR_CREATE(absl::StrFormat(
         "invalid window update: length=%d, flags=%02x", length, flags));
   }
   parser->byte = 0;
   parser->amount = 0;
-  return GRPC_ERROR_NONE;
+  return absl::OkStatus();
 }
 
 grpc_error_handle grpc_chttp2_window_update_parser_parse(
@@ -90,7 +91,7 @@ grpc_error_handle grpc_chttp2_window_update_parser_parse(
     // top bit is reserved and must be ignored.
     uint32_t received_update = p->amount & 0x7fffffffu;
     if (received_update == 0) {
-      return GRPC_ERROR_CREATE_FROM_CPP_STRING(
+      return GRPC_ERROR_CREATE(
           absl::StrCat("invalid window update bytes: ", p->amount));
     }
     GPR_ASSERT(is_last);
@@ -117,5 +118,5 @@ grpc_error_handle grpc_chttp2_window_update_parser_parse(
     }
   }
 
-  return GRPC_ERROR_NONE;
+  return absl::OkStatus();
 }

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

@@ -22,7 +22,6 @@
 
 #include <algorithm>
 #include <cstdint>
-#include <memory>
 
 #include <grpc/slice.h>
 #include <grpc/slice_buffer.h>
@@ -319,7 +318,7 @@ void HPackCompressor::SliceIndex::EmitTo(absl::string_view key,
   auto& table = framer->compressor_->table_;
   using It = std::vector<ValueIndex>::iterator;
   It prev = values_.end();
-  uint32_t transport_length =
+  size_t transport_length =
       key.length() + value.length() + hpack_constants::kEntryOverhead;
   if (transport_length > HPackEncoderTable::MaxEntrySize()) {
     framer->EmitLitHdrWithNonBinaryStringKeyNotIdx(Slice::FromStaticString(key),
@@ -482,7 +481,7 @@ void HPackCompressor::Framer::Encode(HttpMethodMetadata,
 void HPackCompressor::Framer::EncodeAlwaysIndexed(uint32_t* index,
                                                   absl::string_view key,
                                                   Slice value,
-                                                  uint32_t transport_length) {
+                                                  size_t transport_length) {
   if (compressor_->table_.ConvertableToDynamicIndex(*index)) {
     EmitIndexed(compressor_->table_.DynamicIndex(*index));
   } else {
@@ -579,7 +578,7 @@ void HPackCompressor::Framer::Encode(GrpcStatusMetadata,
   }
   Slice key = Slice::FromStaticString(GrpcStatusMetadata::key());
   Slice value = Slice::FromInt64(code);
-  const uint32_t transport_length =
+  const size_t transport_length =
       key.length() + value.length() + hpack_constants::kEntryOverhead;
   if (index != nullptr) {
     *index = compressor_->table_.AllocateIndex(transport_length);
@@ -601,7 +600,7 @@ void HPackCompressor::Framer::Encode(GrpcEncodingMetadata,
   }
   auto key = Slice::FromStaticString(GrpcEncodingMetadata::key());
   auto encoded_value = GrpcEncodingMetadata::Encode(value);
-  uint32_t transport_length =
+  size_t transport_length =
       key.length() + encoded_value.length() + hpack_constants::kEntryOverhead;
   if (index != nullptr) {
     *index = compressor_->table_.AllocateIndex(transport_length);
@@ -625,7 +624,7 @@ void HPackCompressor::Framer::Encode(GrpcAcceptEncodingMetadata,
   }
   auto key = Slice::FromStaticString(GrpcAcceptEncodingMetadata::key());
   auto encoded_value = GrpcAcceptEncodingMetadata::Encode(value);
-  uint32_t transport_length =
+  size_t transport_length =
       key.length() + encoded_value.length() + hpack_constants::kEntryOverhead;
   compressor_->grpc_accept_encoding_index_ =
       compressor_->table_.AllocateIndex(transport_length);

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

@@ -150,7 +150,7 @@ class HPackCompressor {
                                                 Slice value_slice);
 
     void EncodeAlwaysIndexed(uint32_t* index, absl::string_view key,
-                             Slice value, uint32_t transport_length);
+                             Slice value, size_t transport_length);
     void EncodeIndexedKeyWithBinaryValue(uint32_t* index, absl::string_view key,
                                          Slice value);
 

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

@@ -60,7 +60,8 @@ bool HPackEncoderTable::SetMaxSize(uint32_t max_table_size) {
       hpack_constants::EntriesForBytes(max_table_size);
   // TODO(ctiller): integrate with ResourceQuota to rebuild smaller when we can.
   if (max_table_elems > elem_size_.size()) {
-    Rebuild(std::max(max_table_elems, 2 * elem_size_.size()));
+    Rebuild(static_cast<uint32_t>(
+        std::max(max_table_elems, 2 * elem_size_.size())));
   }
   return true;
 }