grpc 1.50.0.pre1 → 1.52.0.pre2

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

@@ -1,20 +1,20 @@
-/*
- *
- * 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.
- *
- */
+//
+//
+// 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
@@ -23,9 +23,10 @@
 
 #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_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,6 +25,8 @@
 #include <grpc/support/log.h>
 
 #include "src/core/lib/debug/stats.h"
+#include "src/core/lib/debug/stats_data.h"
+#include "src/core/lib/gprpp/crash.h"
 
 namespace grpc_core {
 
@@ -39,7 +41,7 @@ grpc_error_handle DecodeCancelStateError(gpr_atm cancel_state) {
   if (cancel_state & kErrorBit) {
     return internal::StatusGetFromHeapPtr(cancel_state & ~kErrorBit);
   }
-  return GRPC_ERROR_NONE;
+  return absl::OkStatus();
 }
 
 }  // namespace
@@ -81,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;
@@ -117,7 +119,7 @@ void CallCombiner::Start(grpc_closure* closure, grpc_error_handle error,
             "==> CallCombiner::Start() [%p] closure=%p [" DEBUG_FMT_STR
             "%s] error=%s",
             this, closure DEBUG_FMT_ARGS, reason,
-            grpc_error_std_string(error).c_str());
+            StatusToString(error).c_str());
   }
   size_t prev_size =
       static_cast<size_t>(gpr_atm_full_fetch_add(&size_, (gpr_atm)1));
@@ -175,7 +177,7 @@ void CallCombiner::Stop(DEBUG_ARGS const char* reason) {
       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());
+                closure, StatusToString(error).c_str());
       }
       ScheduleClosure(closure, error);
       break;
@@ -192,14 +194,14 @@ void CallCombiner::SetNotifyOnCancel(grpc_closure* closure) {
     grpc_error_handle original_error = DecodeCancelStateError(original_state);
     // If error is set, invoke the cancellation closure immediately.
     // Otherwise, store the new closure.
-    if (!GRPC_ERROR_IS_NONE(original_error)) {
+    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,
@@ -209,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);
@@ -218,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;
       }
@@ -233,7 +235,7 @@ void CallCombiner::Cancel(grpc_error_handle error) {
   while (true) {
     gpr_atm original_state = gpr_atm_acq_load(&cancel_state_);
     grpc_error_handle original_error = DecodeCancelStateError(original_state);
-    if (!GRPC_ERROR_IS_NONE(original_error)) {
+    if (!original_error.ok()) {
       internal::StatusFreeHeapPtr(status_ptr);
       break;
     }
@@ -246,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,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.
+//
+//
 
 #ifndef GRPC_CORE_LIB_IOMGR_CALL_COMBINER_H
 #define GRPC_CORE_LIB_IOMGR_CALL_COMBINER_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_CORE_LIB_IOMGR_CALL_COMBINER_H

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

@@ -1,20 +1,20 @@
-/*
- *
- * 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.
- *
- */
+//
+//
+// 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.
+//
+//
 
 #include <grpc/support/port_platform.h>
 
@@ -81,15 +81,14 @@ void CFStreamHandle::ReadCallback(CFReadStreamRef stream,
       stream_error = CFReadStreamCopyError(stream);
       error = grpc_error_set_int(
           GRPC_ERROR_CREATE_FROM_CFERROR(stream_error, "read error"),
-          GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_UNAVAILABLE);
+          grpc_core::StatusIntProperty::kRpcStatus, GRPC_STATUS_UNAVAILABLE);
       CFRelease(stream_error);
-      handle->open_event_.SetShutdown(GRPC_ERROR_REF(error));
-      handle->write_event_.SetShutdown(GRPC_ERROR_REF(error));
-      handle->read_event_.SetShutdown(GRPC_ERROR_REF(error));
-      GRPC_ERROR_UNREF(error);
+      handle->open_event_.SetShutdown(error);
+      handle->write_event_.SetShutdown(error);
+      handle->read_event_.SetShutdown(error);
       break;
     default:
-      GPR_UNREACHABLE_CODE(return );
+      GPR_UNREACHABLE_CODE(return);
   }
 }
 void CFStreamHandle::WriteCallback(CFWriteStreamRef stream,
@@ -116,15 +115,14 @@ void CFStreamHandle::WriteCallback(CFWriteStreamRef stream,
       stream_error = CFWriteStreamCopyError(stream);
       error = grpc_error_set_int(
           GRPC_ERROR_CREATE_FROM_CFERROR(stream_error, "write error"),
-          GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_UNAVAILABLE);
+          grpc_core::StatusIntProperty::kRpcStatus, GRPC_STATUS_UNAVAILABLE);
       CFRelease(stream_error);
-      handle->open_event_.SetShutdown(GRPC_ERROR_REF(error));
-      handle->write_event_.SetShutdown(GRPC_ERROR_REF(error));
-      handle->read_event_.SetShutdown(GRPC_ERROR_REF(error));
-      GRPC_ERROR_UNREF(error);
+      handle->open_event_.SetShutdown(error);
+      handle->write_event_.SetShutdown(error);
+      handle->read_event_.SetShutdown(error);
       break;
     default:
-      GPR_UNREACHABLE_CODE(return );
+      GPR_UNREACHABLE_CODE(return);
   }
 }
 
@@ -172,10 +170,9 @@ void CFStreamHandle::NotifyOnWrite(grpc_closure* closure) {
 }
 
 void CFStreamHandle::Shutdown(grpc_error_handle error) {
-  open_event_.SetShutdown(GRPC_ERROR_REF(error));
-  read_event_.SetShutdown(GRPC_ERROR_REF(error));
-  write_event_.SetShutdown(GRPC_ERROR_REF(error));
-  GRPC_ERROR_UNREF(error);
+  open_event_.SetShutdown(error);
+  read_event_.SetShutdown(error);
+  write_event_.SetShutdown(error);
 }
 
 void CFStreamHandle::Ref(const char* file, int line, const char* reason) {
@@ -202,9 +199,9 @@ void CFStreamHandle::Unref(const char* file, int line, const char* reason) {
 
 #else
 
-/* Creating a phony function so that the grpc_cfstream library will be
- * non-empty.
- */
+// Creating a phony function so that the grpc_cfstream library will be
+// non-empty.
+//
 void CFStreamPhony() {}
 
 #endif

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

@@ -1,23 +1,23 @@
-/*
- *
- * 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.
- *
- */
-
-/* The CFStream handle acts as an event synchronization entity for
- * read/write/open/error/eos events happening on CFStream streams. */
+//
+//
+// 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.
+//
+//
+
+// The CFStream handle acts as an event synchronization entity for
+// read/write/open/error/eos events happening on CFStream streams.
 
 #ifndef GRPC_CORE_LIB_IOMGR_CFSTREAM_HANDLE_H
 #define GRPC_CORE_LIB_IOMGR_CFSTREAM_HANDLE_H
@@ -43,7 +43,7 @@ class CFStreamHandle : public GrpcLibraryInitHolder {
  public:
   static CFStreamHandle* CreateStreamHandle(CFReadStreamRef read_stream,
                                             CFWriteStreamRef write_stream);
-  /** Use CreateStreamHandle function instead of using this directly. */
+  /// Use CreateStreamHandle function instead of using this directly.
   CFStreamHandle(CFReadStreamRef read_stream, CFWriteStreamRef write_stream);
   CFStreamHandle(const CFStreamHandle& ref) = delete;
   CFStreamHandle(CFStreamHandle&& ref) = delete;
@@ -87,4 +87,4 @@ class CFStreamHandle : public GrpcLibraryInitHolder {
 
 #endif
 
-#endif /* GRPC_CORE_LIB_IOMGR_CFSTREAM_HANDLE_H */
+#endif  // GRPC_CORE_LIB_IOMGR_CFSTREAM_HANDLE_H