grpc 1.50.0.pre1 → 1.52.0.pre2

data/src/core/lib/iomgr/tcp_client_posix.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>
 
@@ -36,6 +36,7 @@
 
 #include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/gpr/string.h"
+#include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/iomgr/ev_posix.h"
 #include "src/core/lib/iomgr/executor.h"
 #include "src/core/lib/iomgr/iomgr_internal.h"
@@ -94,28 +95,28 @@ void grpc_tcp_client_global_init() {
 static grpc_error_handle prepare_socket(
     const grpc_resolved_address* addr, int fd,
     const grpc_core::PosixTcpOptions& options) {
-  grpc_error_handle err = GRPC_ERROR_NONE;
+  grpc_error_handle err;
 
   GPR_ASSERT(fd >= 0);
 
   err = grpc_set_socket_nonblocking(fd, 1);
-  if (!GRPC_ERROR_IS_NONE(err)) goto error;
+  if (!err.ok()) goto error;
   err = grpc_set_socket_cloexec(fd, 1);
-  if (!GRPC_ERROR_IS_NONE(err)) goto error;
+  if (!err.ok()) goto error;
   if (!grpc_is_unix_socket(addr)) {
     err = grpc_set_socket_low_latency(fd, 1);
-    if (!GRPC_ERROR_IS_NONE(err)) goto error;
+    if (!err.ok()) goto error;
     err = grpc_set_socket_reuse_addr(fd, 1);
-    if (!GRPC_ERROR_IS_NONE(err)) goto error;
+    if (!err.ok()) goto error;
     err = grpc_set_socket_tcp_user_timeout(fd, options, true /* is_client */);
-    if (!GRPC_ERROR_IS_NONE(err)) goto error;
+    if (!err.ok()) goto error;
   }
   err = grpc_set_socket_no_sigpipe_if_possible(fd);
-  if (!GRPC_ERROR_IS_NONE(err)) goto error;
+  if (!err.ok()) goto error;
 
   err = grpc_apply_socket_mutator_in_args(fd, GRPC_FD_CLIENT_CONNECTION_USAGE,
                                           options);
-  if (!GRPC_ERROR_IS_NONE(err)) goto error;
+  if (!err.ok()) goto error;
 
   goto done;
 
@@ -132,12 +133,11 @@ static void tc_on_alarm(void* acp, grpc_error_handle error) {
   async_connect* ac = static_cast<async_connect*>(acp);
   if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace)) {
     gpr_log(GPR_INFO, "CLIENT_CONNECT: %s: on_alarm: error=%s",
-            ac->addr_str.c_str(), grpc_error_std_string(error).c_str());
+            ac->addr_str.c_str(), grpc_core::StatusToString(error).c_str());
   }
   gpr_mu_lock(&ac->mu);
   if (ac->fd != nullptr) {
-    grpc_fd_shutdown(
-        ac->fd, GRPC_ERROR_CREATE_FROM_STATIC_STRING("connect() timed out"));
+    grpc_fd_shutdown(ac->fd, GRPC_ERROR_CREATE("connect() timed out"));
   }
   done = (--ac->refs == 0);
   gpr_mu_unlock(&ac->mu);
@@ -170,11 +170,9 @@ static void on_writable(void* acp, grpc_error_handle error) {
   std::string addr_str = ac->addr_str;
   grpc_fd* fd;
 
-  (void)GRPC_ERROR_REF(error);
-
   if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace)) {
     gpr_log(GPR_INFO, "CLIENT_CONNECT: %s: on_writable: error=%s",
-            ac->addr_str.c_str(), grpc_error_std_string(error).c_str());
+            ac->addr_str.c_str(), grpc_core::StatusToString(error).c_str());
   }
 
   gpr_mu_lock(&ac->mu);
@@ -187,15 +185,15 @@ static void on_writable(void* acp, grpc_error_handle error) {
   grpc_timer_cancel(&ac->alarm);
 
   gpr_mu_lock(&ac->mu);
-  if (!GRPC_ERROR_IS_NONE(error)) {
-    error =
-        grpc_error_set_str(error, GRPC_ERROR_STR_OS_ERROR, "Timeout occurred");
+  if (!error.ok()) {
+    error = grpc_error_set_str(error, grpc_core::StatusStrProperty::kOsError,
+                               "Timeout occurred");
     goto finish;
   }
 
   if (connect_cancelled) {
     // The callback should not get scheduled in this case.
-    error = GRPC_ERROR_NONE;
+    error = absl::OkStatus();
     goto finish;
   }
 
@@ -216,31 +214,31 @@ static void on_writable(void* acp, grpc_error_handle error) {
       fd = nullptr;
       break;
     case ENOBUFS:
-      /* We will get one of these errors if we have run out of
-         memory in the kernel for the data structures allocated
-         when you connect a socket.  If this happens it is very
-         likely that if we wait a little bit then try again the
-         connection will work (since other programs or this
-         program will close their network connections and free up
-         memory).  This does _not_ indicate that there is anything
-         wrong with the server we are connecting to, this is a
-         local problem.
-
-         If you are looking at this code, then chances are that
-         your program or another program on the same computer
-         opened too many network connections.  The "easy" fix:
-         don't do that! */
+      // We will get one of these errors if we have run out of
+      // memory in the kernel for the data structures allocated
+      // when you connect a socket.  If this happens it is very
+      // likely that if we wait a little bit then try again the
+      // connection will work (since other programs or this
+      // program will close their network connections and free up
+      // memory).  This does _not_ indicate that there is anything
+      // wrong with the server we are connecting to, this is a
+      // local problem.
+
+      // If you are looking at this code, then chances are that
+      // your program or another program on the same computer
+      // opened too many network connections.  The "easy" fix:
+      // don't do that!
       gpr_log(GPR_ERROR, "kernel out of buffers");
       gpr_mu_unlock(&ac->mu);
       grpc_fd_notify_on_write(fd, &ac->write_closure);
       return;
     case ECONNREFUSED:
-      /* This error shouldn't happen for anything other than connect(). */
+      // This error shouldn't happen for anything other than connect().
       error = GRPC_OS_ERROR(so_error, "connect");
       break;
     default:
-      /* We don't really know which syscall triggered the problem here,
-         so punt by reporting getsockopt(). */
+      // We don't really know which syscall triggered the problem here,
+      // so punt by reporting getsockopt().
       error = GRPC_OS_ERROR(so_error, "getsockopt(SO_ERROR)");
       break;
   }
@@ -261,14 +259,17 @@ finish:
   }
   done = (--ac->refs == 0);
   gpr_mu_unlock(&ac->mu);
-  if (!GRPC_ERROR_IS_NONE(error)) {
+  if (!error.ok()) {
     std::string str;
-    bool ret = grpc_error_get_str(error, GRPC_ERROR_STR_DESCRIPTION, &str);
+    bool ret = grpc_error_get_str(
+        error, grpc_core::StatusStrProperty::kDescription, &str);
     GPR_ASSERT(ret);
     std::string description =
         absl::StrCat("Failed to connect to remote host: ", str);
-    error = grpc_error_set_str(error, GRPC_ERROR_STR_DESCRIPTION, description);
-    error = grpc_error_set_str(error, GRPC_ERROR_STR_TARGET_ADDRESS, addr_str);
+    error = grpc_error_set_str(
+        error, grpc_core::StatusStrProperty::kDescription, description);
+    error = grpc_error_set_str(
+        error, grpc_core::StatusStrProperty::kTargetAddress, addr_str);
   }
   if (done) {
     // This is safe even outside the lock, because "done", the sentinel, is
@@ -281,9 +282,6 @@ finish:
   // between the core shutdown mu and the connector mu (b/188239051)
   if (!connect_cancelled) {
     grpc_core::Executor::Run(closure, error);
-  } else if (!GRPC_ERROR_IS_NONE(error)) {
-    // Unref the error here because it is not used.
-    (void)GRPC_ERROR_UNREF(error);
   }
 }
 
@@ -294,27 +292,27 @@ grpc_error_handle grpc_tcp_client_prepare_fd(
   grpc_dualstack_mode dsmode;
   grpc_error_handle error;
   *fd = -1;
-  /* Use dualstack sockets where available. Set mapped to v6 or v4 mapped to
-     v6. */
+  // Use dualstack sockets where available. Set mapped to v6 or v4 mapped to
+  // v6.
   if (!grpc_sockaddr_to_v4mapped(addr, mapped_addr)) {
-    /* addr is v4 mapped to v6 or v6. */
+    // addr is v4 mapped to v6 or v6.
     memcpy(mapped_addr, addr, sizeof(*mapped_addr));
   }
   error =
       grpc_create_dualstack_socket(mapped_addr, SOCK_STREAM, 0, &dsmode, fd);
-  if (!GRPC_ERROR_IS_NONE(error)) {
+  if (!error.ok()) {
     return error;
   }
   if (dsmode == GRPC_DSMODE_IPV4) {
-    /* Original addr is either v4 or v4 mapped to v6. Set mapped_addr to v4. */
+    // Original addr is either v4 or v4 mapped to v6. Set mapped_addr to v4.
     if (!grpc_sockaddr_is_v4mapped(addr, mapped_addr)) {
       memcpy(mapped_addr, addr, sizeof(*mapped_addr));
     }
   }
-  if ((error = prepare_socket(mapped_addr, *fd, options)) != GRPC_ERROR_NONE) {
+  if ((error = prepare_socket(mapped_addr, *fd, options)) != absl::OkStatus()) {
     return error;
   }
-  return GRPC_ERROR_NONE;
+  return absl::OkStatus();
 }
 
 int64_t grpc_tcp_client_create_from_prepared_fd(
@@ -330,8 +328,7 @@ int64_t grpc_tcp_client_create_from_prepared_fd(
 
   auto addr_uri = grpc_sockaddr_to_uri(addr);
   if (!addr_uri.ok()) {
-    grpc_error_handle error =
-        GRPC_ERROR_CREATE_FROM_CPP_STRING(addr_uri.status().ToString());
+    grpc_error_handle error = GRPC_ERROR_CREATE(addr_uri.status().ToString());
     grpc_core::ExecCtx::Run(DEBUG_LOCATION, closure, error);
     return 0;
   }
@@ -348,15 +345,15 @@ int64_t grpc_tcp_client_create_from_prepared_fd(
     // Connection already succeded. Return 0 to discourage any cancellation
     // attempts.
     *ep = grpc_tcp_client_create_from_fd(fdobj, options, addr_uri.value());
-    grpc_core::ExecCtx::Run(DEBUG_LOCATION, closure, GRPC_ERROR_NONE);
+    grpc_core::ExecCtx::Run(DEBUG_LOCATION, closure, absl::OkStatus());
     return 0;
   }
   if (errno != EWOULDBLOCK && errno != EINPROGRESS) {
     // Connection already failed. Return 0 to discourage any cancellation
     // attempts.
     grpc_error_handle error = GRPC_OS_ERROR(errno, "connect");
-    error = grpc_error_set_str(error, GRPC_ERROR_STR_TARGET_ADDRESS,
-                               addr_uri.value());
+    error = grpc_error_set_str(
+        error, grpc_core::StatusStrProperty::kTargetAddress, addr_uri.value());
     grpc_fd_orphan(fdobj, nullptr, nullptr, "tcp_client_connect_error");
     grpc_core::ExecCtx::Run(DEBUG_LOCATION, closure, error);
     return 0;
@@ -409,7 +406,7 @@ static int64_t tcp_connect(grpc_closure* closure, grpc_endpoint** ep,
   grpc_error_handle error;
   *ep = nullptr;
   if ((error = grpc_tcp_client_prepare_fd(options, addr, &mapped_addr, &fd)) !=
-      GRPC_ERROR_NONE) {
+      absl::OkStatus()) {
     grpc_core::ExecCtx::Run(DEBUG_LOCATION, closure, error);
     return 0;
   }
@@ -455,7 +452,7 @@ static bool tcp_cancel_connect(int64_t connection_handle) {
     // Shutdown the fd. This would cause on_writable to run as soon as possible.
     // We dont need to pass a custom error here because it wont be used since
     // the on_connect_closure is not run if connect cancellation is successfull.
-    grpc_fd_shutdown(ac->fd, GRPC_ERROR_NONE);
+    grpc_fd_shutdown(ac->fd, absl::OkStatus());
   }
   bool done = (--ac->refs == 0);
   gpr_mu_unlock(&ac->mu);

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

@@ -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.
+//
+//
 
 #ifndef GRPC_CORE_LIB_IOMGR_TCP_CLIENT_POSIX_H
 #define GRPC_CORE_LIB_IOMGR_TCP_CLIENT_POSIX_H
@@ -26,47 +26,47 @@
 #include "src/core/lib/iomgr/socket_utils_posix.h"
 #include "src/core/lib/iomgr/tcp_client.h"
 
-/* Create an endpoint from a connected grpc_fd.
+// Create an endpoint from a connected grpc_fd.
 
-   fd: a connected FD. Ownership is taken.
-   config: may contain custom settings for the endpoint
-   addr_str: destination address in printable format
-   slice_allocator: ownership is taken by client.
-   Returns: a new endpoint
-*/
+// fd: a connected FD. Ownership is taken.
+// config: may contain custom settings for the endpoint
+// addr_str: destination address in printable format
+// slice_allocator: ownership is taken by client.
+// Returns: a new endpoint
+//
 grpc_endpoint* grpc_tcp_create_from_fd(
     grpc_fd* fd, const grpc_event_engine::experimental::EndpointConfig& config,
     absl::string_view addr_str);
 
-/* Return a configured, unbound, unconnected TCP client fd.
+// Return a configured, unbound, unconnected TCP client fd.
 
-   options: may contain custom settings for the fd
-   addr: the destination address
-   mapped_addr: out parameter. addr mapped to an address appropriate to the
-     type of socket FD created. For example, if addr is IPv4 and dual stack
-     sockets are available, mapped_addr will be an IPv4-mapped IPv6 address
-   fd: out parameter. The new FD
-   Returns: error, if any. Out parameters are not set on error
-*/
+// options: may contain custom settings for the fd
+// addr: the destination address
+// mapped_addr: out parameter. addr mapped to an address appropriate to the
+//   type of socket FD created. For example, if addr is IPv4 and dual stack
+//   sockets are available, mapped_addr will be an IPv4-mapped IPv6 address
+// fd: out parameter. The new FD
+// Returns: error, if any. Out parameters are not set on error
+//
 grpc_error_handle grpc_tcp_client_prepare_fd(
     const grpc_core::PosixTcpOptions& options,
     const grpc_resolved_address* addr, grpc_resolved_address* mapped_addr,
     int* fd);
 
-/* Connect a configured TCP client fd.
+// Connect a configured TCP client fd.
 
-   interested_parties: a set of pollsets that would be interested in this
-     connection being established (in order to continue their work
-   closure: called when complete. On success, *ep will be set.
-   fd: an FD returned from grpc_tcp_client_prepare_fd().
-   options: may contain custom settings for the endpoint
-   deadline: connection deadline
-   ep: out parameter. Set before closure is called if successful
-*/
+// interested_parties: a set of pollsets that would be interested in this
+//   connection being established (in order to continue their work
+// closure: called when complete. On success, *ep will be set.
+// fd: an FD returned from grpc_tcp_client_prepare_fd().
+// options: may contain custom settings for the endpoint
+// deadline: connection deadline
+// ep: out parameter. Set before closure is called if successful
+//
 int64_t grpc_tcp_client_create_from_prepared_fd(
     grpc_pollset_set* interested_parties, grpc_closure* closure, const int fd,
     const grpc_core::PosixTcpOptions& options,
     const grpc_resolved_address* addr, grpc_core::Timestamp deadline,
     grpc_endpoint** ep);
 
-#endif /* GRPC_CORE_LIB_IOMGR_TCP_CLIENT_POSIX_H */
+#endif  // GRPC_CORE_LIB_IOMGR_TCP_CLIENT_POSIX_H

data/src/core/lib/iomgr/tcp_client_windows.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>
 
@@ -31,6 +31,7 @@
 #include <grpc/support/log_windows.h>
 
 #include "src/core/lib/address_utils/sockaddr_utils.h"
+#include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/iomgr/iocp_windows.h"
 #include "src/core/lib/iomgr/sockaddr.h"
 #include "src/core/lib/iomgr/sockaddr_windows.h"
@@ -83,8 +84,6 @@ static void on_connect(void* acp, grpc_error_handle error) {
   GPR_ASSERT(*ep == NULL);
   grpc_closure* on_done = ac->on_done;
 
-  (void)GRPC_ERROR_REF(error);
-
   gpr_mu_lock(&ac->mu);
   grpc_winsocket* socket = ac->socket;
   ac->socket = NULL;
@@ -94,7 +93,7 @@ static void on_connect(void* acp, grpc_error_handle error) {
 
   gpr_mu_lock(&ac->mu);
 
-  if (GRPC_ERROR_IS_NONE(error)) {
+  if (error.ok()) {
     if (socket != NULL) {
       DWORD transfered_bytes = 0;
       DWORD flags;
@@ -110,18 +109,18 @@ static void on_connect(void* acp, grpc_error_handle error) {
         socket = nullptr;
       }
     } else {
-      error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("socket is null");
+      error = GRPC_ERROR_CREATE("socket is null");
     }
   }
 
   async_connect_unlock_and_cleanup(ac, socket);
-  /* If the connection was aborted, the callback was already called when
-     the deadline was met. */
+  // If the connection was aborted, the callback was already called when
+  // the deadline was met.
   grpc_core::ExecCtx::Run(DEBUG_LOCATION, on_done, error);
 }
 
-/* Tries to issue one async connection, then schedules both an IOCP
-   notification request for the connection, and one timeout alert. */
+// Tries to issue one async connection, then schedules both an IOCP
+// notification request for the connection, and one timeout alert.
 static int64_t tcp_connect(grpc_closure* on_done, grpc_endpoint** endpoint,
                            grpc_pollset_set* interested_parties,
                            const EndpointConfig& config,
@@ -137,19 +136,19 @@ static int64_t tcp_connect(grpc_closure* on_done, grpc_endpoint** endpoint,
   GUID guid = WSAID_CONNECTEX;
   DWORD ioctl_num_bytes;
   grpc_winsocket_callback_info* info;
-  grpc_error_handle error = GRPC_ERROR_NONE;
+  grpc_error_handle error;
   async_connect* ac = NULL;
   absl::StatusOr<std::string> addr_uri;
 
   addr_uri = grpc_sockaddr_to_uri(addr);
   if (!addr_uri.ok()) {
-    error = GRPC_ERROR_CREATE_FROM_CPP_STRING(addr_uri.status().ToString());
+    error = GRPC_ERROR_CREATE(addr_uri.status().ToString());
     goto failure;
   }
 
   *endpoint = NULL;
 
-  /* Use dualstack sockets where available. */
+  // Use dualstack sockets where available.
   if (grpc_sockaddr_to_v4mapped(addr, &addr6_v4mapped)) {
     addr = &addr6_v4mapped;
   }
@@ -162,12 +161,12 @@ static int64_t tcp_connect(grpc_closure* on_done, grpc_endpoint** endpoint,
   }
 
   error = grpc_tcp_prepare_socket(sock);
-  if (!GRPC_ERROR_IS_NONE(error)) {
+  if (!error.ok()) {
     goto failure;
   }
 
-  /* Grab the function pointer for ConnectEx for that specific socket.
-     It may change depending on the interface. */
+  // Grab the function pointer for ConnectEx for that specific socket.
+  // It may change depending on the interface.
   status =
       WSAIoctl(sock, SIO_GET_EXTENSION_FUNCTION_POINTER, &guid, sizeof(guid),
                &ConnectEx, sizeof(ConnectEx), &ioctl_num_bytes, NULL, NULL);
@@ -192,8 +191,8 @@ static int64_t tcp_connect(grpc_closure* on_done, grpc_endpoint** endpoint,
   success = ConnectEx(sock, (grpc_sockaddr*)&addr->addr, (int)addr->len, NULL,
                       0, NULL, &info->overlapped);
 
-  /* It wouldn't be unusual to get a success immediately. But we'll still get
-     an IOCP notification, so let's ignore it. */
+  // It wouldn't be unusual to get a success immediately. But we'll still get
+  // an IOCP notification, so let's ignore it.
   if (!success) {
     int last_error = WSAGetLastError();
     if (last_error != ERROR_IO_PENDING) {
@@ -219,13 +218,11 @@ static int64_t tcp_connect(grpc_closure* on_done, grpc_endpoint** endpoint,
   return 0;
 
 failure:
-  GPR_ASSERT(!GRPC_ERROR_IS_NONE(error));
+  GPR_ASSERT(!error.ok());
   grpc_error_handle final_error = grpc_error_set_str(
-      GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING("Failed to connect",
-                                                       &error, 1),
-      GRPC_ERROR_STR_TARGET_ADDRESS,
+      GRPC_ERROR_CREATE_REFERENCING("Failed to connect", &error, 1),
+      grpc_core::StatusStrProperty::kTargetAddress,
       addr_uri.ok() ? *addr_uri : addr_uri.status().ToString());
-  GRPC_ERROR_UNREF(error);
   if (socket != NULL) {
     grpc_winsocket_destroy(socket);
   } else if (sock != INVALID_SOCKET) {
@@ -240,4 +237,4 @@ static bool tcp_cancel_connect(int64_t /*connection_handle*/) { return false; }
 grpc_tcp_client_vtable grpc_windows_tcp_client_vtable = {tcp_connect,
                                                          tcp_cancel_connect};
 
-#endif /* GRPC_WINSOCK_SOCKET */
+#endif  // GRPC_WINSOCK_SOCKET