grpc 1.62.0 → 1.64.0.pre1

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

@@ -0,0 +1,414 @@
+//
+//
+// Copyright 2015 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
+
+#include "src/core/lib/surface/legacy_channel.h"
+
+#include "absl/base/thread_annotations.h"
+#include "absl/log/check.h"
+#include "absl/status/status.h"
+#include "absl/types/optional.h"
+
+#include <grpc/event_engine/event_engine.h>
+#include <grpc/grpc.h>
+#include <grpc/impl/connectivity_state.h>
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
+
+#include "src/core/channelz/channelz.h"
+#include "src/core/client_channel/client_channel_filter.h"
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/channel/channel_fwd.h"
+#include "src/core/lib/channel/channel_stack.h"
+#include "src/core/lib/channel/channel_stack_builder_impl.h"
+#include "src/core/lib/channel/metrics.h"
+#include "src/core/lib/config/core_configuration.h"
+#include "src/core/lib/debug/stats.h"
+#include "src/core/lib/debug/stats_data.h"
+#include "src/core/lib/gprpp/crash.h"
+#include "src/core/lib/gprpp/dual_ref_counted.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/gprpp/sync.h"
+#include "src/core/lib/gprpp/time.h"
+#include "src/core/lib/iomgr/closure.h"
+#include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
+#include "src/core/lib/resource_quota/resource_quota.h"
+#include "src/core/lib/surface/call.h"
+#include "src/core/lib/surface/channel.h"
+#include "src/core/lib/surface/channel_init.h"
+#include "src/core/lib/surface/channel_stack_type.h"
+#include "src/core/lib/surface/completion_queue.h"
+#include "src/core/lib/surface/init_internally.h"
+#include "src/core/lib/surface/lame_client.h"
+#include "src/core/lib/transport/transport.h"
+
+namespace grpc_core {
+
+absl::StatusOr<OrphanablePtr<Channel>> LegacyChannel::Create(
+    std::string target, ChannelArgs args,
+    grpc_channel_stack_type channel_stack_type) {
+  if (grpc_channel_stack_type_is_client(channel_stack_type)) {
+    auto channel_args_mutator =
+        grpc_channel_args_get_client_channel_creation_mutator();
+    if (channel_args_mutator != nullptr) {
+      args = channel_args_mutator(target.c_str(), args, channel_stack_type);
+    }
+  }
+  ChannelStackBuilderImpl builder(
+      grpc_channel_stack_type_string(channel_stack_type), channel_stack_type,
+      args);
+  builder.SetTarget(target.c_str());
+  if (!CoreConfiguration::Get().channel_init().CreateStack(&builder)) {
+    return nullptr;
+  }
+  // Only need to update stats for server channels here.  Stats for client
+  // channels are handled in our base class.
+  if (builder.channel_stack_type() == GRPC_SERVER_CHANNEL) {
+    global_stats().IncrementServerChannelsCreated();
+  }
+  absl::StatusOr<RefCountedPtr<grpc_channel_stack>> r = builder.Build();
+  if (!r.ok()) {
+    auto status = r.status();
+    gpr_log(GPR_ERROR, "channel stack builder failed: %s",
+            status.ToString().c_str());
+    return status;
+  }
+  if (channel_stack_type == GRPC_SERVER_CHANNEL) {
+    *(*r)->stats_plugin_group =
+        GlobalStatsPluginRegistry::GetStatsPluginsForServer(args);
+  } else {
+    experimental::StatsPluginChannelScope scope(
+        target, args.GetOwnedString(GRPC_ARG_DEFAULT_AUTHORITY)
+                    .value_or(CoreConfiguration::Get()
+                                  .resolver_registry()
+                                  .GetDefaultAuthority(target)));
+    *(*r)->stats_plugin_group =
+        GlobalStatsPluginRegistry::GetStatsPluginsForChannel(scope);
+  }
+  return MakeOrphanable<LegacyChannel>(
+      grpc_channel_stack_type_is_client(builder.channel_stack_type()),
+      builder.IsPromising(), std::move(target), args, std::move(*r));
+}
+
+LegacyChannel::LegacyChannel(bool is_client, bool is_promising,
+                             std::string target,
+                             const ChannelArgs& channel_args,
+                             RefCountedPtr<grpc_channel_stack> channel_stack)
+    : Channel(std::move(target), channel_args),
+      is_client_(is_client),
+      is_promising_(is_promising),
+      channel_stack_(std::move(channel_stack)),
+      allocator_(channel_args.GetObject<ResourceQuota>()
+                     ->memory_quota()
+                     ->CreateMemoryOwner()) {
+  // We need to make sure that grpc_shutdown() does not shut things down
+  // until after the channel is destroyed.  However, the channel may not
+  // actually be destroyed by the time grpc_channel_destroy() returns,
+  // since there may be other existing refs to the channel.  If those
+  // refs are held by things that are visible to the wrapped language
+  // (such as outstanding calls on the channel), then the wrapped
+  // language can be responsible for making sure that grpc_shutdown()
+  // does not run until after those refs are released.  However, the
+  // channel may also have refs to itself held internally for various
+  // things that need to be cleaned up at channel destruction (e.g.,
+  // LB policies, subchannels, etc), and because these refs are not
+  // visible to the wrapped language, it cannot be responsible for
+  // deferring grpc_shutdown() until after they are released.  To
+  // accommodate that, we call grpc_init() here and then call
+  // grpc_shutdown() when the channel is actually destroyed, thus
+  // ensuring that shutdown is deferred until that point.
+  InitInternally();
+  RefCountedPtr<channelz::ChannelNode> node;
+  if (channelz_node() != nullptr) {
+    node = channelz_node()->RefAsSubclass<channelz::ChannelNode>();
+  }
+  *channel_stack_->on_destroy = [node = std::move(node)]() {
+    if (node != nullptr) {
+      node->AddTraceEvent(channelz::ChannelTrace::Severity::Info,
+                          grpc_slice_from_static_string("Channel destroyed"));
+    }
+    ShutdownInternally();
+  };
+}
+
+void LegacyChannel::Orphan() {
+  grpc_transport_op* op = grpc_make_transport_op(nullptr);
+  op->disconnect_with_error = GRPC_ERROR_CREATE("Channel Destroyed");
+  grpc_channel_element* elem =
+      grpc_channel_stack_element(channel_stack_.get(), 0);
+  elem->filter->start_transport_op(elem, op);
+  Unref();
+}
+
+bool LegacyChannel::IsLame() const {
+  grpc_channel_element* elem =
+      grpc_channel_stack_last_element(channel_stack_.get());
+  return elem->filter == &LameClientFilter::kFilter;
+}
+
+grpc_call* LegacyChannel::CreateCall(
+    grpc_call* parent_call, uint32_t propagation_mask,
+    grpc_completion_queue* cq, grpc_pollset_set* pollset_set_alternative,
+    Slice path, absl::optional<Slice> authority, Timestamp deadline,
+    bool registered_method) {
+  CHECK(is_client_);
+  CHECK(!(cq != nullptr && pollset_set_alternative != nullptr));
+  grpc_call_create_args args;
+  args.channel = Ref();
+  args.server = nullptr;
+  args.parent = parent_call;
+  args.propagation_mask = propagation_mask;
+  args.cq = cq;
+  args.pollset_set_alternative = pollset_set_alternative;
+  args.server_transport_data = nullptr;
+  args.path = std::move(path);
+  args.authority = std::move(authority);
+  args.send_deadline = deadline;
+  args.registered_method = registered_method;
+  grpc_call* call;
+  GRPC_LOG_IF_ERROR("call_create", grpc_call_create(&args, &call));
+  return call;
+}
+
+grpc_connectivity_state LegacyChannel::CheckConnectivityState(
+    bool try_to_connect) {
+  // Forward through to the underlying client channel.
+  ClientChannelFilter* client_channel = GetClientChannelFilter();
+  if (GPR_UNLIKELY(client_channel == nullptr)) {
+    if (IsLame()) return GRPC_CHANNEL_TRANSIENT_FAILURE;
+    gpr_log(GPR_ERROR,
+            "grpc_channel_check_connectivity_state called on something that is "
+            "not a client channel");
+    return GRPC_CHANNEL_SHUTDOWN;
+  }
+  return client_channel->CheckConnectivityState(try_to_connect);
+}
+
+bool LegacyChannel::SupportsConnectivityWatcher() const {
+  return GetClientChannelFilter() != nullptr;
+}
+
+// A fire-and-forget object to handle external connectivity state watches.
+class LegacyChannel::StateWatcher final : public DualRefCounted<StateWatcher> {
+ public:
+  StateWatcher(RefCountedPtr<LegacyChannel> channel, grpc_completion_queue* cq,
+               void* tag, grpc_connectivity_state last_observed_state,
+               Timestamp deadline)
+      : channel_(std::move(channel)),
+        cq_(cq),
+        tag_(tag),
+        state_(last_observed_state) {
+    CHECK(grpc_cq_begin_op(cq, tag));
+    GRPC_CLOSURE_INIT(&on_complete_, WatchComplete, this, nullptr);
+    ClientChannelFilter* client_channel = channel_->GetClientChannelFilter();
+    if (client_channel == nullptr) {
+      // If the target URI used to create the channel was invalid, channel
+      // stack initialization failed, and that caused us to create a lame
+      // channel.  In that case, connectivity state will never change (it
+      // will always be TRANSIENT_FAILURE), so we don't actually start a
+      // watch, but we are hiding that fact from the application.
+      if (channel_->IsLame()) {
+        // A ref is held by the timer callback.
+        StartTimer(deadline);
+        // Ref from object creation needs to be freed here since lame channel
+        // does not have a watcher.
+        Unref();
+        return;
+      }
+      Crash(
+          "grpc_channel_watch_connectivity_state called on something that is "
+          "not a client channel");
+    }
+    // Ref from object creation is held by the watcher callback.
+    auto* watcher_timer_init_state = new WatcherTimerInitState(this, deadline);
+    client_channel->AddExternalConnectivityWatcher(
+        grpc_polling_entity_create_from_pollset(grpc_cq_pollset(cq)), &state_,
+        &on_complete_, watcher_timer_init_state->closure());
+  }
+
+ private:
+  // A fire-and-forget object used to delay starting the timer until the
+  // ClientChannelFilter actually starts the watch.
+  class WatcherTimerInitState final {
+   public:
+    WatcherTimerInitState(StateWatcher* state_watcher, Timestamp deadline)
+        : state_watcher_(state_watcher), deadline_(deadline) {
+      GRPC_CLOSURE_INIT(&closure_, WatcherTimerInit, this, nullptr);
+    }
+
+    grpc_closure* closure() { return &closure_; }
+
+   private:
+    static void WatcherTimerInit(void* arg, grpc_error_handle /*error*/) {
+      auto* self = static_cast<WatcherTimerInitState*>(arg);
+      self->state_watcher_->StartTimer(self->deadline_);
+      delete self;
+    }
+
+    StateWatcher* state_watcher_;
+    Timestamp deadline_;
+    grpc_closure closure_;
+  };
+
+  void StartTimer(Timestamp deadline) {
+    const Duration timeout = deadline - Timestamp::Now();
+    MutexLock lock(&mu_);
+    timer_handle_ =
+        channel_->event_engine()->RunAfter(timeout, [self = Ref()]() mutable {
+          ApplicationCallbackExecCtx callback_exec_ctx;
+          ExecCtx exec_ctx;
+          self->TimeoutComplete();
+          // StateWatcher deletion might require an active ExecCtx.
+          self.reset();
+        });
+  }
+
+  void TimeoutComplete() {
+    timer_fired_ = true;
+    // If this is a client channel (not a lame channel), cancel the watch.
+    ClientChannelFilter* client_channel = channel_->GetClientChannelFilter();
+    if (client_channel != nullptr) {
+      client_channel->CancelExternalConnectivityWatcher(&on_complete_);
+    }
+  }
+
+  static void WatchComplete(void* arg, grpc_error_handle error) {
+    RefCountedPtr<StateWatcher> self(static_cast<StateWatcher*>(arg));
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_operation_failures)) {
+      GRPC_LOG_IF_ERROR("watch_completion_error", error);
+    }
+    MutexLock lock(&self->mu_);
+    if (self->timer_handle_.has_value()) {
+      self->channel_->event_engine()->Cancel(*self->timer_handle_);
+    }
+  }
+
+  // Invoked when both strong refs are released.
+  void Orphaned() override {
+    WeakRef().release();  // Take a weak ref until completion is finished.
+    grpc_error_handle error =
+        timer_fired_
+            ? GRPC_ERROR_CREATE("Timed out waiting for connection state change")
+            : absl::OkStatus();
+    grpc_cq_end_op(cq_, tag_, error, FinishedCompletion, this,
+                   &completion_storage_);
+  }
+
+  // Called when the completion is returned to the CQ.
+  static void FinishedCompletion(void* arg, grpc_cq_completion* /*ignored*/) {
+    auto* self = static_cast<StateWatcher*>(arg);
+    self->WeakUnref();
+  }
+
+  RefCountedPtr<LegacyChannel> channel_;
+  grpc_completion_queue* cq_;
+  void* tag_;
+
+  grpc_connectivity_state state_;
+  grpc_cq_completion completion_storage_;
+  grpc_closure on_complete_;
+
+  // timer_handle_ might be accessed in parallel from multiple threads, e.g.
+  // timer callback fired immediately on an EventEngine thread before
+  // RunAfter() returns.
+  Mutex mu_;
+  absl::optional<grpc_event_engine::experimental::EventEngine::TaskHandle>
+      timer_handle_ ABSL_GUARDED_BY(mu_);
+  bool timer_fired_ = false;
+};
+
+void LegacyChannel::WatchConnectivityState(
+    grpc_connectivity_state last_observed_state, Timestamp deadline,
+    grpc_completion_queue* cq, void* tag) {
+  new StateWatcher(RefAsSubclass<LegacyChannel>(), cq, tag, last_observed_state,
+                   deadline);
+}
+
+void LegacyChannel::AddConnectivityWatcher(
+    grpc_connectivity_state initial_state,
+    OrphanablePtr<AsyncConnectivityStateWatcherInterface> watcher) {
+  auto* client_channel = GetClientChannelFilter();
+  CHECK_NE(client_channel, nullptr);
+  client_channel->AddConnectivityWatcher(initial_state, std::move(watcher));
+}
+
+void LegacyChannel::RemoveConnectivityWatcher(
+    AsyncConnectivityStateWatcherInterface* watcher) {
+  auto* client_channel = GetClientChannelFilter();
+  CHECK_NE(client_channel, nullptr);
+  client_channel->RemoveConnectivityWatcher(watcher);
+}
+
+void LegacyChannel::GetInfo(const grpc_channel_info* channel_info) {
+  grpc_channel_element* elem =
+      grpc_channel_stack_element(channel_stack_.get(), 0);
+  elem->filter->get_channel_info(elem, channel_info);
+}
+
+void LegacyChannel::ResetConnectionBackoff() {
+  grpc_transport_op* op = grpc_make_transport_op(nullptr);
+  op->reset_connect_backoff = true;
+  grpc_channel_element* elem =
+      grpc_channel_stack_element(channel_stack_.get(), 0);
+  elem->filter->start_transport_op(elem, op);
+}
+
+namespace {
+
+struct ping_result {
+  grpc_closure closure;
+  void* tag;
+  grpc_completion_queue* cq;
+  grpc_cq_completion completion_storage;
+};
+void ping_destroy(void* arg, grpc_cq_completion* /*storage*/) { gpr_free(arg); }
+
+void ping_done(void* arg, grpc_error_handle error) {
+  ping_result* pr = static_cast<ping_result*>(arg);
+  grpc_cq_end_op(pr->cq, pr->tag, error, ping_destroy, pr,
+                 &pr->completion_storage);
+}
+
+}  // namespace
+
+void LegacyChannel::Ping(grpc_completion_queue* cq, void* tag) {
+  ping_result* pr = static_cast<ping_result*>(gpr_malloc(sizeof(*pr)));
+  pr->tag = tag;
+  pr->cq = cq;
+  GRPC_CLOSURE_INIT(&pr->closure, ping_done, pr, grpc_schedule_on_exec_ctx);
+  grpc_transport_op* op = grpc_make_transport_op(nullptr);
+  op->send_ping.on_ack = &pr->closure;
+  op->bind_pollset = grpc_cq_pollset(cq);
+  CHECK(grpc_cq_begin_op(cq, tag));
+  grpc_channel_element* top_elem =
+      grpc_channel_stack_element(channel_stack_.get(), 0);
+  top_elem->filter->start_transport_op(top_elem, op);
+}
+
+ClientChannelFilter* LegacyChannel::GetClientChannelFilter() const {
+  grpc_channel_element* elem =
+      grpc_channel_stack_last_element(channel_stack_.get());
+  if (elem->filter != &ClientChannelFilter::kFilterVtableWithPromises &&
+      elem->filter != &ClientChannelFilter::kFilterVtableWithoutPromises) {
+    return nullptr;
+  }
+  return static_cast<ClientChannelFilter*>(elem->channel_data);
+}
+
+}  // namespace grpc_core

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

@@ -0,0 +1,123 @@
+//
+//
+// Copyright 2015 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
+
+#ifndef GRPC_SRC_CORE_LIB_SURFACE_LEGACY_CHANNEL_H
+#define GRPC_SRC_CORE_LIB_SURFACE_LEGACY_CHANNEL_H
+
+#include <string>
+
+#include "absl/status/statusor.h"
+#include "absl/types/optional.h"
+
+#include <grpc/event_engine/event_engine.h>
+#include <grpc/grpc.h>
+#include <grpc/support/port_platform.h>
+
+#include "src/core/client_channel/client_channel_filter.h"
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/channel/channel_fwd.h"
+#include "src/core/lib/channel/channel_stack.h"  // IWYU pragma: keep
+#include "src/core/lib/debug/stats.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/gprpp/time.h"
+#include "src/core/lib/iomgr/iomgr_fwd.h"
+#include "src/core/lib/slice/slice.h"
+#include "src/core/lib/surface/channel.h"
+#include "src/core/lib/surface/channel_stack_type.h"
+#include "src/core/lib/transport/call_arena_allocator.h"
+
+namespace grpc_core {
+
+class LegacyChannel final : public Channel {
+ public:
+  static absl::StatusOr<OrphanablePtr<Channel>> Create(
+      std::string target, ChannelArgs args,
+      grpc_channel_stack_type channel_stack_type);
+
+  // Do not instantiate directly -- use Create() instead.
+  LegacyChannel(bool is_client, bool is_promising, std::string target,
+                const ChannelArgs& channel_args,
+                RefCountedPtr<grpc_channel_stack> channel_stack);
+
+  void Orphan() override;
+
+  Arena* CreateArena() override {
+    const size_t initial_size = call_size_estimator_.CallSizeEstimate();
+    global_stats().IncrementCallInitialSize(initial_size);
+    return Arena::Create(initial_size, &allocator_);
+  }
+  void DestroyArena(Arena* arena) override {
+    call_size_estimator_.UpdateCallSizeEstimate(arena->TotalUsedBytes());
+    arena->Destroy();
+  }
+
+  bool IsLame() const override;
+
+  grpc_call* CreateCall(grpc_call* parent_call, uint32_t propagation_mask,
+                        grpc_completion_queue* cq,
+                        grpc_pollset_set* pollset_set_alternative, Slice path,
+                        absl::optional<Slice> authority, Timestamp deadline,
+                        bool registered_method) override;
+
+  grpc_event_engine::experimental::EventEngine* event_engine() const override {
+    return channel_stack_->EventEngine();
+  }
+
+  bool SupportsConnectivityWatcher() const override;
+
+  grpc_connectivity_state CheckConnectivityState(bool try_to_connect) override;
+
+  void WatchConnectivityState(grpc_connectivity_state last_observed_state,
+                              Timestamp deadline, grpc_completion_queue* cq,
+                              void* tag) override;
+
+  void AddConnectivityWatcher(
+      grpc_connectivity_state initial_state,
+      OrphanablePtr<AsyncConnectivityStateWatcherInterface> watcher) override;
+  void RemoveConnectivityWatcher(
+      AsyncConnectivityStateWatcherInterface* watcher) override;
+
+  void GetInfo(const grpc_channel_info* channel_info) override;
+
+  void ResetConnectionBackoff() override;
+
+  void Ping(grpc_completion_queue* cq, void* tag) override;
+
+  bool is_client() const override { return is_client_; }
+  bool is_promising() const override { return is_promising_; }
+  grpc_channel_stack* channel_stack() const override {
+    return channel_stack_.get();
+  }
+
+ private:
+  class StateWatcher;
+
+  // Returns the client channel filter if this is a client channel,
+  // otherwise null.
+  ClientChannelFilter* GetClientChannelFilter() const;
+
+  const bool is_client_;
+  const bool is_promising_;
+  RefCountedPtr<grpc_channel_stack> channel_stack_;
+  CallSizeEstimator call_size_estimator_{1024};
+  grpc_event_engine::experimental::MemoryAllocator allocator_;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_LIB_SURFACE_LEGACY_CHANNEL_H

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

@@ -16,12 +16,11 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
 #include <string.h>
 
 #include <grpc/grpc.h>
 #include <grpc/support/alloc.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/surface/api_trace.h"

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

@@ -16,14 +16,13 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/surface/validate_metadata.h"
 
 #include "absl/status/status.h"
 #include "absl/strings/string_view.h"
 
 #include <grpc/grpc.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/gprpp/bitset.h"
 #include "src/core/lib/iomgr/error.h"

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

@@ -19,16 +19,16 @@
 #ifndef GRPC_SRC_CORE_LIB_SURFACE_VALIDATE_METADATA_H
 #define GRPC_SRC_CORE_LIB_SURFACE_VALIDATE_METADATA_H
 
-#include <grpc/support/port_platform.h>
-
 #include <stdint.h>
 
 #include <cstring>
 
+#include "absl/log/check.h"
 #include "absl/strings/string_view.h"
 
 #include <grpc/slice.h>
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/iomgr/error.h"
 
@@ -59,7 +59,7 @@ inline int grpc_key_is_binary_header(const uint8_t* buf, size_t length) {
   return 0 == memcmp(buf + length - 4, "-bin", 4);
 }
 inline int grpc_is_refcounted_slice_binary_header(const grpc_slice& slice) {
-  GPR_DEBUG_ASSERT(slice.refcount != nullptr);
+  DCHECK_NE(slice.refcount, nullptr);
   return grpc_key_is_binary_header(slice.data.refcounted.bytes,
                                    slice.data.refcounted.length);
 }

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

@@ -19,10 +19,9 @@
 // This file is autogenerated from:
 // templates/src/core/surface/version.c.template
 
-#include <grpc/support/port_platform.h>
-
 #include <grpc/grpc.h>
+#include <grpc/support/port_platform.h>
 
-const char* grpc_version_string(void) { return "39.0.0"; }
+const char* grpc_version_string(void) { return "41.0.0"; }
 
-const char* grpc_g_stands_for(void) { return "guardian"; }
+const char* grpc_g_stands_for(void) { return "grateful"; }

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

@@ -12,12 +12,12 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/surface/wait_for_cq_end_op.h"
 
 #include <atomic>
 
+#include <grpc/support/port_platform.h>
+
 #include "src/core/lib/gprpp/match.h"
 #include "src/core/lib/promise/trace.h"