grpc 1.39.0 → 1.41.0

data/src/core/lib/security/transport/security_handshaker.cc

@@ -22,6 +22,7 @@
 
 #include <stdbool.h>
 #include <string.h>
+
 #include <limits>
 
 #include <grpc/slice_buffer.h>
@@ -31,7 +32,7 @@
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channelz.h"
 #include "src/core/lib/channel/handshaker.h"
-#include "src/core/lib/channel/handshaker_registry.h"
+#include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/security/context/security_context.h"
 #include "src/core/lib/security/transport/secure_endpoint.h"
@@ -521,10 +522,18 @@ class FailHandshaker : public Handshaker {
   void Shutdown(grpc_error_handle why) override { GRPC_ERROR_UNREF(why); }
   void DoHandshake(grpc_tcp_server_acceptor* /*acceptor*/,
                    grpc_closure* on_handshake_done,
-                   HandshakerArgs* /*args*/) override {
-    ExecCtx::Run(DEBUG_LOCATION, on_handshake_done,
-                 GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-                     "Failed to create security handshaker"));
+                   HandshakerArgs* args) override {
+    grpc_error_handle error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+        "Failed to create security handshaker");
+    grpc_endpoint_shutdown(args->endpoint, GRPC_ERROR_REF(error));
+    grpc_endpoint_destroy(args->endpoint);
+    args->endpoint = nullptr;
+    grpc_channel_args_destroy(args->args);
+    args->args = nullptr;
+    grpc_slice_buffer_destroy_internal(args->read_buffer);
+    gpr_free(args->read_buffer);
+    args->read_buffer = nullptr;
+    ExecCtx::Run(DEBUG_LOCATION, on_handshake_done, error);
   }
 
  private:
@@ -585,11 +594,11 @@ RefCountedPtr<Handshaker> SecurityHandshakerCreate(
   }
 }
 
-void SecurityRegisterHandshakerFactories() {
-  HandshakerRegistry::RegisterHandshakerFactory(
+void SecurityRegisterHandshakerFactories(CoreConfiguration::Builder* builder) {
+  builder->handshaker_registry()->RegisterHandshakerFactory(
       false /* at_start */, HANDSHAKER_CLIENT,
       absl::make_unique<ClientSecurityHandshakerFactory>());
-  HandshakerRegistry::RegisterHandshakerFactory(
+  builder->handshaker_registry()->RegisterHandshakerFactory(
       false /* at_start */, HANDSHAKER_SERVER,
       absl::make_unique<ServerSecurityHandshakerFactory>());
 }

data/src/core/lib/security/transport/security_handshaker.h

@@ -22,6 +22,7 @@
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/channel/handshaker.h"
+#include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/security/security_connector/security_connector.h"
 
 namespace grpc_core {
@@ -32,7 +33,7 @@ RefCountedPtr<Handshaker> SecurityHandshakerCreate(
     const grpc_channel_args* args);
 
 /// Registers security handshaker factories.
-void SecurityRegisterHandshakerFactories();
+void SecurityRegisterHandshakerFactories(CoreConfiguration::Builder*);
 
 }  // namespace grpc_core
 

data/src/core/lib/security/transport/server_auth_filter.cc

@@ -306,13 +306,6 @@ static grpc_error_handle server_auth_init_channel_elem(
   GPR_ASSERT(!args->is_last);
   grpc_auth_context* auth_context =
       grpc_find_auth_context_in_args(args->channel_args);
-  if (auth_context == nullptr) {
-    grpc_error_handle error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-        "No authorization context found. This might be a TRANSIENT failure due "
-        "to certificates not having been loaded yet.");
-    gpr_log(GPR_DEBUG, "%s", grpc_error_std_string(error).c_str());
-    return error;
-  }
   GPR_ASSERT(auth_context != nullptr);
   grpc_server_credentials* creds =
       grpc_find_server_credentials_in_args(args->channel_args);

data/src/core/lib/security/util/json_util.cc

@@ -18,6 +18,8 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "src/core/lib/security/util/json_util.h"
+
 #include <string.h>
 
 #include "absl/strings/str_cat.h"
@@ -26,7 +28,6 @@
 #include <grpc/support/string_util.h>
 
 #include "src/core/lib/iomgr/error.h"
-#include "src/core/lib/security/util/json_util.h"
 
 const char* grpc_json_get_string_property(const grpc_core::Json& json,
                                           const char* prop_name,
@@ -41,18 +42,15 @@ const char* grpc_json_get_string_property(const grpc_core::Json& json,
   auto it = json.object_value().find(prop_name);
   if (it == json.object_value().end()) {
     if (error != nullptr) {
-      *error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(
-          absl::StrCat("Property ", prop_name, " not found in JSON object.")
-              .c_str());
+      *error = GRPC_ERROR_CREATE_FROM_CPP_STRING(
+          absl::StrCat("Property ", prop_name, " not found in JSON object."));
     }
     return nullptr;
   }
   if (it->second.type() != grpc_core::Json::Type::STRING) {
     if (error != nullptr) {
-      *error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(
-          absl::StrCat("Property ", prop_name,
-                       " n JSON object is not a string.")
-              .c_str());
+      *error = GRPC_ERROR_CREATE_FROM_CPP_STRING(absl::StrCat(
+          "Property ", prop_name, " n JSON object is not a string."));
     }
     return nullptr;
   }

data/src/core/lib/slice/percent_encoding.cc

@@ -20,28 +20,70 @@
 
 #include "src/core/lib/slice/percent_encoding.h"
 
+#include <cstdint>
+
 #include <grpc/support/log.h>
 
+#include "src/core/lib/gprpp/bitset.h"
 #include "src/core/lib/slice/slice_internal.h"
 
-const uint8_t grpc_url_percent_encoding_unreserved_bytes[256 / 8] = {
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0xff, 0x03, 0xfe, 0xff, 0xff,
-    0x87, 0xfe, 0xff, 0xff, 0x47, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
-const uint8_t grpc_compatible_percent_encoding_unreserved_bytes[256 / 8] = {
-    0x00, 0x00, 0x00, 0x00, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-    0xff, 0xff, 0xff, 0xff, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
-
-static bool is_unreserved_character(uint8_t c,
-                                    const uint8_t* unreserved_bytes) {
-  return ((unreserved_bytes[c / 8] >> (c % 8)) & 1) != 0;
+#if __cplusplus > 201103l
+#define GRPC_PCTENCODE_CONSTEXPR_FN constexpr
+#define GRPC_PCTENCODE_CONSTEXPR_VALUE constexpr
+#else
+#define GRPC_PCTENCODE_CONSTEXPR_FN
+#define GRPC_PCTENCODE_CONSTEXPR_VALUE const
+#endif
+
+namespace grpc_core {
+
+namespace {
+class UrlTable : public BitSet<256> {
+ public:
+  GRPC_PCTENCODE_CONSTEXPR_FN UrlTable() {
+    for (int i = 'a'; i <= 'z'; i++) set(i);
+    for (int i = 'A'; i <= 'Z'; i++) set(i);
+    for (int i = '0'; i <= '9'; i++) set(i);
+    set('-');
+    set('_');
+    set('.');
+    set('~');
+  }
+};
+
+static GRPC_PCTENCODE_CONSTEXPR_VALUE UrlTable g_url_table;
+
+class CompatibleTable : public BitSet<256> {
+ public:
+  GRPC_PCTENCODE_CONSTEXPR_FN CompatibleTable() {
+    for (int i = 32; i <= 126; i++) {
+      if (i == '%') continue;
+      set(i);
+    }
+  }
+};
+
+static GRPC_PCTENCODE_CONSTEXPR_VALUE CompatibleTable g_compatible_table;
+
+// Map PercentEncodingType to a lookup table of legal symbols for that encoding.
+const BitSet<256>& LookupTableForPercentEncodingType(PercentEncodingType type) {
+  switch (type) {
+    case PercentEncodingType::URL:
+      return g_url_table;
+    case PercentEncodingType::Compatible:
+      return g_compatible_table;
+  }
+  // Crash if a bad PercentEncodingType was passed in.
+  GPR_UNREACHABLE_CODE(abort());
 }
+}  // namespace
 
-grpc_slice grpc_percent_encode_slice(const grpc_slice& slice,
-                                     const uint8_t* unreserved_bytes) {
+grpc_slice PercentEncodeSlice(const grpc_slice& slice,
+                              PercentEncodingType type) {
   static const uint8_t hex[] = "0123456789ABCDEF";
 
+  const BitSet<256>& lut = LookupTableForPercentEncodingType(type);
+
   // first pass: count the number of bytes needed to output this string
   size_t output_length = 0;
   const uint8_t* slice_start = GRPC_SLICE_START_PTR(slice);
@@ -49,7 +91,7 @@ grpc_slice grpc_percent_encode_slice(const grpc_slice& slice,
   const uint8_t* p;
   bool any_reserved_bytes = false;
   for (p = slice_start; p < slice_end; p++) {
-    bool unres = is_unreserved_character(*p, unreserved_bytes);
+    bool unres = lut.is_set(*p);
     output_length += unres ? 1 : 3;
     any_reserved_bytes |= !unres;
   }
@@ -61,7 +103,7 @@ grpc_slice grpc_percent_encode_slice(const grpc_slice& slice,
   grpc_slice out = GRPC_SLICE_MALLOC(output_length);
   uint8_t* q = GRPC_SLICE_START_PTR(out);
   for (p = slice_start; p < slice_end; p++) {
-    if (is_unreserved_character(*p, unreserved_bytes)) {
+    if (lut.is_set(*p)) {
       *q++ = *p;
     } else {
       *q++ = '%';
@@ -86,34 +128,33 @@ static uint8_t dehex(uint8_t c) {
   GPR_UNREACHABLE_CODE(return 255);
 }
 
-bool grpc_strict_percent_decode_slice(const grpc_slice& slice_in,
-                                      const uint8_t* unreserved_bytes,
-                                      grpc_slice* slice_out) {
+absl::optional<grpc_slice> PercentDecodeSlice(const grpc_slice& slice_in,
+                                              PercentEncodingType type) {
   const uint8_t* p = GRPC_SLICE_START_PTR(slice_in);
   const uint8_t* in_end = GRPC_SLICE_END_PTR(slice_in);
   size_t out_length = 0;
   bool any_percent_encoded_stuff = false;
+  const BitSet<256>& lut = LookupTableForPercentEncodingType(type);
   while (p != in_end) {
     if (*p == '%') {
-      if (!valid_hex(++p, in_end)) return false;
-      if (!valid_hex(++p, in_end)) return false;
+      if (!valid_hex(++p, in_end)) return {};
+      if (!valid_hex(++p, in_end)) return {};
       p++;
       out_length++;
       any_percent_encoded_stuff = true;
-    } else if (is_unreserved_character(*p, unreserved_bytes)) {
+    } else if (lut.is_set(*p)) {
       p++;
       out_length++;
     } else {
-      return false;
+      return {};
     }
   }
   if (!any_percent_encoded_stuff) {
-    *slice_out = grpc_slice_ref_internal(slice_in);
-    return true;
+    return grpc_slice_ref_internal(slice_in);
   }
   p = GRPC_SLICE_START_PTR(slice_in);
-  *slice_out = GRPC_SLICE_MALLOC(out_length);
-  uint8_t* q = GRPC_SLICE_START_PTR(*slice_out);
+  grpc_slice slice_out = GRPC_SLICE_MALLOC(out_length);
+  uint8_t* q = GRPC_SLICE_START_PTR(slice_out);
   while (p != in_end) {
     if (*p == '%') {
       *q++ = static_cast<uint8_t>(dehex(p[1]) << 4) | (dehex(p[2]));
@@ -122,11 +163,11 @@ bool grpc_strict_percent_decode_slice(const grpc_slice& slice_in,
       *q++ = *p++;
     }
   }
-  GPR_ASSERT(q == GRPC_SLICE_END_PTR(*slice_out));
-  return true;
+  GPR_ASSERT(q == GRPC_SLICE_END_PTR(slice_out));
+  return slice_out;
 }
 
-grpc_slice grpc_permissive_percent_decode_slice(const grpc_slice& slice_in) {
+grpc_slice PermissivePercentDecodeSlice(const grpc_slice& slice_in) {
   const uint8_t* p = GRPC_SLICE_START_PTR(slice_in);
   const uint8_t* in_end = GRPC_SLICE_END_PTR(slice_in);
   size_t out_length = 0;
@@ -167,3 +208,5 @@ grpc_slice grpc_permissive_percent_decode_slice(const grpc_slice& slice_in) {
   GPR_ASSERT(q == GRPC_SLICE_END_PTR(out));
   return out;
 }
+
+}  // namespace grpc_core

data/src/core/lib/slice/percent_encoding.h

@@ -30,36 +30,37 @@
 
 #include <stdbool.h>
 
+#include "absl/types/optional.h"
+
 #include <grpc/slice.h>
 
-/* URL percent encoding spec bitfield (usabel as 'unreserved_bytes' in
-   grpc_percent_encode_slice, grpc_strict_percent_decode_slice).
-   Flags [A-Za-z0-9-_.~] as unreserved bytes for the percent encoding routines
-   */
-extern const uint8_t grpc_url_percent_encoding_unreserved_bytes[256 / 8];
-/* URL percent encoding spec bitfield (usabel as 'unreserved_bytes' in
-   grpc_percent_encode_slice, grpc_strict_percent_decode_slice).
-   Flags ascii7 non-control characters excluding '%' as unreserved bytes for the
-   percent encoding routines */
-extern const uint8_t grpc_compatible_percent_encoding_unreserved_bytes[256 / 8];
+namespace grpc_core {
+
+enum class PercentEncodingType {
+  // Flags [A-Za-z0-9-_.~] as unreserved bytes for the percent encoding routines
+  URL,
+  // Flags ascii7 non-control characters excluding '%' as unreserved bytes for
+  // the
+  // percent encoding routines
+  Compatible
+};
+
+// Percent-encode a slice, returning the new slice (this cannot fail):
+// unreserved_bytes is a bitfield indicating which bytes are considered
+// unreserved and thus do not need percent encoding
+grpc_slice PercentEncodeSlice(const grpc_slice& slice,
+                              PercentEncodingType type);
+// Percent-decode a slice, strictly.
+// If the input is legal (contains no unreserved bytes, and legal % encodings),
+// returns the decoded slice.
+// If the input is not legal, returns {}.
+absl::optional<grpc_slice> PercentDecodeSlice(const grpc_slice& slice_in,
+                                              PercentEncodingType type);
+// Percent-decode a slice, permissively.
+// If a % triplet can not be decoded, pass it through verbatim.
+// This cannot fail.
+grpc_slice PermissivePercentDecodeSlice(const grpc_slice& slice_in);
 
-/* Percent-encode a slice, returning the new slice (this cannot fail):
-   unreserved_bytes is a bitfield indicating which bytes are considered
-   unreserved and thus do not need percent encoding */
-grpc_slice grpc_percent_encode_slice(const grpc_slice& slice,
-                                     const uint8_t* unreserved_bytes);
-/* Percent-decode a slice, strictly.
-   If the input is legal (contains no unreserved bytes, and legal % encodings),
-   returns true and sets *slice_out to the decoded slice.
-   If the input is not legal, returns false and leaves *slice_out untouched.
-   unreserved_bytes is a bitfield indicating which bytes are considered
-   unreserved and thus do not need percent encoding */
-bool grpc_strict_percent_decode_slice(const grpc_slice& slice_in,
-                                      const uint8_t* unreserved_bytes,
-                                      grpc_slice* slice_out);
-/* Percent-decode a slice, permissively.
-   If a % triplet can not be decoded, pass it through verbatim.
-   This cannot fail. */
-grpc_slice grpc_permissive_percent_decode_slice(const grpc_slice& slice_in);
+}  // namespace grpc_core
 
 #endif /* GRPC_CORE_LIB_SLICE_PERCENT_ENCODING_H */

data/src/core/lib/slice/slice.cc

@@ -18,17 +18,16 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/slice/slice_internal.h"
+#include <string.h>
 
 #include <grpc/slice.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
-#include <string.h>
-
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
+#include "src/core/lib/slice/slice_internal.h"
 
 char* grpc_slice_to_c_string(grpc_slice slice) {
   char* out = static_cast<char*>(gpr_malloc(GRPC_SLICE_LENGTH(slice) + 1));
@@ -223,11 +222,21 @@ grpc_core::UnmanagedMemorySlice::UnmanagedMemorySlice(const char* source)
                                                             strlen(source)) {}
 
 grpc_slice grpc_slice_from_copied_buffer(const char* source, size_t length) {
-  return grpc_core::UnmanagedMemorySlice(source, length);
+  grpc_slice slice;
+  if (length <= sizeof(slice.data.inlined.bytes)) {
+    slice.refcount = nullptr;
+    slice.data.inlined.length = length;
+  } else {
+    // Create a ref-counted slice.
+    slice = grpc_core::UnmanagedMemorySlice(
+        length, grpc_core::UnmanagedMemorySlice::ForceHeapAllocation());
+  }
+  memcpy(GRPC_SLICE_START_PTR(slice), source, length);
+  return slice;
 }
 
 grpc_slice grpc_slice_from_copied_string(const char* source) {
-  return grpc_core::UnmanagedMemorySlice(source, strlen(source));
+  return grpc_slice_from_copied_buffer(source, strlen(source));
 }
 
 grpc_slice grpc_slice_from_moved_buffer(grpc_core::UniquePtr<char> p,

data/src/core/lib/slice/slice_buffer.cc

@@ -18,10 +18,9 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <grpc/slice_buffer.h>
-
 #include <string.h>
 
+#include <grpc/slice_buffer.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 

data/src/core/lib/slice/slice_intern.cc

@@ -18,9 +18,6 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/slice/slice_internal.h"
-#include "src/core/lib/slice/slice_utils.h"
-
 #include <inttypes.h>
 #include <string.h>
 
@@ -31,7 +28,9 @@
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/iomgr/iomgr_internal.h" /* for iomgr_abort_on_leaks() */
 #include "src/core/lib/profiling/timers.h"
+#include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/slice/slice_string_helpers.h"
+#include "src/core/lib/slice/slice_utils.h"
 #include "src/core/lib/transport/static_metadata.h"
 
 #define LOG2_SHARD_COUNT 5

data/src/core/lib/slice/slice_internal.h

@@ -21,11 +21,11 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <grpc/support/log.h>
+#include <string.h>
 
 #include <grpc/slice.h>
 #include <grpc/slice_buffer.h>
-#include <string.h>
+#include <grpc/support/log.h>
 
 #include "src/core/lib/gpr/murmur_hash.h"
 #include "src/core/lib/gprpp/memory.h"
@@ -231,6 +231,7 @@ inline int grpc_slice_refcount::Eq(const grpc_slice& a, const grpc_slice& b) {
       GPR_DEBUG_ASSERT(
           (GRPC_STATIC_METADATA_INDEX(a) == GRPC_STATIC_METADATA_INDEX(b)) ==
           (a.refcount == b.refcount));
+      ABSL_FALLTHROUGH_INTENDED;
     case Type::INTERNED:
       return a.refcount == b.refcount;
     case Type::NOP:

data/src/core/lib/surface/api_trace.cc

@@ -18,7 +18,8 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/debug/trace.h"
 #include "src/core/lib/surface/api_trace.h"
 
+#include "src/core/lib/debug/trace.h"
+
 grpc_core::TraceFlag grpc_api_trace(false, "api");

data/src/core/lib/surface/api_trace.h

@@ -22,6 +22,7 @@
 #include <grpc/support/port_platform.h>
 
 #include <grpc/support/log.h>
+
 #include "src/core/lib/debug/trace.h"
 
 extern grpc_core::TraceFlag grpc_api_trace;

data/src/core/lib/surface/byte_buffer_reader.cc

@@ -18,10 +18,10 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <grpc/byte_buffer_reader.h>
 #include <string.h>
 
 #include <grpc/byte_buffer.h>
+#include <grpc/byte_buffer_reader.h>
 #include <grpc/grpc.h>
 #include <grpc/slice_buffer.h>
 #include <grpc/support/alloc.h>

data/src/core/lib/surface/call.cc

@@ -18,6 +18,8 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "src/core/lib/surface/call.h"
+
 #include <assert.h>
 #include <limits.h>
 #include <stdio.h>
@@ -51,7 +53,6 @@
 #include "src/core/lib/slice/slice_string_helpers.h"
 #include "src/core/lib/slice/slice_utils.h"
 #include "src/core/lib/surface/api_trace.h"
-#include "src/core/lib/surface/call.h"
 #include "src/core/lib/surface/call_test_only.h"
 #include "src/core/lib/surface/channel.h"
 #include "src/core/lib/surface/completion_queue.h"
@@ -105,13 +106,13 @@ struct batch_control {
   } completion_data;
   grpc_closure start_batch;
   grpc_closure finish_batch;
-  grpc_core::Atomic<intptr_t> steps_to_complete;
+  std::atomic<intptr_t> steps_to_complete{0};
   gpr_atm batch_error = reinterpret_cast<gpr_atm>(GRPC_ERROR_NONE);
   void set_num_steps_to_complete(uintptr_t steps) {
-    steps_to_complete.Store(steps, grpc_core::MemoryOrder::RELEASE);
+    steps_to_complete.store(steps, std::memory_order_release);
   }
   bool completed_batch_step() {
-    return steps_to_complete.FetchSub(1, grpc_core::MemoryOrder::ACQ_REL) == 1;
+    return steps_to_complete.fetch_sub(1, std::memory_order_acq_rel) == 1;
   }
 };
 
@@ -151,6 +152,11 @@ struct grpc_call {
   }
 
   ~grpc_call() {
+    for (int i = 0; i < GRPC_CONTEXT_COUNT; ++i) {
+      if (context[i].destroy) {
+        context[i].destroy(context[i].value);
+      }
+    }
     gpr_free(static_cast<void*>(const_cast<char*>(final_info.error_string)));
   }
 
@@ -554,11 +560,6 @@ static void destroy_call(void* call, grpc_error_handle /*error*/) {
   for (ii = 0; ii < c->send_extra_metadata_count; ii++) {
     GRPC_MDELEM_UNREF(c->send_extra_metadata[ii].md);
   }
-  for (i = 0; i < GRPC_CONTEXT_COUNT; i++) {
-    if (c->context[i].destroy) {
-      c->context[i].destroy(c->context[i].value);
-    }
-  }
   if (c->cq) {
     GRPC_CQ_INTERNAL_UNREF(c->cq, "bind");
   }
@@ -1065,10 +1066,10 @@ static void recv_trailing_filter(void* args, grpc_metadata_batch* b,
     grpc_error_handle error = GRPC_ERROR_NONE;
     if (status_code != GRPC_STATUS_OK) {
       char* peer = grpc_call_get_peer(call);
-      error = grpc_error_set_int(
-          GRPC_ERROR_CREATE_FROM_COPIED_STRING(
-              absl::StrCat("Error received from peer ", peer).c_str()),
-          GRPC_ERROR_INT_GRPC_STATUS, static_cast<intptr_t>(status_code));
+      error = grpc_error_set_int(GRPC_ERROR_CREATE_FROM_CPP_STRING(absl::StrCat(
+                                     "Error received from peer ", peer)),
+                                 GRPC_ERROR_INT_GRPC_STATUS,
+                                 static_cast<intptr_t>(status_code));
       gpr_free(peer);
     }
     if (b->idx.named.grpc_message != nullptr) {
@@ -1625,7 +1626,6 @@ static grpc_call_error call_start_batch(grpc_call* call, const grpc_op* ops,
         grpc_metadata& compression_md = call->compression_md;
         compression_md.key = grpc_empty_slice();
         compression_md.value = grpc_empty_slice();
-        compression_md.flags = 0;
         size_t additional_metadata_count = 0;
         grpc_compression_level effective_compression_level =
             GRPC_COMPRESS_LEVEL_NONE;

data/src/core/lib/surface/call.h

@@ -21,15 +21,15 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <grpc/grpc.h>
+#include <grpc/impl/codegen/compression_types.h>
+
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/channel/context.h"
 #include "src/core/lib/gprpp/arena.h"
 #include "src/core/lib/surface/api_trace.h"
 #include "src/core/lib/surface/server.h"
 
-#include <grpc/grpc.h>
-#include <grpc/impl/codegen/compression_types.h>
-
 typedef void (*grpc_ioreq_completion_func)(grpc_call* call, int success,
                                            void* user_data);
 

data/src/core/lib/surface/call_details.cc

@@ -18,11 +18,11 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <string.h>
+
 #include <grpc/grpc.h>
 #include <grpc/support/alloc.h>
 
-#include <string.h>
-
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/surface/api_trace.h"

data/src/core/lib/surface/call_log_batch.cc

@@ -18,8 +18,6 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/surface/call.h"
-
 #include <inttypes.h>
 
 #include <vector>
@@ -29,8 +27,10 @@
 
 #include <grpc/support/alloc.h>
 #include <grpc/support/string_util.h>
+
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/slice/slice_string_helpers.h"
+#include "src/core/lib/surface/call.h"
 
 static void add_metadata(const grpc_metadata* md, size_t count,
                          std::vector<std::string>* b) {