grpc 1.63.0 → 1.64.0.pre1

data/src/core/client_channel/client_channel_filter.cc

@@ -30,6 +30,7 @@
 #include <vector>
 
 #include "absl/cleanup/cleanup.h"
+#include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/cord.h"
@@ -49,8 +50,8 @@
 #include <grpc/support/string_util.h>
 #include <grpc/support/time.h>
 
+#include "src/core/channelz/channel_trace.h"
 #include "src/core/client_channel/backup_poller.h"
-#include "src/core/client_channel/client_channel_channelz.h"
 #include "src/core/client_channel/client_channel_internal.h"
 #include "src/core/client_channel/client_channel_service_config.h"
 #include "src/core/client_channel/config_selector.h"
@@ -60,10 +61,9 @@
 #include "src/core/client_channel/retry_filter.h"
 #include "src/core/client_channel/subchannel.h"
 #include "src/core/client_channel/subchannel_interface_internal.h"
-#include "src/core/ext/filters/deadline/deadline_filter.h"
+#include "src/core/handshaker/proxy_mapper_registry.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_stack.h"
-#include "src/core/lib/channel/channel_trace.h"
 #include "src/core/lib/channel/status_util.h"
 #include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/debug/trace.h"
@@ -76,7 +76,6 @@
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/gprpp/unique_type_name.h"
 #include "src/core/lib/gprpp/work_serializer.h"
-#include "src/core/lib/handshaker/proxy_mapper_registry.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/polling_entity.h"
 #include "src/core/lib/iomgr/pollset_set.h"
@@ -210,14 +209,14 @@ class ClientChannelFilter::FilterBasedCallData final
                       const grpc_call_element_args& args);
   ~FilterBasedCallData() override;
 
-  grpc_call_element* elem() const { return deadline_state_.elem; }
-  grpc_call_stack* owning_call() const { return deadline_state_.call_stack; }
-  CallCombiner* call_combiner() const { return deadline_state_.call_combiner; }
+  grpc_call_element* elem() const { return elem_; }
+  grpc_call_stack* owning_call() const { return owning_call_; }
+  CallCombiner* call_combiner() const { return call_combiner_; }
 
   ClientChannelFilter* chand() const override {
     return static_cast<ClientChannelFilter*>(elem()->channel_data);
   }
-  Arena* arena() const override { return deadline_state_.arena; }
+  Arena* arena() const override { return arena_; }
   grpc_polling_entity* pollent() override { return pollent_; }
   grpc_metadata_batch* send_initial_metadata() override {
     return pending_batches_[0]
@@ -270,10 +269,8 @@ class ClientChannelFilter::FilterBasedCallData final
   void ResetDeadline(Duration timeout) override {
     const Timestamp per_method_deadline =
         Timestamp::FromCycleCounterRoundUp(call_start_time_) + timeout;
-    if (per_method_deadline < deadline_) {
-      deadline_ = per_method_deadline;
-      grpc_deadline_state_reset(&deadline_state_, deadline_);
-    }
+    static_cast<Call*>(call_context_[GRPC_CONTEXT_CALL].value)
+        ->UpdateDeadline(per_method_deadline);
   }
 
   void CreateDynamicCall();
@@ -286,8 +283,10 @@ class ClientChannelFilter::FilterBasedCallData final
   gpr_cycle_counter call_start_time_;
   Timestamp deadline_;
 
-  // State for handling deadlines.
-  grpc_deadline_state deadline_state_;
+  Arena* const arena_;
+  grpc_call_element* const elem_;
+  grpc_call_stack* const owning_call_;
+  CallCombiner* const call_combiner_;
 
   grpc_polling_entity* pollent_ = nullptr;
 
@@ -387,11 +386,12 @@ class ClientChannelFilter::PromiseBasedCallData final
   }
 
   void ResetDeadline(Duration timeout) override {
+    Call* call = GetContext<Call>();
     CallContext* call_context = GetContext<CallContext>();
     const Timestamp per_method_deadline =
         Timestamp::FromCycleCounterRoundUp(call_context->call_start_time()) +
         timeout;
-    call_context->UpdateDeadline(per_method_deadline);
+    call->UpdateDeadline(per_method_deadline);
   }
 
   ClientChannelFilter* chand_;
@@ -459,8 +459,8 @@ class DynamicTerminationFilter final {
 
   static grpc_error_handle Init(grpc_channel_element* elem,
                                 grpc_channel_element_args* args) {
-    GPR_ASSERT(args->is_last);
-    GPR_ASSERT(elem->filter == &kFilterVtable);
+    CHECK(args->is_last);
+    CHECK(elem->filter == &kFilterVtable);
     new (elem->channel_data) DynamicTerminationFilter(args->channel_args);
     return absl::OkStatus();
   }
@@ -644,7 +644,9 @@ class ClientChannelFilter::SubchannelWrapper final
               chand, this, subchannel_.get());
     }
     GRPC_CHANNEL_STACK_REF(chand_->owning_stack_, "SubchannelWrapper");
-    GPR_DEBUG_ASSERT(chand_->work_serializer_->RunningInWorkSerializer());
+#ifndef NDEBUG
+    DCHECK(chand_->work_serializer_->RunningInWorkSerializer());
+#endif
     if (chand_->channelz_node_ != nullptr) {
       auto* subchannel_node = subchannel_->channelz_node();
       if (subchannel_node != nullptr) {
@@ -672,7 +674,7 @@ class ClientChannelFilter::SubchannelWrapper final
         auto* subchannel_node = subchannel_->channelz_node();
         if (subchannel_node != nullptr) {
           auto it = chand_->subchannel_refcount_map_.find(subchannel_.get());
-          GPR_ASSERT(it != chand_->subchannel_refcount_map_.end());
+          CHECK(it != chand_->subchannel_refcount_map_.end());
           --it->second;
           if (it->second == 0) {
             chand_->channelz_node_->RemoveChildSubchannel(
@@ -699,7 +701,7 @@ class ClientChannelFilter::SubchannelWrapper final
             if (subchannel_node != nullptr) {
               auto it =
                   chand_->subchannel_refcount_map_.find(subchannel_.get());
-              GPR_ASSERT(it != chand_->subchannel_refcount_map_.end());
+              CHECK(it != chand_->subchannel_refcount_map_.end());
               --it->second;
               if (it->second == 0) {
                 chand_->channelz_node_->RemoveChildSubchannel(
@@ -717,7 +719,7 @@ class ClientChannelFilter::SubchannelWrapper final
       std::unique_ptr<ConnectivityStateWatcherInterface> watcher) override
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(*chand_->work_serializer_) {
     auto& watcher_wrapper = watcher_map_[watcher.get()];
-    GPR_ASSERT(watcher_wrapper == nullptr);
+    CHECK_EQ(watcher_wrapper, nullptr);
     watcher_wrapper = new WatcherWrapper(
         std::move(watcher),
         RefAsSubclass<SubchannelWrapper>(DEBUG_LOCATION, "WatcherWrapper"));
@@ -729,7 +731,7 @@ class ClientChannelFilter::SubchannelWrapper final
   void CancelConnectivityStateWatch(ConnectivityStateWatcherInterface* watcher)
       override ABSL_EXCLUSIVE_LOCKS_REQUIRED(*chand_->work_serializer_) {
     auto it = watcher_map_.find(watcher);
-    GPR_ASSERT(it != watcher_map_.end());
+    CHECK(it != watcher_map_.end());
     subchannel_->CancelConnectivityStateWatch(it->second);
     watcher_map_.erase(it);
   }
@@ -746,7 +748,7 @@ class ClientChannelFilter::SubchannelWrapper final
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(*chand_->work_serializer_) {
     static_cast<InternalSubchannelDataWatcherInterface*>(watcher.get())
         ->SetSubchannel(subchannel_.get());
-    GPR_ASSERT(data_watchers_.insert(std::move(watcher)).second);
+    CHECK(data_watchers_.insert(std::move(watcher)).second);
   }
 
   void CancelDataWatcher(DataWatcherInterface* watcher) override
@@ -922,7 +924,7 @@ ClientChannelFilter::ExternalConnectivityWatcher::ExternalConnectivityWatcher(
   {
     MutexLock lock(&chand_->external_watchers_mu_);
     // Will be deleted when the watch is complete.
-    GPR_ASSERT(chand->external_watchers_[on_complete] == nullptr);
+    CHECK(chand->external_watchers_[on_complete] == nullptr);
     // Store a ref to the watcher in the external_watchers_ map.
     chand->external_watchers_[on_complete] =
         RefAsSubclass<ExternalConnectivityWatcher>(
@@ -1200,9 +1202,9 @@ class ClientChannelFilter::ClientChannelControlHelper final
 
 grpc_error_handle ClientChannelFilter::Init(grpc_channel_element* elem,
                                             grpc_channel_element_args* args) {
-  GPR_ASSERT(args->is_last);
-  GPR_ASSERT(elem->filter == &kFilterVtableWithPromises ||
-             elem->filter == &kFilterVtableWithoutPromises);
+  CHECK(args->is_last);
+  CHECK(elem->filter == &kFilterVtableWithPromises ||
+        elem->filter == &kFilterVtableWithoutPromises);
   grpc_error_handle error;
   new (elem->channel_data) ClientChannelFilter(args, &error);
   return error;
@@ -1228,9 +1230,6 @@ RefCountedPtr<SubchannelPoolInterface> GetSubchannelPool(
 ClientChannelFilter::ClientChannelFilter(grpc_channel_element_args* args,
                                          grpc_error_handle* error)
     : channel_args_(args->channel_args),
-      deadline_checking_enabled_(
-          channel_args_.GetBool(GRPC_ARG_ENABLE_DEADLINE_CHECKS)
-              .value_or(!channel_args_.WantMinimalStack())),
       owning_stack_(args->channel_stack),
       client_channel_factory_(channel_args_.GetObject<ClientChannelFactory>()),
       channelz_node_(channel_args_.GetObject<channelz::ChannelNode>()),
@@ -1448,7 +1447,7 @@ RefCountedPtr<LoadBalancingPolicy::Config> ChooseLbPolicy(
   // - A channel arg, in which case we check that the specified policy exists
   //   and accepts an empty config. If not, we revert to using pick_first
   //   lb_policy
-  GPR_ASSERT(lb_policy_config.ok());
+  CHECK(lb_policy_config.ok());
   return std::move(*lb_policy_config);
 }
 
@@ -1728,7 +1727,7 @@ void ClientChannelFilter::UpdateServiceConfigInDataPlaneLocked() {
   }
   RefCountedPtr<DynamicFilters> dynamic_filters =
       DynamicFilters::Create(new_args, std::move(filters));
-  GPR_ASSERT(dynamic_filters != nullptr);
+  CHECK(dynamic_filters != nullptr);
   // Grab data plane lock to update service config.
   //
   // We defer unreffing the old values (and deallocating memory) until
@@ -1759,7 +1758,7 @@ void ClientChannelFilter::CreateResolverLocked() {
       std::make_unique<ResolverResultHandler>(this));
   // Since the validity of the args was checked when the channel was created,
   // CreateResolver() must return a non-null result.
-  GPR_ASSERT(resolver_ != nullptr);
+  CHECK(resolver_ != nullptr);
   UpdateStateLocked(GRPC_CHANNEL_CONNECTING, absl::Status(),
                     "started resolving");
   resolver_->StartLocked();
@@ -1868,7 +1867,7 @@ T HandlePickResult(
   }
   auto* drop_pick =
       absl::get_if<LoadBalancingPolicy::PickResult::Drop>(&result->result);
-  GPR_ASSERT(drop_pick != nullptr);
+  CHECK_NE(drop_pick, nullptr);
   return drop_func(drop_pick);
 }
 
@@ -1962,7 +1961,7 @@ void ClientChannelFilter::StartTransportOpLocked(grpc_transport_op* op) {
       }
     } else {
       // Disconnect.
-      GPR_ASSERT(disconnect_error_.ok());
+      CHECK(disconnect_error_.ok());
       disconnect_error_ = op->disconnect_with_error;
       UpdateStateAndPickerLocked(
           GRPC_CHANNEL_SHUTDOWN, absl::Status(), "shutdown from API",
@@ -1980,7 +1979,7 @@ void ClientChannelFilter::StartTransportOpLocked(grpc_transport_op* op) {
 void ClientChannelFilter::StartTransportOp(grpc_channel_element* elem,
                                            grpc_transport_op* op) {
   auto* chand = static_cast<ClientChannelFilter*>(elem->channel_data);
-  GPR_ASSERT(op->set_accept_stream == false);
+  CHECK(op->set_accept_stream == false);
   // Handle bind_pollset.
   if (op->bind_pollset != nullptr) {
     grpc_pollset_set_add_pollset(chand->interested_parties_, op->bind_pollset);
@@ -2110,8 +2109,7 @@ grpc_error_handle ClientChannelFilter::CallData::ApplyServiceConfigToCallLocked(
   if (method_params != nullptr) {
     // If the deadline from the service config is shorter than the one
     // from the client API, reset the deadline timer.
-    if (chand()->deadline_checking_enabled_ &&
-        method_params->timeout() != Duration::Zero()) {
+    if (method_params->timeout() != Duration::Zero()) {
       ResetDeadline(method_params->timeout());
     }
     // If the service config set wait_for_ready and the application
@@ -2211,12 +2209,10 @@ ClientChannelFilter::FilterBasedCallData::FilterBasedCallData(
       call_context_(args.context),
       call_start_time_(args.start_time),
       deadline_(args.deadline),
-      deadline_state_(
-          elem, args,
-          GPR_LIKELY(static_cast<ClientChannelFilter*>(elem->channel_data)
-                         ->deadline_checking_enabled_)
-              ? args.deadline
-              : Timestamp::InfFuture()) {
+      arena_(args.arena),
+      elem_(elem),
+      owning_call_(args.call_stack),
+      call_combiner_(args.call_combiner) {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_call_trace)) {
     gpr_log(GPR_INFO, "chand=%p calld=%p: created call", chand(), this);
   }
@@ -2226,7 +2222,7 @@ ClientChannelFilter::FilterBasedCallData::~FilterBasedCallData() {
   CSliceUnref(path_);
   // Make sure there are no remaining pending batches.
   for (size_t i = 0; i < GPR_ARRAY_SIZE(pending_batches_); ++i) {
-    GPR_ASSERT(pending_batches_[i] == nullptr);
+    CHECK_EQ(pending_batches_[i], nullptr);
   }
 }
 
@@ -2260,10 +2256,6 @@ void ClientChannelFilter::FilterBasedCallData::StartTransportStreamOpBatch(
     gpr_log(GPR_INFO, "chand=%p calld=%p: batch started from above: %s", chand,
             calld, grpc_transport_stream_op_batch_string(batch, false).c_str());
   }
-  if (GPR_LIKELY(chand->deadline_checking_enabled_)) {
-    grpc_deadline_state_client_start_transport_stream_op_batch(
-        &calld->deadline_state_, batch);
-  }
   // Intercept recv_trailing_metadata to commit the call, in case we wind up
   // failing the call before we get down to the retry or LB call layer.
   if (batch->recv_trailing_metadata) {
@@ -2388,7 +2380,7 @@ void ClientChannelFilter::FilterBasedCallData::PendingBatchesAdd(
             chand(), this, idx);
   }
   grpc_transport_stream_op_batch*& pending = pending_batches_[idx];
-  GPR_ASSERT(pending == nullptr);
+  CHECK_EQ(pending, nullptr);
   pending = batch;
 }
 
@@ -2408,7 +2400,7 @@ void ClientChannelFilter::FilterBasedCallData::FailPendingBatchInCallCombiner(
 void ClientChannelFilter::FilterBasedCallData::PendingBatchesFail(
     grpc_error_handle error,
     YieldCallCombinerPredicate yield_call_combiner_predicate) {
-  GPR_ASSERT(!error.ok());
+  CHECK(!error.ok());
   if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_call_trace)) {
     size_t num_batches = 0;
     for (size_t i = 0; i < GPR_ARRAY_SIZE(pending_batches_); ++i) {
@@ -2957,11 +2949,11 @@ ClientChannelFilter::LoadBalancedCall::PickSubchannel(bool was_queued) {
 
 bool ClientChannelFilter::LoadBalancedCall::PickSubchannelImpl(
     LoadBalancingPolicy::SubchannelPicker* picker, grpc_error_handle* error) {
-  GPR_ASSERT(connected_subchannel_ == nullptr);
+  CHECK(connected_subchannel_ == nullptr);
   // Perform LB pick.
   LoadBalancingPolicy::PickArgs pick_args;
   Slice* path = send_initial_metadata()->get_pointer(HttpPathMetadata());
-  GPR_ASSERT(path != nullptr);
+  CHECK_NE(path, nullptr);
   pick_args.path = path->as_string_view();
   LbCallState lb_call_state(this);
   pick_args.call_state = &lb_call_state;
@@ -2977,7 +2969,7 @@ bool ClientChannelFilter::LoadBalancedCall::PickSubchannelImpl(
                   "chand=%p lb_call=%p: LB pick succeeded: subchannel=%p",
                   chand_, this, complete_pick->subchannel.get());
         }
-        GPR_ASSERT(complete_pick->subchannel != nullptr);
+        CHECK(complete_pick->subchannel != nullptr);
         // Grab a ref to the connected subchannel while we're still
         // holding the data plane mutex.
         SubchannelWrapper* subchannel =
@@ -3054,7 +3046,6 @@ ClientChannelFilter::FilterBasedLoadBalancedCall::FilterBasedLoadBalancedCall(
     absl::AnyInvocable<void()> on_commit, bool is_transparent_retry)
     : LoadBalancedCall(chand, args.context, std::move(on_commit),
                        is_transparent_retry),
-      deadline_(args.deadline),
       arena_(args.arena),
       owning_call_(args.call_stack),
       call_combiner_(args.call_combiner),
@@ -3065,7 +3056,7 @@ ClientChannelFilter::FilterBasedLoadBalancedCall::
     ~FilterBasedLoadBalancedCall() {
   // Make sure there are no remaining pending batches.
   for (size_t i = 0; i < GPR_ARRAY_SIZE(pending_batches_); ++i) {
-    GPR_ASSERT(pending_batches_[i] == nullptr);
+    CHECK_EQ(pending_batches_[i], nullptr);
   }
   if (on_call_destruction_complete_ != nullptr) {
     ExecCtx::Run(DEBUG_LOCATION, on_call_destruction_complete_,
@@ -3108,7 +3099,7 @@ void ClientChannelFilter::FilterBasedLoadBalancedCall::PendingBatchesAdd(
             "chand=%p lb_call=%p: adding pending batch at index %" PRIuPTR,
             chand(), this, idx);
   }
-  GPR_ASSERT(pending_batches_[idx] == nullptr);
+  CHECK_EQ(pending_batches_[idx], nullptr);
   pending_batches_[idx] = batch;
 }
 
@@ -3128,7 +3119,7 @@ void ClientChannelFilter::FilterBasedLoadBalancedCall::
 void ClientChannelFilter::FilterBasedLoadBalancedCall::PendingBatchesFail(
     grpc_error_handle error,
     YieldCallCombinerPredicate yield_call_combiner_predicate) {
-  GPR_ASSERT(!error.ok());
+  CHECK(!error.ok());
   failure_error_ = error;
   if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_lb_call_trace)) {
     size_t num_batches = 0;
@@ -3354,8 +3345,12 @@ void ClientChannelFilter::FilterBasedLoadBalancedCall::
       // Get status from error.
       grpc_status_code code;
       std::string message;
-      grpc_error_get_status(error, self->deadline_, &code, &message,
-                            /*http_error=*/nullptr, /*error_string=*/nullptr);
+      grpc_error_get_status(
+          error,
+          static_cast<Call*>(self->call_context()[GRPC_CONTEXT_CALL].value)
+              ->deadline(),
+          &code, &message,
+          /*http_error=*/nullptr, /*error_string=*/nullptr);
       status = absl::Status(static_cast<absl::StatusCode>(code), message);
     } else {
       // Get status from headers.
@@ -3490,10 +3485,11 @@ void ClientChannelFilter::FilterBasedLoadBalancedCall::RetryPickLocked() {
 
 void ClientChannelFilter::FilterBasedLoadBalancedCall::CreateSubchannelCall() {
   Slice* path = send_initial_metadata()->get_pointer(HttpPathMetadata());
-  GPR_ASSERT(path != nullptr);
+  CHECK_NE(path, nullptr);
   SubchannelCall::Args call_args = {
       connected_subchannel()->Ref(), pollent_, path->Ref(), /*start_time=*/0,
-      deadline_, arena_,
+      static_cast<Call*>(call_context()[GRPC_CONTEXT_CALL].value)->deadline(),
+      arena_,
       // TODO(roth): When we implement hedging support, we will probably
       // need to use a separate call context for each subchannel call.
       call_context(), call_combiner_};

data/src/core/client_channel/client_channel_filter.h

@@ -37,6 +37,7 @@
 #include <grpc/grpc.h>
 #include <grpc/impl/connectivity_state.h>
 
+#include "src/core/channelz/channelz.h"
 #include "src/core/client_channel/client_channel_factory.h"
 #include "src/core/client_channel/config_selector.h"
 #include "src/core/client_channel/dynamic_filters.h"
@@ -46,7 +47,6 @@
 #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/channelz.h"
 #include "src/core/lib/channel/context.h"
 #include "src/core/lib/gpr/time_precise.h"
 #include "src/core/lib/gprpp/orphanable.h"
@@ -63,7 +63,6 @@
 #include "src/core/lib/promise/activity.h"
 #include "src/core/lib/promise/arena_promise.h"
 #include "src/core/lib/resource_quota/arena.h"
-#include "src/core/service_config/service_config.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/transport/connectivity_state.h"
 #include "src/core/lib/transport/metadata_batch.h"
@@ -71,6 +70,7 @@
 #include "src/core/load_balancing/backend_metric_data.h"
 #include "src/core/load_balancing/lb_policy.h"
 #include "src/core/resolver/resolver.h"
+#include "src/core/service_config/service_config.h"
 
 //
 // Client channel filter
@@ -287,7 +287,6 @@ class ClientChannelFilter final {
   // Fields set at construction and never modified.
   //
   ChannelArgs channel_args_;
-  const bool deadline_checking_enabled_;
   grpc_channel_stack* owning_stack_;
   ClientChannelFactory* client_channel_factory_;
   RefCountedPtr<ServiceConfig> default_service_config_;
@@ -558,7 +557,6 @@ class ClientChannelFilter::FilterBasedLoadBalancedCall final
   // TODO(roth): Instead of duplicating these fields in every filter
   // that uses any one of them, we should store them in the call
   // context.  This will save per-call memory overhead.
-  Timestamp deadline_;
   Arena* arena_;
   grpc_call_stack* owning_call_;
   CallCombiner* call_combiner_;

data/src/core/client_channel/client_channel_internal.h

@@ -22,6 +22,7 @@
 #include <utility>
 
 #include "absl/functional/any_invocable.h"
+#include "absl/log/check.h"
 
 #include <grpc/support/log.h>
 
@@ -29,8 +30,8 @@
 #include "src/core/lib/channel/context.h"
 #include "src/core/lib/gprpp/unique_type_name.h"
 #include "src/core/lib/resource_quota/arena.h"
-#include "src/core/service_config/service_config_call_data.h"
 #include "src/core/load_balancing/lb_policy.h"
+#include "src/core/service_config/service_config_call_data.h"
 
 //
 // This file contains internal interfaces used to allow various plugins
@@ -61,7 +62,7 @@ class ClientChannelServiceConfigCallData final : public ServiceConfigCallData {
       : ServiceConfigCallData(arena, call_context) {}
 
   void SetOnCommit(absl::AnyInvocable<void()> on_commit) {
-    GPR_ASSERT(on_commit_ == nullptr);
+    CHECK(on_commit_ == nullptr);
     on_commit_ = std::move(on_commit);
   }
 

data/src/core/client_channel/client_channel_service_config.h

@@ -35,8 +35,8 @@
 #include "src/core/lib/json/json.h"
 #include "src/core/lib/json/json_args.h"
 #include "src/core/lib/json/json_object_loader.h"
-#include "src/core/service_config/service_config_parser.h"
 #include "src/core/load_balancing/lb_policy.h"
+#include "src/core/service_config/service_config_parser.h"
 
 namespace grpc_core {
 namespace internal {

data/src/core/client_channel/config_selector.h

@@ -24,6 +24,7 @@
 #include <utility>
 #include <vector>
 
+#include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "absl/strings/string_view.h"
 
@@ -36,9 +37,9 @@
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/resource_quota/arena.h"
-#include "src/core/service_config/service_config.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/transport/metadata_batch.h"
+#include "src/core/service_config/service_config.h"
 
 // Channel arg key for ConfigSelector.
 #define GRPC_ARG_CONFIG_SELECTOR "grpc.internal.config_selector"
@@ -97,14 +98,14 @@ class DefaultConfigSelector final : public ConfigSelector {
     // The client channel code ensures that this will never be null.
     // If neither the resolver nor the client application provide a
     // config, a default empty config will be used.
-    GPR_DEBUG_ASSERT(service_config_ != nullptr);
+    DCHECK(service_config_ != nullptr);
   }
 
   const char* name() const override { return "default"; }
 
   absl::Status GetCallConfig(GetCallConfigArgs args) override {
     Slice* path = args.initial_metadata->get_pointer(HttpPathMetadata());
-    GPR_ASSERT(path != nullptr);
+    CHECK_NE(path, nullptr);
     auto* parsed_method_configs =
         service_config_->GetMethodParsedConfigVector(path->c_slice());
     args.service_config_call_data->SetServiceConfig(service_config_,

data/src/core/client_channel/connector.h

@@ -19,8 +19,8 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "src/core/channelz/channelz.h"
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/channel/channelz.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/time.h"

data/src/core/client_channel/dynamic_filters.cc

@@ -23,6 +23,7 @@
 #include <new>
 #include <utility>
 
+#include "absl/log/check.h"
 #include "absl/status/statusor.h"
 
 #include <grpc/support/log.h>
@@ -82,8 +83,8 @@ void DynamicFilters::Call::StartTransportStreamOpBatch(
 }
 
 void DynamicFilters::Call::SetAfterCallStackDestroy(grpc_closure* closure) {
-  GPR_ASSERT(after_call_stack_destroy_ == nullptr);
-  GPR_ASSERT(closure != nullptr);
+  CHECK_EQ(after_call_stack_destroy_, nullptr);
+  CHECK_NE(closure, nullptr);
   after_call_stack_destroy_ = closure;
 }
 

data/src/core/client_channel/local_subchannel_pool.cc

@@ -22,6 +22,8 @@
 
 #include <utility>
 
+#include "absl/log/check.h"
+
 #include <grpc/support/log.h>
 
 #include "src/core/client_channel/subchannel.h"
@@ -34,7 +36,7 @@ RefCountedPtr<Subchannel> LocalSubchannelPool::RegisterSubchannel(
   // Because this pool is only accessed under the client channel's work
   // serializer, and because FindSubchannel is checked before invoking
   // RegisterSubchannel, no such subchannel should exist in the map.
-  GPR_ASSERT(it == subchannel_map_.end());
+  CHECK(it == subchannel_map_.end());
   subchannel_map_[key] = constructed.get();
   return constructed;
 }
@@ -45,8 +47,8 @@ void LocalSubchannelPool::UnregisterSubchannel(const SubchannelKey& key,
   // Because this subchannel pool is accessed only under the client
   // channel's work serializer, any subchannel created by RegisterSubchannel
   // will be deleted from the map in UnregisterSubchannel.
-  GPR_ASSERT(it != subchannel_map_.end());
-  GPR_ASSERT(it->second == subchannel);
+  CHECK(it != subchannel_map_.end());
+  CHECK(it->second == subchannel);
   subchannel_map_.erase(it);
 }
 

data/src/core/client_channel/retry_filter.cc

@@ -35,9 +35,9 @@
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/uri/uri_parser.h"
 #include "src/core/service_config/service_config.h"
 #include "src/core/service_config/service_config_call_data.h"
-#include "src/core/lib/uri/uri_parser.h"
 
 //
 // Retry filter

data/src/core/client_channel/retry_filter.h

@@ -24,6 +24,7 @@
 
 #include <new>
 
+#include "absl/log/check.h"
 #include "absl/types/optional.h"
 
 #include <grpc/event_engine/event_engine.h>
@@ -92,8 +93,8 @@ class RetryFilter final {
 
   static grpc_error_handle Init(grpc_channel_element* elem,
                                 grpc_channel_element_args* args) {
-    GPR_ASSERT(args->is_last);
-    GPR_ASSERT(elem->filter == &kVtable);
+    CHECK(args->is_last);
+    CHECK(elem->filter == &kVtable);
     grpc_error_handle error;
     new (elem->channel_data) RetryFilter(args->channel_args, &error);
     return error;

data/src/core/client_channel/retry_filter_legacy_call_data.cc

@@ -21,6 +21,7 @@
 #include <memory>
 #include <new>
 
+#include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 
@@ -1577,7 +1578,7 @@ RetryFilter::LegacyCallData::~LegacyCallData() {
   CSliceUnref(path_);
   // Make sure there are no remaining pending batches.
   for (size_t i = 0; i < GPR_ARRAY_SIZE(pending_batches_); ++i) {
-    GPR_ASSERT(pending_batches_[i].batch == nullptr);
+    CHECK_EQ(pending_batches_[i].batch, nullptr);
   }
 }
 
@@ -1826,7 +1827,7 @@ RetryFilter::LegacyCallData::PendingBatchesAdd(
             chand_, this, idx);
   }
   PendingBatch* pending = &pending_batches_[idx];
-  GPR_ASSERT(pending->batch == nullptr);
+  CHECK_EQ(pending->batch, nullptr);
   pending->batch = batch;
   pending->send_ops_cached = false;
   // Update state in calld about pending batches.
@@ -1910,7 +1911,7 @@ void RetryFilter::LegacyCallData::FailPendingBatchInCallCombiner(
 
 // This is called via the call combiner, so access to calld is synchronized.
 void RetryFilter::LegacyCallData::PendingBatchesFail(grpc_error_handle error) {
-  GPR_ASSERT(!error.ok());
+  CHECK(!error.ok());
   if (GRPC_TRACE_FLAG_ENABLED(grpc_retry_trace)) {
     size_t num_batches = 0;
     for (size_t i = 0; i < GPR_ARRAY_SIZE(pending_batches_); ++i) {
@@ -1991,7 +1992,7 @@ void RetryFilter::LegacyCallData::StartRetryTimer(
   // Compute backoff delay.
   Duration next_attempt_timeout;
   if (server_pushback.has_value()) {
-    GPR_ASSERT(*server_pushback >= Duration::Zero());
+    CHECK(*server_pushback >= Duration::Zero());
     next_attempt_timeout = *server_pushback;
     retry_backoff_.Reset();
   } else {