grpc 1.41.0 → 1.42.0

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

@@ -48,7 +48,7 @@ bool g_test_only_transport_flow_control_window_check;
 namespace {
 
 static constexpr const int kTracePadding = 30;
-static constexpr const uint32_t kMaxWindowUpdateSize = (1u << 31) - 1;
+static constexpr const int64_t kMaxWindowUpdateSize = (1u << 31) - 1;
 
 static char* fmt_int64_diff_str(int64_t old_val, int64_t new_val) {
   std::string str;
@@ -181,7 +181,7 @@ TransportFlowControl::TransportFlowControl(const grpc_chttp2_transport* t,
     : t_(t),
       enable_bdp_probe_(enable_bdp_probe),
       bdp_estimator_(t->peer_string.c_str()),
-      pid_controller_(grpc_core::PidController::Args()
+      pid_controller_(PidController::Args()
                           .set_gain_p(4)
                           .set_gain_i(8)
                           .set_gain_d(0)
@@ -189,7 +189,7 @@ TransportFlowControl::TransportFlowControl(const grpc_chttp2_transport* t,
                           .set_min_control_value(-1)
                           .set_max_control_value(25)
                           .set_integral_range(10)),
-      last_pid_update_(grpc_core::ExecCtx::Get()->Now()) {}
+      last_pid_update_(ExecCtx::Get()->Now()) {}
 
 uint32_t TransportFlowControl::MaybeSendUpdate(bool writing_anyway) {
   FlowControlTrace trace("t updt sent", this, nullptr);
@@ -197,8 +197,9 @@ uint32_t TransportFlowControl::MaybeSendUpdate(bool writing_anyway) {
       static_cast<uint32_t>(target_window());
   if ((writing_anyway || announced_window_ <= target_announced_window / 2) &&
       announced_window_ != target_announced_window) {
-    const uint32_t announce = static_cast<uint32_t> GPR_CLAMP(
-        target_announced_window - announced_window_, 0, kMaxWindowUpdateSize);
+    const uint32_t announce =
+        static_cast<uint32_t>(Clamp(target_announced_window - announced_window_,
+                                    int64_t(0), kMaxWindowUpdateSize));
     announced_window_ += announce;
     return announce;
   }
@@ -280,8 +281,9 @@ uint32_t StreamFlowControl::MaybeSendUpdate() {
     }
   }
   if (local_window_delta_ > announced_window_delta_) {
-    uint32_t announce = static_cast<uint32_t> GPR_CLAMP(
-        local_window_delta_ - announced_window_delta_, 0, kMaxWindowUpdateSize);
+    uint32_t announce = static_cast<uint32_t>(
+        Clamp(local_window_delta_ - announced_window_delta_, int64_t(0),
+              kMaxWindowUpdateSize));
     UpdateAnnouncedWindowDelta(tfc_, announce);
     return announce;
   }
@@ -334,8 +336,8 @@ static double AdjustForMemoryPressure(grpc_resource_quota* quota,
     target = (target - kZeroTarget) * memory_pressure / kLowMemPressure +
              kZeroTarget;
   } else if (memory_pressure > kHighMemPressure) {
-    target *= 1 - GPR_MIN(1, (memory_pressure - kHighMemPressure) /
-                                 (kMaxMemPressure - kHighMemPressure));
+    target *= 1 - std::min(1.0, (memory_pressure - kHighMemPressure) /
+                                    (kMaxMemPressure - kHighMemPressure));
   }
   return target;
 }
@@ -346,7 +348,7 @@ double TransportFlowControl::TargetLogBdp() {
 }
 
 double TransportFlowControl::SmoothLogBdp(double value) {
-  grpc_millis now = grpc_core::ExecCtx::Get()->Now();
+  grpc_millis now = ExecCtx::Get()->Now();
   double bdp_error = value - pid_controller_.last_control_value();
   const double dt = static_cast<double>(now - last_pid_update_) * 1e-3;
   last_pid_update_ = now;
@@ -383,8 +385,8 @@ FlowControlAction TransportFlowControl::PeriodicUpdate() {
     }
     // Though initial window 'could' drop to 0, we keep the floor at
     // kMinInitialWindowSize
-    target_initial_window_size_ = static_cast<int32_t> GPR_CLAMP(
-        target, kMinInitialWindowSize, kMaxInitialWindowSize);
+    target_initial_window_size_ = static_cast<int32_t>(Clamp(
+        target, double(kMinInitialWindowSize), double(kMaxInitialWindowSize)));
     action.set_send_initial_window_update(
         DeltaUrgency(target_initial_window_size_,
                      GRPC_CHTTP2_SETTINGS_INITIAL_WINDOW_SIZE),
@@ -393,10 +395,11 @@ FlowControlAction TransportFlowControl::PeriodicUpdate() {
     // get bandwidth estimate and update max_frame accordingly.
     double bw_dbl = bdp_estimator_.EstimateBandwidth();
     // we target the max of BDP or bandwidth in microseconds.
-    int32_t frame_size = static_cast<int32_t> GPR_CLAMP(
-        GPR_MAX((int32_t)GPR_CLAMP(bw_dbl, 0, INT_MAX) / 1000,
-                target_initial_window_size_),
-        16384, 16777215);
+    int32_t frame_size = static_cast<int32_t>(Clamp(
+        std::max(
+            static_cast<int32_t>(Clamp(bw_dbl, 0.0, double(INT_MAX))) / 1000,
+            static_cast<int32_t>(target_initial_window_size_)),
+        16384, 16777215));
     action.set_send_max_frame_size_update(
         DeltaUrgency(static_cast<int64_t>(frame_size),
                      GRPC_CHTTP2_SETTINGS_MAX_FRAME_SIZE),

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

@@ -274,10 +274,10 @@ class TransportFlowControl final : public TransportFlowControlBase {
   // See comment above announced_stream_total_over_incoming_window_ for the
   // logic behind this decision.
   int64_t target_window() const override {
-    return static_cast<uint32_t> GPR_MIN(
-        (int64_t)((1u << 31) - 1),
-        announced_stream_total_over_incoming_window_ +
-            target_initial_window_size_);
+    return static_cast<uint32_t>(
+        std::min(static_cast<int64_t>((1u << 31) - 1),
+                 announced_stream_total_over_incoming_window_ +
+                     target_initial_window_size_));
   }
 
   const grpc_chttp2_transport* transport() const { return t_; }

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

@@ -133,10 +133,10 @@ grpc_error_handle grpc_deframe_unprocessed_incoming_frames(
                 absl::StrFormat("Bad GRPC frame type 0x%02x", p->frame_type));
             p->error = grpc_error_set_int(p->error, GRPC_ERROR_INT_STREAM_ID,
                                           static_cast<intptr_t>(s->id));
-            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))));
+            grpc_core::UniquePtr<char> dmp(
+                grpc_dump_slice(*slice, GPR_DUMP_HEX | GPR_DUMP_ASCII));
+            p->error = grpc_error_set_str(p->error, GRPC_ERROR_STR_RAW_BYTES,
+                                          dmp.get());
             p->error =
                 grpc_error_set_int(p->error, GRPC_ERROR_INT_OFFSET, cur - beg);
             p->state = GRPC_CHTTP2_DATA_ERROR;

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

@@ -139,7 +139,8 @@ grpc_error_handle grpc_chttp2_goaway_parser_parse(void* parser,
       if (is_last) {
         grpc_chttp2_add_incoming_goaway(
             t, p->error_code, p->last_stream_id,
-            grpc_slice_new(p->debug_data, p->debug_length, gpr_free));
+            absl::string_view(p->debug_data, p->debug_length));
+        gpr_free(p->debug_data);
         p->debug_data = nullptr;
       }
       return GRPC_ERROR_NONE;

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

@@ -112,7 +112,8 @@ grpc_error_handle grpc_chttp2_ping_parser_parse(void* parser,
       }
       if (!g_disable_ping_ack) {
         if (t->ping_ack_count == t->ping_ack_capacity) {
-          t->ping_ack_capacity = GPR_MAX(t->ping_ack_capacity * 3 / 2, 3);
+          t->ping_ack_capacity =
+              std::max(t->ping_ack_capacity * 3 / 2, size_t(3));
           t->ping_acks = static_cast<uint64_t*>(gpr_realloc(
               t->ping_acks, t->ping_ack_capacity * sizeof(*t->ping_acks)));
         }

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

@@ -103,13 +103,12 @@ grpc_error_handle grpc_chttp2_rst_stream_parser_parse(void* parser,
                       ((static_cast<uint32_t>(p->reason_bytes[2])) << 8) |
                       ((static_cast<uint32_t>(p->reason_bytes[3])));
     grpc_error_handle error = GRPC_ERROR_NONE;
-    if (reason != GRPC_HTTP2_NO_ERROR || s->metadata_buffer[1].size == 0) {
+    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_slice_from_cpp_string(absl::StrCat(
-                  "Received RST_STREAM with error code ", reason))),
+              absl::StrCat("Received RST_STREAM with error code ", reason)),
           GRPC_ERROR_INT_HTTP2_ERROR, static_cast<intptr_t>(reason));
     }
     grpc_chttp2_mark_stream_closed(t, s, true, true, error);

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

@@ -217,8 +217,8 @@ grpc_error_handle grpc_chttp2_settings_parser_parse(void* p,
           if (parser->value < sp->min_value || parser->value > sp->max_value) {
             switch (sp->invalid_value_behavior) {
               case GRPC_CHTTP2_CLAMP_INVALID_VALUE:
-                parser->value =
-                    GPR_CLAMP(parser->value, sp->min_value, sp->max_value);
+                parser->value = grpc_core::Clamp(parser->value, sp->min_value,
+                                                 sp->max_value);
                 break;
               case GRPC_CHTTP2_DISCONNECT_ON_INVALID_VALUE:
                 grpc_chttp2_goaway_append(

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

@@ -15,7 +15,7 @@
 #ifndef GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HPACK_CONSTANTS_H
 #define GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HPACK_CONSTANTS_H
 
-#include <grpc/impl/codegen/port_platform.h>
+#include <grpc/support/port_platform.h>
 
 #include <stdint.h>
 

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

@@ -265,6 +265,22 @@ class StringValue {
   VarintWriter<1> len_val_;
 };
 
+class NonBinaryStringValue {
+ public:
+  explicit NonBinaryStringValue(const grpc_slice& value)
+      : value_(value), len_val_(GRPC_SLICE_LENGTH(value)) {}
+
+  size_t prefix_length() const { return len_val_.length(); }
+
+  void WritePrefix(uint8_t* prefix_data) { len_val_.Write(0x00, prefix_data); }
+
+  const grpc_slice& data() { return value_; }
+
+ private:
+  grpc_slice value_;
+  VarintWriter<1> len_val_;
+};
+
 class StringKey {
  public:
   explicit StringKey(grpc_slice key)
@@ -317,6 +333,18 @@ void HPackCompressor::Framer::EmitLitHdrWithStringKeyIncIdx(grpc_mdelem elem) {
   Add(emit.data());
 }
 
+void HPackCompressor::Framer::EmitLitHdrWithNonBinaryStringKeyIncIdx(
+    const grpc_slice& key_slice, const grpc_slice& value_slice) {
+  GRPC_STATS_INC_HPACK_SEND_LITHDR_INCIDX_V();
+  GRPC_STATS_INC_HPACK_SEND_UNCOMPRESSED();
+  StringKey key(key_slice);
+  key.WritePrefix(0x40, AddTiny(key.prefix_length()));
+  Add(grpc_slice_ref_internal(key.key()));
+  NonBinaryStringValue emit(value_slice);
+  emit.WritePrefix(AddTiny(emit.prefix_length()));
+  Add(grpc_slice_ref_internal(emit.data()));
+}
+
 void HPackCompressor::Framer::EmitLitHdrWithStringKeyNotIdx(grpc_mdelem elem) {
   GRPC_STATS_INC_HPACK_SEND_LITHDR_NOTIDX_V();
   GRPC_STATS_INC_HPACK_SEND_UNCOMPRESSED();
@@ -448,7 +476,19 @@ void HPackCompressor::Framer::EncodeDynamic(grpc_mdelem elem) {
   }
 }
 
-void HPackCompressor::Framer::EncodeDeadline(grpc_millis deadline) {
+void HPackCompressor::Framer::Encode(TeMetadata, TeMetadata::ValueType value) {
+  GPR_ASSERT(value == TeMetadata::ValueType::kTrailers);
+  if (compressor_->table_.ConvertableToDynamicIndex(compressor_->te_index_)) {
+    EmitIndexed(compressor_->table_.DynamicIndex(compressor_->te_index_));
+  } else {
+    compressor_->te_index_ = compressor_->table_.AllocateIndex(
+        2 /* te */ + 8 /* trailers */ + hpack_constants::kEntryOverhead);
+    EmitLitHdrWithNonBinaryStringKeyIncIdx(GRPC_MDSTR_TE, GRPC_MDSTR_TRAILERS);
+  }
+}
+
+void HPackCompressor::Framer::Encode(GrpcTimeoutMetadata,
+                                     grpc_millis deadline) {
   char timeout_str[GRPC_HTTP2_TIMEOUT_ENCODE_MIN_BUFSIZE];
   grpc_mdelem mdelem;
   grpc_http2_encode_timeout(deadline - grpc_core::ExecCtx::Get()->Now(),

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

@@ -117,7 +117,8 @@ class HPackCompressor {
     Framer& operator=(const Framer&) = delete;
 
     void Encode(grpc_mdelem md);
-    void EncodeDeadline(grpc_millis deadline);
+    void Encode(GrpcTimeoutMetadata, grpc_millis deadline);
+    void Encode(TeMetadata, TeMetadata::ValueType value);
 
    private:
     struct FramePrefix {
@@ -140,6 +141,8 @@ class HPackCompressor {
     void EmitLitHdrIncIdx(uint32_t key_index, grpc_mdelem elem);
     void EmitLitHdrNotIdx(uint32_t key_index, grpc_mdelem elem);
     void EmitLitHdrWithStringKeyIncIdx(grpc_mdelem elem);
+    void EmitLitHdrWithNonBinaryStringKeyIncIdx(const grpc_slice& key_slice,
+                                                const grpc_slice& value_slice);
     void EmitLitHdrWithStringKeyNotIdx(grpc_mdelem elem);
 
     size_t CurrentFrameSize() const;
@@ -187,7 +190,7 @@ class HPackCompressor {
   // a new literal should be added to the compression table or not.
   // They track a single integer that counts how often a particular value has
   // been seen. When that count reaches max (255), all values are halved.
-  grpc_core::PopularityCount<kNumFilterValues> filter_elems_;
+  PopularityCount<kNumFilterValues> filter_elems_;
 
   class KeyElem {
    public:
@@ -264,8 +267,9 @@ class HPackCompressor {
 
   // entry tables for keys & elems: these tables track values that have been
   // seen and *may* be in the decompressor table
-  grpc_core::HPackEncoderIndex<KeyElem, kNumFilterValues> elem_index_;
-  grpc_core::HPackEncoderIndex<KeySliceRef, kNumFilterValues> key_index_;
+  HPackEncoderIndex<KeyElem, kNumFilterValues> elem_index_;
+  HPackEncoderIndex<KeySliceRef, kNumFilterValues> key_index_;
+  uint32_t te_index_ = 0;
 };
 
 }  // namespace grpc_core

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

@@ -15,7 +15,7 @@
 #ifndef GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HPACK_ENCODER_INDEX_H
 #define GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HPACK_ENCODER_INDEX_H
 
-#include <grpc/impl/codegen/port_platform.h>
+#include <grpc/support/port_platform.h>
 
 #include "absl/types/optional.h"