grpc 1.42.0 → 1.43.1

data/src/core/lib/channel/channel_args_preconditioning.h

@@ -0,0 +1,62 @@
+// Copyright 2021 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_CHANNEL_CHANNEL_ARGS_PRECONDITIONING_H
+#define GRPC_CORE_LIB_CHANNEL_CHANNEL_ARGS_PRECONDITIONING_H
+
+#include <grpc/support/port_platform.h>
+
+#include <functional>
+#include <vector>
+
+#include "src/core/lib/channel/channel_args.h"
+
+namespace grpc_core {
+
+// Registry of mutators for channel args.
+// Surface APIs should call into this with channel args received from outside
+// of gRPC, in order to prepare those channel args for the expections of the
+// gRPC internals.
+class ChannelArgsPreconditioning {
+ public:
+  // Take channel args and mutate them.
+  // Does not take ownership of the channel args passed in.
+  // Returns a new channel args object that is owned by the caller.
+  using Stage =
+      std::function<const grpc_channel_args*(const grpc_channel_args*)>;
+
+  class Builder {
+   public:
+    // Register a new channel args preconditioner.
+    void RegisterStage(Stage stage);
+    // Build out the preconditioners.
+    ChannelArgsPreconditioning Build();
+
+   private:
+    std::vector<Stage> stages_;
+  };
+
+  // Take channel args and precondition them.
+  // Does not take ownership of the channel args passed in.
+  // Returns a new channel args object that is owned by the caller.
+  const grpc_channel_args* PreconditionChannelArgs(
+      const grpc_channel_args* args) const;
+
+ private:
+  std::vector<Stage> stages_;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_CHANNEL_CHANNEL_ARGS_PRECONDITIONING_H

data/src/core/lib/channel/channel_stack_builder.cc

@@ -42,8 +42,6 @@ struct grpc_channel_stack_builder {
   // various set/get-able parameters
   grpc_channel_args* args;
   grpc_transport* transport;
-  grpc_resource_user* resource_user;
-  size_t preallocated_bytes;
   char* target;
   const char* name;
 };

data/src/core/lib/channel/channel_trace.cc

@@ -46,8 +46,8 @@ ChannelTrace::TraceEvent::TraceEvent(Severity severity, const grpc_slice& data,
                                      RefCountedPtr<BaseNode> referenced_entity)
     : severity_(severity),
       data_(data),
-      timestamp_(grpc_millis_to_timespec(grpc_core::ExecCtx::Get()->Now(),
-                                         GPR_CLOCK_REALTIME)),
+      timestamp_(
+          grpc_millis_to_timespec(ExecCtx::Get()->Now(), GPR_CLOCK_REALTIME)),
       next_(nullptr),
       referenced_entity_(std::move(referenced_entity)),
       memory_usage_(sizeof(TraceEvent) + grpc_slice_memory_usage(data)) {}
@@ -55,8 +55,8 @@ ChannelTrace::TraceEvent::TraceEvent(Severity severity, const grpc_slice& data,
 ChannelTrace::TraceEvent::TraceEvent(Severity severity, const grpc_slice& data)
     : severity_(severity),
       data_(data),
-      timestamp_(grpc_millis_to_timespec(grpc_core::ExecCtx::Get()->Now(),
-                                         GPR_CLOCK_REALTIME)),
+      timestamp_(
+          grpc_millis_to_timespec(ExecCtx::Get()->Now(), GPR_CLOCK_REALTIME)),
       next_(nullptr),
       memory_usage_(sizeof(TraceEvent) + grpc_slice_memory_usage(data)) {}
 
@@ -72,8 +72,8 @@ ChannelTrace::ChannelTrace(size_t max_event_memory)
     return;  // tracing is disabled if max_event_memory_ == 0
   }
   gpr_mu_init(&tracer_mu_);
-  time_created_ = grpc_millis_to_timespec(grpc_core::ExecCtx::Get()->Now(),
-                                          GPR_CLOCK_REALTIME);
+  time_created_ =
+      grpc_millis_to_timespec(ExecCtx::Get()->Now(), GPR_CLOCK_REALTIME);
 }
 
 ChannelTrace::~ChannelTrace() {

data/src/core/lib/channel/channelz.cc

@@ -398,7 +398,7 @@ void SecurityArgDestroy(void* p) {
   xds_certificate_provider->Unref();
 }
 
-int SecurityArgCmp(void* p, void* q) { return grpc_core::QsortCompare(p, q); }
+int SecurityArgCmp(void* p, void* q) { return QsortCompare(p, q); }
 
 const grpc_arg_pointer_vtable kChannelArgVtable = {
     SecurityArgCopy, SecurityArgDestroy, SecurityArgCmp};

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

@@ -51,8 +51,9 @@ grpc_channel_args_get_channel_default_compression_algorithm(
   return GRPC_COMPRESS_NONE;
 }
 
-grpc_channel_args* grpc_channel_args_set_channel_default_compression_algorithm(
-    grpc_channel_args* a, grpc_compression_algorithm algorithm) {
+const grpc_channel_args*
+grpc_channel_args_set_channel_default_compression_algorithm(
+    const grpc_channel_args* a, grpc_compression_algorithm algorithm) {
   GPR_ASSERT(algorithm < GRPC_COMPRESS_ALGORITHMS_COUNT);
   grpc_arg tmp;
   tmp.type = GRPC_ARG_INTEGER;
@@ -83,10 +84,11 @@ static int find_compression_algorithm_states_bitset(const grpc_channel_args* a,
   return 0; /* GPR_FALSE */
 }
 
-grpc_channel_args* grpc_channel_args_compression_algorithm_set_state(
-    grpc_channel_args** a, grpc_compression_algorithm algorithm, int state) {
+const grpc_channel_args* grpc_channel_args_compression_algorithm_set_state(
+    const grpc_channel_args** a, grpc_compression_algorithm algorithm,
+    int state) {
   int* states_arg = nullptr;
-  grpc_channel_args* result = *a;
+  const grpc_channel_args* result = *a;
   const int states_arg_found =
       find_compression_algorithm_states_bitset(*a, &states_arg);
 

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

@@ -32,8 +32,9 @@ grpc_channel_args_get_channel_default_compression_algorithm(
 /** Returns a channel arg instance with compression enabled. If \a a is
  * non-NULL, its args are copied. N.B. GRPC_COMPRESS_NONE disables compression
  * for the channel. */
-grpc_channel_args* grpc_channel_args_set_channel_default_compression_algorithm(
-    grpc_channel_args* a, grpc_compression_algorithm algorithm);
+const grpc_channel_args*
+grpc_channel_args_set_channel_default_compression_algorithm(
+    const grpc_channel_args* a, grpc_compression_algorithm algorithm);
 
 /** Sets the support for the given compression algorithm. By default, all
  * compression algorithms are enabled. It's an error to disable an algorithm set
@@ -42,8 +43,9 @@ grpc_channel_args* grpc_channel_args_set_channel_default_compression_algorithm(
  * Returns an instance with the updated algorithm states. The \a a pointer is
  * modified to point to the returned instance (which may be different from the
  * input value of \a a). */
-grpc_channel_args* grpc_channel_args_compression_algorithm_set_state(
-    grpc_channel_args** a, grpc_compression_algorithm algorithm, int state);
+const grpc_channel_args* grpc_channel_args_compression_algorithm_set_state(
+    const grpc_channel_args** a, grpc_compression_algorithm algorithm,
+    int state);
 
 /** Returns the bitset representing the support state (true for enabled, false
  * for disabled) for compression algorithms.

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

@@ -31,7 +31,9 @@ CoreConfiguration* CoreConfiguration::Builder::Build() {
 }
 
 CoreConfiguration::CoreConfiguration(Builder* builder)
-    : channel_init_(builder->channel_init_.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) {

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

@@ -19,6 +19,7 @@
 
 #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"
 
@@ -35,6 +36,10 @@ 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() {
@@ -44,6 +49,7 @@ class CoreConfiguration {
    private:
     friend class CoreConfiguration;
 
+    ChannelArgsPreconditioning::Builder channel_args_preconditioning_;
     ChannelInit::Builder channel_init_;
     HandshakerRegistry::Builder handshaker_registry_;
 
@@ -111,6 +117,10 @@ class CoreConfiguration {
 
   // Accessors
 
+  const ChannelArgsPreconditioning& channel_args_preconditioning() const {
+    return channel_args_preconditioning_;
+  }
+
   const ChannelInit& channel_init() const { return channel_init_; }
 
   const HandshakerRegistry& handshaker_registry() const {
@@ -135,6 +145,7 @@ class CoreConfiguration {
   // Extra registered builders
   static std::atomic<RegisteredBuilder*> builders_;
 
+  ChannelArgsPreconditioning channel_args_preconditioning_;
   ChannelInit channel_init_;
   HandshakerRegistry handshaker_registry_;
 };

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

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

@@ -0,0 +1,33 @@
+// 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.
+#ifndef GRPC_CORE_LIB_EVENT_ENGINE_EVENT_ENGINE_FACTORY_H
+#define GRPC_CORE_LIB_EVENT_ENGINE_EVENT_ENGINE_FACTORY_H
+
+#include <grpc/support/port_platform.h>
+
+#include <grpc/event_engine/event_engine.h>
+
+namespace grpc_event_engine {
+namespace experimental {
+
+/// Access the shared global EventEngine instance.
+///
+/// The concept of a global EventEngine may go away in a post-iomgr world.
+/// Strongly consider whether you could use \a CreateEventEngine instead.
+EventEngine* GetDefaultEventEngine();
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_CORE_LIB_EVENT_ENGINE_EVENT_ENGINE_FACTORY_H

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

@@ -0,0 +1,70 @@
+// Copyright 2021 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/memory_allocator.h>
+
+#include "src/core/lib/gprpp/ref_counted.h"
+#include "src/core/lib/slice/slice_refcount.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+namespace {
+
+// Reference count for a slice allocated by MemoryAllocator::MakeSlice.
+// Takes care of releasing memory back when the slice is destroyed.
+class SliceRefCount {
+ public:
+  static void Destroy(void* p) {
+    auto* rc = static_cast<SliceRefCount*>(p);
+    rc->~SliceRefCount();
+    gpr_free(rc);
+  }
+  SliceRefCount(std::shared_ptr<internal::MemoryAllocatorImpl> allocator,
+                size_t size)
+      : base_(grpc_slice_refcount::Type::REGULAR, &refs_, Destroy, this,
+              &base_),
+        allocator_(std::move(allocator)),
+        size_(size) {
+    // Nothing to do here.
+  }
+  ~SliceRefCount() { allocator_->Release(size_); }
+
+  grpc_slice_refcount* base_refcount() { return &base_; }
+
+ private:
+  grpc_slice_refcount base_;
+  std::atomic<size_t> refs_{1};
+  std::shared_ptr<internal::MemoryAllocatorImpl> allocator_;
+  size_t size_;
+};
+
+}  // namespace
+
+grpc_slice MemoryAllocator::MakeSlice(MemoryRequest request) {
+  auto size = Reserve(request.Increase(sizeof(SliceRefCount)));
+  void* p = gpr_malloc(size);
+  new (p) SliceRefCount(allocator_, size);
+  grpc_slice slice;
+  slice.refcount = static_cast<SliceRefCount*>(p)->base_refcount();
+  slice.data.refcounted.bytes =
+      static_cast<uint8_t*>(p) + sizeof(SliceRefCount);
+  slice.data.refcounted.length = size - sizeof(SliceRefCount);
+  return slice;
+}
+
+}  // namespace experimental
+}  // namespace grpc_event_engine

data/src/core/lib/gpr/tls.h

@@ -118,6 +118,12 @@ class PthreadTlsImpl : TlsTypeConstrainer<T> {
     return t;
   }
 
+  T operator->() const {
+    static_assert(std::is_pointer<T>::value,
+                  "operator-> only usable on pointers");
+    return this->operator T();
+  }
+
   T operator=(T t) {
     char* src = reinterpret_cast<char*>(&t);
     for (pthread_key_t key : keys_) {

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

@@ -0,0 +1,45 @@
+// Copyright 2021 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_CPP_IMPL_OF_H
+#define GRPC_CORE_LIB_GPRPP_CPP_IMPL_OF_H
+
+namespace grpc_core {
+
+// Declares CppType to be the backing implementation of CType.
+// Use via the curiously recursive template:
+// class Foo : public CppImplOf<Foo, grpc_foo> {};
+// Provides casting methods each way.
+// grpc_foo should be `typedef struct grpc_foo grpc_foo` and otherwise
+// not defined.
+template <typename CppType, typename CType>
+class CppImplOf {
+ public:
+  // Convert the C struct to C++
+  static CppType* FromC(CType* c_type) {
+    return reinterpret_cast<CppType*>(c_type);
+  }
+
+  // Retrieve a c pointer (of the same ownership as this)
+  CType* c_ptr() {
+    return reinterpret_cast<CType*>(static_cast<CppType*>(this));
+  }
+
+ protected:
+  ~CppImplOf() = default;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_GPRPP_CPP_IMPL_OF_H

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

@@ -58,8 +58,8 @@ void SetGlobalConfigEnvErrorFunction(GlobalConfigEnvErrorFunctionType func) {
   g_global_config_env_error_func = func;
 }
 
-grpc_core::UniquePtr<char> GlobalConfigEnv::GetValue() {
-  return grpc_core::UniquePtr<char>(gpr_getenv(GetName()));
+UniquePtr<char> GlobalConfigEnv::GetValue() {
+  return UniquePtr<char>(gpr_getenv(GetName()));
 }
 
 void GlobalConfigEnv::SetValue(const char* value) {
@@ -80,7 +80,7 @@ static_assert(std::is_trivially_destructible<GlobalConfigEnvBool>::value,
               "GlobalConfigEnvBool needs to be trivially destructible.");
 
 bool GlobalConfigEnvBool::Get() {
-  grpc_core::UniquePtr<char> str = GetValue();
+  UniquePtr<char> str = GetValue();
   if (str == nullptr) {
     return default_value_;
   }
@@ -101,7 +101,7 @@ static_assert(std::is_trivially_destructible<GlobalConfigEnvInt32>::value,
               "GlobalConfigEnvInt32 needs to be trivially destructible.");
 
 int32_t GlobalConfigEnvInt32::Get() {
-  grpc_core::UniquePtr<char> str = GetValue();
+  UniquePtr<char> str = GetValue();
   if (str == nullptr) {
     return default_value_;
   }
@@ -124,10 +124,10 @@ void GlobalConfigEnvInt32::Set(int32_t value) {
 static_assert(std::is_trivially_destructible<GlobalConfigEnvString>::value,
               "GlobalConfigEnvString needs to be trivially destructible.");
 
-grpc_core::UniquePtr<char> GlobalConfigEnvString::Get() {
-  grpc_core::UniquePtr<char> str = GetValue();
+UniquePtr<char> GlobalConfigEnvString::Get() {
+  UniquePtr<char> str = GetValue();
   if (str == nullptr) {
-    return grpc_core::UniquePtr<char>(gpr_strdup(default_value_));
+    return UniquePtr<char>(gpr_strdup(default_value_));
   }
   return str;
 }

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

@@ -43,7 +43,7 @@ class GlobalConfigEnv {
 
  public:
   // Returns the value of `name` variable.
-  grpc_core::UniquePtr<char> GetValue();
+  UniquePtr<char> GetValue();
 
   // Sets the value of `name` variable.
   void SetValue(const char* value);
@@ -87,7 +87,7 @@ class GlobalConfigEnvString : public GlobalConfigEnv {
   constexpr GlobalConfigEnvString(char* name, const char* default_value)
       : GlobalConfigEnv(name), default_value_(default_value) {}
 
-  grpc_core::UniquePtr<char> Get();
+  UniquePtr<char> Get();
   void Set(const char* value);
 
  private:

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

@@ -163,9 +163,8 @@ class PolymorphicManualConstructor {
   }
 
   typename std::aligned_storage<
-      grpc_core::manual_ctor_impl::max_size_of<DerivedTypes...>::value,
-      grpc_core::manual_ctor_impl::max_align_of<DerivedTypes...>::value>::type
-      space_;
+      manual_ctor_impl::max_size_of<DerivedTypes...>::value,
+      manual_ctor_impl::max_align_of<DerivedTypes...>::value>::type space_;
 };
 
 template <typename Type>

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

@@ -117,7 +117,7 @@ class InternallyRefCounted : public Orphanable {
     refs_.Ref(location, reason);
   }
 
-  grpc_core::RefCount refs_;
+  RefCount refs_;
 };
 
 }  // namespace grpc_core

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

@@ -208,7 +208,7 @@ class PolymorphicRefCount {
 };
 
 // NonPolymorphicRefCount does not enforce polymorphic destruction of
-// RefCounted. Please refer to grpc_core::RefCounted for more details, and
+// RefCounted. Please refer to RefCounted for more details, and
 // when in doubt use PolymorphicRefCount.
 class NonPolymorphicRefCount {
  public:

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

@@ -40,8 +40,7 @@ class RefCountedPtr {
 
   // If value is non-null, we take ownership of a ref to it.
   template <typename Y>
-  // NOLINTNEXTLINE(google-explicit-constructor)
-  RefCountedPtr(Y* value) : value_(value) {}
+  explicit RefCountedPtr(Y* value) : value_(value) {}
 
   // Move ctors.
   RefCountedPtr(RefCountedPtr&& other) noexcept {
@@ -191,8 +190,7 @@ class WeakRefCountedPtr {
 
   // If value is non-null, we take ownership of a ref to it.
   template <typename Y>
-  // NOLINTNEXTLINE(google-explicit-constructor)
-  WeakRefCountedPtr(Y* value) {
+  explicit WeakRefCountedPtr(Y* value) {
     value_ = value;
   }
 

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

@@ -160,7 +160,7 @@ google_rpc_Status* StatusToProto(const absl::Status& status,
 /// This is for internal implementation & test only
 absl::Status StatusFromProto(google_rpc_Status* msg) GRPC_MUST_USE_RESULT;
 
-/// The same value of grpc_core::internal::StatusAllocPtr(absl::OkStatus())
+/// The same value of internal::StatusAllocPtr(absl::OkStatus())
 static constexpr uintptr_t kOkStatusPtr = 0;
 
 /// Returns ptr where the given status is copied into.