grpc 1.43.1 → 1.44.0.pre2

data/src/core/lib/transport/timeout_encoding.h

@@ -21,18 +21,48 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <grpc/slice.h>
-#include <grpc/support/time.h>
-
-#include "src/core/lib/gpr/string.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
+#include "src/core/lib/slice/slice.h"
+
+namespace grpc_core {
+
+class Timeout {
+ public:
+  static Timeout FromDuration(grpc_millis duration);
+
+  // Computes: 100 * ((this - other) / other)
+  double RatioVersus(Timeout other) const;
+  Slice Encode() const;
+  grpc_millis AsDuration() const;
+
+ private:
+  enum class Unit : uint8_t {
+    kNanoseconds,
+    kMilliseconds,
+    kTenMilliseconds,
+    kHundredMilliseconds,
+    kSeconds,
+    kTenSeconds,
+    kHundredSeconds,
+    kMinutes,
+    kTenMinutes,
+    kHundredMinutes,
+    kHours,
+  };
+
+  Timeout(uint16_t value, Unit unit) : value_(value), unit_(unit) {}
+
+  static Timeout FromMillis(int64_t millis);
+  static Timeout FromSeconds(int64_t seconds);
+  static Timeout FromMinutes(int64_t minutes);
+  static Timeout FromHours(int64_t hours);
+
+  uint16_t value_;
+  Unit unit_;
+};
 
-#define GRPC_HTTP2_TIMEOUT_ENCODE_MIN_BUFSIZE 10
+absl::optional<grpc_millis> ParseTimeout(const Slice& text);
 
-/* Encode/decode timeouts to the GRPC over HTTP/2 format;
-   encoding may round up arbitrarily. If the timeout is larger than about 1157
-   days, it will be capped and "99999999S" will be sent on the wire. */
-void grpc_http2_encode_timeout(grpc_millis timeout, char* buffer);
-int grpc_http2_decode_timeout(const grpc_slice& text, grpc_millis* timeout);
+}  // namespace grpc_core
 
 #endif /* GRPC_CORE_LIB_TRANSPORT_TIMEOUT_ENCODING_H */

data/src/core/lib/transport/transport.h

@@ -24,13 +24,13 @@
 #include <stddef.h>
 
 #include "src/core/lib/channel/context.h"
-#include "src/core/lib/gprpp/arena.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/iomgr/call_combiner.h"
 #include "src/core/lib/iomgr/endpoint.h"
 #include "src/core/lib/iomgr/polling_entity.h"
 #include "src/core/lib/iomgr/pollset.h"
 #include "src/core/lib/iomgr/pollset_set.h"
+#include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/transport/byte_stream.h"
 #include "src/core/lib/transport/connectivity_state.h"

data/src/core/lib/transport/transport_op_string.cc

@@ -40,47 +40,14 @@
 /* These routines are here to facilitate debugging - they produce string
    representations of various transport data structures */
 
-namespace {
-class MetadataListEncoder {
- public:
-  explicit MetadataListEncoder(std::vector<std::string>* out) : out_(out) {}
-  void Encode(const grpc_mdelem& md) {
-    MaybeAddComma();
-    out_->push_back("key=");
-    char* dump = grpc_dump_slice(GRPC_MDKEY(md), GPR_DUMP_HEX | GPR_DUMP_ASCII);
-    out_->push_back(dump);
-    gpr_free(dump);
-    out_->push_back(" value=");
-    dump = grpc_dump_slice(GRPC_MDVALUE(md), GPR_DUMP_HEX | GPR_DUMP_ASCII);
-    out_->push_back(dump);
-    gpr_free(dump);
-  }
-
-  void Encode(grpc_core::GrpcTimeoutMetadata, grpc_millis deadline) {
-    MaybeAddComma();
-    out_->push_back(absl::StrFormat("deadline=%" PRId64, deadline));
-  }
-
-  template <typename Which>
-  void Encode(Which, const typename Which::ValueType& value) {
-    MaybeAddComma();
-    out_->push_back(
-        absl::StrCat(Which::key(), "=", Which::DisplayValue(value)));
-  }
-
- private:
-  void MaybeAddComma() {
-    if (out_->size() != initial_size_) out_->push_back(", ");
-  }
-  std::vector<std::string>* const out_;
-  const size_t initial_size_ = out_->size();
-};
-}  // namespace
-
 static void put_metadata_list(const grpc_metadata_batch& md,
                               std::vector<std::string>* out) {
-  MetadataListEncoder encoder(out);
-  md.Encode(&encoder);
+  bool first = true;
+  md.Log([out, &first](absl::string_view key, absl::string_view value) {
+    if (!first) out->push_back(", ");
+    first = false;
+    out->push_back(absl::StrCat(key, "=", value));
+  });
 }
 
 std::string grpc_transport_stream_op_batch_string(

data/src/core/lib/uri/uri_parser.cc

@@ -1,20 +1,18 @@
-/*
- *
- * 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,14 +34,127 @@
 namespace grpc_core {
 
 namespace {
-// Checks if this string is made up of pchars, '/', '?', and '%' exclusively.
+
+// Returns true for any sub-delim character, as defined in:
+// https://datatracker.ietf.org/doc/html/rfc3986#section-2.2
+bool IsSubDelimChar(char c) {
+  switch (c) {
+    case '!':
+    case '$':
+    case '&':
+    case '\'':
+    case '(':
+    case ')':
+    case '*':
+    case '+':
+    case ',':
+    case ';':
+    case '=':
+      return true;
+  }
+  return false;
+}
+
+// Returns true for any unreserved character, as defined in:
+// https://datatracker.ietf.org/doc/html/rfc3986#section-2.3
+bool IsUnreservedChar(char c) {
+  if (absl::ascii_isalnum(c)) return true;
+  switch (c) {
+    case '-':
+    case '.':
+    case '_':
+    case '~':
+      return true;
+  }
+  return false;
+}
+
+// Returns true for any character in scheme, as defined in:
+// https://datatracker.ietf.org/doc/html/rfc3986#section-3.1
+bool IsSchemeChar(char c) {
+  if (absl::ascii_isalnum(c)) return true;
+  switch (c) {
+    case '+':
+    case '-':
+    case '.':
+      return true;
+  }
+  return false;
+}
+
+// Returns true for any character in authority, as defined in:
+// https://datatracker.ietf.org/doc/html/rfc3986#section-3.2
+bool IsAuthorityChar(char c) {
+  if (IsUnreservedChar(c)) return true;
+  if (IsSubDelimChar(c)) return true;
+  switch (c) {
+    case ':':
+    case '[':
+    case ']':
+    case '@':
+      return true;
+  }
+  return false;
+}
+
+// Returns true for any character in pchar, as defined in:
+// https://datatracker.ietf.org/doc/html/rfc3986#section-3.3
+bool IsPChar(char c) {
+  if (IsUnreservedChar(c)) return true;
+  if (IsSubDelimChar(c)) return true;
+  switch (c) {
+    case ':':
+    case '@':
+      return true;
+  }
+  return false;
+}
+
+// Returns true for any character allowed in a URI path, as defined in:
+// https://datatracker.ietf.org/doc/html/rfc3986#section-3.3
+bool IsPathChar(char c) { return IsPChar(c) || c == '/'; }
+
+// Returns true for any character allowed in a URI query or fragment,
+// as defined in:
 // See https://tools.ietf.org/html/rfc3986#section-3.4
-bool IsPCharString(absl::string_view str) {
-  return (str.find_first_not_of("ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-                                "abcdefghijklmnopqrstuvwxyz"
-                                "0123456789"
-                                "?/:@\\-._~!$&'()*+,;=%") ==
-          absl::string_view::npos);
+bool IsQueryOrFragmentChar(char c) {
+  return IsPChar(c) || c == '/' || c == '?';
+}
+
+// Same as IsQueryOrFragmentChar(), but excludes '&' and '='.
+bool IsQueryKeyOrValueChar(char c) {
+  return c != '&' && c != '=' && IsQueryOrFragmentChar(c);
+}
+
+// Returns a copy of str, percent-encoding any character for which
+// is_allowed_char() returns false.
+std::string PercentEncode(absl::string_view str,
+                          std::function<bool(char)> is_allowed_char) {
+  std::string out;
+  for (char c : str) {
+    if (!is_allowed_char(c)) {
+      std::string hex = absl::BytesToHexString(absl::string_view(&c, 1));
+      GPR_ASSERT(hex.size() == 2);
+      // BytesToHexString() returns lower case, but
+      // https://datatracker.ietf.org/doc/html/rfc3986#section-6.2.2.1 says
+      // to prefer upper-case.
+      absl::AsciiStrToUpper(&hex);
+      out.push_back('%');
+      out.append(hex);
+    } else {
+      out.push_back(c);
+    }
+  }
+  return out;
+}
+
+// Checks if this string is made up of query/fragment chars and '%' exclusively.
+// See https://tools.ietf.org/html/rfc3986#section-3.4
+bool IsQueryOrFragmentString(absl::string_view str) {
+  for (char c : str) {
+    if (!IsQueryOrFragmentChar(c) && c != '%') return false;
+  }
+  return true;
 }
 
 absl::Status MakeInvalidURIStatus(absl::string_view part_name,
@@ -52,8 +163,13 @@ absl::Status MakeInvalidURIStatus(absl::string_view part_name,
   return absl::InvalidArgumentError(absl::StrFormat(
       "Could not parse '%s' from uri '%s'. %s", part_name, uri, extra));
 }
+
 }  // namespace
 
+std::string URI::PercentEncodePath(absl::string_view str) {
+  return PercentEncode(str, IsPathChar);
+}
+
 // Similar to `grpc_permissive_percent_decode_slice`, this %-decodes all valid
 // triplets, and passes through the rest verbatim.
 std::string URI::PercentDecode(absl::string_view str) {
@@ -65,18 +181,14 @@ std::string URI::PercentDecode(absl::string_view str) {
   out.reserve(str.size());
   for (size_t i = 0; i < str.length(); i++) {
     unescaped = "";
-    if (str[i] != '%') {
-      out += str[i];
-      continue;
-    }
-    if (i + 3 >= str.length() ||
-        !absl::CUnescape(absl::StrCat("\\x", str.substr(i + 1, 2)),
-                         &unescaped) ||
-        unescaped.length() > 1) {
-      out += str[i];
-    } else {
+    if (str[i] == '%' && i + 3 <= str.length() &&
+        absl::CUnescape(absl::StrCat("\\x", str.substr(i + 1, 2)),
+                        &unescaped) &&
+        unescaped.length() == 1) {
       out += unescaped[0];
       i += 2;
+    } else {
+      out += str[i];
     }
   }
   return out;
@@ -86,11 +198,11 @@ absl::StatusOr<URI> URI::Parse(absl::string_view uri_text) {
   absl::StatusOr<std::string> decoded;
   absl::string_view remaining = uri_text;
   // parse scheme
-  size_t idx = remaining.find(':');
-  if (idx == remaining.npos || idx == 0) {
+  size_t offset = remaining.find(':');
+  if (offset == remaining.npos || offset == 0) {
     return MakeInvalidURIStatus("scheme", uri_text, "Scheme not found.");
   }
-  std::string scheme(remaining.substr(0, idx));
+  std::string scheme(remaining.substr(0, offset));
   if (scheme.find_first_not_of("ABCDEFGHIJKLMNOPQRSTUVWXYZ"
                                "abcdefghijklmnopqrstuvwxyz"
                                "0123456789+-.") != std::string::npos) {
@@ -102,30 +214,38 @@ absl::StatusOr<URI> URI::Parse(absl::string_view uri_text) {
         "scheme", uri_text,
         "Scheme must begin with an alpha character [A-Za-z].");
   }
-  remaining.remove_prefix(scheme.length() + 1);
+  remaining.remove_prefix(offset + 1);
   // parse authority
   std::string authority;
-  if (absl::StartsWith(remaining, "//")) {
-    remaining.remove_prefix(2);
-    authority =
-        PercentDecode(remaining.substr(0, remaining.find_first_of("/?#")));
-    remaining.remove_prefix(authority.length());
+  if (absl::ConsumePrefix(&remaining, "//")) {
+    offset = remaining.find_first_of("/?#");
+    authority = PercentDecode(remaining.substr(0, offset));
+    if (offset == remaining.npos) {
+      remaining = "";
+    } else {
+      remaining.remove_prefix(offset);
+    }
   }
   // parse path
   std::string path;
   if (!remaining.empty()) {
-    path = PercentDecode(remaining.substr(0, remaining.find_first_of("?#")));
-    remaining.remove_prefix(path.length());
+    offset = remaining.find_first_of("?#");
+    path = PercentDecode(remaining.substr(0, offset));
+    if (offset == remaining.npos) {
+      remaining = "";
+    } else {
+      remaining.remove_prefix(offset);
+    }
   }
   // parse query
   std::vector<QueryParam> query_param_pairs;
-  if (!remaining.empty() && remaining[0] == '?') {
-    remaining.remove_prefix(1);
-    absl::string_view tmp_query = remaining.substr(0, remaining.find('#'));
+  if (absl::ConsumePrefix(&remaining, "?")) {
+    offset = remaining.find('#');
+    absl::string_view tmp_query = remaining.substr(0, offset);
     if (tmp_query.empty()) {
       return MakeInvalidURIStatus("query", uri_text, "Invalid query string.");
     }
-    if (!IsPCharString(tmp_query)) {
+    if (!IsQueryOrFragmentString(tmp_query)) {
       return MakeInvalidURIStatus("query string", uri_text,
                                   "Query string contains invalid characters.");
     }
@@ -136,12 +256,15 @@ absl::StatusOr<URI> URI::Parse(absl::string_view uri_text) {
       query_param_pairs.push_back({PercentDecode(possible_kv.first),
                                    PercentDecode(possible_kv.second)});
     }
-    remaining.remove_prefix(tmp_query.length());
+    if (offset == remaining.npos) {
+      remaining = "";
+    } else {
+      remaining.remove_prefix(offset);
+    }
   }
   std::string fragment;
-  if (!remaining.empty() && remaining[0] == '#') {
-    remaining.remove_prefix(1);
-    if (!IsPCharString(remaining)) {
+  if (absl::ConsumePrefix(&remaining, "#")) {
+    if (!IsQueryOrFragmentString(remaining)) {
       return MakeInvalidURIStatus("fragment", uri_text,
                                   "Fragment contains invalid characters.");
     }
@@ -151,6 +274,18 @@ absl::StatusOr<URI> URI::Parse(absl::string_view uri_text) {
              std::move(query_param_pairs), std::move(fragment));
 }
 
+absl::StatusOr<URI> URI::Create(std::string scheme, std::string authority,
+                                std::string path,
+                                std::vector<QueryParam> query_parameter_pairs,
+                                std::string fragment) {
+  if (!authority.empty() && !path.empty() && path[0] != '/') {
+    return absl::InvalidArgumentError(
+        "if authority is present, path must start with a '/'");
+  }
+  return URI(std::move(scheme), std::move(authority), std::move(path),
+             std::move(query_parameter_pairs), std::move(fragment));
+}
+
 URI::URI(std::string scheme, std::string authority, std::string path,
          std::vector<QueryParam> query_parameter_pairs, std::string fragment)
     : scheme_(std::move(scheme)),
@@ -188,4 +323,39 @@ URI& URI::operator=(const URI& other) {
   }
   return *this;
 }
+
+namespace {
+
+// A pair formatter for use with absl::StrJoin() for formatting query params.
+struct QueryParameterFormatter {
+  void operator()(std::string* out, const URI::QueryParam& query_param) const {
+    out->append(
+        absl::StrCat(PercentEncode(query_param.key, IsQueryKeyOrValueChar), "=",
+                     PercentEncode(query_param.value, IsQueryKeyOrValueChar)));
+  }
+};
+
+}  // namespace
+
+std::string URI::ToString() const {
+  std::vector<std::string> parts = {PercentEncode(scheme_, IsSchemeChar), ":"};
+  if (!authority_.empty()) {
+    parts.emplace_back("//");
+    parts.emplace_back(PercentEncode(authority_, IsAuthorityChar));
+  }
+  if (!path_.empty()) {
+    parts.emplace_back(PercentEncode(path_, IsPathChar));
+  }
+  if (!query_parameter_pairs_.empty()) {
+    parts.push_back("?");
+    parts.push_back(
+        absl::StrJoin(query_parameter_pairs_, "&", QueryParameterFormatter()));
+  }
+  if (!fragment_.empty()) {
+    parts.push_back("#");
+    parts.push_back(PercentEncode(fragment_, IsQueryOrFragmentChar));
+  }
+  return absl::StrJoin(parts, "");
+}
+
 }  // namespace grpc_core

data/src/core/lib/uri/uri_parser.h

@@ -1,20 +1,18 @@
-/*
- *
- * 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_URI_URI_PARSER_H
 #define GRPC_CORE_LIB_URI_URI_PARSER_H
@@ -40,15 +38,23 @@ class URI {
     bool operator==(const QueryParam& other) const {
       return key == other.key && value == other.value;
     }
+    bool operator<(const QueryParam& other) const {
+      int c = key.compare(other.key);
+      if (c != 0) return c < 0;
+      return value < other.value;
+    }
   };
 
-  // Creates an instance of GrpcURI by parsing an rfc3986 URI string. Returns
-  // an IllegalArgumentError on failure.
+  // Creates a URI by parsing an rfc3986 URI string. Returns an
+  // InvalidArgumentError on failure.
   static absl::StatusOr<URI> Parse(absl::string_view uri_text);
-  // Explicit construction by individual URI components
-  URI(std::string scheme, std::string authority, std::string path,
-      std::vector<QueryParam> query_parameter_pairs, std::string fragment_);
+  // Creates a URI from components. Returns an InvalidArgumentError on failure.
+  static absl::StatusOr<URI> Create(
+      std::string scheme, std::string authority, std::string path,
+      std::vector<QueryParam> query_parameter_pairs, std::string fragment);
+
   URI() = default;
+
   // Copy construction and assignment
   URI(const URI& other);
   URI& operator=(const URI& other);
@@ -56,6 +62,8 @@ class URI {
   URI(URI&&) = default;
   URI& operator=(URI&&) = default;
 
+  static std::string PercentEncodePath(absl::string_view str);
+
   static std::string PercentDecode(absl::string_view str);
 
   const std::string& scheme() const { return scheme_; }
@@ -76,7 +84,12 @@ class URI {
   }
   const std::string& fragment() const { return fragment_; }
 
+  std::string ToString() const;
+
  private:
+  URI(std::string scheme, std::string authority, std::string path,
+      std::vector<QueryParam> query_parameter_pairs, std::string fragment);
+
   std::string scheme_;
   std::string authority_;
   std::string path_;
@@ -86,4 +99,4 @@ class URI {
 };
 }  // namespace grpc_core
 
-#endif /* GRPC_CORE_LIB_URI_URI_PARSER_H */
+#endif  // GRPC_CORE_LIB_URI_URI_PARSER_H

data/src/core/plugin_registry/grpc_plugin_registry.cc

@@ -27,8 +27,6 @@ void grpc_chttp2_plugin_init(void);
 void grpc_chttp2_plugin_shutdown(void);
 void grpc_client_channel_init(void);
 void grpc_client_channel_shutdown(void);
-void grpc_inproc_plugin_init(void);
-void grpc_inproc_plugin_shutdown(void);
 void grpc_resolver_fake_init(void);
 void grpc_resolver_fake_shutdown(void);
 void grpc_lb_policy_grpclb_init(void);
@@ -64,6 +62,8 @@ void ServiceConfigParserShutdown(void);
 
 #ifndef GRPC_NO_XDS
 namespace grpc_core {
+void RbacFilterInit(void);
+void RbacFilterShutdown(void);
 void XdsClientGlobalInit();
 void XdsClientGlobalShutdown();
 }  // namespace grpc_core
@@ -99,7 +99,6 @@ void grpc_register_built_in_plugins(void) {
   grpc_register_plugin(grpc_core::ServiceConfigParserInit,
                        grpc_core::ServiceConfigParserShutdown);
   grpc_register_plugin(grpc_client_channel_init, grpc_client_channel_shutdown);
-  grpc_register_plugin(grpc_inproc_plugin_init, grpc_inproc_plugin_shutdown);
   grpc_register_plugin(grpc_resolver_fake_init, grpc_resolver_fake_shutdown);
   grpc_register_plugin(grpc_lb_policy_grpclb_init,
                        grpc_lb_policy_grpclb_shutdown);
@@ -128,6 +127,8 @@ void grpc_register_built_in_plugins(void) {
   grpc_register_plugin(grpc_core::FaultInjectionFilterInit,
                        grpc_core::FaultInjectionFilterShutdown);
 #ifndef GRPC_NO_XDS
+  // rbac_filter is being guarded with GRPC_NO_XDS to avoid a dependency on the re2 library by default
+  grpc_register_plugin(grpc_core::RbacFilterInit, grpc_core::RbacFilterShutdown);
   grpc_register_plugin(grpc_core::XdsClientGlobalInit,
                        grpc_core::XdsClientGlobalShutdown);
   grpc_register_plugin(grpc_certificate_provider_registry_init,

data/src/core/tsi/alts/handshaker/alts_handshaker_client.cc

@@ -717,11 +717,11 @@ alts_handshaker_client* alts_grpc_handshaker_client_create(
                 channel, nullptr, GRPC_PROPAGATE_DEFAULTS, interested_parties,
                 grpc_slice_from_static_string(ALTS_SERVICE_METHOD), &slice,
                 GRPC_MILLIS_INF_FUTURE, nullptr);
+  grpc_slice_unref_internal(slice);
   GRPC_CLOSURE_INIT(&client->on_handshaker_service_resp_recv, grpc_cb, client,
                     grpc_schedule_on_exec_ctx);
   GRPC_CLOSURE_INIT(&client->on_status_received, on_status_received, client,
                     grpc_schedule_on_exec_ctx);
-  grpc_slice_unref_internal(slice);
   return &client->base;
 }
 

data/src/core/tsi/ssl/session_cache/ssl_session.h

@@ -21,11 +21,9 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <grpc/slice.h>
-
-extern "C" {
 #include <openssl/ssl.h>
-}
+
+#include <grpc/slice.h>
 
 #include "src/core/lib/gprpp/ref_counted.h"
 

data/src/core/tsi/ssl/session_cache/ssl_session_cache.h

@@ -21,14 +21,12 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <grpc/slice.h>
-#include <grpc/support/sync.h>
+#include <map>
 
-extern "C" {
 #include <openssl/ssl.h>
-}
 
-#include <map>
+#include <grpc/slice.h>
+#include <grpc/support/sync.h>
 
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/gprpp/ref_counted.h"