grpc 1.41.1 → 1.44.0.pre2

data/src/core/lib/compression/compression_internal.h

@@ -21,77 +21,72 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <grpc/compression.h>
-#include <grpc/slice.h>
-
-#include "src/core/lib/gpr/useful.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef enum {
-  GRPC_MESSAGE_COMPRESS_NONE = 0,
-  GRPC_MESSAGE_COMPRESS_DEFLATE,
-  GRPC_MESSAGE_COMPRESS_GZIP,
-  /* TODO(ctiller): snappy */
-  GRPC_MESSAGE_COMPRESS_ALGORITHMS_COUNT
-} grpc_message_compression_algorithm;
-
-/** Stream compression algorithms supported by gRPC */
-typedef enum {
-  GRPC_STREAM_COMPRESS_NONE = 0,
-  GRPC_STREAM_COMPRESS_GZIP,
-  GRPC_STREAM_COMPRESS_ALGORITHMS_COUNT
-} grpc_stream_compression_algorithm;
-
-/* Interfaces performing transformation between compression algorithms and
- * levels. */
-
-grpc_message_compression_algorithm
-grpc_compression_algorithm_to_message_compression_algorithm(
-    grpc_compression_algorithm algo);
-
-grpc_stream_compression_algorithm
-grpc_compression_algorithm_to_stream_compression_algorithm(
-    grpc_compression_algorithm algo);
-
-uint32_t grpc_compression_bitset_to_message_bitset(uint32_t bitset);
+#include <initializer_list>
 
-uint32_t grpc_compression_bitset_to_stream_bitset(uint32_t bitset);
+#include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
 
-uint32_t grpc_compression_bitset_from_message_stream_compression_bitset(
-    uint32_t message_bitset, uint32_t stream_bitset);
-
-int grpc_compression_algorithm_from_message_stream_compression_algorithm(
-    grpc_compression_algorithm* algorithm,
-    grpc_message_compression_algorithm message_algorithm,
-    grpc_stream_compression_algorithm stream_algorithm);
-
-/* Interfaces for message compression. */
-
-int grpc_message_compression_algorithm_name(
-    grpc_message_compression_algorithm algorithm, const char** name);
-
-grpc_message_compression_algorithm grpc_message_compression_algorithm_for_level(
-    grpc_compression_level level, uint32_t accepted_encodings);
-
-int grpc_message_compression_algorithm_parse(
-    grpc_slice value, grpc_message_compression_algorithm* algorithm);
-
-/* Interfaces for stream compression. */
-
-int grpc_stream_compression_algorithm_parse(
-    grpc_slice value, grpc_stream_compression_algorithm* algorithm);
-
-#ifdef __cplusplus
-}
-#endif
+#include <grpc/compression.h>
+#include <grpc/impl/codegen/grpc_types.h>
+#include <grpc/slice.h>
 
-inline int grpc_compression_options_is_algorithm_enabled_internal(
-    const grpc_compression_options* opts,
-    grpc_compression_algorithm algorithm) {
-  return GPR_BITGET(opts->enabled_algorithms_bitset, algorithm);
-}
+#include "src/core/lib/gprpp/bitset.h"
+#include "src/core/lib/slice/slice.h"
+
+namespace grpc_core {
+
+// Given a string naming a compression algorithm, return the corresponding enum
+// or nullopt on error.
+absl::optional<grpc_compression_algorithm> ParseCompressionAlgorithm(
+    absl::string_view algorithm);
+// Convert a compression algorithm to a string. Returns nullptr if a name is not
+// known.
+const char* CompressionAlgorithmAsString(grpc_compression_algorithm algorithm);
+// Retrieve the default compression algorithm from channel args, return nullopt
+// if not found.
+absl::optional<grpc_compression_algorithm>
+DefaultCompressionAlgorithmFromChannelArgs(const grpc_channel_args* args);
+
+// A set of grpc_compression_algorithm values.
+class CompressionAlgorithmSet {
+ public:
+  // Construct from a uint32_t bitmask - bit 0 => algorithm 0, bit 1 =>
+  // algorithm 1, etc.
+  static CompressionAlgorithmSet FromUint32(uint32_t value);
+  // Locate in channel args and construct from the found value.
+  static CompressionAlgorithmSet FromChannelArgs(const grpc_channel_args* args);
+  // Parse a string of comma-separated compression algorithms.
+  static CompressionAlgorithmSet FromString(absl::string_view str);
+  // Construct an empty set.
+  CompressionAlgorithmSet();
+  // Construct from a std::initializer_list of grpc_compression_algorithm
+  // values.
+  CompressionAlgorithmSet(
+      std::initializer_list<grpc_compression_algorithm> algorithms);
+
+  // Given a compression level, choose an appropriate algorithm from this set.
+  grpc_compression_algorithm CompressionAlgorithmForLevel(
+      grpc_compression_level level) const;
+  // Return true if this set contains algorithm, false otherwise.
+  bool IsSet(grpc_compression_algorithm algorithm) const;
+  // Add algorithm to this set.
+  void Set(grpc_compression_algorithm algorithm);
+
+  // Return a comma separated string of the algorithms in this set.
+  std::string ToString() const;
+  Slice ToSlice() const;
+
+  // Return a bitmask of the algorithms in this set.
+  uint32_t ToLegacyBitmask() const;
+
+  bool operator==(const CompressionAlgorithmSet& other) const {
+    return set_ == other.set_;
+  }
+
+ private:
+  BitSet<GRPC_COMPRESS_ALGORITHMS_COUNT> set_;
+};
+
+}  // namespace grpc_core
 
 #endif /* GRPC_CORE_LIB_COMPRESSION_COMPRESSION_INTERNAL_H */

data/src/core/lib/compression/message_compress.cc

@@ -148,25 +148,25 @@ static int copy(grpc_slice_buffer* input, grpc_slice_buffer* output) {
   return 1;
 }
 
-static int compress_inner(grpc_message_compression_algorithm algorithm,
+static int compress_inner(grpc_compression_algorithm algorithm,
                           grpc_slice_buffer* input, grpc_slice_buffer* output) {
   switch (algorithm) {
-    case GRPC_MESSAGE_COMPRESS_NONE:
+    case GRPC_COMPRESS_NONE:
       /* the fallback path always needs to be send uncompressed: we simply
          rely on that here */
       return 0;
-    case GRPC_MESSAGE_COMPRESS_DEFLATE:
+    case GRPC_COMPRESS_DEFLATE:
       return zlib_compress(input, output, 0);
-    case GRPC_MESSAGE_COMPRESS_GZIP:
+    case GRPC_COMPRESS_GZIP:
       return zlib_compress(input, output, 1);
-    case GRPC_MESSAGE_COMPRESS_ALGORITHMS_COUNT:
+    case GRPC_COMPRESS_ALGORITHMS_COUNT:
       break;
   }
   gpr_log(GPR_ERROR, "invalid compression algorithm %d", algorithm);
   return 0;
 }
 
-int grpc_msg_compress(grpc_message_compression_algorithm algorithm,
+int grpc_msg_compress(grpc_compression_algorithm algorithm,
                       grpc_slice_buffer* input, grpc_slice_buffer* output) {
   if (!compress_inner(algorithm, input, output)) {
     copy(input, output);
@@ -175,16 +175,16 @@ int grpc_msg_compress(grpc_message_compression_algorithm algorithm,
   return 1;
 }
 
-int grpc_msg_decompress(grpc_message_compression_algorithm algorithm,
+int grpc_msg_decompress(grpc_compression_algorithm algorithm,
                         grpc_slice_buffer* input, grpc_slice_buffer* output) {
   switch (algorithm) {
-    case GRPC_MESSAGE_COMPRESS_NONE:
+    case GRPC_COMPRESS_NONE:
       return copy(input, output);
-    case GRPC_MESSAGE_COMPRESS_DEFLATE:
+    case GRPC_COMPRESS_DEFLATE:
       return zlib_decompress(input, output, 0);
-    case GRPC_MESSAGE_COMPRESS_GZIP:
+    case GRPC_COMPRESS_GZIP:
       return zlib_decompress(input, output, 1);
-    case GRPC_MESSAGE_COMPRESS_ALGORITHMS_COUNT:
+    case GRPC_COMPRESS_ALGORITHMS_COUNT:
       break;
   }
   gpr_log(GPR_ERROR, "invalid compression algorithm %d", algorithm);

data/src/core/lib/compression/message_compress.h

@@ -28,13 +28,13 @@
 /* compress 'input' to 'output' using 'algorithm'.
    On success, appends compressed slices to output and returns 1.
    On failure, appends uncompressed slices to output and returns 0. */
-int grpc_msg_compress(grpc_message_compression_algorithm algorithm,
+int grpc_msg_compress(grpc_compression_algorithm algorithm,
                       grpc_slice_buffer* input, grpc_slice_buffer* output);
 
 /* decompress 'input' to 'output' using 'algorithm'.
    On success, appends slices to output and returns 1.
    On failure, output is unchanged, and returns 0. */
-int grpc_msg_decompress(grpc_message_compression_algorithm algorithm,
+int grpc_msg_decompress(grpc_compression_algorithm algorithm,
                         grpc_slice_buffer* input, grpc_slice_buffer* output);
 
 #endif /* GRPC_CORE_LIB_COMPRESSION_MESSAGE_COMPRESS_H */

data/src/core/lib/config/core_configuration.cc

@@ -12,13 +12,17 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include <grpc/impl/codegen/port_platform.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/config/core_configuration.h"
 
+#include <grpc/support/log.h>
+
 namespace grpc_core {
 
 std::atomic<CoreConfiguration*> CoreConfiguration::config_{nullptr};
+std::atomic<CoreConfiguration::RegisteredBuilder*> CoreConfiguration::builders_{
+    nullptr};
 
 CoreConfiguration::Builder::Builder() = default;
 
@@ -27,11 +31,44 @@ CoreConfiguration* CoreConfiguration::Builder::Build() {
 }
 
 CoreConfiguration::CoreConfiguration(Builder* builder)
-    : handshaker_registry_(builder->handshaker_registry_.Build()) {}
+    : channel_args_preconditioning_(
+          builder->channel_args_preconditioning_.Build()),
+      channel_init_(builder->channel_init_.Build()),
+      handshaker_registry_(builder->handshaker_registry_.Build()) {}
+
+void CoreConfiguration::RegisterBuilder(std::function<void(Builder*)> builder) {
+  GPR_ASSERT(config_.load(std::memory_order_relaxed) == nullptr &&
+             "CoreConfiguration was already instantiated before builder "
+             "registration was completed");
+  RegisteredBuilder* n = new RegisteredBuilder();
+  n->builder = std::move(builder);
+  n->next = builders_.load(std::memory_order_relaxed);
+  while (!builders_.compare_exchange_weak(n->next, n, std::memory_order_acq_rel,
+                                          std::memory_order_relaxed)) {
+  }
+  GPR_ASSERT(config_.load(std::memory_order_relaxed) == nullptr &&
+             "CoreConfiguration was already instantiated before builder "
+             "registration was completed");
+}
 
 const CoreConfiguration& CoreConfiguration::BuildNewAndMaybeSet() {
   // Construct builder, pass it up to code that knows about build configuration
   Builder builder;
+  // The linked list of builders stores things in reverse registration order.
+  // To get things registered as systems relying on this expect however, we
+  // actually need to run things in forward registration order, so we iterate
+  // once over the linked list to build a vector of builders, and then iterate
+  // over said vector in reverse to actually run the builders.
+  std::vector<RegisteredBuilder*> registered_builders;
+  for (RegisteredBuilder* b = builders_.load(std::memory_order_acquire);
+       b != nullptr; b = b->next) {
+    registered_builders.push_back(b);
+  }
+  for (auto it = registered_builders.rbegin(); it != registered_builders.rend();
+       ++it) {
+    (*it)->builder(&builder);
+  }
+  // Finally, call the built in configuration builder.
   BuildCoreConfiguration(&builder);
   // Use builder to construct a confguration
   CoreConfiguration* p = builder.Build();
@@ -49,6 +86,13 @@ const CoreConfiguration& CoreConfiguration::BuildNewAndMaybeSet() {
 
 void CoreConfiguration::Reset() {
   delete config_.exchange(nullptr, std::memory_order_acquire);
+  RegisteredBuilder* builder =
+      builders_.exchange(nullptr, std::memory_order_acquire);
+  while (builder != nullptr) {
+    RegisteredBuilder* next = builder->next;
+    delete builder;
+    builder = next;
+  }
 }
 
 }  // namespace grpc_core

data/src/core/lib/config/core_configuration.h

@@ -15,11 +15,13 @@
 #ifndef GRPC_CORE_LIB_CONFIG_CORE_CONFIGURATION_H
 #define GRPC_CORE_LIB_CONFIG_CORE_CONFIGURATION_H
 
-#include <grpc/impl/codegen/port_platform.h>
+#include <grpc/support/port_platform.h>
 
 #include <atomic>
 
+#include "src/core/lib/channel/channel_args_preconditioning.h"
 #include "src/core/lib/channel/handshaker_registry.h"
+#include "src/core/lib/surface/channel_init.h"
 
 namespace grpc_core {
 
@@ -34,6 +36,12 @@ class CoreConfiguration {
   // their configuration and assemble the published CoreConfiguration.
   class Builder {
    public:
+    ChannelArgsPreconditioning::Builder* channel_args_preconditioning() {
+      return &channel_args_preconditioning_;
+    }
+
+    ChannelInit::Builder* channel_init() { return &channel_init_; }
+
     HandshakerRegistry::Builder* handshaker_registry() {
       return &handshaker_registry_;
     }
@@ -41,6 +49,8 @@ class CoreConfiguration {
    private:
     friend class CoreConfiguration;
 
+    ChannelArgsPreconditioning::Builder channel_args_preconditioning_;
+    ChannelInit::Builder channel_init_;
     HandshakerRegistry::Builder handshaker_registry_;
 
     Builder();
@@ -77,13 +87,42 @@ class CoreConfiguration {
     delete config_.exchange(p, std::memory_order_release);
   }
 
+  // Attach a registration function globally.
+  // Each registration function is called *in addition to*
+  // BuildCoreConfiguration for the default core configuration. When using
+  // BuildSpecialConfiguration, one can use CallRegisteredBuilders to call them.
+  // Must be called before a configuration is built.
+  static void RegisterBuilder(std::function<void(Builder*)> builder);
+
+  // Call all registered builders.
+  // See RegisterBuilder for why you might want to call this.
+  static void CallRegisteredBuilders(Builder* builder);
+
   // Drop the core configuration. Users must ensure no other threads are
   // accessing the configuration.
   // Clears any dynamically registered builders.
   static void Reset();
 
+  // Helper for tests: Reset the configuration, build a special one, run some
+  // code, and then reset the configuration again.
+  // Templatized to be sure no codegen in normal builds.
+  template <typename BuildFunc, typename RunFunc>
+  static void RunWithSpecialConfiguration(BuildFunc build_configuration,
+                                          RunFunc code_to_run) {
+    Reset();
+    BuildSpecialConfiguration(build_configuration);
+    code_to_run();
+    Reset();
+  }
+
   // Accessors
 
+  const ChannelArgsPreconditioning& channel_args_preconditioning() const {
+    return channel_args_preconditioning_;
+  }
+
+  const ChannelInit& channel_init() const { return channel_init_; }
+
   const HandshakerRegistry& handshaker_registry() const {
     return handshaker_registry_;
   }
@@ -91,13 +130,23 @@ class CoreConfiguration {
  private:
   explicit CoreConfiguration(Builder* builder);
 
+  // Stores a builder for RegisterBuilder
+  struct RegisteredBuilder {
+    std::function<void(Builder*)> builder;
+    RegisteredBuilder* next;
+  };
+
   // Create a new CoreConfiguration, and either set it or throw it away.
   // We allow multiple CoreConfiguration's to be created in parallel.
   static const CoreConfiguration& BuildNewAndMaybeSet();
 
   // The configuration
   static std::atomic<CoreConfiguration*> config_;
+  // Extra registered builders
+  static std::atomic<RegisteredBuilder*> builders_;
 
+  ChannelArgsPreconditioning channel_args_preconditioning_;
+  ChannelInit channel_init_;
   HandshakerRegistry handshaker_registry_;
 };
 

data/src/core/lib/debug/stats.cc

@@ -38,7 +38,7 @@ grpc_stats_data* grpc_stats_per_cpu_storage = nullptr;
 static size_t g_num_cores;
 
 void grpc_stats_init(void) {
-  g_num_cores = GPR_MAX(1, gpr_cpu_num_cores());
+  g_num_cores = std::max(1u, gpr_cpu_num_cores());
   grpc_stats_per_cpu_storage = static_cast<grpc_stats_data*>(
       gpr_zalloc(sizeof(grpc_stats_data) * g_num_cores));
 }

data/src/core/lib/debug/stats_data.cc

@@ -353,7 +353,7 @@ const uint8_t grpc_stats_table_7[102] = {
 const int grpc_stats_table_8[9] = {0, 1, 2, 4, 7, 13, 23, 39, 64};
 const uint8_t grpc_stats_table_9[9] = {0, 0, 1, 2, 2, 3, 4, 4, 5};
 void grpc_stats_inc_call_initial_size(int value) {
-  value = GPR_CLAMP(value, 0, 262144);
+  value = grpc_core::Clamp(value, 0, 262144);
   if (value < 6) {
     GRPC_STATS_INC_HISTOGRAM(GRPC_STATS_HISTOGRAM_CALL_INITIAL_SIZE, value);
     return;
@@ -376,7 +376,7 @@ void grpc_stats_inc_call_initial_size(int value) {
       grpc_stats_histo_find_bucket_slow(value, grpc_stats_table_0, 64));
 }
 void grpc_stats_inc_poll_events_returned(int value) {
-  value = GPR_CLAMP(value, 0, 1024);
+  value = grpc_core::Clamp(value, 0, 1024);
   if (value < 29) {
     GRPC_STATS_INC_HISTOGRAM(GRPC_STATS_HISTOGRAM_POLL_EVENTS_RETURNED, value);
     return;
@@ -399,7 +399,7 @@ void grpc_stats_inc_poll_events_returned(int value) {
       grpc_stats_histo_find_bucket_slow(value, grpc_stats_table_2, 128));
 }
 void grpc_stats_inc_tcp_write_size(int value) {
-  value = GPR_CLAMP(value, 0, 16777216);
+  value = grpc_core::Clamp(value, 0, 16777216);
   if (value < 5) {
     GRPC_STATS_INC_HISTOGRAM(GRPC_STATS_HISTOGRAM_TCP_WRITE_SIZE, value);
     return;
@@ -422,7 +422,7 @@ void grpc_stats_inc_tcp_write_size(int value) {
       grpc_stats_histo_find_bucket_slow(value, grpc_stats_table_4, 64));
 }
 void grpc_stats_inc_tcp_write_iov_size(int value) {
-  value = GPR_CLAMP(value, 0, 1024);
+  value = grpc_core::Clamp(value, 0, 1024);
   if (value < 13) {
     GRPC_STATS_INC_HISTOGRAM(GRPC_STATS_HISTOGRAM_TCP_WRITE_IOV_SIZE, value);
     return;
@@ -445,7 +445,7 @@ void grpc_stats_inc_tcp_write_iov_size(int value) {
       grpc_stats_histo_find_bucket_slow(value, grpc_stats_table_6, 64));
 }
 void grpc_stats_inc_tcp_read_size(int value) {
-  value = GPR_CLAMP(value, 0, 16777216);
+  value = grpc_core::Clamp(value, 0, 16777216);
   if (value < 5) {
     GRPC_STATS_INC_HISTOGRAM(GRPC_STATS_HISTOGRAM_TCP_READ_SIZE, value);
     return;
@@ -468,7 +468,7 @@ void grpc_stats_inc_tcp_read_size(int value) {
       grpc_stats_histo_find_bucket_slow(value, grpc_stats_table_4, 64));
 }
 void grpc_stats_inc_tcp_read_offer(int value) {
-  value = GPR_CLAMP(value, 0, 16777216);
+  value = grpc_core::Clamp(value, 0, 16777216);
   if (value < 5) {
     GRPC_STATS_INC_HISTOGRAM(GRPC_STATS_HISTOGRAM_TCP_READ_OFFER, value);
     return;
@@ -491,7 +491,7 @@ void grpc_stats_inc_tcp_read_offer(int value) {
       grpc_stats_histo_find_bucket_slow(value, grpc_stats_table_4, 64));
 }
 void grpc_stats_inc_tcp_read_offer_iov_size(int value) {
-  value = GPR_CLAMP(value, 0, 1024);
+  value = grpc_core::Clamp(value, 0, 1024);
   if (value < 13) {
     GRPC_STATS_INC_HISTOGRAM(GRPC_STATS_HISTOGRAM_TCP_READ_OFFER_IOV_SIZE,
                              value);
@@ -516,7 +516,7 @@ void grpc_stats_inc_tcp_read_offer_iov_size(int value) {
       grpc_stats_histo_find_bucket_slow(value, grpc_stats_table_6, 64));
 }
 void grpc_stats_inc_http2_send_message_size(int value) {
-  value = GPR_CLAMP(value, 0, 16777216);
+  value = grpc_core::Clamp(value, 0, 16777216);
   if (value < 5) {
     GRPC_STATS_INC_HISTOGRAM(GRPC_STATS_HISTOGRAM_HTTP2_SEND_MESSAGE_SIZE,
                              value);
@@ -541,7 +541,7 @@ void grpc_stats_inc_http2_send_message_size(int value) {
       grpc_stats_histo_find_bucket_slow(value, grpc_stats_table_4, 64));
 }
 void grpc_stats_inc_http2_send_initial_metadata_per_write(int value) {
-  value = GPR_CLAMP(value, 0, 1024);
+  value = grpc_core::Clamp(value, 0, 1024);
   if (value < 13) {
     GRPC_STATS_INC_HISTOGRAM(
         GRPC_STATS_HISTOGRAM_HTTP2_SEND_INITIAL_METADATA_PER_WRITE, value);
@@ -566,7 +566,7 @@ void grpc_stats_inc_http2_send_initial_metadata_per_write(int value) {
       grpc_stats_histo_find_bucket_slow(value, grpc_stats_table_6, 64));
 }
 void grpc_stats_inc_http2_send_message_per_write(int value) {
-  value = GPR_CLAMP(value, 0, 1024);
+  value = grpc_core::Clamp(value, 0, 1024);
   if (value < 13) {
     GRPC_STATS_INC_HISTOGRAM(GRPC_STATS_HISTOGRAM_HTTP2_SEND_MESSAGE_PER_WRITE,
                              value);
@@ -591,7 +591,7 @@ void grpc_stats_inc_http2_send_message_per_write(int value) {
       grpc_stats_histo_find_bucket_slow(value, grpc_stats_table_6, 64));
 }
 void grpc_stats_inc_http2_send_trailing_metadata_per_write(int value) {
-  value = GPR_CLAMP(value, 0, 1024);
+  value = grpc_core::Clamp(value, 0, 1024);
   if (value < 13) {
     GRPC_STATS_INC_HISTOGRAM(
         GRPC_STATS_HISTOGRAM_HTTP2_SEND_TRAILING_METADATA_PER_WRITE, value);
@@ -616,7 +616,7 @@ void grpc_stats_inc_http2_send_trailing_metadata_per_write(int value) {
       grpc_stats_histo_find_bucket_slow(value, grpc_stats_table_6, 64));
 }
 void grpc_stats_inc_http2_send_flowctl_per_write(int value) {
-  value = GPR_CLAMP(value, 0, 1024);
+  value = grpc_core::Clamp(value, 0, 1024);
   if (value < 13) {
     GRPC_STATS_INC_HISTOGRAM(GRPC_STATS_HISTOGRAM_HTTP2_SEND_FLOWCTL_PER_WRITE,
                              value);
@@ -641,7 +641,7 @@ void grpc_stats_inc_http2_send_flowctl_per_write(int value) {
       grpc_stats_histo_find_bucket_slow(value, grpc_stats_table_6, 64));
 }
 void grpc_stats_inc_server_cqs_checked(int value) {
-  value = GPR_CLAMP(value, 0, 64);
+  value = grpc_core::Clamp(value, 0, 64);
   if (value < 3) {
     GRPC_STATS_INC_HISTOGRAM(GRPC_STATS_HISTOGRAM_SERVER_CQS_CHECKED, value);
     return;

data/src/core/lib/debug/trace.h

@@ -56,7 +56,7 @@ class TraceFlagList {
 };
 
 namespace testing {
-void grpc_tracer_enable_flag(grpc_core::TraceFlag* flag);
+void grpc_tracer_enable_flag(TraceFlag* flag);
 }
 
 class TraceFlag {
@@ -90,7 +90,7 @@ class TraceFlag {
 #endif /* defined(GRPC_USE_TRACERS) || !defined(NDEBUG) */
 
  private:
-  friend void grpc_core::testing::grpc_tracer_enable_flag(TraceFlag* flag);
+  friend void testing::grpc_tracer_enable_flag(TraceFlag* flag);
   friend class TraceFlagList;
 
   void set_enabled(bool enabled) {

data/src/core/lib/event_engine/{endpoint_config.cc → channel_args_endpoint_config.cc}

@@ -13,12 +13,13 @@
 // limitations under the License.
 #include <grpc/support/port_platform.h>
 
+#include "src/core/lib/event_engine/channel_args_endpoint_config.h"
+
 #include <grpc/event_engine/endpoint_config.h>
 #include <grpc/impl/codegen/grpc_types.h>
 #include <grpc/impl/codegen/log.h>
 
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/event_engine/endpoint_config_internal.h"
 #include "src/core/lib/gpr/useful.h"
 
 namespace grpc_event_engine {

data/src/core/lib/event_engine/{endpoint_config_internal.h → channel_args_endpoint_config.h}

@@ -11,8 +11,8 @@
 // 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_EVENT_ENGINE_ENDPOINT_CONFIG_INTERNAL_H
-#define GRPC_CORE_LIB_EVENT_ENGINE_ENDPOINT_CONFIG_INTERNAL_H
+#ifndef GRPC_CORE_LIB_EVENT_ENGINE_CHANNEL_ARGS_ENDPOINT_CONFIG_H
+#define GRPC_CORE_LIB_EVENT_ENGINE_CHANNEL_ARGS_ENDPOINT_CONFIG_H
 
 #include <grpc/support/port_platform.h>
 
@@ -39,4 +39,4 @@ class ChannelArgsEndpointConfig : public EndpointConfig {
 }  // namespace experimental
 }  // namespace grpc_event_engine
 
-#endif  // GRPC_CORE_LIB_EVENT_ENGINE_ENDPOINT_CONFIG_INTERNAL_H
+#endif  // GRPC_CORE_LIB_EVENT_ENGINE_CHANNEL_ARGS_ENDPOINT_CONFIG_H

data/src/core/lib/event_engine/event_engine.cc

@@ -13,17 +13,10 @@
 // limitations under the License.
 #include <grpc/support/port_platform.h>
 
-#include "absl/strings/str_format.h"
-#include "absl/strings/str_join.h"
-
-#include <grpc/event_engine/endpoint_config.h>
 #include <grpc/event_engine/event_engine.h>
 #include <grpc/event_engine/port.h>
-#include <grpc/impl/codegen/grpc_types.h>
 #include <grpc/support/log.h>
 
-#include "src/core/lib/event_engine/sockaddr.h"
-
 namespace grpc_event_engine {
 namespace experimental {
 
@@ -40,11 +33,5 @@ const struct sockaddr* EventEngine::ResolvedAddress::address() const {
 
 socklen_t EventEngine::ResolvedAddress::size() const { return size_; }
 
-std::shared_ptr<grpc_event_engine::experimental::EventEngine>
-DefaultEventEngineFactory() {
-  // TODO(nnoble): delete when uv-ee is merged
-  abort();
-}
-
 }  // namespace experimental
 }  // namespace grpc_event_engine

data/src/core/lib/event_engine/event_engine_factory.cc

@@ -0,0 +1,49 @@
+// Copyright 2021 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.
+#include <grpc/support/port_platform.h>
+
+#include <grpc/event_engine/event_engine.h>
+
+#include "src/core/lib/gprpp/sync.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+namespace {
+std::function<std::unique_ptr<EventEngine>()>* g_event_engine_factory = nullptr;
+grpc_core::Mutex* g_mu = new grpc_core::Mutex();
+}  // namespace
+
+EventEngine* GetDefaultEventEngine() {
+  static EventEngine* default_event_engine = CreateEventEngine().release();
+  return default_event_engine;
+}
+
+void SetDefaultEventEngineFactory(
+    std::function<std::unique_ptr<EventEngine>()>* factory) {
+  grpc_core::MutexLock lock(g_mu);
+  g_event_engine_factory = factory;
+}
+
+std::unique_ptr<EventEngine> CreateEventEngine() {
+  grpc_core::MutexLock lock(g_mu);
+  if (g_event_engine_factory == nullptr) {
+    // TODO(hork): call LibuvEventEngineFactory
+    abort();
+  }
+  return (*g_event_engine_factory)();
+}
+
+}  // namespace experimental
+}  // namespace grpc_event_engine