grpc 1.46.3-x86_64-linux → 1.47.0-x86_64-linux

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

@@ -17,16 +17,23 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <string.h>
+
 #include <cstdint>
+#include <string>
 #include <type_traits>
+#include <utility>
 
+#include "absl/functional/function_ref.h"
 #include "absl/meta/type_traits.h"
 #include "absl/strings/match.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
+
+#include <grpc/slice.h>
 
 #include "src/core/lib/gprpp/time.h"
-#include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/slice/slice.h"
-#include "src/core/lib/surface/validate_metadata.h"
 
 namespace grpc_core {
 
@@ -371,7 +378,7 @@ ParsedMetadata<MetadataContainer>::KeyValueVTable(absl::string_view key) {
   };
   static const auto set = [](const Buffer& value, MetadataContainer* map) {
     auto* p = static_cast<KV*>(value.pointer);
-    map->AppendUnknown(p->first.as_string_view(), p->second.Ref());
+    map->unknown_.Append(p->first.as_string_view(), p->second.Ref());
   };
   static const auto with_new_value = [](Slice* value, MetadataParseErrorFn,
                                         ParsedMetadata* result) {

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

@@ -20,6 +20,8 @@
 
 #include "src/core/lib/transport/status_conversion.h"
 
+#include "src/core/lib/iomgr/exec_ctx.h"
+
 grpc_http2_error_code grpc_status_to_http2_error(grpc_status_code status) {
   switch (status) {
     case GRPC_STATUS_OK:

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

@@ -21,9 +21,9 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <grpc/grpc.h>
+#include <grpc/status.h>
 
-#include "src/core/lib/iomgr/exec_ctx.h"
+#include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/transport/http2_errors.h"
 
 /* Conversion of grpc status codes to http2 error codes (for RST_STREAM) */

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

@@ -0,0 +1,253 @@
+//
+//
+// Copyright 2022 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>
+
+#include "src/core/lib/transport/tcp_connect_handshaker.h"
+
+#include <memory>
+
+#include "absl/base/thread_annotations.h"
+#include "absl/memory/memory.h"
+#include "absl/status/statusor.h"
+
+#include <grpc/impl/codegen/grpc_types.h>
+#include <grpc/slice.h>
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+
+#include "src/core/lib/address_utils/parse_address.h"
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/config/core_configuration.h"
+#include "src/core/lib/gpr/useful.h"
+#include "src/core/lib/gprpp/debug_location.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/gprpp/sync.h"
+#include "src/core/lib/iomgr/closure.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/polling_entity.h"
+#include "src/core/lib/iomgr/pollset_set.h"
+#include "src/core/lib/iomgr/resolved_address.h"
+#include "src/core/lib/iomgr/tcp_client.h"
+#include "src/core/lib/iomgr/tcp_server.h"
+#include "src/core/lib/slice/slice_internal.h"
+#include "src/core/lib/transport/handshaker.h"
+#include "src/core/lib/transport/handshaker_factory.h"
+#include "src/core/lib/transport/handshaker_registry.h"
+#include "src/core/lib/uri/uri_parser.h"
+
+namespace grpc_core {
+
+namespace {
+
+class TCPConnectHandshaker : public Handshaker {
+ public:
+  explicit TCPConnectHandshaker(grpc_pollset_set* pollset_set);
+  void Shutdown(grpc_error_handle why) override;
+  void DoHandshake(grpc_tcp_server_acceptor* /*acceptor*/,
+                   grpc_closure* on_handshake_done,
+                   HandshakerArgs* args) override;
+  const char* name() const override { return "tcp_connect"; }
+
+ private:
+  ~TCPConnectHandshaker() override;
+  void CleanupArgsForFailureLocked() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+  void FinishLocked(grpc_error_handle error) ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+  static void Connected(void* arg, grpc_error_handle error);
+
+  Mutex mu_;
+  bool shutdown_ ABSL_GUARDED_BY(mu_) = false;
+  // Endpoint and read buffer to destroy after a shutdown.
+  grpc_endpoint* endpoint_to_destroy_ ABSL_GUARDED_BY(mu_) = nullptr;
+  grpc_slice_buffer* read_buffer_to_destroy_ ABSL_GUARDED_BY(mu_) = nullptr;
+  grpc_closure* on_handshake_done_ ABSL_GUARDED_BY(mu_) = nullptr;
+  grpc_pollset_set* interested_parties_ = nullptr;
+  grpc_polling_entity pollent_;
+  HandshakerArgs* args_ = nullptr;
+  bool bind_endpoint_to_pollset_ = false;
+  grpc_resolved_address addr_;
+  grpc_closure connected_;
+};
+
+TCPConnectHandshaker::TCPConnectHandshaker(grpc_pollset_set* pollset_set)
+    : interested_parties_(grpc_pollset_set_create()),
+      pollent_(grpc_polling_entity_create_from_pollset_set(pollset_set)) {
+  // Interested parties might be null for platforms like Apple.
+  // Explicitly check before adding/deleting from pollset_set to handle this
+  // use case.
+  if (interested_parties_ != nullptr) {
+    grpc_polling_entity_add_to_pollset_set(&pollent_, interested_parties_);
+  }
+  GRPC_CLOSURE_INIT(&connected_, Connected, this, grpc_schedule_on_exec_ctx);
+}
+
+void TCPConnectHandshaker::Shutdown(grpc_error_handle why) {
+  // TODO(anramach): After migration to EventEngine, cancel the in-progress
+  // TCP connection attempt.
+  {
+    MutexLock lock(&mu_);
+    if (!shutdown_) {
+      shutdown_ = true;
+      // If we are shutting down while connecting, respond back with
+      // handshake done.
+      // The callback from grpc_tcp_client_connect will perform
+      // the necessary clean up.
+      if (on_handshake_done_ != nullptr) {
+        CleanupArgsForFailureLocked();
+        FinishLocked(
+            GRPC_ERROR_CREATE_FROM_STATIC_STRING("tcp handshaker shutdown"));
+      }
+    }
+  }
+  GRPC_ERROR_UNREF(why);
+}
+
+void TCPConnectHandshaker::DoHandshake(grpc_tcp_server_acceptor* /*acceptor*/,
+                                       grpc_closure* on_handshake_done,
+                                       HandshakerArgs* args) {
+  {
+    MutexLock lock(&mu_);
+    on_handshake_done_ = on_handshake_done;
+  }
+  GPR_ASSERT(args->endpoint == nullptr);
+  args_ = args;
+  char* address = grpc_channel_args_find_string(
+      args->args, GRPC_ARG_TCP_HANDSHAKER_RESOLVED_ADDRESS);
+  absl::StatusOr<URI> uri = URI::Parse(address);
+  if (!uri.ok() || !grpc_parse_uri(*uri, &addr_)) {
+    MutexLock lock(&mu_);
+    FinishLocked(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+        "Resolved address in invalid format"));
+    return;
+  }
+  bind_endpoint_to_pollset_ = grpc_channel_args_find_bool(
+      args->args, GRPC_ARG_TCP_HANDSHAKER_BIND_ENDPOINT_TO_POLLSET, false);
+  const char* args_to_remove[] = {
+      GRPC_ARG_TCP_HANDSHAKER_RESOLVED_ADDRESS,
+      GRPC_ARG_TCP_HANDSHAKER_BIND_ENDPOINT_TO_POLLSET};
+  // Update args to not contain the args relevant to TCP connect handshaker.
+  grpc_channel_args* channel_args = grpc_channel_args_copy_and_remove(
+      args->args, args_to_remove, GPR_ARRAY_SIZE(args_to_remove));
+  grpc_channel_args_destroy(args->args);
+  args->args = channel_args;
+  // In some implementations, the closure can be flushed before
+  // grpc_tcp_client_connect() returns, and since the closure requires access
+  // to mu_, this can result in a deadlock (see
+  // https://github.com/grpc/grpc/issues/16427 for details).
+  // grpc_tcp_client_connect() will fill endpoint_ with proper contents, and we
+  // make sure that we still exist at that point by taking a ref.
+  Ref().release();  // Ref held by callback.
+  // As we fake the TCP client connection failure when shutdown is called
+  // we don't want to pass args->endpoint directly.
+  // Instead pass endpoint_ and swap this endpoint to
+  // args endpoint on success.
+  grpc_tcp_client_connect(&connected_, &endpoint_to_destroy_,
+                          interested_parties_, args->args, &addr_,
+                          args->deadline);
+}
+
+void TCPConnectHandshaker::Connected(void* arg, grpc_error_handle error) {
+  RefCountedPtr<TCPConnectHandshaker> self(
+      static_cast<TCPConnectHandshaker*>(arg));
+  {
+    MutexLock lock(&self->mu_);
+    if (error != GRPC_ERROR_NONE || self->shutdown_) {
+      if (error == GRPC_ERROR_NONE) {
+        error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("tcp handshaker shutdown");
+      } else {
+        error = GRPC_ERROR_REF(error);
+      }
+      if (self->endpoint_to_destroy_ != nullptr) {
+        grpc_endpoint_shutdown(self->endpoint_to_destroy_,
+                               GRPC_ERROR_REF(error));
+      }
+      if (!self->shutdown_) {
+        self->CleanupArgsForFailureLocked();
+        self->shutdown_ = true;
+        self->FinishLocked(error);
+      } else {
+        // The on_handshake_done_ is already as part of shutdown when connecting
+        // So nothing to be done here other than unrefing the error.
+        GRPC_ERROR_UNREF(error);
+      }
+      return;
+    }
+    GPR_ASSERT(self->endpoint_to_destroy_ != nullptr);
+    self->args_->endpoint = self->endpoint_to_destroy_;
+    self->endpoint_to_destroy_ = nullptr;
+    if (self->bind_endpoint_to_pollset_) {
+      grpc_endpoint_add_to_pollset_set(self->args_->endpoint,
+                                       self->interested_parties_);
+    }
+    self->FinishLocked(GRPC_ERROR_NONE);
+  }
+}
+
+TCPConnectHandshaker::~TCPConnectHandshaker() {
+  if (endpoint_to_destroy_ != nullptr) {
+    grpc_endpoint_destroy(endpoint_to_destroy_);
+  }
+  if (read_buffer_to_destroy_ != nullptr) {
+    grpc_slice_buffer_destroy_internal(read_buffer_to_destroy_);
+    gpr_free(read_buffer_to_destroy_);
+  }
+  grpc_pollset_set_destroy(interested_parties_);
+}
+
+void TCPConnectHandshaker::CleanupArgsForFailureLocked() {
+  read_buffer_to_destroy_ = args_->read_buffer;
+  args_->read_buffer = nullptr;
+  grpc_channel_args_destroy(args_->args);
+  args_->args = nullptr;
+}
+
+void TCPConnectHandshaker::FinishLocked(grpc_error_handle error) {
+  if (interested_parties_ != nullptr) {
+    grpc_polling_entity_del_from_pollset_set(&pollent_, interested_parties_);
+  }
+  ExecCtx::Run(DEBUG_LOCATION, on_handshake_done_, error);
+  on_handshake_done_ = nullptr;
+}
+
+//
+// TCPConnectHandshakerFactory
+//
+
+class TCPConnectHandshakerFactory : public HandshakerFactory {
+ public:
+  void AddHandshakers(const grpc_channel_args* /*args*/,
+                      grpc_pollset_set* interested_parties,
+                      HandshakeManager* handshake_mgr) override {
+    handshake_mgr->Add(
+        MakeRefCounted<TCPConnectHandshaker>(interested_parties));
+  }
+  ~TCPConnectHandshakerFactory() override = default;
+};
+
+}  // namespace
+
+void RegisterTCPConnectHandshaker(CoreConfiguration::Builder* builder) {
+  builder->handshaker_registry()->RegisterHandshakerFactory(
+      true /* at_start */, HANDSHAKER_CLIENT,
+      absl::make_unique<TCPConnectHandshakerFactory>());
+}
+
+}  // namespace grpc_core

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

@@ -0,0 +1,39 @@
+//
+// Copyright 2022 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_TRANSPORT_TCP_CONNECT_HANDSHAKER_H
+#define GRPC_CORE_LIB_TRANSPORT_TCP_CONNECT_HANDSHAKER_H
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/config/core_configuration.h"
+
+// Indicates the address that the tcp connect handshaker should connect to.
+#define GRPC_ARG_TCP_HANDSHAKER_RESOLVED_ADDRESS \
+  "grpc.internal.tcp_handshaker_resolved_address"
+
+// Whether the TCP connect handshaker should bind the endpoint to the pollset.
+#define GRPC_ARG_TCP_HANDSHAKER_BIND_ENDPOINT_TO_POLLSET \
+  "grpc.internal.tcp_handshaker_bind_endpoint_to_pollset"
+
+namespace grpc_core {
+
+// Register the TCP Connect handshaker into the configuration builder.
+void RegisterTCPConnectHandshaker(CoreConfiguration::Builder* builder);
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_TRANSPORT_TCP_CONNECT_HANDSHAKER_H

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

@@ -20,14 +20,10 @@
 
 #include "src/core/lib/transport/timeout_encoding.h"
 
-#include <stdio.h>
-#include <string.h>
-
-#include <cstdint>
+#include "absl/base/attributes.h"
 
 #include <grpc/support/log.h>
-
-#include "src/core/lib/gpr/string.h"
+#include <grpc/support/time.h>
 
 namespace grpc_core {
 

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

@@ -21,7 +21,11 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/iomgr/exec_ctx.h"
+#include <stdint.h>
+
+#include "absl/types/optional.h"
+
+#include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/slice/slice.h"
 
 namespace grpc_core {

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

@@ -22,18 +22,12 @@
 
 #include <string.h>
 
-#include <grpc/support/alloc.h>
-#include <grpc/support/atm.h>
-#include <grpc/support/log.h>
-#include <grpc/support/sync.h>
+#include <new>
 
 #include "src/core/lib/gpr/alloc.h"
-#include "src/core/lib/gpr/string.h"
-#include "src/core/lib/gprpp/memory.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/executor.h"
 #include "src/core/lib/iomgr/iomgr.h"
-#include "src/core/lib/slice/slice_internal.h"
-#include "src/core/lib/slice/slice_string_helpers.h"
 #include "src/core/lib/transport/transport_impl.h"
 
 grpc_core::DebugOnlyTraceFlag grpc_trace_stream_refcount(false,
@@ -157,6 +151,16 @@ grpc_endpoint* grpc_transport_get_endpoint(grpc_transport* transport) {
 void grpc_transport_stream_op_batch_finish_with_failure(
     grpc_transport_stream_op_batch* batch, grpc_error_handle error,
     grpc_core::CallCombiner* call_combiner) {
+  grpc_core::CallCombinerClosureList closures;
+  grpc_transport_stream_op_batch_queue_finish_with_failure(batch, error,
+                                                           &closures);
+  // Execute closures.
+  closures.RunClosures(call_combiner);
+}
+
+void grpc_transport_stream_op_batch_queue_finish_with_failure(
+    grpc_transport_stream_op_batch* batch, grpc_error_handle error,
+    grpc_core::CallCombinerClosureList* closures) {
   if (batch->send_message) {
     batch->payload->send_message.send_message.reset();
   }
@@ -164,27 +168,24 @@ void grpc_transport_stream_op_batch_finish_with_failure(
     GRPC_ERROR_UNREF(batch->payload->cancel_stream.cancel_error);
   }
   // Construct a list of closures to execute.
-  grpc_core::CallCombinerClosureList closures;
   if (batch->recv_initial_metadata) {
-    closures.Add(
+    closures->Add(
         batch->payload->recv_initial_metadata.recv_initial_metadata_ready,
         GRPC_ERROR_REF(error), "failing recv_initial_metadata_ready");
   }
   if (batch->recv_message) {
-    closures.Add(batch->payload->recv_message.recv_message_ready,
-                 GRPC_ERROR_REF(error), "failing recv_message_ready");
+    closures->Add(batch->payload->recv_message.recv_message_ready,
+                  GRPC_ERROR_REF(error), "failing recv_message_ready");
   }
   if (batch->recv_trailing_metadata) {
-    closures.Add(
+    closures->Add(
         batch->payload->recv_trailing_metadata.recv_trailing_metadata_ready,
         GRPC_ERROR_REF(error), "failing recv_trailing_metadata_ready");
   }
   if (batch->on_complete != nullptr) {
-    closures.Add(batch->on_complete, GRPC_ERROR_REF(error),
-                 "failing on_complete");
+    closures->Add(batch->on_complete, GRPC_ERROR_REF(error),
+                  "failing on_complete");
   }
-  // Execute closures.
-  closures.RunClosures(call_combiner);
   GRPC_ERROR_UNREF(error);
 }
 

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

@@ -22,22 +22,45 @@
 #include <grpc/support/port_platform.h>
 
 #include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+
+#include <functional>
+#include <string>
+
+#include "absl/status/status.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
+
+#include <grpc/impl/codegen/connectivity_state.h>
+#include <grpc/slice.h>
+#include <grpc/status.h>
+#include <grpc/support/atm.h>
+#include <grpc/support/log.h>
 
 #include "src/core/lib/channel/context.h"
+#include "src/core/lib/debug/trace.h"
+#include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/orphanable.h"
+#include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/iomgr/call_combiner.h"
+#include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/endpoint.h"
+#include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/iomgr/iomgr_fwd.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/promise/arena_promise.h"
+#include "src/core/lib/promise/context.h"
 #include "src/core/lib/promise/latch.h"
 #include "src/core/lib/resource_quota/arena.h"
-#include "src/core/lib/slice/slice_internal.h"
+#include "src/core/lib/slice/slice.h"
 #include "src/core/lib/transport/byte_stream.h"
 #include "src/core/lib/transport/connectivity_state.h"
 #include "src/core/lib/transport/metadata_batch.h"
 
+struct grpc_transport_stream_op_batch_payload;
+
 /* Minimum and maximum protocol accepted versions. */
 #define GRPC_PROTOCOL_VERSION_MAX_MAJOR 2
 #define GRPC_PROTOCOL_VERSION_MAX_MINOR 1
@@ -514,6 +537,9 @@ void grpc_transport_destroy_stream(grpc_transport* transport,
 void grpc_transport_stream_op_batch_finish_with_failure(
     grpc_transport_stream_op_batch* batch, grpc_error_handle error,
     grpc_core::CallCombiner* call_combiner);
+void grpc_transport_stream_op_batch_queue_finish_with_failure(
+    grpc_transport_stream_op_batch* batch, grpc_error_handle error,
+    grpc_core::CallCombinerClosureList* closures);
 
 std::string grpc_transport_stream_op_batch_string(
     grpc_transport_stream_op_batch* op);

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

@@ -21,6 +21,16 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <stddef.h>
+
+#include "absl/strings/string_view.h"
+
+#include "src/core/lib/iomgr/closure.h"
+#include "src/core/lib/iomgr/endpoint.h"
+#include "src/core/lib/iomgr/iomgr_fwd.h"
+#include "src/core/lib/iomgr/pollset.h"
+#include "src/core/lib/promise/arena_promise.h"
+#include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/transport/transport.h"
 
 typedef struct grpc_transport_vtable {

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

@@ -18,25 +18,24 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <inttypes.h>
-#include <stdarg.h>
-#include <stdio.h>
-#include <string.h>
-
+#include <algorithm>
+#include <memory>
+#include <string>
 #include <vector>
 
-#include "absl/strings/escaping.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_join.h"
 
-#include <grpc/support/alloc.h>
-#include <grpc/support/string_util.h>
+#include <grpc/support/log.h>
 
 #include "src/core/lib/channel/channel_stack.h"
-#include "src/core/lib/gpr/string.h"
-#include "src/core/lib/slice/slice_string_helpers.h"
+#include "src/core/lib/gprpp/orphanable.h"
+#include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/transport/byte_stream.h"
 #include "src/core/lib/transport/connectivity_state.h"
+#include "src/core/lib/transport/metadata_batch.h"
+#include "src/core/lib/transport/transport.h"
 
 /* These routines are here to facilitate debugging - they produce string
    representations of various transport data structures */

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

@@ -18,19 +18,27 @@
 
 #include "src/core/lib/uri/uri_parser.h"
 
-#include <string.h>
+#include <ctype.h>
+#include <stddef.h>
 
+#include <algorithm>
+#include <functional>
 #include <map>
 #include <string>
+#include <utility>
 
+#include "absl/status/status.h"
+#include "absl/strings/ascii.h"
 #include "absl/strings/escaping.h"
+#include "absl/strings/match.h"
+#include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
+#include "absl/strings/str_join.h"
 #include "absl/strings/str_split.h"
+#include "absl/strings/strip.h"
 
 #include <grpc/support/log.h>
 
-#include "src/core/lib/gpr/string.h"
-
 namespace grpc_core {
 
 namespace {

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

@@ -19,8 +19,6 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <stddef.h>
-
 #include <map>
 #include <string>
 #include <vector>

data/src/core/plugin_registry/grpc_plugin_registry.cc

@@ -22,6 +22,8 @@
 
 #include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/surface/builtins.h"
+#include "src/core/lib/transport/http_connect_handshaker.h"
+#include "src/core/lib/transport/tcp_connect_handshaker.h"
 
 extern void grpc_register_extra_plugins(void);
 
@@ -33,6 +35,8 @@ void grpc_lb_policy_grpclb_init(void);
 void grpc_lb_policy_grpclb_shutdown(void);
 void grpc_lb_policy_priority_init(void);
 void grpc_lb_policy_priority_shutdown(void);
+void grpc_lb_policy_outlier_detection_init(void);
+void grpc_lb_policy_outlier_detection_shutdown(void);
 void grpc_lb_policy_weighted_target_init(void);
 void grpc_lb_policy_weighted_target_shutdown(void);
 void grpc_lb_policy_pick_first_init(void);
@@ -58,6 +62,8 @@ void grpc_register_built_in_plugins(void) {
   grpc_register_plugin(grpc_core::RlsLbPluginInit,
                        grpc_core::RlsLbPluginShutdown);
 #endif  // !GRPC_NO_RLS
+  grpc_register_plugin(grpc_lb_policy_outlier_detection_init,
+                       grpc_lb_policy_outlier_detection_shutdown);
   grpc_register_plugin(grpc_lb_policy_priority_init,
                        grpc_lb_policy_priority_shutdown);
   grpc_register_plugin(grpc_lb_policy_weighted_target_init,
@@ -101,6 +107,11 @@ extern void RegisterBinderResolver(CoreConfiguration::Builder* builder);
 #endif
 
 void BuildCoreConfiguration(CoreConfiguration::Builder* builder) {
+  // The order of the handshaker registration is crucial here.
+  // We want TCP connect handshaker to be registered last so that it is added to
+  // the start of the handshaker list.
+  RegisterHttpConnectHandshaker(builder);
+  RegisterTCPConnectHandshaker(builder);
   BuildClientChannelConfiguration(builder);
   SecurityRegisterHandshakerFactories(builder);
   RegisterClientAuthorityFilter(builder);

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

@@ -21,6 +21,8 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <memory>
+
 #include <openssl/ssl.h>
 
 #include <grpc/slice.h>

data/src/core/tsi/ssl/session_cache/ssl_session_boringssl.cc

@@ -22,6 +22,8 @@
 
 #ifdef OPENSSL_IS_BORINGSSL
 
+#include "absl/memory/memory.h"
+
 // BoringSSL allows SSL_SESSION to outlive SSL and SSL_CTX objects which are
 // re-created by gRPC on every certificate rotation or subchannel creation.
 // BoringSSL guarantees that SSL_SESSION is immutable so it's safe to share