grpc 1.51.0 → 1.52.0.pre2

data/src/core/ext/xds/xds_route_config.h

@@ -27,7 +27,6 @@
 #include <string>
 #include <vector>
 
-#include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 #include "absl/types/variant.h"
@@ -44,6 +43,7 @@
 #include "src/core/ext/xds/xds_resource_type_impl.h"
 #include "src/core/lib/channel/status_util.h"
 #include "src/core/lib/gprpp/time.h"
+#include "src/core/lib/gprpp/validation_errors.h"
 #include "src/core/lib/matchers/matchers.h"
 
 namespace grpc_core {
@@ -102,25 +102,35 @@ struct XdsRouteConfigResource : public XdsResourceType::ResourceData {
 
     struct RouteAction {
       struct HashPolicy {
-        enum Type { HEADER, CHANNEL_ID };
-        Type type;
-        bool terminal = false;
-        // Fields used for type HEADER.
-        std::string header_name;
-        std::unique_ptr<RE2> regex = nullptr;
-        std::string regex_substitution;
+        struct Header {
+          std::string header_name;
+          std::unique_ptr<RE2> regex;
+          std::string regex_substitution;
+
+          Header() = default;
+
+          // Copyable.
+          Header(const Header& other);
+          Header& operator=(const Header& other);
 
-        HashPolicy() {}
+          // Movable.
+          Header(Header&& other) noexcept;
+          Header& operator=(Header&& other) noexcept;
 
-        // Copyable.
-        HashPolicy(const HashPolicy& other);
-        HashPolicy& operator=(const HashPolicy& other);
+          bool operator==(const Header& other) const;
+          std::string ToString() const;
+        };
 
-        // Moveable.
-        HashPolicy(HashPolicy&& other) noexcept;
-        HashPolicy& operator=(HashPolicy&& other) noexcept;
+        struct ChannelId {
+          bool operator==(const ChannelId&) const { return true; }
+        };
 
-        bool operator==(const HashPolicy& other) const;
+        absl::variant<Header, ChannelId> policy;
+        bool terminal = false;
+
+        bool operator==(const HashPolicy& other) const {
+          return policy == other.policy && terminal == other.terminal;
+        }
         std::string ToString() const;
       };
 
@@ -210,9 +220,10 @@ struct XdsRouteConfigResource : public XdsResourceType::ResourceData {
   }
   std::string ToString() const;
 
-  static absl::StatusOr<XdsRouteConfigResource> Parse(
+  static XdsRouteConfigResource Parse(
       const XdsResourceType::DecodeContext& context,
-      const envoy_config_route_v3_RouteConfiguration* route_config);
+      const envoy_config_route_v3_RouteConfiguration* route_config,
+      ValidationErrors* errors);
 };
 
 class XdsRouteConfigResourceType

data/src/core/ext/xds/xds_server_config_fetcher.cc

@@ -42,7 +42,6 @@
 
 #include <grpc/grpc.h>
 #include <grpc/grpc_security.h>
-#include <grpc/impl/codegen/grpc_types.h>
 #include <grpc/slice.h>
 #include <grpc/status.h>
 #include <grpc/support/log.h>
@@ -70,11 +69,9 @@
 #include "src/core/lib/gprpp/host_port.h"
 #include "src/core/lib/gprpp/match.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
-#include "src/core/lib/gprpp/status_helper.h"
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/gprpp/unique_type_name.h"
 #include "src/core/lib/iomgr/endpoint.h"
-#include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/iomgr_fwd.h"
 #include "src/core/lib/iomgr/resolved_address.h"
@@ -319,7 +316,8 @@ class XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
           http_filters);
   ~XdsServerConfigSelector() override = default;
 
-  CallConfig GetCallConfig(grpc_metadata_batch* metadata) override;
+  absl::StatusOr<CallConfig> GetCallConfig(
+      grpc_metadata_batch* metadata) override;
 
  private:
   struct VirtualHost {
@@ -1188,30 +1186,26 @@ XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
   return config_selector;
 }
 
-ServerConfigSelector::CallConfig XdsServerConfigFetcher::ListenerWatcher::
-    FilterChainMatchManager::XdsServerConfigSelector::GetCallConfig(
-        grpc_metadata_batch* metadata) {
+absl::StatusOr<ServerConfigSelector::CallConfig>
+XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
+    XdsServerConfigSelector::GetCallConfig(grpc_metadata_batch* metadata) {
   CallConfig call_config;
   if (metadata->get_pointer(HttpPathMetadata()) == nullptr) {
-    call_config.error = GRPC_ERROR_CREATE("No path found");
-    return call_config;
+    return absl::InternalError("no path found");
   }
   absl::string_view path =
       metadata->get_pointer(HttpPathMetadata())->as_string_view();
   if (metadata->get_pointer(HttpAuthorityMetadata()) == nullptr) {
-    call_config.error = GRPC_ERROR_CREATE("No authority found");
-    return call_config;
+    return absl::InternalError("no authority found");
   }
   absl::string_view authority =
       metadata->get_pointer(HttpAuthorityMetadata())->as_string_view();
   auto vhost_index = XdsRouting::FindVirtualHostForDomain(
       VirtualHostListIterator(&virtual_hosts_), authority);
   if (!vhost_index.has_value()) {
-    call_config.error = grpc_error_set_int(
-        GRPC_ERROR_CREATE(absl::StrCat("could not find VirtualHost for ",
-                                       authority, " in RouteConfiguration")),
-        StatusIntProperty::kRpcStatus, GRPC_STATUS_UNAVAILABLE);
-    return call_config;
+    return absl::UnavailableError(
+        absl::StrCat("could not find VirtualHost for ", authority,
+                     " in RouteConfiguration"));
   }
   auto& virtual_host = virtual_hosts_[vhost_index.value()];
   auto route_index = XdsRouting::GetRouteForRequest(
@@ -1220,10 +1214,7 @@ ServerConfigSelector::CallConfig XdsServerConfigFetcher::ListenerWatcher::
     auto& route = virtual_host.routes[route_index.value()];
     // Found the matching route
     if (route.unsupported_action) {
-      call_config.error = grpc_error_set_int(
-          GRPC_ERROR_CREATE("Matching route has unsupported action"),
-          StatusIntProperty::kRpcStatus, GRPC_STATUS_UNAVAILABLE);
-      return call_config;
+      return absl::UnavailableError("matching route has unsupported action");
     }
     if (route.method_config != nullptr) {
       call_config.method_configs =
@@ -1232,10 +1223,7 @@ ServerConfigSelector::CallConfig XdsServerConfigFetcher::ListenerWatcher::
     }
     return call_config;
   }
-  call_config.error = grpc_error_set_int(GRPC_ERROR_CREATE("No route matched"),
-                                         StatusIntProperty::kRpcStatus,
-                                         GRPC_STATUS_UNAVAILABLE);
-  return call_config;
+  return absl::UnavailableError("no route matched");
 }
 
 //

data/src/core/ext/xds/xds_transport_grpc.cc

@@ -29,8 +29,8 @@
 #include <grpc/byte_buffer.h>
 #include <grpc/byte_buffer_reader.h>
 #include <grpc/grpc.h>
-#include <grpc/impl/codegen/connectivity_state.h>
-#include <grpc/impl/codegen/propagation_bits.h>
+#include <grpc/impl/connectivity_state.h>
+#include <grpc/impl/propagation_bits.h>
 #include <grpc/slice.h>
 #include <grpc/support/log.h>
 

data/src/core/ext/xds/xds_transport_grpc.h

@@ -25,7 +25,7 @@
 
 #include "absl/status/status.h"
 
-#include <grpc/impl/codegen/grpc_types.h>
+#include <grpc/grpc.h>
 #include <grpc/slice.h>
 #include <grpc/status.h>
 

data/src/core/lib/address_utils/parse_address.cc

@@ -1,20 +1,20 @@
-/*
- *
- * Copyright 2016 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 2016 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>
 
@@ -117,7 +117,7 @@ grpc_error_handle UnixAbstractSockaddrPopulate(
 
 }  // namespace grpc_core
 
-#else  /* GRPC_HAVE_UNIX_SOCKET */
+#else   // GRPC_HAVE_UNIX_SOCKET
 
 bool grpc_parse_unix(const grpc_core::URI& /* uri */,
                      grpc_resolved_address* /* resolved_addr */) {
@@ -142,7 +142,7 @@ grpc_error_handle UnixAbstractSockaddrPopulate(
 }
 
 }  // namespace grpc_core
-#endif /* GRPC_HAVE_UNIX_SOCKET */
+#endif  // GRPC_HAVE_UNIX_SOCKET
 
 bool grpc_parse_ipv4_hostport(absl::string_view hostport,
                               grpc_resolved_address* addr, bool log_errors) {

data/src/core/lib/address_utils/parse_address.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_ADDRESS_UTILS_PARSE_ADDRESS_H
 #define GRPC_CORE_LIB_ADDRESS_UTILS_PARSE_ADDRESS_H
@@ -30,37 +30,37 @@
 #include "src/core/lib/iomgr/resolved_address.h"
 #include "src/core/lib/uri/uri_parser.h"
 
-/** Populate \a resolved_addr from \a uri, whose path is expected to contain a
- * unix socket path. Returns true upon success. */
+/// Populate \a resolved_addr from \a uri, whose path is expected to contain a
+/// unix socket path. Returns true upon success.
 bool grpc_parse_unix(const grpc_core::URI& uri,
                      grpc_resolved_address* resolved_addr);
 
-/** Populate \a resolved_addr from \a uri, whose path is expected to contain a
- * unix socket path in the abstract namespace. Returns true upon success. */
+/// Populate \a resolved_addr from \a uri, whose path is expected to contain a
+/// unix socket path in the abstract namespace. Returns true upon success.
 bool grpc_parse_unix_abstract(const grpc_core::URI& uri,
                               grpc_resolved_address* resolved_addr);
 
-/** Populate \a resolved_addr from \a uri, whose path is expected to contain an
- * IPv4 host:port pair. Returns true upon success. */
+/// Populate \a resolved_addr from \a uri, whose path is expected to contain an
+/// IPv4 host:port pair. Returns true upon success.
 bool grpc_parse_ipv4(const grpc_core::URI& uri,
                      grpc_resolved_address* resolved_addr);
 
-/** Populate \a resolved_addr from \a uri, whose path is expected to contain an
- * IPv6 host:port pair. Returns true upon success. */
+/// Populate \a resolved_addr from \a uri, whose path is expected to contain an
+/// IPv6 host:port pair. Returns true upon success.
 bool grpc_parse_ipv6(const grpc_core::URI& uri,
                      grpc_resolved_address* resolved_addr);
 
-/** Populate \a resolved_addr from \a uri. Returns true upon success. */
+/// Populate \a resolved_addr from \a uri. Returns true upon success.
 bool grpc_parse_uri(const grpc_core::URI& uri,
                     grpc_resolved_address* resolved_addr);
 
-/** Parse bare IPv4 or IPv6 "IP:port" strings. */
+/// Parse bare IPv4 or IPv6 "IP:port" strings.
 bool grpc_parse_ipv4_hostport(absl::string_view hostport,
                               grpc_resolved_address* addr, bool log_errors);
 bool grpc_parse_ipv6_hostport(absl::string_view hostport,
                               grpc_resolved_address* addr, bool log_errors);
 
-/* Converts named or numeric port to a uint16 suitable for use in a sockaddr. */
+// Converts named or numeric port to a uint16 suitable for use in a sockaddr.
 uint16_t grpc_strhtons(const char* port);
 
 namespace grpc_core {
@@ -72,15 +72,15 @@ absl::StatusOr<grpc_resolved_address> StringToSockaddr(
 absl::StatusOr<grpc_resolved_address> StringToSockaddr(
     absl::string_view address, int port);
 
-/** Populate \a resolved_addr to be a unix socket at |path| */
+/// Populate \a resolved_addr to be a unix socket at |path|
 grpc_error_handle UnixSockaddrPopulate(absl::string_view path,
                                        grpc_resolved_address* resolved_addr);
 
-/** Populate \a resolved_addr to be a unix socket in the abstract namespace
- * at |path| */
+/// Populate \a resolved_addr to be a unix socket in the abstract namespace
+/// at |path|
 grpc_error_handle UnixAbstractSockaddrPopulate(
     absl::string_view path, grpc_resolved_address* resolved_addr);
 
 }  // namespace grpc_core
 
-#endif /* GRPC_CORE_LIB_ADDRESS_UTILS_PARSE_ADDRESS_H */
+#endif  // GRPC_CORE_LIB_ADDRESS_UTILS_PARSE_ADDRESS_H

data/src/core/lib/address_utils/sockaddr_utils.cc

@@ -1,20 +1,20 @@
-/*
- *
- * Copyright 2016 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 2016 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>
 
@@ -33,6 +33,7 @@
 
 #include <grpc/support/log.h>
 
+#include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/gprpp/host_port.h"
 #include "src/core/lib/iomgr/port.h"
 #include "src/core/lib/iomgr/sockaddr.h"
@@ -93,10 +94,10 @@ int grpc_sockaddr_is_v4mapped(const grpc_resolved_address* resolved_addr,
     if (memcmp(addr6->sin6_addr.s6_addr, kV4MappedPrefix,
                sizeof(kV4MappedPrefix)) == 0) {
       if (resolved_addr4_out != nullptr) {
-        /* Normalize ::ffff:0.0.0.0/96 to IPv4. */
+        // Normalize ::ffff:0.0.0.0/96 to IPv4.
         memset(resolved_addr4_out, 0, sizeof(*resolved_addr4_out));
         addr4_out->sin_family = GRPC_AF_INET;
-        /* s6_addr32 would be nice, but it's non-standard. */
+        // s6_addr32 would be nice, but it's non-standard.
         memcpy(&addr4_out->sin_addr, &addr6->sin6_addr.s6_addr[12], 4);
         addr4_out->sin_port = addr6->sin6_port;
         resolved_addr4_out->len =
@@ -138,7 +139,7 @@ int grpc_sockaddr_is_wildcard(const grpc_resolved_address* resolved_addr,
   }
   addr = reinterpret_cast<const grpc_sockaddr*>(resolved_addr->addr);
   if (addr->sa_family == GRPC_AF_INET) {
-    /* Check for 0.0.0.0 */
+    // Check for 0.0.0.0
     const grpc_sockaddr_in* addr4 =
         reinterpret_cast<const grpc_sockaddr_in*>(addr);
     if (addr4->sin_addr.s_addr != 0) {
@@ -147,7 +148,7 @@ int grpc_sockaddr_is_wildcard(const grpc_resolved_address* resolved_addr,
     *port_out = grpc_ntohs(addr4->sin_port);
     return 1;
   } else if (addr->sa_family == GRPC_AF_INET6) {
-    /* Check for :: */
+    // Check for ::
     const grpc_sockaddr_in6* addr6 =
         reinterpret_cast<const grpc_sockaddr_in6*>(addr);
     int i;
@@ -252,7 +253,7 @@ absl::StatusOr<std::string> grpc_sockaddr_to_string(
     return absl::InvalidArgumentError(
         absl::StrCat("Unknown sockaddr family: ", addr->sa_family));
   }
-  /* This is probably redundant, but we wouldn't want to log the wrong error. */
+  // This is probably redundant, but we wouldn't want to log the wrong error.
   errno = save_errno;
   return out;
 }
@@ -356,7 +357,7 @@ std::string grpc_sockaddr_get_packed_host(
     const char* addr_bytes = reinterpret_cast<const char*>(&addr6->sin6_addr);
     return std::string(addr_bytes, 16);
   } else {
-    GPR_ASSERT(false);
+    grpc_core::Crash("unknown socket family");
   }
 }
 
@@ -371,7 +372,7 @@ void grpc_sockaddr_mask_bits(grpc_resolved_address* address,
     } else if (mask_bits >= 32) {
       return;
     }
-    uint32_t mask_ip_addr = (~(uint32_t(0))) << (32 - mask_bits);
+    uint32_t mask_ip_addr = (~(uint32_t{0})) << (32 - mask_bits);
     addr4->sin_addr.s_addr &= grpc_htonl(mask_ip_addr);
   } else if (addr->sa_family == GRPC_AF_INET6) {
     grpc_sockaddr_in6* addr6 = reinterpret_cast<grpc_sockaddr_in6*>(addr);
@@ -387,25 +388,25 @@ void grpc_sockaddr_mask_bits(grpc_resolved_address* address,
     GPR_ASSERT(sizeof(addr6->sin6_addr) == sizeof(address_parts));
     memcpy(address_parts, &addr6->sin6_addr, sizeof(grpc_in6_addr));
     if (mask_bits <= 32) {
-      uint32_t mask_ip_addr = (~(uint32_t(0))) << (32 - mask_bits);
+      uint32_t mask_ip_addr = (~(uint32_t{0})) << (32 - mask_bits);
       address_parts[0] &= grpc_htonl(mask_ip_addr);
       memset(&address_parts[1], 0, sizeof(uint32_t));
       memset(&address_parts[2], 0, sizeof(uint32_t));
       memset(&address_parts[3], 0, sizeof(uint32_t));
     } else if (mask_bits <= 64) {
       mask_bits -= 32;
-      uint32_t mask_ip_addr = (~(uint32_t(0))) << (32 - mask_bits);
+      uint32_t mask_ip_addr = (~(uint32_t{0})) << (32 - mask_bits);
       address_parts[1] &= grpc_htonl(mask_ip_addr);
       memset(&address_parts[2], 0, sizeof(uint32_t));
       memset(&address_parts[3], 0, sizeof(uint32_t));
     } else if (mask_bits <= 96) {
       mask_bits -= 64;
-      uint32_t mask_ip_addr = (~(uint32_t(0))) << (32 - mask_bits);
+      uint32_t mask_ip_addr = (~(uint32_t{0})) << (32 - mask_bits);
       address_parts[2] &= grpc_htonl(mask_ip_addr);
       memset(&address_parts[3], 0, sizeof(uint32_t));
     } else {
       mask_bits -= 96;
-      uint32_t mask_ip_addr = (~(uint32_t(0))) << (32 - mask_bits);
+      uint32_t mask_ip_addr = (~(uint32_t{0})) << (32 - mask_bits);
       address_parts[3] &= grpc_htonl(mask_ip_addr);
     }
     memcpy(&addr6->sin6_addr, address_parts, sizeof(grpc_in6_addr));

data/src/core/lib/address_utils/sockaddr_utils.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_ADDRESS_UTILS_SOCKADDR_UTILS_H
 #define GRPC_CORE_LIB_ADDRESS_UTILS_SOCKADDR_UTILS_H
@@ -29,37 +29,37 @@
 
 #include "src/core/lib/iomgr/resolved_address.h"
 
-/* Returns true if addr is an IPv4-mapped IPv6 address within the
-   ::ffff:0.0.0.0/96 range, or false otherwise.
+// Returns true if addr is an IPv4-mapped IPv6 address within the
+// ::ffff:0.0.0.0/96 range, or false otherwise.
 
-   If addr4_out is non-NULL, the inner IPv4 address will be copied here when
-   returning true. */
+// If addr4_out is non-NULL, the inner IPv4 address will be copied here when
+// returning true.
 int grpc_sockaddr_is_v4mapped(const grpc_resolved_address* addr,
                               grpc_resolved_address* addr4_out);
 
-/* If addr is an AF_INET address, writes the corresponding ::ffff:0.0.0.0/96
-   address to addr6_out and returns true.  Otherwise returns false. */
+// If addr is an AF_INET address, writes the corresponding ::ffff:0.0.0.0/96
+// address to addr6_out and returns true.  Otherwise returns false.
 int grpc_sockaddr_to_v4mapped(const grpc_resolved_address* addr,
                               grpc_resolved_address* addr6_out);
 
-/* If addr is ::, 0.0.0.0, or ::ffff:0.0.0.0, writes the port number to
- *port_out (if not NULL) and returns true, otherwise returns false. */
+// If addr is ::, 0.0.0.0, or ::ffff:0.0.0.0, writes the port number to
+// port_out (if not NULL) and returns true, otherwise returns false.
 int grpc_sockaddr_is_wildcard(const grpc_resolved_address* addr, int* port_out);
 
-/* Writes 0.0.0.0:port and [::]:port to separate sockaddrs. */
+// Writes 0.0.0.0:port and [::]:port to separate sockaddrs.
 void grpc_sockaddr_make_wildcards(int port, grpc_resolved_address* wild4_out,
                                   grpc_resolved_address* wild6_out);
 
-/* Writes 0.0.0.0:port. */
+// Writes 0.0.0.0:port.
 void grpc_sockaddr_make_wildcard4(int port, grpc_resolved_address* wild_out);
 
-/* Writes [::]:port. */
+// Writes [::]:port.
 void grpc_sockaddr_make_wildcard6(int port, grpc_resolved_address* wild_out);
 
-/* Return the IP port number of a sockaddr */
+// Return the IP port number of a sockaddr
 int grpc_sockaddr_get_port(const grpc_resolved_address* addr);
 
-/* Set IP port number of a sockaddr */
+// Set IP port number of a sockaddr
 int grpc_sockaddr_set_port(grpc_resolved_address* addr, int port);
 
 // Converts a sockaddr into a newly-allocated human-readable string.
@@ -70,11 +70,11 @@ int grpc_sockaddr_set_port(grpc_resolved_address* addr, int port);
 absl::StatusOr<std::string> grpc_sockaddr_to_string(
     const grpc_resolved_address* addr, bool normalize) GRPC_MUST_USE_RESULT;
 
-/* Returns the URI string corresponding to \a addr */
+// Returns the URI string corresponding to \a addr
 absl::StatusOr<std::string> grpc_sockaddr_to_uri(
     const grpc_resolved_address* addr);
 
-/* Returns the URI scheme corresponding to \a addr */
+// Returns the URI scheme corresponding to \a addr
 const char* grpc_sockaddr_get_uri_scheme(const grpc_resolved_address* addr);
 
 int grpc_sockaddr_get_family(const grpc_resolved_address* resolved_addr);
@@ -97,4 +97,4 @@ bool grpc_sockaddr_match_subnet(const grpc_resolved_address* address,
                                 const grpc_resolved_address* subnet_address,
                                 uint32_t mask_bits);
 
-#endif /* GRPC_CORE_LIB_ADDRESS_UTILS_SOCKADDR_UTILS_H */
+#endif  // GRPC_CORE_LIB_ADDRESS_UTILS_SOCKADDR_UTILS_H

data/src/core/lib/avl/avl.h

@@ -215,7 +215,7 @@ class AVL {
 
   static NodePtr RotateLeftRight(K key, V value, const NodePtr& left,
                                  const NodePtr& right) {
-    /* rotate_right(..., rotate_left(left), right) */
+    // rotate_right(..., rotate_left(left), right)
     return MakeNode(
         left->right->kv.first, left->right->kv.second,
         MakeNode(left->kv.first, left->kv.second, left->left,
@@ -225,7 +225,7 @@ class AVL {
 
   static NodePtr RotateRightLeft(K key, V value, const NodePtr& left,
                                  const NodePtr& right) {
-    /* rotate_left(..., left, rotate_right(right)) */
+    // rotate_left(..., left, rotate_right(right))
     return MakeNode(
         right->left->kv.first, right->left->kv.second,
         MakeNode(std::move(key), std::move(value), left, right->left->left),
@@ -390,7 +390,7 @@ class AVL<K, void> {
 
   static NodePtr RotateLeftRight(K key, const NodePtr& left,
                                  const NodePtr& right) {
-    /* rotate_right(..., rotate_left(left), right) */
+    // rotate_right(..., rotate_left(left), right)
     return MakeNode(left->right->key,
                     MakeNode(left->key, left->left, left->right->left),
                     MakeNode(std::move(key), left->right->right, right));
@@ -398,7 +398,7 @@ class AVL<K, void> {
 
   static NodePtr RotateRightLeft(K key, const NodePtr& left,
                                  const NodePtr& right) {
-    /* rotate_left(..., left, rotate_right(right)) */
+    // rotate_left(..., left, rotate_right(right))
     return MakeNode(right->left->key,
                     MakeNode(std::move(key), left, right->left->left),
                     MakeNode(right->key, right->left->right, right->right));