grpc 1.46.3 → 1.53.1

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

@@ -1,20 +1,20 @@
-/*
- *
- * Copyright 2020 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 2020 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>
 
@@ -28,9 +28,9 @@
 
 #ifndef GRPC_SET_SOCKET_DUALSTACK_CUSTOM
 
-/* This should be 0 in production, but it may be enabled for testing or
-   debugging purposes, to simulate an environment where IPv6 sockets can't
-   also speak IPv4. */
+// This should be 0 in production, but it may be enabled for testing or
+// debugging purposes, to simulate an environment where IPv6 sockets can't
+// also speak IPv4.
 int grpc_forbid_dualstack_sockets_for_testing = 0;
 
 int grpc_set_socket_dualstack(int fd) {
@@ -38,7 +38,7 @@ int grpc_set_socket_dualstack(int fd) {
     const int off = 0;
     return 0 == setsockopt(fd, IPPROTO_IPV6, IPV6_V6ONLY, &off, sizeof(off));
   } else {
-    /* Force an IPv6-only socket, for testing purposes. */
+    // Force an IPv6-only socket, for testing purposes.
     const int on = 1;
     setsockopt(fd, IPPROTO_IPV6, IPV6_V6ONLY, &on, sizeof(on));
     return 0;

data/src/core/lib/iomgr/dynamic_annotations.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.
- *
- */
+//
+//
+// 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_DYNAMIC_ANNOTATIONS_H
-#define GRPC_CORE_LIB_IOMGR_DYNAMIC_ANNOTATIONS_H
+#ifndef GRPC_SRC_CORE_LIB_IOMGR_DYNAMIC_ANNOTATIONS_H
+#define GRPC_SRC_CORE_LIB_IOMGR_DYNAMIC_ANNOTATIONS_H
 
 #include <grpc/support/port_platform.h>
 
@@ -53,7 +53,7 @@ void AnnotateRWLockReleased(const char* file, int line,
 }
 #endif
 
-#else /* GRPC_TSAN_ENABLED */
+#else  // GRPC_TSAN_ENABLED
 
 #define TSAN_ANNOTATE_HAPPENS_BEFORE(addr)
 #define TSAN_ANNOTATE_HAPPENS_AFTER(addr)
@@ -62,6 +62,6 @@ void AnnotateRWLockReleased(const char* file, int line,
 #define TSAN_ANNOTATE_RWLOCK_ACQUIRED(addr, is_w)
 #define TSAN_ANNOTATE_RWLOCK_RELEASED(addr, is_w)
 
-#endif /* GRPC_TSAN_ENABLED */
+#endif  // GRPC_TSAN_ENABLED
 
-#endif /* GRPC_CORE_LIB_IOMGR_DYNAMIC_ANNOTATIONS_H */
+#endif  // GRPC_SRC_CORE_LIB_IOMGR_DYNAMIC_ANNOTATIONS_H

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

@@ -1,20 +1,20 @@
-/*
- *
- * 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.
- *
- */
+//
+//
+// 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 <grpc/support/port_platform.h>
 
@@ -23,13 +23,13 @@
 grpc_core::TraceFlag grpc_tcp_trace(false, "tcp");
 
 void grpc_endpoint_read(grpc_endpoint* ep, grpc_slice_buffer* slices,
-                        grpc_closure* cb, bool urgent) {
-  ep->vtable->read(ep, slices, cb, urgent);
+                        grpc_closure* cb, bool urgent, int min_progress_size) {
+  ep->vtable->read(ep, slices, cb, urgent, min_progress_size);
 }
 
 void grpc_endpoint_write(grpc_endpoint* ep, grpc_slice_buffer* slices,
-                         grpc_closure* cb, void* arg) {
-  ep->vtable->write(ep, slices, cb, arg);
+                         grpc_closure* cb, void* arg, int max_frame_size) {
+  ep->vtable->write(ep, slices, cb, arg, max_frame_size);
 }
 
 void grpc_endpoint_add_to_pollset(grpc_endpoint* ep, grpc_pollset* pollset) {

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

@@ -1,23 +1,23 @@
-/*
- *
- * 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_CORE_LIB_IOMGR_ENDPOINT_H
-#define GRPC_CORE_LIB_IOMGR_ENDPOINT_H
+//
+//
+// 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_IOMGR_ENDPOINT_H
+#define GRPC_SRC_CORE_LIB_IOMGR_ENDPOINT_H
 
 #include <grpc/support/port_platform.h>
 
@@ -30,17 +30,17 @@
 #include "src/core/lib/iomgr/pollset.h"
 #include "src/core/lib/iomgr/pollset_set.h"
 
-/* An endpoint caps a streaming channel between two communicating processes.
-   Examples may be: a tcp socket, <stdin+stdout>, or some shared memory. */
+// An endpoint caps a streaming channel between two communicating processes.
+// Examples may be: a tcp socket, <stdin+stdout>, or some shared memory.
 
 typedef struct grpc_endpoint grpc_endpoint;
 typedef struct grpc_endpoint_vtable grpc_endpoint_vtable;
 
 struct grpc_endpoint_vtable {
   void (*read)(grpc_endpoint* ep, grpc_slice_buffer* slices, grpc_closure* cb,
-               bool urgent);
+               bool urgent, int min_progress_size);
   void (*write)(grpc_endpoint* ep, grpc_slice_buffer* slices, grpc_closure* cb,
-                void* arg);
+                void* arg, int max_frame_size);
   void (*add_to_pollset)(grpc_endpoint* ep, grpc_pollset* pollset);
   void (*add_to_pollset_set)(grpc_endpoint* ep, grpc_pollset_set* pollset);
   void (*delete_from_pollset_set)(grpc_endpoint* ep, grpc_pollset_set* pollset);
@@ -52,49 +52,51 @@ struct grpc_endpoint_vtable {
   bool (*can_track_err)(grpc_endpoint* ep);
 };
 
-/* When data is available on the connection, calls the callback with slices.
-   Callback success indicates that the endpoint can accept more reads, failure
-   indicates the endpoint is closed.
-   Valid slices may be placed into \a slices even when the callback is
-   invoked with error != GRPC_ERROR_NONE. */
+// When data is available on the connection, calls the callback with slices.
+// Callback success indicates that the endpoint can accept more reads, failure
+// indicates the endpoint is closed.
+// Valid slices may be placed into \a slices even when the callback is
+// invoked with !error.ok().
 void grpc_endpoint_read(grpc_endpoint* ep, grpc_slice_buffer* slices,
-                        grpc_closure* cb, bool urgent);
+                        grpc_closure* cb, bool urgent, int min_progress_size);
 
 absl::string_view grpc_endpoint_get_peer(grpc_endpoint* ep);
 
 absl::string_view grpc_endpoint_get_local_address(grpc_endpoint* ep);
 
-/* Get the file descriptor used by \a ep. Return -1 if \a ep is not using an fd.
- */
+// Get the file descriptor used by \a ep. Return -1 if \a ep is not using an fd.
+//
 int grpc_endpoint_get_fd(grpc_endpoint* ep);
 
-/* Write slices out to the socket.
-
-   If the connection is ready for more data after the end of the call, it
-   returns GRPC_ENDPOINT_DONE.
-   Otherwise it returns GRPC_ENDPOINT_PENDING and calls cb when the
-   connection is ready for more data.
-   \a slices may be mutated at will by the endpoint until cb is called.
-   No guarantee is made to the content of slices after a write EXCEPT that
-   it is a valid slice buffer.
-   \a arg is platform specific. It is currently only used by TCP on linux
-   platforms as an argument that would be forwarded to the timestamps callback.
-   */
+// Write slices out to the socket.
+
+// If the connection is ready for more data after the end of the call, it
+// returns GRPC_ENDPOINT_DONE.
+// Otherwise it returns GRPC_ENDPOINT_PENDING and calls cb when the
+// connection is ready for more data.
+// \a slices may be mutated at will by the endpoint until cb is called.
+// No guarantee is made to the content of slices after a write EXCEPT that
+// it is a valid slice buffer.
+// \a arg is platform specific. It is currently only used by TCP on linux
+// platforms as an argument that would be forwarded to the timestamps callback.
+// \a max_frame_size. A hint to the endpoint implementation to construct
+// frames which do not exceed the specified size.
+//
 void grpc_endpoint_write(grpc_endpoint* ep, grpc_slice_buffer* slices,
-                         grpc_closure* cb, void* arg);
+                         grpc_closure* cb, void* arg, int max_frame_size);
 
-/* Causes any pending and future read/write callbacks to run immediately with
-   success==0 */
+// Causes any pending and future read/write callbacks to run immediately with
+// success==0
 void grpc_endpoint_shutdown(grpc_endpoint* ep, grpc_error_handle why);
 void grpc_endpoint_destroy(grpc_endpoint* ep);
 
-/* Add an endpoint to a pollset or pollset_set, so that when the pollset is
-   polled, events from this endpoint are considered */
+// Add an endpoint to a pollset or pollset_set, so that when the pollset is
+// polled, events from this endpoint are considered
 void grpc_endpoint_add_to_pollset(grpc_endpoint* ep, grpc_pollset* pollset);
 void grpc_endpoint_add_to_pollset_set(grpc_endpoint* ep,
                                       grpc_pollset_set* pollset_set);
 
-/* Delete an endpoint from a pollset_set */
+// Delete an endpoint from a pollset_set
 void grpc_endpoint_delete_from_pollset_set(grpc_endpoint* ep,
                                            grpc_pollset_set* pollset_set);
 
@@ -104,4 +106,4 @@ struct grpc_endpoint {
   const grpc_endpoint_vtable* vtable;
 };
 
-#endif /* GRPC_CORE_LIB_IOMGR_ENDPOINT_H */
+#endif  // GRPC_SRC_CORE_LIB_IOMGR_ENDPOINT_H

data/src/core/lib/iomgr/endpoint_cfstream.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>
 
@@ -36,6 +36,7 @@
 #import "src/core/lib/iomgr/endpoint_cfstream.h"
 #include "src/core/lib/iomgr/error_cfstream.h"
 #include "src/core/lib/iomgr/sockaddr.h"
+#include "src/core/lib/slice/slice.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/slice/slice_string_helpers.h"
 
@@ -106,9 +107,9 @@ static void CFStreamRef(CFStreamEndpoint* ep) { gpr_ref(&ep->refcount); }
 static grpc_error_handle CFStreamAnnotateError(grpc_error_handle src_error,
                                                CFStreamEndpoint* ep) {
   return grpc_error_set_str(
-      grpc_error_set_int(src_error, GRPC_ERROR_INT_GRPC_STATUS,
+      grpc_error_set_int(src_error, grpc_core::StatusIntProperty::kRpcStatus,
                          GRPC_STATUS_UNAVAILABLE),
-      GRPC_ERROR_STR_TARGET_ADDRESS, ep->peer_string);
+      grpc_core::StatusStrProperty::kTargetAddress, ep->peer_string);
 }
 
 static void CallReadCb(CFStreamEndpoint* ep, grpc_error_handle error) {
@@ -116,7 +117,8 @@ static void CallReadCb(CFStreamEndpoint* ep, grpc_error_handle error) {
     gpr_log(GPR_DEBUG, "CFStream endpoint:%p call_read_cb %p %p:%p", ep,
             ep->read_cb, ep->read_cb->cb, ep->read_cb->cb_arg);
     size_t i;
-    gpr_log(GPR_DEBUG, "read: error=%s", grpc_error_std_string(error).c_str());
+    gpr_log(GPR_DEBUG, "read: error=%s",
+            grpc_core::StatusToString(error).c_str());
 
     for (i = 0; i < ep->read_slices->count; i++) {
       char* dump = grpc_dump_slice(ep->read_slices->slices[i],
@@ -136,7 +138,8 @@ static void CallWriteCb(CFStreamEndpoint* ep, grpc_error_handle error) {
   if (grpc_tcp_trace.enabled()) {
     gpr_log(GPR_DEBUG, "CFStream endpoint:%p call_write_cb %p %p:%p", ep,
             ep->write_cb, ep->write_cb->cb, ep->write_cb->cb_arg);
-    gpr_log(GPR_DEBUG, "write: error=%s", grpc_error_std_string(error).c_str());
+    gpr_log(GPR_DEBUG, "write: error=%s",
+            grpc_core::StatusToString(error).c_str());
   }
   grpc_closure* cb = ep->write_cb;
   ep->write_cb = nullptr;
@@ -147,9 +150,9 @@ static void CallWriteCb(CFStreamEndpoint* ep, grpc_error_handle error) {
 static void ReadAction(void* arg, grpc_error_handle error) {
   CFStreamEndpoint* ep = static_cast<CFStreamEndpoint*>(arg);
   GPR_ASSERT(ep->read_cb != nullptr);
-  if (error != GRPC_ERROR_NONE) {
-    grpc_slice_buffer_reset_and_unref_internal(ep->read_slices);
-    CallReadCb(ep, GRPC_ERROR_REF(error));
+  if (!error.ok()) {
+    grpc_slice_buffer_reset_and_unref(ep->read_slices);
+    CallReadCb(ep, error);
     EP_UNREF(ep, "read");
     return;
   }
@@ -160,28 +163,27 @@ static void ReadAction(void* arg, grpc_error_handle error) {
   CFIndex read_size =
       CFReadStreamRead(ep->read_stream, GRPC_SLICE_START_PTR(slice), len);
   if (read_size == -1) {
-    grpc_slice_buffer_reset_and_unref_internal(ep->read_slices);
+    grpc_slice_buffer_reset_and_unref(ep->read_slices);
     CFErrorRef stream_error = CFReadStreamCopyError(ep->read_stream);
     if (stream_error != nullptr) {
       error = CFStreamAnnotateError(
           GRPC_ERROR_CREATE_FROM_CFERROR(stream_error, "Read error"), ep);
       CFRelease(stream_error);
     } else {
-      error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("Read error");
+      error = GRPC_ERROR_CREATE("Read error");
     }
     CallReadCb(ep, error);
     EP_UNREF(ep, "read");
   } else if (read_size == 0) {
-    grpc_slice_buffer_reset_and_unref_internal(ep->read_slices);
+    grpc_slice_buffer_reset_and_unref(ep->read_slices);
     CallReadCb(ep,
-               CFStreamAnnotateError(
-                   GRPC_ERROR_CREATE_FROM_STATIC_STRING("Socket closed"), ep));
+               CFStreamAnnotateError(GRPC_ERROR_CREATE("Socket closed"), ep));
     EP_UNREF(ep, "read");
   } else {
     if (read_size < static_cast<CFIndex>(len)) {
       grpc_slice_buffer_trim_end(ep->read_slices, len - read_size, nullptr);
     }
-    CallReadCb(ep, GRPC_ERROR_NONE);
+    CallReadCb(ep, absl::OkStatus());
     EP_UNREF(ep, "read");
   }
 }
@@ -189,26 +191,25 @@ static void ReadAction(void* arg, grpc_error_handle error) {
 static void WriteAction(void* arg, grpc_error_handle error) {
   CFStreamEndpoint* ep = static_cast<CFStreamEndpoint*>(arg);
   GPR_ASSERT(ep->write_cb != nullptr);
-  if (error != GRPC_ERROR_NONE) {
-    grpc_slice_buffer_reset_and_unref_internal(ep->write_slices);
-    CallWriteCb(ep, GRPC_ERROR_REF(error));
+  if (!error.ok()) {
+    grpc_slice_buffer_reset_and_unref(ep->write_slices);
+    CallWriteCb(ep, error);
     EP_UNREF(ep, "write");
     return;
   }
-
   grpc_slice slice = grpc_slice_buffer_take_first(ep->write_slices);
   size_t slice_len = GRPC_SLICE_LENGTH(slice);
   CFIndex write_size = CFWriteStreamWrite(
       ep->write_stream, GRPC_SLICE_START_PTR(slice), slice_len);
   if (write_size == -1) {
-    grpc_slice_buffer_reset_and_unref_internal(ep->write_slices);
+    grpc_slice_buffer_reset_and_unref(ep->write_slices);
     CFErrorRef stream_error = CFWriteStreamCopyError(ep->write_stream);
     if (stream_error != nullptr) {
       error = CFStreamAnnotateError(
           GRPC_ERROR_CREATE_FROM_CFERROR(stream_error, "write failed."), ep);
       CFRelease(stream_error);
     } else {
-      error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("write failed.");
+      error = GRPC_ERROR_CREATE("write failed.");
     }
     CallWriteCb(ep, error);
     EP_UNREF(ep, "write");
@@ -220,7 +221,7 @@ static void WriteAction(void* arg, grpc_error_handle error) {
     if (ep->write_slices->length > 0) {
       ep->stream_sync->NotifyOnWrite(&ep->write_action);
     } else {
-      CallWriteCb(ep, GRPC_ERROR_NONE);
+      CallWriteCb(ep, absl::OkStatus());
       EP_UNREF(ep, "write");
     }
 
@@ -230,14 +231,15 @@ static void WriteAction(void* arg, grpc_error_handle error) {
       gpr_log(GPR_DEBUG, "WRITE %p (peer=%s): %s", ep, ep->peer_string.c_str(),
               dump);
       gpr_free(dump);
-      grpc_slice_unref_internal(trace_slice);
+      grpc_core::CSliceUnref(trace_slice);
     }
   }
-  grpc_slice_unref_internal(slice);
+  grpc_core::CSliceUnref(slice);
 }
 
 static void CFStreamRead(grpc_endpoint* ep, grpc_slice_buffer* slices,
-                         grpc_closure* cb, bool urgent) {
+                         grpc_closure* cb, bool urgent,
+                         int /*min_progress_size*/) {
   CFStreamEndpoint* ep_impl = reinterpret_cast<CFStreamEndpoint*>(ep);
   if (grpc_tcp_trace.enabled()) {
     gpr_log(GPR_DEBUG, "CFStream endpoint:%p read (%p, %p) length:%zu", ep_impl,
@@ -246,7 +248,7 @@ static void CFStreamRead(grpc_endpoint* ep, grpc_slice_buffer* slices,
   GPR_ASSERT(ep_impl->read_cb == nullptr);
   ep_impl->read_cb = cb;
   ep_impl->read_slices = slices;
-  grpc_slice_buffer_reset_and_unref_internal(slices);
+  grpc_slice_buffer_reset_and_unref(slices);
   grpc_slice_buffer_add_indexed(
       slices, GRPC_SLICE_MALLOC(GRPC_TCP_DEFAULT_READ_SLICE_SIZE));
   EP_REF(ep_impl, "read");
@@ -254,7 +256,7 @@ static void CFStreamRead(grpc_endpoint* ep, grpc_slice_buffer* slices,
 }
 
 static void CFStreamWrite(grpc_endpoint* ep, grpc_slice_buffer* slices,
-                          grpc_closure* cb, void* arg) {
+                          grpc_closure* cb, void* arg, int /*max_frame_size*/) {
   CFStreamEndpoint* ep_impl = reinterpret_cast<CFStreamEndpoint*>(ep);
   if (grpc_tcp_trace.enabled()) {
     gpr_log(GPR_DEBUG, "CFStream endpoint:%p write (%p, %p) length:%zu",
@@ -271,14 +273,14 @@ void CFStreamShutdown(grpc_endpoint* ep, grpc_error_handle why) {
   CFStreamEndpoint* ep_impl = reinterpret_cast<CFStreamEndpoint*>(ep);
   if (grpc_tcp_trace.enabled()) {
     gpr_log(GPR_DEBUG, "CFStream endpoint:%p shutdown (%s)", ep_impl,
-            grpc_error_std_string(why).c_str());
+            grpc_core::StatusToString(why).c_str());
   }
   CFReadStreamClose(ep_impl->read_stream);
   CFWriteStreamClose(ep_impl->write_stream);
   ep_impl->stream_sync->Shutdown(why);
   if (grpc_tcp_trace.enabled()) {
     gpr_log(GPR_DEBUG, "CFStream endpoint:%p shutdown DONE (%s)", ep_impl,
-            grpc_error_std_string(why).c_str());
+            grpc_core::StatusToString(why).c_str());
   }
 }
 
@@ -351,11 +353,13 @@ grpc_endpoint* grpc_cfstream_endpoint_create(CFReadStreamRef read_stream,
   if (native_handle) {
     CFRelease(native_handle);
   }
+  absl::StatusOr<std::string> addr_uri;
   if (getsockname(sockfd, reinterpret_cast<sockaddr*>(resolved_local_addr.addr),
-                  &resolved_local_addr.len) < 0) {
+                  &resolved_local_addr.len) < 0 ||
+      !(addr_uri = grpc_sockaddr_to_uri(&resolved_local_addr)).ok()) {
     ep_impl->local_address = "";
   } else {
-    ep_impl->local_address = grpc_sockaddr_to_uri(&resolved_local_addr);
+    ep_impl->local_address = addr_uri.value();
   }
   ep_impl->read_cb = nil;
   ep_impl->write_cb = nil;
@@ -369,4 +373,4 @@ grpc_endpoint* grpc_cfstream_endpoint_create(CFReadStreamRef read_stream,
   return &ep_impl->base;
 }
 
-#endif /* GRPC_CFSTREAM_ENDPOINT */
+#endif  // GRPC_CFSTREAM_ENDPOINT

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

@@ -1,33 +1,33 @@
-/*
- *
- * 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_ENDPOINT_CFSTREAM_H
-#define GRPC_CORE_LIB_IOMGR_ENDPOINT_CFSTREAM_H
-/*
-   Low level TCP "bottom half" implementation, for use by transports built on
-   top of a TCP connection.
-
-   Note that this file does not (yet) include APIs for creating the socket in
-   the first place.
-
-   All calls passing slice transfer ownership of a slice refcount unless
-   otherwise specified.
-*/
+//
+//
+// 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_ENDPOINT_CFSTREAM_H
+#define GRPC_SRC_CORE_LIB_IOMGR_ENDPOINT_CFSTREAM_H
+//
+// Low level TCP "bottom half" implementation, for use by transports built on
+// top of a TCP connection.
+
+// Note that this file does not (yet) include APIs for creating the socket in
+// the first place.
+
+// All calls passing slice transfer ownership of a slice refcount unless
+// otherwise specified.
+//
 
 #include <grpc/support/port_platform.h>
 
@@ -44,6 +44,6 @@ grpc_endpoint* grpc_cfstream_endpoint_create(CFReadStreamRef read_stream,
                                              const char* peer_string,
                                              CFStreamHandle* stream_sync);
 
-#endif /* GRPC_CFSTREAM */
+#endif  // GRPC_CFSTREAM
 
-#endif /* GRPC_CORE_LIB_IOMGR_ENDPOINT_CFSTREAM_H */
+#endif  // GRPC_SRC_CORE_LIB_IOMGR_ENDPOINT_CFSTREAM_H