grpc 1.43.1 → 1.53.0

data/src/core/ext/filters/client_channel/health/health_check_client.h

@@ -1,177 +1,43 @@
-/*
- *
- * Copyright 2018 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_EXT_FILTERS_CLIENT_CHANNEL_HEALTH_HEALTH_CHECK_CLIENT_H
-#define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_HEALTH_HEALTH_CHECK_CLIENT_H
+//
+// Copyright 2018 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_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_HEALTH_HEALTH_CHECK_CLIENT_H
+#define GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_HEALTH_HEALTH_CHECK_CLIENT_H
 
 #include <grpc/support/port_platform.h>
 
-#include <atomic>
-
-#include <grpc/grpc.h>
-#include <grpc/support/sync.h>
+#include <string>
 
 #include "src/core/ext/filters/client_channel/client_channel_channelz.h"
 #include "src/core/ext/filters/client_channel/subchannel.h"
-#include "src/core/lib/backoff/backoff.h"
-#include "src/core/lib/gprpp/arena.h"
+#include "src/core/ext/filters/client_channel/subchannel_stream_client.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
-#include "src/core/lib/gprpp/sync.h"
-#include "src/core/lib/iomgr/call_combiner.h"
-#include "src/core/lib/iomgr/closure.h"
-#include "src/core/lib/iomgr/polling_entity.h"
-#include "src/core/lib/iomgr/timer.h"
-#include "src/core/lib/transport/byte_stream.h"
-#include "src/core/lib/transport/metadata_batch.h"
-#include "src/core/lib/transport/transport.h"
+#include "src/core/lib/iomgr/iomgr_fwd.h"
+#include "src/core/lib/transport/connectivity_state.h"
 
 namespace grpc_core {
 
-class HealthCheckClient : public InternallyRefCounted<HealthCheckClient> {
- public:
-  HealthCheckClient(std::string service_name,
-                    RefCountedPtr<ConnectedSubchannel> connected_subchannel,
-                    grpc_pollset_set* interested_parties,
-                    RefCountedPtr<channelz::SubchannelNode> channelz_node,
-                    RefCountedPtr<ConnectivityStateWatcherInterface> watcher);
-
-  ~HealthCheckClient() override;
-
-  void Orphan() override;
-
- private:
-  // Contains a call to the backend and all the data related to the call.
-  class CallState : public Orphanable {
-   public:
-    CallState(RefCountedPtr<HealthCheckClient> health_check_client,
-              grpc_pollset_set* interested_parties_);
-    ~CallState() override;
-
-    void Orphan() override;
-
-    void StartCall() ABSL_EXCLUSIVE_LOCKS_REQUIRED(&HealthCheckClient::mu_);
-
-   private:
-    void Cancel();
-
-    void StartBatch(grpc_transport_stream_op_batch* batch);
-    static void StartBatchInCallCombiner(void* arg, grpc_error_handle error);
-
-    void CallEndedLocked(bool retry)
-        ABSL_EXCLUSIVE_LOCKS_REQUIRED(health_check_client_->mu_);
-
-    static void OnComplete(void* arg, grpc_error_handle error);
-    static void RecvInitialMetadataReady(void* arg, grpc_error_handle error);
-    static void RecvMessageReady(void* arg, grpc_error_handle error);
-    static void RecvTrailingMetadataReady(void* arg, grpc_error_handle error);
-    static void StartCancel(void* arg, grpc_error_handle error);
-    static void OnCancelComplete(void* arg, grpc_error_handle error);
-
-    static void OnByteStreamNext(void* arg, grpc_error_handle error);
-    void ContinueReadingRecvMessage();
-    grpc_error_handle PullSliceFromRecvMessage();
-    void DoneReadingRecvMessage(grpc_error_handle error);
-
-    static void AfterCallStackDestruction(void* arg, grpc_error_handle error);
-
-    RefCountedPtr<HealthCheckClient> health_check_client_;
-    grpc_polling_entity pollent_;
-
-    Arena* arena_;
-    CallCombiner call_combiner_;
-    grpc_call_context_element context_[GRPC_CONTEXT_COUNT] = {};
-
-    // The streaming call to the backend. Always non-null.
-    // Refs are tracked manually; when the last ref is released, the
-    // CallState object will be automatically destroyed.
-    SubchannelCall* call_;
-
-    grpc_transport_stream_op_batch_payload payload_;
-    grpc_transport_stream_op_batch batch_;
-    grpc_transport_stream_op_batch recv_message_batch_;
-    grpc_transport_stream_op_batch recv_trailing_metadata_batch_;
-
-    grpc_closure on_complete_;
-
-    // send_initial_metadata
-    grpc_metadata_batch send_initial_metadata_;
-    grpc_linked_mdelem path_metadata_storage_;
-
-    // send_message
-    ManualConstructor<SliceBufferByteStream> send_message_;
-
-    // send_trailing_metadata
-    grpc_metadata_batch send_trailing_metadata_;
-
-    // recv_initial_metadata
-    grpc_metadata_batch recv_initial_metadata_;
-    grpc_closure recv_initial_metadata_ready_;
-
-    // recv_message
-    OrphanablePtr<ByteStream> recv_message_;
-    grpc_closure recv_message_ready_;
-    grpc_slice_buffer recv_message_buffer_;
-    std::atomic<bool> seen_response_{false};
-
-    // True if the cancel_stream batch has been started.
-    std::atomic<bool> cancelled_{false};
-
-    // recv_trailing_metadata
-    grpc_metadata_batch recv_trailing_metadata_;
-    grpc_transport_stream_stats collect_stats_;
-    grpc_closure recv_trailing_metadata_ready_;
-
-    // Closure for call stack destruction.
-    grpc_closure after_call_stack_destruction_;
-  };
-
-  void StartCall();
-  void StartCallLocked() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
-
-  void StartRetryTimerLocked() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
-  static void OnRetryTimer(void* arg, grpc_error_handle error);
-
-  void SetHealthStatus(grpc_connectivity_state state, const char* reason);
-  void SetHealthStatusLocked(grpc_connectivity_state state, const char* reason)
-      ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
-
-  std::string service_name_;
-  RefCountedPtr<ConnectedSubchannel> connected_subchannel_;
-  grpc_pollset_set* interested_parties_;  // Do not own.
-  RefCountedPtr<channelz::SubchannelNode> channelz_node_;
-
-  Mutex mu_;
-  RefCountedPtr<ConnectivityStateWatcherInterface> watcher_
-      ABSL_GUARDED_BY(mu_);
-  bool shutting_down_ ABSL_GUARDED_BY(mu_) = false;
-
-  // The data associated with the current health check call.  It holds a ref
-  // to this HealthCheckClient object.
-  OrphanablePtr<CallState> call_state_ ABSL_GUARDED_BY(mu_);
-
-  // Call retry state.
-  BackOff retry_backoff_ ABSL_GUARDED_BY(mu_);
-  grpc_timer retry_timer_ ABSL_GUARDED_BY(mu_);
-  grpc_closure retry_timer_callback_ ABSL_GUARDED_BY(mu_);
-  bool retry_timer_callback_pending_ ABSL_GUARDED_BY(mu_) = false;
-};
+OrphanablePtr<SubchannelStreamClient> MakeHealthCheckClient(
+    std::string service_name,
+    RefCountedPtr<ConnectedSubchannel> connected_subchannel,
+    grpc_pollset_set* interested_parties,
+    RefCountedPtr<channelz::SubchannelNode> channelz_node,
+    RefCountedPtr<ConnectivityStateWatcherInterface> watcher);
 
 }  // namespace grpc_core
 
-#endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_HEALTH_HEALTH_CHECK_CLIENT_H */
+#endif  // GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_HEALTH_HEALTH_CHECK_CLIENT_H

data/src/core/ext/filters/client_channel/http_proxy.cc

@@ -1,110 +1,117 @@
-/*
- *
- * 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>
 
 #include "src/core/ext/filters/client_channel/http_proxy.h"
 
-#include <stdbool.h>
 #include <string.h>
 
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/match.h"
 #include "absl/strings/str_cat.h"
+#include "absl/strings/str_split.h"
+#include "absl/strings/string_view.h"
 #include "absl/strings/strip.h"
+#include "absl/types/optional.h"
 
+#include <grpc/grpc.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
-#include <grpc/support/string_util.h>
 
-#include "src/core/ext/filters/client_channel/http_connect_handshaker.h"
-#include "src/core/ext/filters/client_channel/proxy_mapper_registry.h"
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/gpr/env.h"
 #include "src/core/lib/gpr/string.h"
+#include "src/core/lib/gprpp/env.h"
 #include "src/core/lib/gprpp/host_port.h"
+#include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/iomgr/resolve_address.h"
 #include "src/core/lib/slice/b64.h"
+#include "src/core/lib/transport/http_connect_handshaker.h"
 #include "src/core/lib/uri/uri_parser.h"
 
 namespace grpc_core {
 namespace {
 
-/**
- * Parses the 'https_proxy' env var (fallback on 'http_proxy') and returns the
- * proxy hostname to resolve or nullptr on error. Also sets 'user_cred' to user
- * credentials if present in the 'http_proxy' env var, otherwise leaves it
- * unchanged. It is caller's responsibility to gpr_free user_cred.
- */
-// TODO(hork): change this to return std::string
-char* GetHttpProxyServer(const grpc_channel_args* args, char** user_cred) {
+///
+/// Parses the 'https_proxy' env var (fallback on 'http_proxy') and returns the
+/// proxy hostname to resolve or nullopt on error. Also sets 'user_cred' to user
+/// credentials if present in the 'http_proxy' env var, otherwise leaves it
+/// unchanged.
+///
+absl::optional<std::string> GetHttpProxyServer(
+    const ChannelArgs& args, absl::optional<std::string>* user_cred) {
   GPR_ASSERT(user_cred != nullptr);
   absl::StatusOr<URI> uri;
-  char* proxy_name = nullptr;
-  char** authority_strs = nullptr;
-  size_t authority_nstrs;
-  /* We check the following places to determine the HTTP proxy to use, stopping
-   * at the first one that is set:
-   * 1. GRPC_ARG_HTTP_PROXY channel arg
-   * 2. grpc_proxy environment variable
-   * 3. https_proxy environment variable
-   * 4. http_proxy environment variable
-   * If none of the above are set, then no HTTP proxy will be used.
-   */
-  char* uri_str =
-      gpr_strdup(grpc_channel_args_find_string(args, GRPC_ARG_HTTP_PROXY));
-  if (uri_str == nullptr) uri_str = gpr_getenv("grpc_proxy");
-  if (uri_str == nullptr) uri_str = gpr_getenv("https_proxy");
-  if (uri_str == nullptr) uri_str = gpr_getenv("http_proxy");
-  if (uri_str == nullptr) return nullptr;
+  // We check the following places to determine the HTTP proxy to use, stopping
+  // at the first one that is set:
+  // 1. GRPC_ARG_HTTP_PROXY channel arg
+  // 2. grpc_proxy environment variable
+  // 3. https_proxy environment variable
+  // 4. http_proxy environment variable
+  // If none of the above are set, then no HTTP proxy will be used.
+  //
+  absl::optional<std::string> uri_str =
+      args.GetOwnedString(GRPC_ARG_HTTP_PROXY);
+  if (!uri_str.has_value()) uri_str = GetEnv("grpc_proxy");
+  if (!uri_str.has_value()) uri_str = GetEnv("https_proxy");
+  if (!uri_str.has_value()) uri_str = GetEnv("http_proxy");
+  if (!uri_str.has_value()) return absl::nullopt;
   // an emtpy value means "don't use proxy"
-  if (uri_str[0] == '\0') goto done;
-  uri = URI::Parse(uri_str);
+  if (uri_str->empty()) return absl::nullopt;
+  uri = URI::Parse(*uri_str);
   if (!uri.ok() || uri->authority().empty()) {
     gpr_log(GPR_ERROR, "cannot parse value of 'http_proxy' env var. Error: %s",
             uri.status().ToString().c_str());
-    goto done;
+    return absl::nullopt;
   }
   if (uri->scheme() != "http") {
     gpr_log(GPR_ERROR, "'%s' scheme not supported in proxy URI",
             uri->scheme().c_str());
-    goto done;
+    return absl::nullopt;
   }
-  /* Split on '@' to separate user credentials from host */
+  // Split on '@' to separate user credentials from host
+  char** authority_strs = nullptr;
+  size_t authority_nstrs;
   gpr_string_split(uri->authority().c_str(), "@", &authority_strs,
                    &authority_nstrs);
-  GPR_ASSERT(authority_nstrs != 0); /* should have at least 1 string */
+  GPR_ASSERT(authority_nstrs != 0);  // should have at least 1 string
+  absl::optional<std::string> proxy_name;
   if (authority_nstrs == 1) {
-    /* User cred not present in authority */
+    // User cred not present in authority
     proxy_name = authority_strs[0];
   } else if (authority_nstrs == 2) {
-    /* User cred found */
+    // User cred found
     *user_cred = authority_strs[0];
     proxy_name = authority_strs[1];
     gpr_log(GPR_DEBUG, "userinfo found in proxy URI");
   } else {
-    /* Bad authority */
-    for (size_t i = 0; i < authority_nstrs; i++) {
-      gpr_free(authority_strs[i]);
-    }
-    proxy_name = nullptr;
+    // Bad authority
+    proxy_name = absl::nullopt;
+  }
+  for (size_t i = 0; i < authority_nstrs; i++) {
+    gpr_free(authority_strs[i]);
   }
   gpr_free(authority_strs);
-done:
-  gpr_free(uri_str);
   return proxy_name;
 }
 
@@ -119,114 +126,73 @@ std::string MaybeAddDefaultPort(absl::string_view target) {
   return std::string(target);
 }
 
-class HttpProxyMapper : public ProxyMapperInterface {
- public:
-  bool MapName(const char* server_uri, const grpc_channel_args* args,
-               char** name_to_resolve, grpc_channel_args** new_args) override {
-    if (!grpc_channel_args_find_bool(args, GRPC_ARG_ENABLE_HTTP_PROXY, true)) {
-      return false;
-    }
-    char* user_cred = nullptr;
-    *name_to_resolve = GetHttpProxyServer(args, &user_cred);
-    if (*name_to_resolve == nullptr) return false;
-    char* no_proxy_str = nullptr;
-    std::string server_target;
-    absl::StatusOr<URI> uri = URI::Parse(server_uri);
-    if (!uri.ok() || uri->path().empty()) {
-      gpr_log(GPR_ERROR,
-              "'http_proxy' environment variable set, but cannot "
-              "parse server URI '%s' -- not using proxy. Error: %s",
-              server_uri, uri.status().ToString().c_str());
-      goto no_use_proxy;
-    }
-    if (uri->scheme() == "unix") {
-      gpr_log(GPR_INFO, "not using proxy for Unix domain socket '%s'",
-              server_uri);
-      goto no_use_proxy;
-    }
-    /* Prefer using 'no_grpc_proxy'. Fallback on 'no_proxy' if it is not set. */
-    no_proxy_str = gpr_getenv("no_grpc_proxy");
-    if (no_proxy_str == nullptr) no_proxy_str = gpr_getenv("no_proxy");
-    if (no_proxy_str != nullptr) {
-      static const char* NO_PROXY_SEPARATOR = ",";
-      bool use_proxy = true;
-      std::string server_host;
-      std::string server_port;
-      if (!SplitHostPort(absl::StripPrefix(uri->path(), "/"), &server_host,
-                         &server_port)) {
-        gpr_log(GPR_INFO,
-                "unable to split host and port, not checking no_proxy list for "
-                "host '%s'",
-                server_uri);
-        gpr_free(no_proxy_str);
-      } else {
-        size_t uri_len = server_host.size();
-        char** no_proxy_hosts;
-        size_t num_no_proxy_hosts;
-        gpr_string_split(no_proxy_str, NO_PROXY_SEPARATOR, &no_proxy_hosts,
-                         &num_no_proxy_hosts);
-        for (size_t i = 0; i < num_no_proxy_hosts; i++) {
-          char* no_proxy_entry = no_proxy_hosts[i];
-          size_t no_proxy_len = strlen(no_proxy_entry);
-          if (no_proxy_len <= uri_len &&
-              gpr_stricmp(no_proxy_entry,
-                          &(server_host.c_str()[uri_len - no_proxy_len])) ==
-                  0) {
-            gpr_log(GPR_INFO, "not using proxy for host in no_proxy list '%s'",
-                    server_uri);
-            use_proxy = false;
-            break;
-          }
-        }
-        for (size_t i = 0; i < num_no_proxy_hosts; i++) {
-          gpr_free(no_proxy_hosts[i]);
+}  // namespace
+
+absl::optional<std::string> HttpProxyMapper::MapName(
+    absl::string_view server_uri, ChannelArgs* args) {
+  if (!args->GetBool(GRPC_ARG_ENABLE_HTTP_PROXY).value_or(true)) {
+    return absl::nullopt;
+  }
+  absl::optional<std::string> user_cred;
+  auto name_to_resolve = GetHttpProxyServer(*args, &user_cred);
+  if (!name_to_resolve.has_value()) return name_to_resolve;
+  absl::StatusOr<URI> uri = URI::Parse(server_uri);
+  if (!uri.ok() || uri->path().empty()) {
+    gpr_log(GPR_ERROR,
+            "'http_proxy' environment variable set, but cannot "
+            "parse server URI '%s' -- not using proxy. Error: %s",
+            std::string(server_uri).c_str(), uri.status().ToString().c_str());
+    return absl::nullopt;
+  }
+  if (uri->scheme() == "unix") {
+    gpr_log(GPR_INFO, "not using proxy for Unix domain socket '%s'",
+            std::string(server_uri).c_str());
+    return absl::nullopt;
+  }
+  // Prefer using 'no_grpc_proxy'. Fallback on 'no_proxy' if it is not set.
+  auto no_proxy_str = GetEnv("no_grpc_proxy");
+  if (!no_proxy_str.has_value()) {
+    no_proxy_str = GetEnv("no_proxy");
+  }
+  if (no_proxy_str.has_value()) {
+    bool use_proxy = true;
+    std::string server_host;
+    std::string server_port;
+    if (!SplitHostPort(absl::StripPrefix(uri->path(), "/"), &server_host,
+                       &server_port)) {
+      gpr_log(GPR_INFO,
+              "unable to split host and port, not checking no_proxy list for "
+              "host '%s'",
+              std::string(server_uri).c_str());
+    } else {
+      std::vector<absl::string_view> no_proxy_hosts =
+          absl::StrSplit(*no_proxy_str, ',', absl::SkipEmpty());
+      for (const auto& no_proxy_entry : no_proxy_hosts) {
+        if (absl::EndsWithIgnoreCase(server_host, no_proxy_entry)) {
+          gpr_log(GPR_INFO, "not using proxy for host in no_proxy list '%s'",
+                  std::string(server_uri).c_str());
+          use_proxy = false;
+          break;
         }
-        gpr_free(no_proxy_hosts);
-        gpr_free(no_proxy_str);
-        if (!use_proxy) goto no_use_proxy;
       }
+      if (!use_proxy) return absl::nullopt;
     }
-    server_target =
-        MaybeAddDefaultPort(absl::StripPrefix(uri->path(), "/")).c_str();
-    grpc_arg args_to_add[2];
-    args_to_add[0] = grpc_channel_arg_string_create(
-        const_cast<char*>(GRPC_ARG_HTTP_CONNECT_SERVER),
-        const_cast<char*>(server_target.c_str()));
-    if (user_cred != nullptr) {
-      /* Use base64 encoding for user credentials as stated in RFC 7617 */
-      char* encoded_user_cred =
-          grpc_base64_encode(user_cred, strlen(user_cred), 0, 0);
-      std::string header =
-          absl::StrCat("Proxy-Authorization:Basic ", encoded_user_cred);
-      gpr_free(encoded_user_cred);
-      args_to_add[1] = grpc_channel_arg_string_create(
-          const_cast<char*>(GRPC_ARG_HTTP_CONNECT_HEADERS),
-          const_cast<char*>(header.c_str()));
-      *new_args = grpc_channel_args_copy_and_add(args, args_to_add, 2);
-    } else {
-      *new_args = grpc_channel_args_copy_and_add(args, args_to_add, 1);
-    }
-    gpr_free(user_cred);
-    return true;
-  no_use_proxy:
-    gpr_free(*name_to_resolve);
-    *name_to_resolve = nullptr;
-    gpr_free(user_cred);
-    return false;
   }
-
-  bool MapAddress(const grpc_resolved_address& /*address*/,
-                  const grpc_channel_args* /*args*/,
-                  grpc_resolved_address** /*new_address*/,
-                  grpc_channel_args** /*new_args*/) override {
-    return false;
+  *args = args->Set(GRPC_ARG_HTTP_CONNECT_SERVER,
+                    MaybeAddDefaultPort(absl::StripPrefix(uri->path(), "/")));
+  if (user_cred.has_value()) {
+    // Use base64 encoding for user credentials as stated in RFC 7617
+    auto encoded_user_cred = UniquePtr<char>(
+        grpc_base64_encode(user_cred->data(), user_cred->length(), 0, 0));
+    *args = args->Set(
+        GRPC_ARG_HTTP_CONNECT_HEADERS,
+        absl::StrCat("Proxy-Authorization:Basic ", encoded_user_cred.get()));
   }
-};
-
-}  // namespace
+  return name_to_resolve;
+}
 
-void RegisterHttpProxyMapper() {
-  ProxyMapperRegistry::Register(
+void RegisterHttpProxyMapper(CoreConfiguration::Builder* builder) {
+  builder->proxy_mapper_registry()->Register(
       true /* at_start */,
       std::unique_ptr<ProxyMapperInterface>(new HttpProxyMapper()));
 }

data/src/core/ext/filters/client_channel/http_proxy.h

@@ -1,28 +1,52 @@
-/*
- *
- * 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.
- *
- */
-
-#ifndef GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_HTTP_PROXY_H
-#define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_HTTP_PROXY_H
+//
+//
+// 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.
+//
+//
+
+#ifndef GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_HTTP_PROXY_H
+#define GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_HTTP_PROXY_H
+
+#include <grpc/support/port_platform.h>
+
+#include <string>
+
+#include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
+
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/config/core_configuration.h"
+#include "src/core/lib/handshaker/proxy_mapper.h"
+#include "src/core/lib/iomgr/resolved_address.h"
 
 namespace grpc_core {
 
-void RegisterHttpProxyMapper();
+class HttpProxyMapper : public ProxyMapperInterface {
+ public:
+  absl::optional<std::string> MapName(absl::string_view server_uri,
+                                      ChannelArgs* args) override;
+
+  absl::optional<grpc_resolved_address> MapAddress(
+      const grpc_resolved_address& /*address*/,
+      ChannelArgs* /*args*/) override {
+    return absl::nullopt;
+  }
+};
+
+void RegisterHttpProxyMapper(CoreConfiguration::Builder* builder);
 
 }  // namespace grpc_core
 
-#endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_HTTP_PROXY_H */
+#endif  // GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_HTTP_PROXY_H