grpc 1.46.3 → 1.53.1

data/src/core/lib/iomgr/buffer_list.h

@@ -1,31 +1,32 @@
-/*
- *
- * Copyright 2018 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_CORE_LIB_IOMGR_BUFFER_LIST_H
-#define GRPC_CORE_LIB_IOMGR_BUFFER_LIST_H
+//
+//
+// Copyright 2018 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_IOMGR_BUFFER_LIST_H
+#define GRPC_SRC_CORE_LIB_IOMGR_BUFFER_LIST_H
 
 #include <grpc/support/port_platform.h>
 
 #include "absl/types/optional.h"
 
+#include <grpc/grpc.h>
 #include <grpc/support/time.h>
 
-#include "src/core/lib/gprpp/memory.h"
+#include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/internal_errqueue.h"
 #include "src/core/lib/iomgr/port.h"
@@ -33,58 +34,58 @@
 namespace grpc_core {
 
 struct ConnectionMetrics {
-  /* Delivery rate in Bytes/s. */
+  // Delivery rate in Bytes/s.
   absl::optional<uint64_t> delivery_rate;
-  /* If the delivery rate is limited by the application, this is set to true. */
+  // If the delivery rate is limited by the application, this is set to true.
   absl::optional<bool> is_delivery_rate_app_limited;
-  /* Total packets retransmitted. */
+  // Total packets retransmitted.
   absl::optional<uint32_t> packet_retx;
-  /* Total packets retransmitted spuriously. This metric is smaller than or
-  equal to packet_retx. */
+  // Total packets retransmitted spuriously. This metric is smaller than or
+  // equal to packet_retx.
   absl::optional<uint32_t> packet_spurious_retx;
-  /* Total packets sent. */
+  // Total packets sent.
   absl::optional<uint32_t> packet_sent;
-  /* Total packets delivered. */
+  // Total packets delivered.
   absl::optional<uint32_t> packet_delivered;
-  /* Total packets delivered with ECE marked. This metric is smaller than or
-  equal to packet_delivered. */
+  // Total packets delivered with ECE marked. This metric is smaller than or
+  // equal to packet_delivered.
   absl::optional<uint32_t> packet_delivered_ce;
-  /* Total bytes lost so far. */
+  // Total bytes lost so far.
   absl::optional<uint64_t> data_retx;
-  /* Total bytes sent so far. */
+  // Total bytes sent so far.
   absl::optional<uint64_t> data_sent;
-  /* Total bytes in write queue but not sent. */
+  // Total bytes in write queue but not sent.
   absl::optional<uint64_t> data_notsent;
-  /* Pacing rate of the connection in Bps */
+  // Pacing rate of the connection in Bps
   absl::optional<uint64_t> pacing_rate;
-  /* Minimum RTT observed in usec. */
+  // Minimum RTT observed in usec.
   absl::optional<uint32_t> min_rtt;
-  /* Smoothed RTT in usec */
+  // Smoothed RTT in usec
   absl::optional<uint32_t> srtt;
-  /* Send congestion window. */
+  // Send congestion window.
   absl::optional<uint32_t> congestion_window;
-  /* Slow start threshold in packets. */
+  // Slow start threshold in packets.
   absl::optional<uint32_t> snd_ssthresh;
-  /* Maximum degree of reordering (i.e., maximum number of packets reodered)
-   on the connection. */
+  // Maximum degree of reordering (i.e., maximum number of packets reodered)
+  // on the connection.
   absl::optional<uint32_t> reordering;
-  /* Represents the number of recurring retransmissions of the first sequence
-  that is not acknowledged yet. */
+  // Represents the number of recurring retransmissions of the first sequence
+  // that is not acknowledged yet.
   absl::optional<uint8_t> recurring_retrans;
-  /* The cumulative time (in usec) that the transport protocol was busy
-   sending data. */
+  // The cumulative time (in usec) that the transport protocol was busy
+  // sending data.
   absl::optional<uint64_t> busy_usec;
-  /* The cumulative time (in usec) that the transport protocol was limited by
-   the receive window size. */
+  // The cumulative time (in usec) that the transport protocol was limited by
+  // the receive window size.
   absl::optional<uint64_t> rwnd_limited_usec;
-  /* The cumulative time (in usec) that the transport protocol was limited by
-   the send buffer size. */
+  // The cumulative time (in usec) that the transport protocol was limited by
+  // the send buffer size.
   absl::optional<uint64_t> sndbuf_limited_usec;
 };
 
 struct BufferTimestamp {
   gpr_timespec time;
-  ConnectionMetrics metrics; /* Metrics collected with this timestamp */
+  ConnectionMetrics metrics;  // Metrics collected with this timestamp
 };
 
 struct Timestamps {
@@ -93,71 +94,92 @@ struct Timestamps {
   BufferTimestamp sent_time;
   BufferTimestamp acked_time;
 
-  uint32_t byte_offset; /* byte offset relative to the start of the RPC */
+  uint32_t byte_offset;  // byte offset relative to the start of the RPC
 
 #ifdef GRPC_LINUX_ERRQUEUE
-  tcp_info info; /* tcp_info collected on sendmsg */
-#endif           /* GRPC_LINUX_ERRQUEUE */
+  tcp_info info;  // tcp_info collected on sendmsg
+#endif            // GRPC_LINUX_ERRQUEUE
 };
 
-/** TracedBuffer is a class to keep track of timestamps for a specific buffer in
- * the TCP layer. We are only tracking timestamps for Linux kernels and hence
- * this class would only be used by Linux platforms. For all other platforms,
- * TracedBuffer would be an empty class.
- *
- * The timestamps collected are according to Timestamps declared
- * above.
- *
- * A TracedBuffer list is kept track of using the head element of the list. If
- * the head element of the list is nullptr, then the list is empty.
- */
+// TracedBuffer is a class to keep track of timestamps for a specific buffer in
+// the TCP layer. We are only tracking timestamps for Linux kernels and hence
+// this class would only be used by Linux platforms. For all other platforms,
+// TracedBuffer would be an empty class.
+// The timestamps collected are according to Timestamps declared above A
+// TracedBuffer list is kept track of using the head element of the list. If
+// *the head element of the list is nullptr, then the list is empty.
 #ifdef GRPC_LINUX_ERRQUEUE
-class TracedBuffer {
+
+class TracedBufferList {
  public:
-  /** Use AddNewEntry function instead of using this directly. */
-  TracedBuffer(uint32_t seq_no, void* arg)
-      : seq_no_(seq_no), arg_(arg), next_(nullptr) {}
-
-  /** Add a new entry in the TracedBuffer list pointed to by head. Also saves
-   * sendmsg_time with the current timestamp. */
-  static void AddNewEntry(TracedBuffer** head, uint32_t seq_no, int fd,
-                          void* arg);
-
-  /** Processes a received timestamp based on sock_extended_err and
-   * scm_timestamping structures. It will invoke the timestamps callback if the
-   * timestamp type is SCM_TSTAMP_ACK. */
-  static void ProcessTimestamp(TracedBuffer** head,
-                               struct sock_extended_err* serr,
-                               struct cmsghdr* opt_stats,
-                               struct scm_timestamping* tss);
-
-  /** Cleans the list by calling the callback for each traced buffer in the list
-   * with timestamps that it has. */
-  static void Shutdown(TracedBuffer** head, void* remaining,
-                       grpc_error_handle shutdown_err);
+  TracedBufferList() = default;
+  ~TracedBufferList() = default;
+  // Add a new entry in the TracedBuffer list pointed to by head. Also saves
+  // sendmsg_time with the current timestamp.
+  void AddNewEntry(int32_t seq_no, int fd, void* arg);
+  // Processes a received timestamp based on sock_extended_err and
+  // scm_timestamping structures. It will invoke the timestamps callback if the
+  // timestamp type is SCM_TSTAMP_ACK.
+  void ProcessTimestamp(struct sock_extended_err* serr,
+                        struct cmsghdr* opt_stats,
+                        struct scm_timestamping* tss);
+  // The Size() operation is slow and is used only in tests.
+  int Size() {
+    MutexLock lock(&mu_);
+    int size = 0;
+    TracedBuffer* curr = head_;
+    while (curr) {
+      ++size;
+      curr = curr->next_;
+    }
+    return size;
+  }
+  // Cleans the list by calling the callback for each traced buffer in the list
+  // with timestamps that it has.
+  void Shutdown(void* /*remaining*/, absl::Status /*shutdown_err*/);
 
  private:
-  uint32_t seq_no_;    /* The sequence number for the last byte in the buffer */
-  void* arg_;          /* The arg to pass to timestamps_callback */
-  Timestamps ts_;      /* The timestamps corresponding to this buffer */
-  TracedBuffer* next_; /* The next TracedBuffer in the list */
+  class TracedBuffer {
+   public:
+    TracedBuffer(uint32_t seq_no, void* arg) : seq_no_(seq_no), arg_(arg) {}
+
+    bool Finished(gpr_timespec ts);
+
+   private:
+    friend class TracedBufferList;
+    gpr_timespec last_timestamp_;
+    TracedBuffer* next_ = nullptr;
+    uint32_t seq_no_;  // The sequence number for the last byte in the buffer
+    void* arg_;        // The arg to pass to timestamps_callback
+    Timestamps ts_;    // The timestamps corresponding to this buffer
+  };
+  Mutex mu_;
+  // TracedBuffers are ordered by sequence number and would need to be processed
+  // in a FIFO order starting with the smallest sequence number. To enable this,
+  // they are stored in a singly linked with head and tail pointers which allows
+  // easy appends and forward iteration operations.
+  TracedBuffer* head_ = nullptr;
+  TracedBuffer* tail_ = nullptr;
 };
-#else  /* GRPC_LINUX_ERRQUEUE */
-class TracedBuffer {
+
+#else   // GRPC_LINUX_ERRQUEUE
+// TracedBufferList implementation is a no-op for this platform.
+class TracedBufferList {
  public:
-  /* Phony shutdown function */
-  static void Shutdown(TracedBuffer** /*head*/, void* /*remaining*/,
-                       grpc_error_handle shutdown_err) {
-    GRPC_ERROR_UNREF(shutdown_err);
-  }
+  void AddNewEntry(int32_t /*seq_no*/, int /*fd*/, void* /*arg*/) {}
+  void ProcessTimestamp(struct sock_extended_err* /*serr*/,
+                        struct cmsghdr* /*opt_stats*/,
+                        struct scm_timestamping* /*tss*/) {}
+  int Size() { return 0; }
+  void Shutdown(void* /*remaining*/, absl::Status /*shutdown_err*/) {}
 };
-#endif /* GRPC_LINUX_ERRQUEUE */
+#endif  // GRPC_LINUX_ERRQUEUE
 
-/** Sets the callback function to call when timestamps for a write are
- *  collected. The callback does not own a reference to error. */
+/// Sets the callback function to call when timestamps for a write are
+/// collected. The callback does not own a reference to error.
 void grpc_tcp_set_write_timestamps_callback(
     void (*fn)(void*, Timestamps*, grpc_error_handle error));
 
-} /* namespace grpc_core */
+}  // namespace grpc_core
 
-#endif /* GRPC_CORE_LIB_IOMGR_BUFFER_LIST_H */
+#endif  // GRPC_SRC_CORE_LIB_IOMGR_BUFFER_LIST_H

data/src/core/lib/iomgr/call_combiner.cc

@@ -1,20 +1,20 @@
-/*
- *
- * Copyright 2017 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.
- *
- */
+//
+//
+// Copyright 2017 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 <grpc/support/port_platform.h>
 
@@ -25,7 +25,8 @@
 #include <grpc/support/log.h>
 
 #include "src/core/lib/debug/stats.h"
-#include "src/core/lib/profiling/timers.h"
+#include "src/core/lib/debug/stats_data.h"
+#include "src/core/lib/gprpp/crash.h"
 
 namespace grpc_core {
 
@@ -38,13 +39,9 @@ constexpr intptr_t kErrorBit = 1;
 
 grpc_error_handle DecodeCancelStateError(gpr_atm cancel_state) {
   if (cancel_state & kErrorBit) {
-#ifdef GRPC_ERROR_IS_ABSEIL_STATUS
     return internal::StatusGetFromHeapPtr(cancel_state & ~kErrorBit);
-#else
-    return reinterpret_cast<grpc_error_handle>(cancel_state & ~kErrorBit);
-#endif
   }
-  return GRPC_ERROR_NONE;
+  return absl::OkStatus();
 }
 
 }  // namespace
@@ -60,12 +57,7 @@ CallCombiner::CallCombiner() {
 
 CallCombiner::~CallCombiner() {
   if (cancel_state_ & kErrorBit) {
-#ifdef GRPC_ERROR_IS_ABSEIL_STATUS
     internal::StatusFreeHeapPtr(cancel_state_ & ~kErrorBit);
-#else
-    GRPC_ERROR_UNREF(reinterpret_cast<grpc_error_handle>(
-        cancel_state_ & ~static_cast<gpr_atm>(kErrorBit)));
-#endif
   }
 }
 
@@ -91,7 +83,7 @@ void CallCombiner::TsanClosure(void* arg, grpc_error_handle error) {
   } else {
     lock.reset();
   }
-  Closure::Run(DEBUG_LOCATION, self->original_closure_, GRPC_ERROR_REF(error));
+  Closure::Run(DEBUG_LOCATION, self->original_closure_, error);
   if (lock != nullptr) {
     TSAN_ANNOTATE_RWLOCK_RELEASED(&lock->taken, true);
     bool prev = true;
@@ -122,13 +114,12 @@ void CallCombiner::ScheduleClosure(grpc_closure* closure,
 
 void CallCombiner::Start(grpc_closure* closure, grpc_error_handle error,
                          DEBUG_ARGS const char* reason) {
-  GPR_TIMER_SCOPE("CallCombiner::Start", 0);
   if (GRPC_TRACE_FLAG_ENABLED(grpc_call_combiner_trace)) {
     gpr_log(GPR_INFO,
-            "==> CallCombiner::Start() [%p] closure=%p [" DEBUG_FMT_STR
+            "==> CallCombiner::Start() [%p] closure=%s [" DEBUG_FMT_STR
             "%s] error=%s",
-            this, closure DEBUG_FMT_ARGS, reason,
-            grpc_error_std_string(error).c_str());
+            this, closure->DebugString().c_str() DEBUG_FMT_ARGS, reason,
+            StatusToString(error).c_str());
   }
   size_t prev_size =
       static_cast<size_t>(gpr_atm_full_fetch_add(&size_, (gpr_atm)1));
@@ -136,10 +127,7 @@ void CallCombiner::Start(grpc_closure* closure, grpc_error_handle error,
     gpr_log(GPR_INFO, "  size: %" PRIdPTR " -> %" PRIdPTR, prev_size,
             prev_size + 1);
   }
-  GRPC_STATS_INC_CALL_COMBINER_LOCKS_SCHEDULED_ITEMS();
   if (prev_size == 0) {
-    GRPC_STATS_INC_CALL_COMBINER_LOCKS_INITIATED();
-    GPR_TIMER_MARK("call_combiner_initiate", 0);
     if (GRPC_TRACE_FLAG_ENABLED(grpc_call_combiner_trace)) {
       gpr_log(GPR_INFO, "  EXECUTING IMMEDIATELY");
     }
@@ -150,18 +138,13 @@ void CallCombiner::Start(grpc_closure* closure, grpc_error_handle error,
       gpr_log(GPR_INFO, "  QUEUING");
     }
     // Queue was not empty, so add closure to queue.
-#ifdef GRPC_ERROR_IS_ABSEIL_STATUS
     closure->error_data.error = internal::StatusAllocHeapPtr(error);
-#else
-    closure->error_data.error = reinterpret_cast<intptr_t>(error);
-#endif
     queue_.Push(
         reinterpret_cast<MultiProducerSingleConsumerQueue::Node*>(closure));
   }
 }
 
 void CallCombiner::Stop(DEBUG_ARGS const char* reason) {
-  GPR_TIMER_SCOPE("CallCombiner::Stop", 0);
   if (GRPC_TRACE_FLAG_ENABLED(grpc_call_combiner_trace)) {
     gpr_log(GPR_INFO, "==> CallCombiner::Stop() [%p] [" DEBUG_FMT_STR "%s]",
             this DEBUG_FMT_ARGS, reason);
@@ -189,17 +172,12 @@ void CallCombiner::Stop(DEBUG_ARGS const char* reason) {
         }
         continue;
       }
-#ifdef GRPC_ERROR_IS_ABSEIL_STATUS
       grpc_error_handle error =
           internal::StatusMoveFromHeapPtr(closure->error_data.error);
-#else
-      grpc_error_handle error =
-          reinterpret_cast<grpc_error_handle>(closure->error_data.error);
-#endif
       closure->error_data.error = 0;
       if (GRPC_TRACE_FLAG_ENABLED(grpc_call_combiner_trace)) {
-        gpr_log(GPR_INFO, "  EXECUTING FROM QUEUE: closure=%p error=%s",
-                closure, grpc_error_std_string(error).c_str());
+        gpr_log(GPR_INFO, "  EXECUTING FROM QUEUE: closure=%s error=%s",
+                closure->DebugString().c_str(), StatusToString(error).c_str());
       }
       ScheduleClosure(closure, error);
       break;
@@ -210,21 +188,20 @@ void CallCombiner::Stop(DEBUG_ARGS const char* reason) {
 }
 
 void CallCombiner::SetNotifyOnCancel(grpc_closure* closure) {
-  GRPC_STATS_INC_CALL_COMBINER_SET_NOTIFY_ON_CANCEL();
   while (true) {
     // Decode original state.
     gpr_atm original_state = gpr_atm_acq_load(&cancel_state_);
     grpc_error_handle original_error = DecodeCancelStateError(original_state);
     // If error is set, invoke the cancellation closure immediately.
     // Otherwise, store the new closure.
-    if (original_error != GRPC_ERROR_NONE) {
+    if (!original_error.ok()) {
       if (GRPC_TRACE_FLAG_ENABLED(grpc_call_combiner_trace)) {
         gpr_log(GPR_INFO,
                 "call_combiner=%p: scheduling notify_on_cancel callback=%p "
                 "for pre-existing cancellation",
                 this, closure);
       }
-      ExecCtx::Run(DEBUG_LOCATION, closure, GRPC_ERROR_REF(original_error));
+      ExecCtx::Run(DEBUG_LOCATION, closure, original_error);
       break;
     } else {
       if (gpr_atm_full_cas(&cancel_state_, original_state,
@@ -234,7 +211,7 @@ void CallCombiner::SetNotifyOnCancel(grpc_closure* closure) {
                   this, closure);
         }
         // If we replaced an earlier closure, invoke the original
-        // closure with GRPC_ERROR_NONE.  This allows callers to clean
+        // closure with absl::OkStatus().  This allows callers to clean
         // up any resources they may be holding for the callback.
         if (original_state != 0) {
           closure = reinterpret_cast<grpc_closure*>(original_state);
@@ -243,7 +220,7 @@ void CallCombiner::SetNotifyOnCancel(grpc_closure* closure) {
                     "call_combiner=%p: scheduling old cancel callback=%p", this,
                     closure);
           }
-          ExecCtx::Run(DEBUG_LOCATION, closure, GRPC_ERROR_NONE);
+          ExecCtx::Run(DEBUG_LOCATION, closure, absl::OkStatus());
         }
         break;
       }
@@ -253,22 +230,13 @@ void CallCombiner::SetNotifyOnCancel(grpc_closure* closure) {
 }
 
 void CallCombiner::Cancel(grpc_error_handle error) {
-  GRPC_STATS_INC_CALL_COMBINER_CANCELLED();
-#ifdef GRPC_ERROR_IS_ABSEIL_STATUS
   intptr_t status_ptr = internal::StatusAllocHeapPtr(error);
   gpr_atm new_state = kErrorBit | status_ptr;
-#else
-  gpr_atm new_state = kErrorBit | reinterpret_cast<gpr_atm>(error);
-#endif
   while (true) {
     gpr_atm original_state = gpr_atm_acq_load(&cancel_state_);
     grpc_error_handle original_error = DecodeCancelStateError(original_state);
-    if (original_error != GRPC_ERROR_NONE) {
-#ifdef GRPC_ERROR_IS_ABSEIL_STATUS
+    if (!original_error.ok()) {
       internal::StatusFreeHeapPtr(status_ptr);
-#else
-      GRPC_ERROR_UNREF(error);
-#endif
       break;
     }
     if (gpr_atm_full_cas(&cancel_state_, original_state, new_state)) {
@@ -280,7 +248,7 @@ void CallCombiner::Cancel(grpc_error_handle error) {
                   "call_combiner=%p: scheduling notify_on_cancel callback=%p",
                   this, notify_on_cancel);
         }
-        ExecCtx::Run(DEBUG_LOCATION, notify_on_cancel, GRPC_ERROR_REF(error));
+        ExecCtx::Run(DEBUG_LOCATION, notify_on_cancel, error);
       }
       break;
     }

data/src/core/lib/iomgr/call_combiner.h

@@ -1,23 +1,23 @@
-/*
- *
- * Copyright 2017 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_CORE_LIB_IOMGR_CALL_COMBINER_H
-#define GRPC_CORE_LIB_IOMGR_CALL_COMBINER_H
+//
+//
+// Copyright 2017 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_IOMGR_CALL_COMBINER_H
+#define GRPC_SRC_CORE_LIB_IOMGR_CALL_COMBINER_H
 
 #include <grpc/support/port_platform.h>
 
@@ -80,7 +80,7 @@ class CallCombiner {
   /// once; this allows the closure to hold references that will be freed
   /// regardless of whether or not the call was cancelled.  If a cancellation
   /// does occur, the closure will be scheduled with the cancellation error;
-  /// otherwise, it will be scheduled with GRPC_ERROR_NONE.
+  /// otherwise, it will be scheduled with absl::OkStatus().
   ///
   /// The closure will be scheduled in the following cases:
   /// - If Cancel() was called prior to registering the closure, it will be
@@ -89,7 +89,7 @@ class CallCombiner {
   ///   be scheduled with the cancellation error.
   /// - If SetNotifyOnCancel() is called again to register a new cancellation
   ///   closure, the previous cancellation closure will be scheduled with
-  ///   GRPC_ERROR_NONE.
+  ///   absl::OkStatus().
   ///
   /// If \a closure is NULL, then no closure will be invoked on
   /// cancellation; this effectively unregisters the previously set closure.
@@ -173,8 +173,7 @@ class CallCombinerClosureList {
               "CallCombinerClosureList executing closure while already "
               "holding call_combiner %p: closure=%p error=%s reason=%s",
               call_combiner, closures_[0].closure,
-              grpc_error_std_string(closures_[0].error).c_str(),
-              closures_[0].reason);
+              StatusToString(closures_[0].error).c_str(), closures_[0].reason);
     }
     // This will release the call combiner.
     ExecCtx::Run(DEBUG_LOCATION, closures_[0].closure, closures_[0].error);
@@ -212,4 +211,4 @@ class CallCombinerClosureList {
 
 }  // namespace grpc_core
 
-#endif /* GRPC_CORE_LIB_IOMGR_CALL_COMBINER_H */
+#endif  // GRPC_SRC_CORE_LIB_IOMGR_CALL_COMBINER_H