grpc 1.49.1-x86_64-linux → 1.50.0-x86_64-linux

data/src/core/lib/gprpp/ref_counted_ptr.h

@@ -55,14 +55,12 @@ class RefCountedPtr {
 
   // Move assignment.
   RefCountedPtr& operator=(RefCountedPtr&& other) noexcept {
-    reset(other.value_);
-    other.value_ = nullptr;
+    reset(std::exchange(other.value_, nullptr));
     return *this;
   }
   template <typename Y>
   RefCountedPtr& operator=(RefCountedPtr<Y>&& other) noexcept {
-    reset(other.value_);
-    other.value_ = nullptr;
+    reset(std::exchange(other.value_, nullptr));
     return *this;
   }
 
@@ -108,39 +106,32 @@ class RefCountedPtr {
 
   // If value is non-null, we take ownership of a ref to it.
   void reset(T* value = nullptr) {
-    if (value_ != nullptr) value_->Unref();
-    value_ = value;
+    T* old_value = std::exchange(value_, value);
+    if (old_value != nullptr) old_value->Unref();
   }
   void reset(const DebugLocation& location, const char* reason,
              T* value = nullptr) {
-    if (value_ != nullptr) value_->Unref(location, reason);
-    value_ = value;
+    T* old_value = std::exchange(value_, value);
+    if (old_value != nullptr) old_value->Unref(location, reason);
   }
   template <typename Y>
   void reset(Y* value = nullptr) {
     static_assert(std::has_virtual_destructor<T>::value,
                   "T does not have a virtual dtor");
-    if (value_ != nullptr) value_->Unref();
-    value_ = static_cast<T*>(value);
+    reset(static_cast<T*>(value));
   }
   template <typename Y>
   void reset(const DebugLocation& location, const char* reason,
              Y* value = nullptr) {
     static_assert(std::has_virtual_destructor<T>::value,
                   "T does not have a virtual dtor");
-    if (value_ != nullptr) value_->Unref(location, reason);
-    value_ = static_cast<T*>(value);
+    reset(location, reason, static_cast<T*>(value));
   }
 
-  // TODO(roth): This method exists solely as a transition mechanism to allow
-  // us to pass a ref to idiomatic C code that does not use RefCountedPtr<>.
-  // Once all of our code has been converted to idiomatic C++, this
-  // method should go away.
-  T* release() {
-    T* value = value_;
-    value_ = nullptr;
-    return value;
-  }
+  // This method is mostly useful for interoperating with C code.
+  // Eventually use within core should be banned, except at the surface API
+  // boundaries.
+  T* release() { return std::exchange(value_, nullptr); }
 
   T* get() const { return value_; }
 
@@ -207,14 +198,12 @@ class WeakRefCountedPtr {
 
   // Move assignment.
   WeakRefCountedPtr& operator=(WeakRefCountedPtr&& other) noexcept {
-    reset(other.value_);
-    other.value_ = nullptr;
+    reset(std::exchange(other.value_, nullptr));
     return *this;
   }
   template <typename Y>
   WeakRefCountedPtr& operator=(WeakRefCountedPtr<Y>&& other) noexcept {
-    reset(other.value_);
-    other.value_ = nullptr;
+    reset(std::exchange(other.value_, nullptr));
     return *this;
   }
 
@@ -260,28 +249,26 @@ class WeakRefCountedPtr {
 
   // If value is non-null, we take ownership of a ref to it.
   void reset(T* value = nullptr) {
-    if (value_ != nullptr) value_->WeakUnref();
-    value_ = value;
+    T* old_value = std::exchange(value_, value);
+    if (old_value != nullptr) old_value->WeakUnref();
   }
   void reset(const DebugLocation& location, const char* reason,
              T* value = nullptr) {
-    if (value_ != nullptr) value_->WeakUnref(location, reason);
-    value_ = value;
+    T* old_value = std::exchange(value_, value);
+    if (old_value != nullptr) old_value->WeakUnref(location, reason);
   }
   template <typename Y>
   void reset(Y* value = nullptr) {
     static_assert(std::has_virtual_destructor<T>::value,
                   "T does not have a virtual dtor");
-    if (value_ != nullptr) value_->WeakUnref();
-    value_ = static_cast<T*>(value);
+    reset(static_cast<T*>(value));
   }
   template <typename Y>
   void reset(const DebugLocation& location, const char* reason,
              Y* value = nullptr) {
     static_assert(std::has_virtual_destructor<T>::value,
                   "T does not have a virtual dtor");
-    if (value_ != nullptr) value_->WeakUnref(location, reason);
-    value_ = static_cast<T*>(value);
+    reset(location, reason, static_cast<T*>(value));
   }
 
   // TODO(roth): This method exists solely as a transition mechanism to allow

data/src/core/lib/gprpp/sorted_pack.h

@@ -0,0 +1,98 @@
+// 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_GPRPP_SORTED_PACK_H
+#define GRPC_CORE_LIB_GPRPP_SORTED_PACK_H
+
+#include <grpc/support/port_platform.h>
+
+#include <type_traits>
+
+namespace grpc_core {
+
+namespace sorted_pack_detail {
+
+// A list of types
+template <typename... A>
+struct Typelist {
+  template <template <typename...> class T>
+  using Instantiate = T<A...>;
+
+  template <typename C>
+  using PushFront = Typelist<C, A...>;
+};
+
+// Find the smallest element of Args, and the rest of the elements
+template <template <typename, typename> class Cmp, typename Args>
+struct Smallest;
+
+template <template <typename, typename> class Cmp, typename Arg,
+          typename... Args>
+struct Smallest<Cmp, Typelist<Arg, Args...>> {
+  using SmallestRest = Smallest<Cmp, Typelist<Args...>>;
+  using PrevSmallest = typename SmallestRest::Result;
+  using PrevRest = typename SmallestRest::Rest;
+  static constexpr bool kCmpResult = Cmp<Arg, PrevSmallest>::kValue;
+  using Result = typename std::conditional<kCmpResult, Arg, PrevSmallest>::type;
+  using Prefix = typename std::conditional<kCmpResult, PrevSmallest, Arg>::type;
+  using Rest = typename PrevRest::template PushFront<Prefix>;
+};
+
+template <template <typename, typename> class Cmp, typename Arg>
+struct Smallest<Cmp, Typelist<Arg>> {
+  using Result = Arg;
+  using Rest = Typelist<>;
+};
+
+// Sort a list of types into a typelist
+template <template <typename, typename> class Cmp, typename Args>
+struct Sorted;
+
+template <template <typename, typename> class Cmp, typename... Args>
+struct Sorted<Cmp, Typelist<Args...>> {
+  using SmallestResult = Smallest<Cmp, Typelist<Args...>>;
+  using SmallestType = typename SmallestResult::Result;
+  using RestOfTypes = typename SmallestResult::Rest;
+  using SortedRestOfTypes = typename Sorted<Cmp, RestOfTypes>::Result;
+  using Result = typename SortedRestOfTypes::template PushFront<SmallestType>;
+};
+
+template <template <typename, typename> class Cmp, typename Arg>
+struct Sorted<Cmp, Typelist<Arg>> {
+  using Result = Typelist<Arg>;
+};
+
+template <template <typename, typename> class Cmp>
+struct Sorted<Cmp, Typelist<>> {
+  using Result = Typelist<>;
+};
+
+}  // namespace sorted_pack_detail
+
+// Given a type T<A...>, and a type comparator Cmp<P,Q>, and some set of types
+// Args...:
+// Sort Args... using Cmp into SortedArgs..., then instantiate T<SortedArgs...>
+// as Type.
+// Cmp<P,Q> should have a single constant `kValue` that is true if P < Q.
+template <template <typename...> class T,
+          template <typename, typename> class Cmp, typename... Args>
+struct WithSortedPack {
+  using Type = typename sorted_pack_detail::Sorted<
+      Cmp,
+      sorted_pack_detail::Typelist<Args...>>::Result::template Instantiate<T>;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_GPRPP_SORTED_PACK_H

data/src/core/lib/gprpp/status_helper.h

@@ -38,6 +38,12 @@ struct google_rpc_Status;
 struct upb_Arena;
 }
 
+#define RETURN_IF_ERROR(expr)           \
+  do {                                  \
+    const absl::Status status = (expr); \
+    if (!status.ok()) return status;    \
+  } while (0)
+
 namespace grpc_core {
 
 /// This enum should have the same value of grpc_error_ints

data/src/core/lib/gprpp/table.h

@@ -218,7 +218,7 @@ class Table {
 
   // Check if this table has index I.
   template <size_t I>
-      absl::enable_if_t < I<sizeof...(Ts), bool> has() const {
+  absl::enable_if_t<(I < sizeof...(Ts)), bool> has() const {
     return present_bits_.is_set(I);
   }
 
@@ -317,6 +317,14 @@ class Table {
     ForEachImpl(std::move(f), absl::make_index_sequence<sizeof...(Ts)>());
   }
 
+  // Iterate through each set field in the table if it exists in Vs, in the
+  // order of Vs.
+  template <typename F, typename... Vs>
+  void ForEachIn(F f) const {
+    ForEachImpl(std::move(f),
+                absl::index_sequence<table_detail::IndexOf<Vs, Ts...>()...>());
+  }
+
   // Count the number of set fields in the table
   size_t count() const { return present_bits_.count(); }
 

data/src/core/lib/gprpp/tchar.cc

@@ -0,0 +1,49 @@
+// 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/gprpp/tchar.h"
+
+#ifdef GPR_WINDOWS
+
+namespace grpc_core {
+
+#if defined UNICODE || defined _UNICODE
+TcharString CharToTchar(std::string input) {
+  int needed = MultiByteToWideChar(CP_UTF8, 0, input.c_str(), -1, NULL, 0);
+  if (needed <= 0) return TcharString();
+  TcharString ret(needed, L'\0');
+  MultiByteToWideChar(CP_UTF8, 0, input.c_str(), -1,
+                      const_cast<LPTSTR>(ret.data()), needed);
+  return ret;
+}
+
+std::string TcharToChar(TcharString input) {
+  int needed =
+      WideCharToMultiByte(CP_UTF8, 0, input.c_str(), -1, NULL, 0, NULL, NULL);
+  if (needed <= 0) return std::string();
+  std::string ret(needed, '\0');
+  WideCharToMultiByte(CP_UTF8, 0, input.c_str(), -1,
+                      const_cast<LPSTR>(ret.data()), needed, NULL, NULL);
+  return ret;
+}
+#else
+TcharString CharToTchar(std::string input) { return input; }
+std::string TcharToChar(TcharString input) { return input; }
+#endif
+
+}  // namespace grpc_core
+
+#endif

data/src/core/lib/gprpp/tchar.h

@@ -0,0 +1,33 @@
+// 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_GPRPP_TCHAR_H
+#define GRPC_CORE_LIB_GPRPP_TCHAR_H
+
+#include <grpc/support/port_platform.h>
+
+#ifdef GPR_WINDOWS
+#include <string>
+
+namespace grpc_core {
+
+using TcharString = std::basic_string<TCHAR>;
+
+TcharString CharToTchar(std::string input);
+std::string TcharToChar(TcharString input);
+
+}  // namespace grpc_core
+#endif
+
+#endif  // GRPC_CORE_LIB_GPRPP_TCHAR_H

data/src/core/lib/gprpp/time.cc

@@ -28,6 +28,8 @@
 #include <grpc/impl/codegen/gpr_types.h>
 #include <grpc/support/log.h>
 
+#include "src/core/lib/gprpp/no_destruct.h"
+
 namespace grpc_core {
 
 namespace {
@@ -35,6 +37,13 @@ namespace {
 std::atomic<int64_t> g_process_epoch_seconds;
 std::atomic<gpr_cycle_counter> g_process_epoch_cycles;
 
+class GprNowTimeSource final : public Timestamp::Source {
+ public:
+  Timestamp Now() override {
+    return Timestamp::FromTimespecRoundDown(gpr_now(GPR_CLOCK_MONOTONIC));
+  }
+};
+
 GPR_ATTRIBUTE_NOINLINE std::pair<int64_t, gpr_cycle_counter> InitTime() {
   gpr_cycle_counter cycles_start = 0;
   gpr_cycle_counter cycles_end = 0;
@@ -133,6 +142,18 @@ int64_t TimespanToMillisRoundDown(gpr_timespec ts) {
 
 }  // namespace
 
+GPR_THREAD_LOCAL(Timestamp::Source*)
+Timestamp::thread_local_time_source_{
+    NoDestructSingleton<GprNowTimeSource>::Get()};
+
+Timestamp ScopedTimeCache::Now() {
+  if (!cached_time_.has_value()) {
+    previous()->InvalidateCache();
+    cached_time_ = previous()->Now();
+  }
+  return cached_time_.value();
+}
+
 Timestamp Timestamp::FromTimespecRoundUp(gpr_timespec ts) {
   return FromMillisecondsAfterProcessEpoch(TimespanToMillisRoundUp(gpr_time_sub(
       gpr_convert_clock_type(ts, GPR_CLOCK_MONOTONIC), StartTime())));

data/src/core/lib/gprpp/time.h

@@ -23,11 +23,14 @@
 #include <ostream>
 #include <string>
 
+#include "absl/types/optional.h"
+
 #include <grpc/event_engine/event_engine.h>
 #include <grpc/impl/codegen/gpr_types.h>
 #include <grpc/support/time.h>
 
 #include "src/core/lib/gpr/time_precise.h"
+#include "src/core/lib/gpr/tls.h"
 #include "src/core/lib/gpr/useful.h"
 
 namespace grpc_core {
@@ -61,6 +64,35 @@ class Duration;
 // Timestamp represents a discrete point in time.
 class Timestamp {
  public:
+  // Base interface for time providers.
+  class Source {
+   public:
+    // Return the current time.
+    virtual Timestamp Now() = 0;
+    virtual void InvalidateCache() {}
+
+   protected:
+    // We don't delete through this interface, so non-virtual dtor is fine.
+    ~Source() = default;
+  };
+
+  class ScopedSource : public Source {
+   public:
+    ScopedSource() : previous_(thread_local_time_source_) {
+      thread_local_time_source_ = this;
+    }
+    ScopedSource(const ScopedSource&) = delete;
+    ScopedSource& operator=(const ScopedSource&) = delete;
+    void InvalidateCache() override { previous_->InvalidateCache(); }
+
+   protected:
+    ~ScopedSource() { thread_local_time_source_ = previous_; }
+    Source* previous() const { return previous_; }
+
+   private:
+    Source* const previous_;
+  };
+
   constexpr Timestamp() = default;
   // Constructs a Timestamp from a gpr_timespec.
   static Timestamp FromTimespecRoundDown(gpr_timespec t);
@@ -70,6 +102,8 @@ class Timestamp {
   static Timestamp FromCycleCounterRoundUp(gpr_cycle_counter c);
   static Timestamp FromCycleCounterRoundDown(gpr_cycle_counter c);
 
+  static Timestamp Now() { return thread_local_time_source_->Now(); }
+
   static constexpr Timestamp FromMillisecondsAfterProcessEpoch(int64_t millis) {
     return Timestamp(millis);
   }
@@ -116,6 +150,21 @@ class Timestamp {
   explicit constexpr Timestamp(int64_t millis) : millis_(millis) {}
 
   int64_t millis_ = 0;
+  static GPR_THREAD_LOCAL(Timestamp::Source*) thread_local_time_source_;
+};
+
+class ScopedTimeCache final : public Timestamp::ScopedSource {
+ public:
+  Timestamp Now() override;
+
+  void InvalidateCache() override {
+    cached_time_ = absl::nullopt;
+    Timestamp::ScopedSource::InvalidateCache();
+  }
+  void TestOnlySetNow(Timestamp now) { cached_time_ = now; }
+
+ private:
+  absl::optional<Timestamp> cached_time_;
 };
 
 // Duration represents a span of time.
@@ -200,6 +249,7 @@ class Duration {
     }
     return *this;
   }
+  Duration& operator*=(double multiplier);
   Duration& operator+=(Duration other) {
     millis_ += other.millis_;
     return *this;
@@ -287,6 +337,11 @@ inline Duration Duration::FromSecondsAsDouble(double seconds) {
   return Milliseconds(static_cast<int64_t>(millis));
 }
 
+inline Duration& Duration::operator*=(double multiplier) {
+  *this = *this * multiplier;
+  return *this;
+}
+
 inline Timestamp& Timestamp::operator+=(Duration duration) {
   return *this = (*this + duration);
 }

data/src/core/lib/gprpp/validation_errors.cc

@@ -0,0 +1,61 @@
+// Copyright 2020 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/gprpp/validation_errors.h"
+
+#include <algorithm>
+#include <utility>
+
+#include "absl/status/status.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_join.h"
+#include "absl/strings/strip.h"
+
+namespace grpc_core {
+
+void ValidationErrors::PushField(absl::string_view ext) {
+  // Skip leading '.' for top-level field names.
+  if (fields_.empty()) absl::ConsumePrefix(&ext, ".");
+  fields_.emplace_back(std::string(ext));
+}
+
+void ValidationErrors::PopField() { fields_.pop_back(); }
+
+void ValidationErrors::AddError(absl::string_view error) {
+  field_errors_[absl::StrJoin(fields_, "")].emplace_back(error);
+}
+
+bool ValidationErrors::FieldHasErrors() const {
+  return field_errors_.find(absl::StrJoin(fields_, "")) != field_errors_.end();
+}
+
+absl::Status ValidationErrors::status(absl::string_view prefix) const {
+  if (field_errors_.empty()) return absl::OkStatus();
+  std::vector<std::string> errors;
+  for (const auto& p : field_errors_) {
+    if (p.second.size() > 1) {
+      errors.emplace_back(absl::StrCat("field:", p.first, " errors:[",
+                                       absl::StrJoin(p.second, "; "), "]"));
+    } else {
+      errors.emplace_back(
+          absl::StrCat("field:", p.first, " error:", p.second[0]));
+    }
+  }
+  return absl::InvalidArgumentError(
+      absl::StrCat(prefix, ": [", absl::StrJoin(errors, "; "), "]"));
+}
+
+}  // namespace grpc_core

data/src/core/lib/gprpp/validation_errors.h

@@ -0,0 +1,110 @@
+// Copyright 2020 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_GPRPP_VALIDATION_ERRORS_H
+#define GRPC_CORE_LIB_GPRPP_VALIDATION_ERRORS_H
+
+#include <grpc/support/port_platform.h>
+
+#include <stddef.h>
+
+#include <map>
+#include <string>
+#include <vector>
+
+#include "absl/status/status.h"
+#include "absl/strings/string_view.h"
+
+namespace grpc_core {
+
+// Tracks errors that occur during validation of a data structure (e.g.,
+// a JSON object or protobuf message).  Errors are tracked based on
+// which field they are associated with.  If at least one error occurs
+// during validation, the validation failed.
+//
+// Example usage:
+//
+// absl::StatusOr<std::string> GetFooBar(const Json::Object& json) {
+//   ValidationErrors errors;
+//   {
+//     ValidationErrors::ScopedField field("foo");
+//     auto it = json.object_value().find("foo");
+//     if (it == json.object_value().end()) {
+//       errors.AddError("field not present");
+//     } else if (it->second.type() != Json::Type::OBJECT) {
+//       errors.AddError("must be a JSON object");
+//     } else {
+//       const Json& foo = it->second;
+//       ValidationErrors::ScopedField field(".bar");
+//       auto it = foo.object_value().find("bar");
+//       if (it == json.object_value().end()) {
+//         errors.AddError("field not present");
+//       } else if (it->second.type() != Json::Type::STRING) {
+//         errors.AddError("must be a JSON string");
+//       } else {
+//         return it->second.string_value();
+//       }
+//     }
+//   }
+//   return errors.status("errors validating foo.bar");
+// }
+class ValidationErrors {
+ public:
+  // Pushes a field name onto the stack at construction and pops it off
+  // of the stack at destruction.
+  class ScopedField {
+   public:
+    ScopedField(ValidationErrors* errors, absl::string_view field_name)
+        : errors_(errors) {
+      errors_->PushField(field_name);
+    }
+    ~ScopedField() { errors_->PopField(); }
+
+   private:
+    ValidationErrors* errors_;
+  };
+
+  // Records that we've encountered an error associated with the current
+  // field.
+  void AddError(absl::string_view error) GPR_ATTRIBUTE_NOINLINE;
+
+  // Returns true if the current field has errors.
+  bool FieldHasErrors() const GPR_ATTRIBUTE_NOINLINE;
+
+  // Returns the resulting status of parsing.
+  absl::Status status(absl::string_view prefix) const;
+
+  // Returns true if there are no errors.
+  bool ok() const { return field_errors_.empty(); }
+
+  size_t size() const { return field_errors_.size(); }
+
+ private:
+  // Pushes a field name onto the stack.
+  void PushField(absl::string_view ext) GPR_ATTRIBUTE_NOINLINE;
+  // Pops a field name off of the stack.
+  void PopField() GPR_ATTRIBUTE_NOINLINE;
+
+  // Errors that we have encountered so far, keyed by field name.
+  // TODO(roth): If we don't actually have any fields for which we
+  // report more than one error, simplify this data structure.
+  std::map<std::string /*field_name*/, std::vector<std::string>> field_errors_;
+  // Stack of field names indicating the field that we are currently
+  // validating.
+  std::vector<std::string> fields_;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_GPRPP_VALIDATION_ERRORS_H

data/src/core/{ext/filters/client_channel → lib/handshaker}/proxy_mapper.h

@@ -16,8 +16,8 @@
  *
  */
 
-#ifndef GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_PROXY_MAPPER_H
-#define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_PROXY_MAPPER_H
+#ifndef GRPC_CORE_LIB_HANDSHAKER_PROXY_MAPPER_H
+#define GRPC_CORE_LIB_HANDSHAKER_PROXY_MAPPER_H
 
 #include <grpc/support/port_platform.h>
 
@@ -50,4 +50,4 @@ class ProxyMapperInterface {
 
 }  // namespace grpc_core
 
-#endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_PROXY_MAPPER_H */
+#endif /* GRPC_CORE_LIB_HANDSHAKER_PROXY_MAPPER_H */