grpc 1.60.0 → 1.62.0

data/include/grpc/event_engine/event_engine.h

@@ -16,7 +16,6 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <functional>
 #include <vector>
 
 #include "absl/functional/any_invocable.h"
@@ -24,6 +23,7 @@
 #include "absl/status/statusor.h"
 
 #include <grpc/event_engine/endpoint_config.h>
+#include <grpc/event_engine/extensible.h>
 #include <grpc/event_engine/memory_allocator.h>
 #include <grpc/event_engine/port.h>
 #include <grpc/event_engine/slice_buffer.h>
@@ -79,7 +79,7 @@ namespace experimental {
 ///
 ///
 /// Blocking EventEngine Callbacks
-/// -----------------------------
+/// ------------------------------
 ///
 /// Doing blocking work in EventEngine callbacks is generally not advisable.
 /// While gRPC's default EventEngine implementations have some capacity to scale
@@ -90,8 +90,18 @@ namespace experimental {
 /// *Best Practice* : Occasional blocking work may be fine, but we do not
 /// recommend running a mostly blocking workload in EventEngine threads.
 ///
+///
+/// Thread-safety guarantees
+/// ------------------------
+///
+/// All EventEngine methods are guaranteed to be thread-safe, no external
+/// synchronization is required to call any EventEngine method. Please note that
+/// this does not apply to application callbacks, which may be run concurrently;
+/// application state synchronization must be managed by the application.
+///
 ////////////////////////////////////////////////////////////////////////////////
-class EventEngine : public std::enable_shared_from_this<EventEngine> {
+class EventEngine : public std::enable_shared_from_this<EventEngine>,
+                    public Extensible {
  public:
   /// A duration between two events.
   ///
@@ -167,7 +177,7 @@ class EventEngine : public std::enable_shared_from_this<EventEngine> {
   /// allocations. gRPC allows applications to set memory constraints per
   /// Channel or Server, and the implementation depends on all dynamic memory
   /// allocation being handled by the quota system.
-  class Endpoint {
+  class Endpoint : public Extensible {
    public:
     /// Shuts down all connections and invokes all pending read or write
     /// callbacks with an error status.
@@ -259,7 +269,7 @@ class EventEngine : public std::enable_shared_from_this<EventEngine> {
 
   /// Listens for incoming connection requests from gRPC clients and initiates
   /// request processing once connections are established.
-  class Listener {
+  class Listener : public Extensible {
    public:
     /// Called when the listener has accepted a new client connection.
     using AcceptCallback = absl::AnyInvocable<void(
@@ -405,8 +415,8 @@ class EventEngine : public std::enable_shared_from_this<EventEngine> {
 
   /// Asynchronously executes a task as soon as possible.
   ///
-  /// \a Closures scheduled with \a Run cannot be cancelled. The \a closure will
-  /// not be deleted after it has been run, ownership remains with the caller.
+  /// \a Closures passed to \a Run cannot be cancelled. The \a closure will not
+  /// be deleted after it has been run, ownership remains with the caller.
   ///
   /// Implementations must not execute the closure in the calling thread before
   /// \a Run returns. For example, if the caller must release a lock before the
@@ -415,9 +425,9 @@ class EventEngine : public std::enable_shared_from_this<EventEngine> {
   virtual void Run(Closure* closure) = 0;
   /// Asynchronously executes a task as soon as possible.
   ///
-  /// \a Closures scheduled with \a Run cannot be cancelled. Unlike the
-  /// overloaded \a Closure alternative, the absl::AnyInvocable version's \a
-  /// closure will be deleted by the EventEngine after the closure has been run.
+  /// \a Closures passed to \a Run cannot be cancelled. Unlike the overloaded \a
+  /// Closure alternative, the absl::AnyInvocable version's \a closure will be
+  /// deleted by the EventEngine after the closure has been run.
   ///
   /// This version of \a Run may be less performant than the \a Closure version
   /// in some scenarios. This overload is useful in situations where performance
@@ -453,13 +463,12 @@ class EventEngine : public std::enable_shared_from_this<EventEngine> {
                               absl::AnyInvocable<void()> closure) = 0;
   /// Request cancellation of a task.
   ///
-  /// If the associated closure has already been scheduled to run, it will not
-  /// be cancelled, and this function will return false.
+  /// If the associated closure cannot be cancelled for any reason, this
+  /// function will return false.
   ///
-  /// If the associated closure has not been scheduled to run, it will be
-  /// cancelled, and this method will return true. The associated
-  /// absl::AnyInvocable or \a Closure* will not be called. If the closure type
-  /// was an absl::AnyInvocable, it will be destroyed before the method returns.
+  /// If the associated closure can be cancelled, the associated callback will
+  /// never be run, and this method will return true. If the callback type was
+  /// an absl::AnyInvocable, it will be destroyed before the method returns.
   virtual bool Cancel(TaskHandle handle) = 0;
 };
 

data/include/grpc/event_engine/extensible.h

@@ -0,0 +1,68 @@
+// Copyright 2024 The 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_EVENT_ENGINE_EXTENSIBLE_H
+#define GRPC_EVENT_ENGINE_EXTENSIBLE_H
+
+#include <grpc/support/port_platform.h>
+
+#include "absl/strings/string_view.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+class Extensible {
+ public:
+  /// A method which allows users to query whether an implementation supports a
+  /// specified extension. The name of the extension is provided as an input.
+  ///
+  /// An extension could be any type with a unique string id. Each extension may
+  /// support additional capabilities and if the implementation supports the
+  /// queried extension, it should return a valid pointer to the extension type.
+  ///
+  /// E.g., use case of an EventEngine::Endpoint supporting a custom extension.
+  ///
+  /// class CustomEndpointExtension {
+  ///  public:
+  ///   static std::string EndpointExtensionName() {
+  ///     return "my.namespace.extension_name";
+  ///   }
+  ///   virtual void Process() = 0;
+  /// }
+  ///
+  /// class CustomEndpoint :
+  ///        public EventEngine::Endpoint, public CustomEndpointExtension {
+  ///   public:
+  ///     void* QueryExtension(absl::string_view id) override {
+  ///       if (id == CustomEndpointExtension::EndpointExtensionName()) {
+  ///         return static_cast<CustomEndpointExtension*>(this);
+  ///       }
+  ///       return nullptr;
+  ///     }
+  ///     void Process() override { ... }
+  ///     ...
+  /// }
+  ///
+  /// auto endpoint =
+  ///     static_cast<CustomEndpointExtension*>(endpoint->QueryExtension(
+  ///         CustomEndpointExtension::EndpointExtensionName()));
+  /// if (endpoint != nullptr) endpoint->Process();
+  ///
+  virtual void* QueryExtension(absl::string_view /*id*/) { return nullptr; }
+};
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_EVENT_ENGINE_EXTENSIBLE_H

data/include/grpc/event_engine/internal/memory_allocator_impl.h

@@ -50,6 +50,12 @@ class MemoryAllocatorImpl
   /// request.max() inclusively.
   virtual size_t Reserve(MemoryRequest request) = 0;
 
+  /// Allocate a slice, using MemoryRequest to size the number of returned
+  /// bytes. For a variable length request, check the returned slice length to
+  /// verify how much memory was allocated. Takes care of reserving memory for
+  /// any relevant control structures also.
+  virtual grpc_slice MakeSlice(MemoryRequest request) = 0;
+
   /// Release some bytes that were previously reserved.
   /// If more bytes are released than were reserved, we will have undefined
   /// behavior.

data/include/grpc/event_engine/internal/slice_cast.h

@@ -60,6 +60,18 @@ Result& SliceCast(T& value, SliceCastable<Result, T> = {}) {
   return reinterpret_cast<Result&>(value);
 }
 
+// Cast to `Result&&` from `T&&` without any runtime checks.
+// This is only valid if `sizeof(Result) == sizeof(T)`, and if `Result`, `T` are
+// opted in as compatible via `SliceCastable`.
+template <typename Result, typename T>
+Result&& SliceCast(T&& value, SliceCastable<Result, T> = {}) {
+  // Insist upon sizes being equal to catch mismatches.
+  // We assume if sizes are opted in and sizes are equal then yes, these two
+  // types are expected to be layout compatible and actually appear to be.
+  static_assert(sizeof(Result) == sizeof(T), "size mismatch");
+  return reinterpret_cast<Result&&>(value);
+}
+
 }  // namespace internal
 }  // namespace experimental
 }  // namespace grpc_event_engine

data/include/grpc/event_engine/memory_allocator.h

@@ -134,7 +134,9 @@ class MemoryAllocator {
   /// bytes. For a variable length request, check the returned slice length to
   /// verify how much memory was allocated. Takes care of reserving memory for
   /// any relevant control structures also.
-  grpc_slice MakeSlice(MemoryRequest request);
+  grpc_slice MakeSlice(MemoryRequest request) {
+    return allocator_->MakeSlice(request);
+  }
 
   /// A C++ allocator for containers of T.
   template <typename T>

data/include/grpc/event_engine/slice.h

@@ -169,6 +169,11 @@ struct CopyConstructors {
     return Out(grpc_slice_from_copied_buffer(p, len));
   }
 
+  static Out FromCopiedBuffer(const uint8_t* p, size_t len) {
+    return Out(
+        grpc_slice_from_copied_buffer(reinterpret_cast<const char*>(p), len));
+  }
+
   template <typename Buffer>
   static Out FromCopiedBuffer(const Buffer& buffer) {
     return FromCopiedBuffer(reinterpret_cast<const char*>(buffer.data()),

data/include/grpc/grpc_security.h

@@ -815,6 +815,24 @@ GRPCAPI void grpc_tls_certificate_provider_release(
  */
 GRPCAPI grpc_tls_credentials_options* grpc_tls_credentials_options_create(void);
 
+/**
+ * EXPERIMENTAL API - Subject to change
+ *
+ * Sets the minimum TLS version that will be negotiated during the TLS
+ * handshake. If not set, the underlying SSL library will set it to TLS v1.2.
+ */
+GRPCAPI void grpc_tls_credentials_options_set_min_tls_version(
+    grpc_tls_credentials_options* options, grpc_tls_version min_tls_version);
+
+/**
+ * EXPERIMENTAL API - Subject to change
+ *
+ * Sets the maximum TLS version that will be negotiated during the TLS
+ * handshake. If not set, the underlying SSL library will set it to TLS v1.3.
+ */
+GRPCAPI void grpc_tls_credentials_options_set_max_tls_version(
+    grpc_tls_credentials_options* options, grpc_tls_version max_tls_version);
+
 /**
  * EXPERIMENTAL API - Subject to change
  *
@@ -894,7 +912,10 @@ GRPCAPI void grpc_tls_credentials_options_set_identity_cert_name(
 GRPCAPI void grpc_tls_credentials_options_set_cert_request_type(
     grpc_tls_credentials_options* options,
     grpc_ssl_client_certificate_request_type type);
-/**
+
+/** Deprecated in favor of grpc_tls_credentials_options_set_crl_provider. The
+ * crl provider interface provides a significantly more flexible approach to
+ * using CRLs. See gRFC A69 for details.
  * EXPERIMENTAL API - Subject to change
  *
  * If set, gRPC will read all hashed x.509 CRL files in the directory and

data/include/grpc/impl/call.h

@@ -0,0 +1,29 @@
+// Copyright 2023 The 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_IMPL_CALL_H
+#define GRPC_IMPL_CALL_H
+
+#include <grpc/support/port_platform.h>
+
+#include "absl/functional/any_invocable.h"
+
+#include <grpc/grpc.h>
+
+// Run a callback in the call's EventEngine.
+// Internal-only
+void grpc_call_run_in_event_engine(const grpc_call* call,
+                                   absl::AnyInvocable<void()> cb);
+
+#endif /* GRPC_IMPL_CALL_H */

data/include/grpc/impl/channel_arg_names.h

@@ -15,7 +15,7 @@
 #ifndef GRPC_IMPL_CHANNEL_ARG_NAMES_H
 #define GRPC_IMPL_CHANNEL_ARG_NAMES_H
 
-// IWYU pragma: private, include "third_party/grpc/include/grpc/grpc.h"
+// IWYU pragma: private, include <grpc/grpc.h>
 // IWYU pragma: friend "src/.*"
 // IWYU pragma: friend "test/.*"
 
@@ -106,6 +106,12 @@
  */
 #define GRPC_ARG_HTTP2_MIN_RECV_PING_INTERVAL_WITHOUT_DATA_MS \
   "grpc.http2.min_ping_interval_without_data_ms"
+/** Maximum time to allow a request to be:
+    (1) received by the server, but
+    (2) not requested by a RequestCall (in the completion queue based API)
+    before the request is cancelled */
+#define GRPC_ARG_SERVER_MAX_UNREQUESTED_TIME_IN_SERVER_SECONDS \
+  "grpc.server_max_unrequested_time_in_server"
 /** Channel arg to override the http2 :scheme header */
 #define GRPC_ARG_HTTP2_SCHEME "grpc.http2_scheme"
 /** How many pings can the client send before needing to send a
@@ -384,6 +390,11 @@
  *  Defaults to 250ms. */
 #define GRPC_ARG_HAPPY_EYEBALLS_CONNECTION_ATTEMPT_DELAY_MS \
   "grpc.happy_eyeballs_connection_attempt_delay_ms"
+/** It accepts a MemoryAllocatorFactory as input and If specified, it forces
+ * the default event engine to use memory allocators created using the provided
+ * factory. */
+#define GRPC_ARG_EVENT_ENGINE_USE_MEMORY_ALLOCATOR_FACTORY \
+  "grpc.event_engine_use_memory_allocator_factory"
 /** \} */
 
 #endif /* GRPC_IMPL_CHANNEL_ARG_NAMES_H */

data/include/grpc/impl/slice_type.h

@@ -74,7 +74,7 @@ struct grpc_slice {
   } data;
 };
 
-#define GRPC_SLICE_BUFFER_INLINE_ELEMENTS 8
+#define GRPC_SLICE_BUFFER_INLINE_ELEMENTS 6
 
 /** Represents an expandable array of slices, to be interpreted as a
    single item. */

data/include/grpc/module.modulemap

@@ -13,6 +13,7 @@ header "byte_buffer.h"
   header "grpc_posix.h"
   header "grpc_security.h"
   header "grpc_security_constants.h"
+  header "impl/call.h"
   header "impl/channel_arg_names.h"
   header "impl/codegen/atm.h"
   header "impl/codegen/byte_buffer.h"

data/include/grpc/support/port_platform.h

@@ -19,14 +19,6 @@
 #ifndef GRPC_SUPPORT_PORT_PLATFORM_H
 #define GRPC_SUPPORT_PORT_PLATFORM_H
 
-/*
- * Define GPR_BACKWARDS_COMPATIBILITY_MODE to try harder to be ABI
- * compatible with older platforms (currently only on Linux)
- * Causes:
- *  - some libc calls to be gotten via dlsym
- *  - some syscalls to be made directly
- */
-
 // [[deprecated]] attribute is only available since C++14
 #if __cplusplus >= 201402L
 #define GRPC_DEPRECATED(reason) [[deprecated(reason)]]
@@ -525,18 +517,6 @@
 #endif
 #endif /* GPR_NO_AUTODETECT_PLATFORM */
 
-#if defined(GPR_BACKWARDS_COMPATIBILITY_MODE)
-/*
- * For backward compatibility mode, reset _FORTIFY_SOURCE to prevent
- * a library from having non-standard symbols such as __asprintf_chk.
- * This helps non-glibc systems such as alpine using musl to find symbols.
- */
-#if defined(_FORTIFY_SOURCE) && _FORTIFY_SOURCE > 0
-#undef _FORTIFY_SOURCE
-#define _FORTIFY_SOURCE 0
-#endif
-#endif
-
 #if defined(__has_include)
 #if __has_include(<atomic>)
 #define GRPC_HAS_CXX11_ATOMIC
@@ -690,6 +670,18 @@ typedef unsigned __int64 uint64_t;
 #endif
 #endif
 
+#ifndef GRPC_REINITIALIZES
+#if defined(__clang__)
+#if GPR_HAS_CPP_ATTRIBUTE(clang::reinitializes)
+#define GRPC_REINITIALIZES [[clang::reinitializes]]
+#else
+#define GRPC_REINITIALIZES
+#endif
+#else
+#define GRPC_REINITIALIZES
+#endif
+#endif
+
 #ifndef GPR_HAS_ATTRIBUTE
 #ifdef __has_attribute
 #define GPR_HAS_ATTRIBUTE(a) __has_attribute(a)

data/src/core/{ext/filters/client_channel → client_channel}/backend_metric.cc

@@ -16,7 +16,7 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/ext/filters/client_channel/backend_metric.h"
+#include "src/core/client_channel/backend_metric.h"
 
 #include <string.h>
 
@@ -24,8 +24,8 @@
 
 #include "absl/strings/string_view.h"
 #include "upb/base/string_view.h"
-#include "upb/collections/map.h"
-#include "upb/upb.hpp"
+#include "upb/mem/arena.hpp"
+#include "upb/message/map.h"
 #include "xds/data/orca/v3/orca_load_report.upb.h"
 
 namespace grpc_core {

data/src/core/{ext/filters/client_channel → client_channel}/backend_metric.h

@@ -14,8 +14,8 @@
 // limitations under the License.
 //
 
-#ifndef GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_BACKEND_METRIC_H
-#define GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_BACKEND_METRIC_H
+#ifndef GRPC_SRC_CORE_CLIENT_CHANNEL_BACKEND_METRIC_H
+#define GRPC_SRC_CORE_CLIENT_CHANNEL_BACKEND_METRIC_H
 
 #include <grpc/support/port_platform.h>
 
@@ -23,7 +23,7 @@
 
 #include "absl/strings/string_view.h"
 
-#include "src/core/ext/filters/client_channel/lb_policy/backend_metric_data.h"
+#include "src/core/load_balancing/backend_metric_data.h"
 
 namespace grpc_core {
 
@@ -44,4 +44,4 @@ const BackendMetricData* ParseBackendMetricData(
 
 }  // namespace grpc_core
 
-#endif  // GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_BACKEND_METRIC_H
+#endif  // GRPC_SRC_CORE_CLIENT_CHANNEL_BACKEND_METRIC_H

data/src/core/{ext/filters/client_channel → client_channel}/backup_poller.cc

@@ -18,7 +18,7 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/ext/filters/client_channel/backup_poller.h"
+#include "src/core/client_channel/backup_poller.h"
 
 #include <inttypes.h>
 

data/src/core/{ext/filters/client_channel → client_channel}/backup_poller.h

@@ -16,8 +16,8 @@
 //
 //
 
-#ifndef GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_BACKUP_POLLER_H
-#define GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_BACKUP_POLLER_H
+#ifndef GRPC_SRC_CORE_CLIENT_CHANNEL_BACKUP_POLLER_H
+#define GRPC_SRC_CORE_CLIENT_CHANNEL_BACKUP_POLLER_H
 
 #include <grpc/support/port_platform.h>
 
@@ -34,4 +34,4 @@ void grpc_client_channel_start_backup_polling(
 void grpc_client_channel_stop_backup_polling(
     grpc_pollset_set* interested_parties);
 
-#endif  // GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_BACKUP_POLLER_H
+#endif  // GRPC_SRC_CORE_CLIENT_CHANNEL_BACKUP_POLLER_H

data/src/core/{ext/filters/client_channel → client_channel}/channel_connectivity.cc

@@ -28,7 +28,7 @@
 #include <grpc/support/log.h>
 #include <grpc/support/time.h>
 
-#include "src/core/ext/filters/client_channel/client_channel.h"
+#include "src/core/client_channel/client_channel_filter.h"
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/debug/trace.h"
@@ -67,8 +67,8 @@ grpc_connectivity_state grpc_channel_check_connectivity_state(
       (c_channel, try_to_connect));
   grpc_core::Channel* channel = grpc_core::Channel::FromC(c_channel);
   // Forward through to the underlying client channel.
-  grpc_core::ClientChannel* client_channel =
-      grpc_core::ClientChannel::GetFromChannel(channel);
+  grpc_core::ClientChannelFilter* client_channel =
+      grpc_core::ClientChannelFilter::GetFromChannel(channel);
   if (GPR_UNLIKELY(client_channel == nullptr)) {
     if (grpc_core::IsLameChannel(channel)) {
       return GRPC_CHANNEL_TRANSIENT_FAILURE;
@@ -83,8 +83,8 @@ grpc_connectivity_state grpc_channel_check_connectivity_state(
 
 int grpc_channel_num_external_connectivity_watchers(grpc_channel* c_channel) {
   grpc_core::Channel* channel = grpc_core::Channel::FromC(c_channel);
-  grpc_core::ClientChannel* client_channel =
-      grpc_core::ClientChannel::GetFromChannel(channel);
+  grpc_core::ClientChannelFilter* client_channel =
+      grpc_core::ClientChannelFilter::GetFromChannel(channel);
   if (client_channel == nullptr) {
     if (!grpc_core::IsLameChannel(channel)) {
       gpr_log(GPR_ERROR,
@@ -97,7 +97,7 @@ int grpc_channel_num_external_connectivity_watchers(grpc_channel* c_channel) {
 }
 
 int grpc_channel_support_connectivity_watcher(grpc_channel* channel) {
-  return grpc_core::ClientChannel::GetFromChannel(
+  return grpc_core::ClientChannelFilter::GetFromChannel(
              grpc_core::Channel::FromC(channel)) != nullptr;
 }
 
@@ -115,8 +115,8 @@ class StateWatcher : public DualRefCounted<StateWatcher> {
         state_(last_observed_state) {
     GPR_ASSERT(grpc_cq_begin_op(cq, tag));
     GRPC_CLOSURE_INIT(&on_complete_, WatchComplete, this, nullptr);
-    ClientChannel* client_channel =
-        ClientChannel::GetFromChannel(channel_.get());
+    ClientChannelFilter* client_channel =
+        ClientChannelFilter::GetFromChannel(channel_.get());
     if (client_channel == nullptr) {
       // If the target URI used to create the channel was invalid, channel
       // stack initialization failed, and that caused us to create a lame
@@ -145,7 +145,7 @@ class StateWatcher : public DualRefCounted<StateWatcher> {
 
  private:
   // A fire-and-forget object used to delay starting the timer until the
-  // ClientChannel actually starts the watch.
+  // ClientChannelFilter actually starts the watch.
   class WatcherTimerInitState {
    public:
     WatcherTimerInitState(StateWatcher* state_watcher, Timestamp deadline)
@@ -201,8 +201,8 @@ class StateWatcher : public DualRefCounted<StateWatcher> {
   void TimeoutComplete() {
     timer_fired_ = true;
     // If this is a client channel (not a lame channel), cancel the watch.
-    ClientChannel* client_channel =
-        ClientChannel::GetFromChannel(channel_.get());
+    ClientChannelFilter* client_channel =
+        ClientChannelFilter::GetFromChannel(channel_.get());
     if (client_channel != nullptr) {
       client_channel->CancelExternalConnectivityWatcher(&on_complete_);
     }

data/src/core/{ext/filters/client_channel → client_channel}/client_channel_channelz.cc

@@ -18,7 +18,7 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/ext/filters/client_channel/client_channel_channelz.h"
+#include "src/core/client_channel/client_channel_channelz.h"
 
 #include "absl/strings/str_cat.h"
 

data/src/core/{ext/filters/client_channel → client_channel}/client_channel_channelz.h

@@ -16,8 +16,8 @@
 //
 //
 
-#ifndef GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_CLIENT_CHANNEL_CHANNELZ_H
-#define GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_CLIENT_CHANNEL_CHANNELZ_H
+#ifndef GRPC_SRC_CORE_CLIENT_CHANNEL_CLIENT_CHANNEL_CHANNELZ_H
+#define GRPC_SRC_CORE_CLIENT_CHANNEL_CLIENT_CHANNEL_CHANNELZ_H
 
 #include <grpc/support/port_platform.h>
 
@@ -82,4 +82,4 @@ class SubchannelNode : public BaseNode {
 }  // namespace channelz
 }  // namespace grpc_core
 
-#endif  // GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_CLIENT_CHANNEL_CHANNELZ_H
+#endif  // GRPC_SRC_CORE_CLIENT_CHANNEL_CLIENT_CHANNEL_CHANNELZ_H

data/src/core/{ext/filters/client_channel → client_channel}/client_channel_factory.cc

@@ -18,7 +18,7 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/ext/filters/client_channel/client_channel_factory.h"
+#include "src/core/client_channel/client_channel_factory.h"
 
 // Channel arg key for client channel factory.
 #define GRPC_ARG_CLIENT_CHANNEL_FACTORY "grpc.client_channel_factory"

data/src/core/{ext/filters/client_channel → client_channel}/client_channel_factory.h

@@ -14,14 +14,14 @@
 // limitations under the License.
 //
 
-#ifndef GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_CLIENT_CHANNEL_FACTORY_H
-#define GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_CLIENT_CHANNEL_FACTORY_H
+#ifndef GRPC_SRC_CORE_CLIENT_CHANNEL_CLIENT_CHANNEL_FACTORY_H
+#define GRPC_SRC_CORE_CLIENT_CHANNEL_CLIENT_CHANNEL_FACTORY_H
 
 #include <grpc/support/port_platform.h>
 
 #include "absl/strings/string_view.h"
 
-#include "src/core/ext/filters/client_channel/subchannel.h"
+#include "src/core/client_channel/subchannel.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/iomgr/resolved_address.h"
@@ -43,4 +43,4 @@ class ClientChannelFactory {
 
 }  // namespace grpc_core
 
-#endif  // GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_CLIENT_CHANNEL_FACTORY_H
+#endif  // GRPC_SRC_CORE_CLIENT_CHANNEL_CLIENT_CHANNEL_FACTORY_H