grpc 1.67.0.pre1 → 1.68.1

data/src/core/{lib/gprpp → util}/dump_args.h

@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef GRPC_SRC_CORE_LIB_GPRPP_DUMP_ARGS_H
-#define GRPC_SRC_CORE_LIB_GPRPP_DUMP_ARGS_H
+#ifndef GRPC_SRC_CORE_UTIL_DUMP_ARGS_H
+#define GRPC_SRC_CORE_UTIL_DUMP_ARGS_H
 
 #include <ostream>
 #include <vector>
@@ -78,20 +78,25 @@ class DumpArgs {
     return 0;
   }
 
-  int AddDumper(void** p) {
+  int AddDumper(void const* const* p) {
     arg_dumpers_.push_back(
         [p](CustomSink& os) { os.Append(absl::StrFormat("%p", *p)); });
     return 0;
   }
 
   template <typename T>
-  int AddDumper(T** p) {
-    return AddDumper(reinterpret_cast<void**>(p));
+  int AddDumper(T const* const* p) {
+    return AddDumper(reinterpret_cast<void const* const*>(p));
   }
 
   template <typename T>
   int AddDumper(T* const* p) {
-    return AddDumper(const_cast<T**>(p));
+    return AddDumper(const_cast<T const* const*>(p));
+  }
+
+  template <typename T>
+  int AddDumper(T const** p) {
+    return AddDumper(const_cast<T const* const*>(p));
   }
 
   void Stringify(CustomSink& sink) const;
@@ -114,4 +119,4 @@ class DumpArgs {
 #define GRPC_DUMP_ARGS(...) \
   grpc_core::dump_args_detail::DumpArgs(#__VA_ARGS__, __VA_ARGS__)
 
-#endif  // GRPC_SRC_CORE_LIB_GPRPP_DUMP_ARGS_H
+#endif  // GRPC_SRC_CORE_UTIL_DUMP_ARGS_H

data/src/core/{lib/gprpp → util}/env.h

@@ -16,15 +16,15 @@
 //
 //
 
-#ifndef GRPC_SRC_CORE_LIB_GPRPP_ENV_H
-#define GRPC_SRC_CORE_LIB_GPRPP_ENV_H
+#ifndef GRPC_SRC_CORE_UTIL_ENV_H
+#define GRPC_SRC_CORE_UTIL_ENV_H
+
+#include <grpc/support/port_platform.h>
 
 #include <string>
 
 #include "absl/types/optional.h"
 
-#include <grpc/support/port_platform.h>
-
 namespace grpc_core {
 
 // Gets the environment variable value with the specified name. */
@@ -50,4 +50,4 @@ void SetOrUnsetEnv(const char* name, const absl::optional<T>& value) {
 
 }  // namespace grpc_core
 
-#endif  // GRPC_SRC_CORE_LIB_GPRPP_ENV_H
+#endif  // GRPC_SRC_CORE_UTIL_ENV_H

data/src/core/{lib/debug → util}/event_log.cc

@@ -12,7 +12,9 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "src/core/lib/debug/event_log.h"
+#include "src/core/util/event_log.h"
+
+#include <grpc/support/port_platform.h>
 
 #include <algorithm>
 #include <atomic>
@@ -21,8 +23,6 @@
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_join.h"
 
-#include <grpc/support/port_platform.h>
-
 namespace grpc_core {
 
 std::atomic<EventLog*> EventLog::g_instance_{nullptr};

data/src/core/{lib/debug → util}/event_log.h

@@ -12,9 +12,10 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef GRPC_SRC_CORE_LIB_DEBUG_EVENT_LOG_H
-#define GRPC_SRC_CORE_LIB_DEBUG_EVENT_LOG_H
+#ifndef GRPC_SRC_CORE_UTIL_EVENT_LOG_H
+#define GRPC_SRC_CORE_UTIL_EVENT_LOG_H
 
+#include <grpc/support/port_platform.h>
 #include <stdint.h>
 
 #include <atomic>
@@ -24,11 +25,8 @@
 #include "absl/base/thread_annotations.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/span.h"
-
-#include <grpc/support/port_platform.h>
-
-#include "src/core/lib/gprpp/per_cpu.h"
-#include "src/core/lib/gprpp/sync.h"
+#include "src/core/util/per_cpu.h"
+#include "src/core/util/sync.h"
 #include "src/core/util/time_precise.h"
 
 namespace grpc_core {
@@ -78,4 +76,4 @@ class EventLog {
 
 }  // namespace grpc_core
 
-#endif  // GRPC_SRC_CORE_LIB_DEBUG_EVENT_LOG_H
+#endif  // GRPC_SRC_CORE_UTIL_EVENT_LOG_H

data/src/core/{lib/gprpp → util}/examine_stack.cc

@@ -16,7 +16,7 @@
 //
 //
 
-#include "src/core/lib/gprpp/examine_stack.h"
+#include "src/core/util/examine_stack.h"
 
 #include <grpc/support/port_platform.h>
 

data/src/core/{lib/gprpp → util}/examine_stack.h

@@ -16,15 +16,15 @@
 //
 //
 
-#ifndef GRPC_SRC_CORE_LIB_GPRPP_EXAMINE_STACK_H
-#define GRPC_SRC_CORE_LIB_GPRPP_EXAMINE_STACK_H
+#ifndef GRPC_SRC_CORE_UTIL_EXAMINE_STACK_H
+#define GRPC_SRC_CORE_UTIL_EXAMINE_STACK_H
+
+#include <grpc/support/port_platform.h>
 
 #include <string>
 
 #include "absl/types/optional.h"
 
-#include <grpc/support/port_platform.h>
-
 namespace grpc_core {
 
 typedef std::string (*gpr_current_stack_trace_func)();
@@ -42,4 +42,4 @@ absl::optional<std::string> GetCurrentStackTrace();
 
 }  // namespace grpc_core
 
-#endif  // GRPC_SRC_CORE_LIB_GPRPP_EXAMINE_STACK_H
+#endif  // GRPC_SRC_CORE_UTIL_EXAMINE_STACK_H

data/src/core/{lib/gprpp → util}/fork.cc

@@ -16,18 +16,18 @@
 //
 //
 
-#include "src/core/lib/gprpp/fork.h"
-
-#include <utility>
+#include "src/core/util/fork.h"
 
 #include <grpc/support/atm.h>
 #include <grpc/support/port_platform.h>
 #include <grpc/support/sync.h>
 #include <grpc/support/time.h>
 
+#include <utility>
+
 #include "src/core/lib/config/config_vars.h"
 #include "src/core/lib/event_engine/thread_local.h"
-#include "src/core/lib/gprpp/no_destruct.h"
+#include "src/core/util/no_destruct.h"
 
 //
 // NOTE: FORKING IS NOT GENERALLY SUPPORTED, THIS IS ONLY INTENDED TO WORK

data/src/core/{lib/gprpp → util}/fork.h

@@ -16,14 +16,14 @@
 //
 //
 
-#ifndef GRPC_SRC_CORE_LIB_GPRPP_FORK_H
-#define GRPC_SRC_CORE_LIB_GPRPP_FORK_H
+#ifndef GRPC_SRC_CORE_UTIL_FORK_H
+#define GRPC_SRC_CORE_UTIL_FORK_H
+
+#include <grpc/support/port_platform.h>
 
 #include <atomic>
 #include <set>
 
-#include <grpc/support/port_platform.h>
-
 //
 // NOTE: FORKING IS NOT GENERALLY SUPPORTED, THIS IS ONLY INTENDED TO WORK
 //       AROUND VERY SPECIFIC USE CASES.
@@ -95,4 +95,4 @@ class GPR_DLL Fork {
 
 }  // namespace grpc_core
 
-#endif  // GRPC_SRC_CORE_LIB_GPRPP_FORK_H
+#endif  // GRPC_SRC_CORE_UTIL_FORK_H

data/src/core/util/gcp_metadata_query.cc

@@ -16,10 +16,12 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/util/gcp_metadata_query.h"
 
+#include <grpc/credentials.h>
+#include <grpc/grpc.h>
+#include <grpc/grpc_security.h>
+#include <grpc/support/port_platform.h>
 #include <string.h>
 
 #include <memory>
@@ -31,17 +33,12 @@
 #include "absl/status/statusor.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/string_view.h"
-
-#include <grpc/credentials.h>
-#include <grpc/grpc.h>
-#include <grpc/grpc_security.h>
-
 #include "src/core/lib/debug/trace.h"
-#include "src/core/lib/gprpp/ref_counted_ptr.h"
-#include "src/core/lib/gprpp/status_helper.h"
-#include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/security/credentials/credentials.h"
-#include "src/core/lib/uri/uri_parser.h"
+#include "src/core/util/ref_counted_ptr.h"
+#include "src/core/util/status_helper.h"
+#include "src/core/util/time.h"
+#include "src/core/util/uri.h"
 
 namespace grpc_core {
 

data/src/core/util/gcp_metadata_query.h

@@ -23,14 +23,13 @@
 
 #include "absl/functional/any_invocable.h"
 #include "absl/status/statusor.h"
-
-#include "src/core/lib/gprpp/orphanable.h"
-#include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/polling_entity.h"
 #include "src/core/util/http_client/httpcli.h"
 #include "src/core/util/http_client/parser.h"
+#include "src/core/util/orphanable.h"
+#include "src/core/util/time.h"
 
 namespace grpc_core {
 

data/src/core/{lib/iomgr → util}/gethostname.h

@@ -16,11 +16,11 @@
 //
 //
 
-#ifndef GRPC_SRC_CORE_LIB_IOMGR_GETHOSTNAME_H
-#define GRPC_SRC_CORE_LIB_IOMGR_GETHOSTNAME_H
+#ifndef GRPC_SRC_CORE_UTIL_GETHOSTNAME_H
+#define GRPC_SRC_CORE_UTIL_GETHOSTNAME_H
 
 // Returns the hostname of the local machine.
 // Caller takes ownership of result.
 char* grpc_gethostname();
 
-#endif  // GRPC_SRC_CORE_LIB_IOMGR_GETHOSTNAME_H
+#endif  // GRPC_SRC_CORE_UTIL_GETHOSTNAME_H

data/src/core/{lib/iomgr → util}/gethostname_fallback.cc

@@ -18,8 +18,8 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/iomgr/gethostname.h"
 #include "src/core/lib/iomgr/port.h"
+#include "src/core/util/gethostname.h"
 
 #ifdef GRPC_GETHOSTNAME_FALLBACK
 

data/src/core/{lib/iomgr → util}/gethostname_host_name_max.cc

@@ -18,16 +18,15 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/iomgr/gethostname.h"
 #include "src/core/lib/iomgr/port.h"
+#include "src/core/util/gethostname.h"
 
 #ifdef GRPC_POSIX_HOST_NAME_MAX
 
+#include <grpc/support/alloc.h>
 #include <limits.h>
 #include <unistd.h>
 
-#include <grpc/support/alloc.h>
-
 char* grpc_gethostname() {
   char* hostname = static_cast<char*>(gpr_malloc(HOST_NAME_MAX));
   if (gethostname(hostname, HOST_NAME_MAX) != 0) {

data/src/core/{lib/iomgr → util}/gethostname_sysconf.cc

@@ -18,14 +18,13 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/iomgr/gethostname.h"
 #include "src/core/lib/iomgr/port.h"
+#include "src/core/util/gethostname.h"
 
 #ifdef GRPC_POSIX_SYSCONF
 
-#include <unistd.h>
-
 #include <grpc/support/alloc.h>
+#include <unistd.h>
 
 char* grpc_gethostname() {
   size_t host_name_max = (size_t)sysconf(_SC_HOST_NAME_MAX);

data/src/core/{lib/gprpp → util}/glob.h

@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef GRPC_SRC_CORE_LIB_GPRPP_GLOB_H
-#define GRPC_SRC_CORE_LIB_GPRPP_GLOB_H
+#ifndef GRPC_SRC_CORE_UTIL_GLOB_H
+#define GRPC_SRC_CORE_UTIL_GLOB_H
 
 #include "absl/strings/string_view.h"
 
@@ -26,4 +26,4 @@ bool GlobMatch(absl::string_view name, absl::string_view pattern);
 
 }  // namespace grpc_core
 
-#endif  // GRPC_SRC_CORE_LIB_GPRPP_GLOB_H
+#endif  // GRPC_SRC_CORE_UTIL_GLOB_H

data/src/core/util/gpr_time.cc

@@ -0,0 +1,268 @@
+//
+//
+// Copyright 2015 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
+
+// Generic implementation of time calls.
+
+#include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
+#include <grpc/support/time.h>
+#include <limits.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "absl/log/check.h"
+#include "src/core/util/crash.h"
+
+int gpr_time_cmp(gpr_timespec a, gpr_timespec b) {
+  int cmp = (a.tv_sec > b.tv_sec) - (a.tv_sec < b.tv_sec);
+  CHECK(a.clock_type == b.clock_type);
+  if (cmp == 0 && a.tv_sec != INT64_MAX && a.tv_sec != INT64_MIN) {
+    cmp = (a.tv_nsec > b.tv_nsec) - (a.tv_nsec < b.tv_nsec);
+  }
+  return cmp;
+}
+
+gpr_timespec gpr_time_min(gpr_timespec a, gpr_timespec b) {
+  return gpr_time_cmp(a, b) < 0 ? a : b;
+}
+
+gpr_timespec gpr_time_max(gpr_timespec a, gpr_timespec b) {
+  return gpr_time_cmp(a, b) > 0 ? a : b;
+}
+
+gpr_timespec gpr_time_0(gpr_clock_type type) {
+  gpr_timespec out;
+  out.tv_sec = 0;
+  out.tv_nsec = 0;
+  out.clock_type = type;
+  return out;
+}
+
+gpr_timespec gpr_inf_future(gpr_clock_type type) {
+  gpr_timespec out;
+  out.tv_sec = INT64_MAX;
+  out.tv_nsec = 0;
+  out.clock_type = type;
+  return out;
+}
+
+gpr_timespec gpr_inf_past(gpr_clock_type type) {
+  gpr_timespec out;
+  out.tv_sec = INT64_MIN;
+  out.tv_nsec = 0;
+  out.clock_type = type;
+  return out;
+}
+
+static gpr_timespec to_seconds_from_sub_second_time(int64_t time_in_units,
+                                                    int64_t units_per_sec,
+                                                    gpr_clock_type type) {
+  gpr_timespec out;
+  if (time_in_units == INT64_MAX) {
+    out = gpr_inf_future(type);
+  } else if (time_in_units == INT64_MIN) {
+    out = gpr_inf_past(type);
+  } else {
+    DCHECK_EQ(GPR_NS_PER_SEC % units_per_sec, 0);
+
+    out.tv_sec = time_in_units / units_per_sec;
+    out.tv_nsec =
+        static_cast<int32_t>((time_in_units - (out.tv_sec * units_per_sec)) *
+                             (GPR_NS_PER_SEC / units_per_sec));
+    /// `out.tv_nsec` should always be positive.
+    if (out.tv_nsec < 0) {
+      out.tv_nsec += GPR_NS_PER_SEC;
+      out.tv_sec--;
+    }
+
+    out.clock_type = type;
+  }
+  return out;
+}
+
+static gpr_timespec to_seconds_from_above_second_time(int64_t time_in_units,
+                                                      int64_t secs_per_unit,
+                                                      gpr_clock_type type) {
+  gpr_timespec out;
+  if (time_in_units >= INT64_MAX / secs_per_unit) {
+    out = gpr_inf_future(type);
+  } else if (time_in_units <= INT64_MIN / secs_per_unit) {
+    out = gpr_inf_past(type);
+  } else {
+    out.tv_sec = time_in_units * secs_per_unit;
+    out.tv_nsec = 0;
+    out.clock_type = type;
+  }
+  return out;
+}
+
+gpr_timespec gpr_time_from_nanos(int64_t ns, gpr_clock_type clock_type) {
+  return to_seconds_from_sub_second_time(ns, GPR_NS_PER_SEC, clock_type);
+}
+
+gpr_timespec gpr_time_from_micros(int64_t us, gpr_clock_type clock_type) {
+  return to_seconds_from_sub_second_time(us, GPR_US_PER_SEC, clock_type);
+}
+
+gpr_timespec gpr_time_from_millis(int64_t ms, gpr_clock_type clock_type) {
+  return to_seconds_from_sub_second_time(ms, GPR_MS_PER_SEC, clock_type);
+}
+
+gpr_timespec gpr_time_from_seconds(int64_t s, gpr_clock_type clock_type) {
+  return to_seconds_from_sub_second_time(s, 1, clock_type);
+}
+
+gpr_timespec gpr_time_from_minutes(int64_t m, gpr_clock_type clock_type) {
+  return to_seconds_from_above_second_time(m, 60, clock_type);
+}
+
+gpr_timespec gpr_time_from_hours(int64_t h, gpr_clock_type clock_type) {
+  return to_seconds_from_above_second_time(h, 3600, clock_type);
+}
+
+gpr_timespec gpr_time_add(gpr_timespec a, gpr_timespec b) {
+  gpr_timespec sum;
+  int64_t inc = 0;
+  CHECK(b.clock_type == GPR_TIMESPAN);
+  // tv_nsec in a timespan is always +ve. -ve timespan is represented as (-ve
+  // tv_sec, +ve tv_nsec). For example, timespan = -2.5 seconds is represented
+  // as {-3, 5e8, GPR_TIMESPAN}
+  CHECK_GE(b.tv_nsec, 0);
+  sum.clock_type = a.clock_type;
+  sum.tv_nsec = a.tv_nsec + b.tv_nsec;
+  if (sum.tv_nsec >= GPR_NS_PER_SEC) {
+    sum.tv_nsec -= GPR_NS_PER_SEC;
+    inc++;
+  }
+  if (a.tv_sec == INT64_MAX || a.tv_sec == INT64_MIN) {
+    sum = a;
+  } else if (b.tv_sec == INT64_MAX ||
+             (b.tv_sec >= 0 && a.tv_sec >= INT64_MAX - b.tv_sec)) {
+    sum = gpr_inf_future(sum.clock_type);
+  } else if (b.tv_sec == INT64_MIN ||
+             (b.tv_sec <= 0 && a.tv_sec <= INT64_MIN - b.tv_sec)) {
+    sum = gpr_inf_past(sum.clock_type);
+  } else {
+    sum.tv_sec = a.tv_sec + b.tv_sec;
+    if (inc != 0 && sum.tv_sec == INT64_MAX - 1) {
+      sum = gpr_inf_future(sum.clock_type);
+    } else {
+      sum.tv_sec += inc;
+    }
+  }
+  return sum;
+}
+
+gpr_timespec gpr_time_sub(gpr_timespec a, gpr_timespec b) {
+  gpr_timespec diff;
+  int64_t dec = 0;
+  if (b.clock_type == GPR_TIMESPAN) {
+    diff.clock_type = a.clock_type;
+    // tv_nsec in a timespan is always +ve. -ve timespan is represented as (-ve
+    // tv_sec, +ve tv_nsec). For example, timespan = -2.5 seconds is represented
+    // as {-3, 5e8, GPR_TIMESPAN}
+    CHECK_GE(b.tv_nsec, 0);
+  } else {
+    CHECK(a.clock_type == b.clock_type);
+    diff.clock_type = GPR_TIMESPAN;
+  }
+  diff.tv_nsec = a.tv_nsec - b.tv_nsec;
+  if (diff.tv_nsec < 0) {
+    diff.tv_nsec += GPR_NS_PER_SEC;
+    dec++;
+  }
+  if (a.tv_sec == INT64_MAX || a.tv_sec == INT64_MIN) {
+    diff.tv_sec = a.tv_sec;
+    diff.tv_nsec = a.tv_nsec;
+  } else if (b.tv_sec == INT64_MIN ||
+             (b.tv_sec <= 0 && a.tv_sec >= INT64_MAX + b.tv_sec)) {
+    diff = gpr_inf_future(GPR_CLOCK_REALTIME);
+  } else if (b.tv_sec == INT64_MAX ||
+             (b.tv_sec >= 0 && a.tv_sec <= INT64_MIN + b.tv_sec)) {
+    diff = gpr_inf_past(GPR_CLOCK_REALTIME);
+  } else {
+    diff.tv_sec = a.tv_sec - b.tv_sec;
+    if (dec != 0 && diff.tv_sec == INT64_MIN + 1) {
+      diff = gpr_inf_past(GPR_CLOCK_REALTIME);
+    } else {
+      diff.tv_sec -= dec;
+    }
+  }
+  return diff;
+}
+
+int gpr_time_similar(gpr_timespec a, gpr_timespec b, gpr_timespec threshold) {
+  int cmp_ab;
+
+  CHECK(a.clock_type == b.clock_type);
+  CHECK(threshold.clock_type == GPR_TIMESPAN);
+
+  cmp_ab = gpr_time_cmp(a, b);
+  if (cmp_ab == 0) return 1;
+  if (cmp_ab < 0) {
+    return gpr_time_cmp(gpr_time_sub(b, a), threshold) <= 0;
+  } else {
+    return gpr_time_cmp(gpr_time_sub(a, b), threshold) <= 0;
+  }
+}
+
+int32_t gpr_time_to_millis(gpr_timespec t) {
+  if (t.tv_sec >= 2147483) {
+    if (t.tv_sec == 2147483 && t.tv_nsec < 648 * GPR_NS_PER_MS) {
+      return 2147483 * GPR_MS_PER_SEC + t.tv_nsec / GPR_NS_PER_MS;
+    }
+    return 2147483647;
+  } else if (t.tv_sec <= -2147483) {
+    // TODO(ctiller): correct handling here (it's so far in the past do we
+    // care?)
+    return -2147483647;
+  } else {
+    return static_cast<int32_t>(t.tv_sec * GPR_MS_PER_SEC +
+                                t.tv_nsec / GPR_NS_PER_MS);
+  }
+}
+
+double gpr_timespec_to_micros(gpr_timespec t) {
+  return static_cast<double>(t.tv_sec) * GPR_US_PER_SEC + t.tv_nsec * 1e-3;
+}
+
+gpr_timespec gpr_convert_clock_type(gpr_timespec t, gpr_clock_type clock_type) {
+  if (t.clock_type == clock_type) {
+    return t;
+  }
+
+  if (t.tv_sec == INT64_MAX || t.tv_sec == INT64_MIN) {
+    t.clock_type = clock_type;
+    return t;
+  }
+
+  if (clock_type == GPR_TIMESPAN) {
+    return gpr_time_sub(t, gpr_now(t.clock_type));
+  }
+
+  if (t.clock_type == GPR_TIMESPAN) {
+    return gpr_time_add(gpr_now(clock_type), t);
+  }
+
+  // If the given input hits this code, the same result is not guaranteed for
+  // the same input because it relies on `gpr_now` to calculate the difference
+  // between two different clocks. Please be careful when you want to use this
+  // function in unit tests. (e.g. https://github.com/grpc/grpc/pull/22655)
+  return gpr_time_add(gpr_now(clock_type),
+                      gpr_time_sub(t, gpr_now(t.clock_type)));
+}

data/src/core/{lib/iomgr → util}/grpc_if_nametoindex.h

@@ -16,15 +16,14 @@
 //
 //
 
-#ifndef GRPC_SRC_CORE_LIB_IOMGR_GRPC_IF_NAMETOINDEX_H
-#define GRPC_SRC_CORE_LIB_IOMGR_GRPC_IF_NAMETOINDEX_H
-
-#include <stddef.h>
+#ifndef GRPC_SRC_CORE_UTIL_GRPC_IF_NAMETOINDEX_H
+#define GRPC_SRC_CORE_UTIL_GRPC_IF_NAMETOINDEX_H
 
 #include <grpc/support/port_platform.h>
+#include <stddef.h>
 
 // Returns the interface index corresponding to the interface "name" provided.
 // Returns non-zero upon success, and zero upon failure.
 uint32_t grpc_if_nametoindex(char* name);
 
-#endif  // GRPC_SRC_CORE_LIB_IOMGR_GRPC_IF_NAMETOINDEX_H
+#endif  // GRPC_SRC_CORE_UTIL_GRPC_IF_NAMETOINDEX_H

data/src/core/{lib/iomgr → util}/grpc_if_nametoindex_posix.cc

@@ -26,9 +26,8 @@
 #include <net/if.h>
 
 #include "absl/log/log.h"
-
-#include "src/core/lib/gprpp/crash.h"
-#include "src/core/lib/iomgr/grpc_if_nametoindex.h"
+#include "src/core/util/crash.h"
+#include "src/core/util/grpc_if_nametoindex.h"
 
 uint32_t grpc_if_nametoindex(char* name) {
   uint32_t out = if_nametoindex(name);

data/src/core/{lib/iomgr → util}/grpc_if_nametoindex_unsupported.cc

@@ -23,9 +23,8 @@
 #if GRPC_IF_NAMETOINDEX == 0 || !defined(GRPC_POSIX_SOCKET_IF_NAMETOINDEX)
 
 #include "absl/log/log.h"
-
-#include "src/core/lib/gprpp/crash.h"
-#include "src/core/lib/iomgr/grpc_if_nametoindex.h"
+#include "src/core/util/crash.h"
+#include "src/core/util/grpc_if_nametoindex.h"
 
 uint32_t grpc_if_nametoindex(char* name) {
   VLOG(2) << "Not attempting to convert interface name " << name

data/src/core/{lib/gprpp → util}/host_port.cc

@@ -16,16 +16,15 @@
 //
 //
 
-#include "src/core/lib/gprpp/host_port.h"
+#include "src/core/util/host_port.h"
 
+#include <grpc/support/port_platform.h>
 #include <stddef.h>
 
 #include "absl/log/check.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/string_view.h"
 
-#include <grpc/support/port_platform.h>
-
 namespace grpc_core {
 
 std::string JoinHostPort(absl::string_view host, int port) {