grpc 1.50.0 → 1.51.0

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

@@ -362,8 +362,7 @@ class ClientChannel {
   std::set<SubchannelWrapper*> subchannel_wrappers_
       ABSL_GUARDED_BY(*work_serializer_);
   int keepalive_time_ ABSL_GUARDED_BY(*work_serializer_) = -1;
-  grpc_error_handle disconnect_error_ ABSL_GUARDED_BY(*work_serializer_) =
-      GRPC_ERROR_NONE;
+  grpc_error_handle disconnect_error_ ABSL_GUARDED_BY(*work_serializer_);
 
   //
   // Fields guarded by a mutex, since they need to be accessed
@@ -508,10 +507,10 @@ class ClientChannel::LoadBalancedCall
   gpr_cycle_counter lb_call_start_time_ = gpr_get_cycle_counter();
 
   // Set when we get a cancel_stream op.
-  grpc_error_handle cancel_error_ = GRPC_ERROR_NONE;
+  grpc_error_handle cancel_error_;
 
   // Set when we fail inside the LB call.
-  grpc_error_handle failure_error_ = GRPC_ERROR_NONE;
+  grpc_error_handle failure_error_;
 
   grpc_closure pick_closure_;
 

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

@@ -20,8 +20,6 @@
 
 #include "src/core/ext/filters/client_channel/client_channel_channelz.h"
 
-#include <map>
-
 #include "src/core/lib/transport/connectivity_state.h"
 
 // IWYU pragma: no_include <type_traits>

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

@@ -19,7 +19,7 @@
 #include <grpc/support/port_platform.h>
 
 #include "src/core/ext/filters/client_channel/client_channel.h"
-#include "src/core/ext/filters/client_channel/resolver_result_parsing.h"
+#include "src/core/ext/filters/client_channel/client_channel_service_config.h"
 #include "src/core/ext/filters/client_channel/retry_service_config.h"
 #include "src/core/lib/channel/channel_stack_builder.h"
 #include "src/core/lib/config/core_configuration.h"

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

@@ -0,0 +1,153 @@
+//
+// Copyright 2018 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/ext/filters/client_channel/client_channel_service_config.h"
+
+#include <map>
+#include <utility>
+
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/ascii.h"
+#include "absl/strings/str_cat.h"
+#include "absl/types/optional.h"
+
+#include "src/core/lib/load_balancing/lb_policy_registry.h"
+
+// As per the retry design, we do not allow more than 5 retry attempts.
+#define MAX_MAX_RETRY_ATTEMPTS 5
+
+namespace grpc_core {
+namespace internal {
+
+//
+// ClientChannelGlobalParsedConfig::HealthCheckConfig
+//
+
+const JsonLoaderInterface*
+ClientChannelGlobalParsedConfig::HealthCheckConfig::JsonLoader(
+    const JsonArgs&) {
+  static const auto* loader =
+      JsonObjectLoader<HealthCheckConfig>()
+          .OptionalField("serviceName", &HealthCheckConfig::service_name)
+          .Finish();
+  return loader;
+}
+
+//
+// ClientChannelGlobalParsedConfig
+//
+
+const JsonLoaderInterface* ClientChannelGlobalParsedConfig::JsonLoader(
+    const JsonArgs&) {
+  static const auto* loader =
+      JsonObjectLoader<ClientChannelGlobalParsedConfig>()
+          // Note: "loadBalancingConfig" requires special handling, so
+          // that field will be parsed in JsonPostLoad() instead.
+          .OptionalField(
+              "loadBalancingPolicy",
+              &ClientChannelGlobalParsedConfig::parsed_deprecated_lb_policy_)
+          .OptionalField("healthCheckConfig",
+                         &ClientChannelGlobalParsedConfig::health_check_config_)
+          .Finish();
+  return loader;
+}
+
+void ClientChannelGlobalParsedConfig::JsonPostLoad(const Json& json,
+                                                   const JsonArgs&,
+                                                   ValidationErrors* errors) {
+  const auto& lb_policy_registry =
+      CoreConfiguration::Get().lb_policy_registry();
+  // Parse LB config.
+  {
+    ValidationErrors::ScopedField field(errors, ".loadBalancingConfig");
+    auto it = json.object_value().find("loadBalancingConfig");
+    if (it != json.object_value().end()) {
+      auto config = lb_policy_registry.ParseLoadBalancingConfig(it->second);
+      if (!config.ok()) {
+        errors->AddError(config.status().message());
+      } else {
+        parsed_lb_config_ = std::move(*config);
+      }
+    }
+  }
+  // Sanity-check deprecated "loadBalancingPolicy" field.
+  if (!parsed_deprecated_lb_policy_.empty()) {
+    ValidationErrors::ScopedField field(errors, ".loadBalancingPolicy");
+    // Convert to lower-case.
+    absl::AsciiStrToLower(&parsed_deprecated_lb_policy_);
+    bool requires_config = false;
+    if (!lb_policy_registry.LoadBalancingPolicyExists(
+            parsed_deprecated_lb_policy_, &requires_config)) {
+      errors->AddError(absl::StrCat("unknown LB policy \"",
+                                    parsed_deprecated_lb_policy_, "\""));
+    } else if (requires_config) {
+      errors->AddError(absl::StrCat(
+          "LB policy \"", parsed_deprecated_lb_policy_,
+          "\" requires a config. Please use loadBalancingConfig instead."));
+    }
+  }
+}
+
+//
+// ClientChannelMethodParsedConfig
+//
+
+const JsonLoaderInterface* ClientChannelMethodParsedConfig::JsonLoader(
+    const JsonArgs&) {
+  static const auto* loader =
+      JsonObjectLoader<ClientChannelMethodParsedConfig>()
+          .OptionalField("timeout", &ClientChannelMethodParsedConfig::timeout_)
+          .OptionalField("waitForReady",
+                         &ClientChannelMethodParsedConfig::wait_for_ready_)
+          .Finish();
+  return loader;
+}
+
+//
+// ClientChannelServiceConfigParser
+//
+
+size_t ClientChannelServiceConfigParser::ParserIndex() {
+  return CoreConfiguration::Get().service_config_parser().GetParserIndex(
+      parser_name());
+}
+
+void ClientChannelServiceConfigParser::Register(
+    CoreConfiguration::Builder* builder) {
+  builder->service_config_parser()->RegisterParser(
+      std::make_unique<ClientChannelServiceConfigParser>());
+}
+
+std::unique_ptr<ServiceConfigParser::ParsedConfig>
+ClientChannelServiceConfigParser::ParseGlobalParams(const ChannelArgs& /*args*/,
+                                                    const Json& json,
+                                                    ValidationErrors* errors) {
+  return LoadFromJson<std::unique_ptr<ClientChannelGlobalParsedConfig>>(
+      json, JsonArgs(), errors);
+}
+
+std::unique_ptr<ServiceConfigParser::ParsedConfig>
+ClientChannelServiceConfigParser::ParsePerMethodParams(
+    const ChannelArgs& /*args*/, const Json& json, ValidationErrors* errors) {
+  return LoadFromJson<std::unique_ptr<ClientChannelMethodParsedConfig>>(
+      json, JsonArgs(), errors);
+}
+
+}  // namespace internal
+}  // namespace grpc_core

data/src/core/ext/filters/client_channel/{resolver_result_parsing.h → client_channel_service_config.h}

@@ -14,8 +14,8 @@
 // limitations under the License.
 //
 
-#ifndef GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_RESULT_PARSING_H
-#define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_RESULT_PARSING_H
+#ifndef GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_CLIENT_CHANNEL_SERVICE_CONFIG_H
+#define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_CLIENT_CHANNEL_SERVICE_CONFIG_H
 
 #include <grpc/support/port_platform.h>
 
@@ -23,9 +23,7 @@
 
 #include <memory>
 #include <string>
-#include <utility>
 
-#include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 
@@ -33,7 +31,10 @@
 #include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/time.h"
+#include "src/core/lib/gprpp/validation_errors.h"
 #include "src/core/lib/json/json.h"
+#include "src/core/lib/json/json_args.h"
+#include "src/core/lib/json/json_object_loader.h"
 #include "src/core/lib/load_balancing/lb_policy.h"
 #include "src/core/lib/service_config/service_config_parser.h"
 
@@ -43,14 +44,6 @@ namespace internal {
 class ClientChannelGlobalParsedConfig
     : public ServiceConfigParser::ParsedConfig {
  public:
-  ClientChannelGlobalParsedConfig(
-      RefCountedPtr<LoadBalancingPolicy::Config> parsed_lb_config,
-      std::string parsed_deprecated_lb_policy,
-      absl::optional<std::string> health_check_service_name)
-      : parsed_lb_config_(std::move(parsed_lb_config)),
-        parsed_deprecated_lb_policy_(std::move(parsed_deprecated_lb_policy)),
-        health_check_service_name_(std::move(health_check_service_name)) {}
-
   RefCountedPtr<LoadBalancingPolicy::Config> parsed_lb_config() const {
     return parsed_lb_config_;
   }
@@ -60,26 +53,34 @@ class ClientChannelGlobalParsedConfig
   }
 
   const absl::optional<std::string>& health_check_service_name() const {
-    return health_check_service_name_;
+    return health_check_config_.service_name;
   }
 
+  static const JsonLoaderInterface* JsonLoader(const JsonArgs&);
+  void JsonPostLoad(const Json& json, const JsonArgs&,
+                    ValidationErrors* errors);
+
  private:
+  struct HealthCheckConfig {
+    absl::optional<std::string> service_name;
+
+    static const JsonLoaderInterface* JsonLoader(const JsonArgs&);
+  };
+
   RefCountedPtr<LoadBalancingPolicy::Config> parsed_lb_config_;
   std::string parsed_deprecated_lb_policy_;
-  absl::optional<std::string> health_check_service_name_;
+  HealthCheckConfig health_check_config_;
 };
 
 class ClientChannelMethodParsedConfig
     : public ServiceConfigParser::ParsedConfig {
  public:
-  ClientChannelMethodParsedConfig(Duration timeout,
-                                  const absl::optional<bool>& wait_for_ready)
-      : timeout_(timeout), wait_for_ready_(wait_for_ready) {}
-
   Duration timeout() const { return timeout_; }
 
   absl::optional<bool> wait_for_ready() const { return wait_for_ready_; }
 
+  static const JsonLoaderInterface* JsonLoader(const JsonArgs&);
+
  private:
   Duration timeout_;
   absl::optional<bool> wait_for_ready_;
@@ -89,11 +90,13 @@ class ClientChannelServiceConfigParser : public ServiceConfigParser::Parser {
  public:
   absl::string_view name() const override { return parser_name(); }
 
-  absl::StatusOr<std::unique_ptr<ServiceConfigParser::ParsedConfig>>
-  ParseGlobalParams(const ChannelArgs& /*args*/, const Json& json) override;
+  std::unique_ptr<ServiceConfigParser::ParsedConfig> ParseGlobalParams(
+      const ChannelArgs& /*args*/, const Json& json,
+      ValidationErrors* errors) override;
 
-  absl::StatusOr<std::unique_ptr<ServiceConfigParser::ParsedConfig>>
-  ParsePerMethodParams(const ChannelArgs& /*args*/, const Json& json) override;
+  std::unique_ptr<ServiceConfigParser::ParsedConfig> ParsePerMethodParams(
+      const ChannelArgs& /*args*/, const Json& json,
+      ValidationErrors* errors) override;
 
   static size_t ParserIndex();
   static void Register(CoreConfiguration::Builder* builder);
@@ -105,4 +108,4 @@ class ClientChannelServiceConfigParser : public ServiceConfigParser::Parser {
 }  // namespace internal
 }  // namespace grpc_core
 
-#endif  // GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_RESULT_PARSING_H
+#endif  // GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_CLIENT_CHANNEL_SERVICE_CONFIG_H

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

@@ -74,7 +74,7 @@ class SubchannelConnector : public InternallyRefCounted<SubchannelConnector> {
   virtual void Shutdown(grpc_error_handle error) = 0;
 
   void Orphan() override {
-    Shutdown(GRPC_ERROR_CREATE_FROM_STATIC_STRING("Subchannel disconnected"));
+    Shutdown(GRPC_ERROR_CREATE("Subchannel disconnected"));
     Unref();
   }
 };

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

@@ -24,15 +24,17 @@
 #include <string>
 #include <utility>
 
-#include "absl/status/status.h"
+#include "absl/status/statusor.h"
 
-#include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_stack.h"
+#include "src/core/lib/channel/channel_stack_builder_impl.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gpr/alloc.h"
+#include "src/core/lib/gprpp/status_helper.h"
+#include "src/core/lib/surface/channel_stack_type.h"
 #include "src/core/lib/surface/lame_client.h"
 
 // Conversion between call and call stack.
@@ -63,10 +65,10 @@ DynamicFilters::Call::Call(Args args, grpc_error_handle* error)
       args.arena,        /* arena */
       args.call_combiner /* call_combiner */
   };
-  *error = grpc_call_stack_init(channel_stack_->channel_stack_, 1, Destroy,
-                                this, &call_args);
-  if (GPR_UNLIKELY(!GRPC_ERROR_IS_NONE(*error))) {
-    gpr_log(GPR_ERROR, "error: %s", grpc_error_std_string(*error).c_str());
+  *error = grpc_call_stack_init(channel_stack_->channel_stack_.get(), 1,
+                                Destroy, this, &call_args);
+  if (GPR_UNLIKELY(!error->ok())) {
+    gpr_log(GPR_ERROR, "error: %s", StatusToString(*error).c_str());
     return;
   }
   grpc_call_stack_set_pollset_or_pollset_set(call_stack, args.pollent);
@@ -136,58 +138,29 @@ void DynamicFilters::Call::IncrementRefCount(const DebugLocation& /*location*/,
 
 namespace {
 
-void DestroyChannelStack(void* arg, grpc_error_handle /*error*/) {
-  grpc_channel_stack* channel_stack = static_cast<grpc_channel_stack*>(arg);
-  grpc_channel_stack_destroy(channel_stack);
-  gpr_free(channel_stack);
-}
-
-std::pair<grpc_channel_stack*, grpc_error_handle> CreateChannelStack(
-    const grpc_channel_args* args,
-    std::vector<const grpc_channel_filter*> filters) {
-  // Allocate memory for channel stack.
-  const size_t channel_stack_size =
-      grpc_channel_stack_size(filters.data(), filters.size());
-  grpc_channel_stack* channel_stack =
-      reinterpret_cast<grpc_channel_stack*>(gpr_zalloc(channel_stack_size));
-  // Initialize stack.
-  grpc_error_handle error = grpc_channel_stack_init(
-      /*initial_refs=*/1, DestroyChannelStack, channel_stack, filters.data(),
-      filters.size(), args, "DynamicFilters", channel_stack);
-  if (!GRPC_ERROR_IS_NONE(error)) {
-    gpr_log(GPR_ERROR, "error initializing client internal stack: %s",
-            grpc_error_std_string(error).c_str());
-    grpc_channel_stack_destroy(channel_stack);
-    gpr_free(channel_stack);
-    return {nullptr, error};
+absl::StatusOr<RefCountedPtr<grpc_channel_stack>> CreateChannelStack(
+    const ChannelArgs& args, std::vector<const grpc_channel_filter*> filters) {
+  ChannelStackBuilderImpl builder("DynamicFilters", GRPC_CLIENT_DYNAMIC, args);
+  for (auto filter : filters) {
+    builder.AppendFilter(filter);
   }
-  return {channel_stack, GRPC_ERROR_NONE};
+  return builder.Build();
 }
 
 }  // namespace
 
 RefCountedPtr<DynamicFilters> DynamicFilters::Create(
-    const grpc_channel_args* args,
-    std::vector<const grpc_channel_filter*> filters) {
+    const ChannelArgs& args, std::vector<const grpc_channel_filter*> filters) {
   // Attempt to create channel stack from requested filters.
   auto p = CreateChannelStack(args, std::move(filters));
-  if (!GRPC_ERROR_IS_NONE(p.second)) {
+  if (!p.ok()) {
     // Channel stack creation failed with requested filters.
     // Create with lame filter instead.
-    grpc_error_handle error = p.second;
-    grpc_arg error_arg = MakeLameClientErrorArg(&error);
-    grpc_channel_args* new_args =
-        grpc_channel_args_copy_and_add(args, &error_arg, 1);
-    GRPC_ERROR_UNREF(error);
-    p = CreateChannelStack(new_args, {&LameClientFilter::kFilter});
-    GPR_ASSERT(GRPC_ERROR_IS_NONE(p.second));
-    grpc_channel_args_destroy(new_args);
+    auto error = p.status();
+    p = CreateChannelStack(args.Set(MakeLameClientErrorArg(&error)),
+                           {&LameClientFilter::kFilter});
   }
-  return MakeRefCounted<DynamicFilters>(p.first);
-}
-
-DynamicFilters::~DynamicFilters() {
-  GRPC_CHANNEL_STACK_UNREF(channel_stack_, "~DynamicFilters");
+  return MakeRefCounted<DynamicFilters>(std::move(p.value()));
 }
 
 RefCountedPtr<DynamicFilters::Call> DynamicFilters::CreateCall(

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

@@ -19,12 +19,14 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <utility>
 #include <vector>
 
-#include <grpc/impl/codegen/grpc_types.h>
 #include <grpc/slice.h>
 
+#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
+#include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/channel/context.h"
 #include "src/core/lib/gpr/time_precise.h"
 #include "src/core/lib/gprpp/debug_location.h"
@@ -90,18 +92,15 @@ class DynamicFilters : public RefCounted<DynamicFilters> {
   };
 
   static RefCountedPtr<DynamicFilters> Create(
-      const grpc_channel_args* args,
-      std::vector<const grpc_channel_filter*> filters);
+      const ChannelArgs& args, std::vector<const grpc_channel_filter*> filters);
 
-  explicit DynamicFilters(grpc_channel_stack* channel_stack)
-      : channel_stack_(channel_stack) {}
-
-  ~DynamicFilters() override;
+  explicit DynamicFilters(RefCountedPtr<grpc_channel_stack> channel_stack)
+      : channel_stack_(std::move(channel_stack)) {}
 
   RefCountedPtr<Call> CreateCall(Call::Args args, grpc_error_handle* error);
 
  private:
-  grpc_channel_stack* channel_stack_;
+  RefCountedPtr<grpc_channel_stack> channel_stack_;
 };
 
 }  // namespace grpc_core

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

@@ -25,7 +25,6 @@
 #include <memory>
 #include <utility>
 
-#include "absl/memory/memory.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
@@ -165,9 +164,9 @@ OrphanablePtr<SubchannelStreamClient> MakeHealthCheckClient(
     RefCountedPtr<ConnectivityStateWatcherInterface> watcher) {
   return MakeOrphanable<SubchannelStreamClient>(
       std::move(connected_subchannel), interested_parties,
-      absl::make_unique<HealthStreamEventHandler>(std::move(service_name),
-                                                  std::move(channelz_node),
-                                                  std::move(watcher)),
+      std::make_unique<HealthStreamEventHandler>(std::move(service_name),
+                                                 std::move(channelz_node),
+                                                 std::move(watcher)),
       GRPC_TRACE_FLAG_ENABLED(grpc_health_check_client_trace)
           ? "HealthCheckClient"
           : nullptr);

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

@@ -44,7 +44,6 @@
 #include "src/core/lib/gprpp/env.h"
 #include "src/core/lib/gprpp/host_port.h"
 #include "src/core/lib/gprpp/memory.h"
-#include "src/core/lib/handshaker/proxy_mapper_registry.h"
 #include "src/core/lib/iomgr/resolve_address.h"
 #include "src/core/lib/slice/b64.h"
 #include "src/core/lib/transport/http_connect_handshaker.h"

data/src/core/ext/filters/client_channel/lb_policy/address_filtering.cc

@@ -23,7 +23,6 @@
 #include <algorithm>
 #include <utility>
 
-#include "absl/memory/memory.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_join.h"
 
@@ -41,7 +40,7 @@ class HierarchicalPathAttribute : public ServerAddress::AttributeInterface {
       : path_(std::move(path)) {}
 
   std::unique_ptr<AttributeInterface> Copy() const override {
-    return absl::make_unique<HierarchicalPathAttribute>(path_);
+    return std::make_unique<HierarchicalPathAttribute>(path_);
   }
 
   int Cmp(const AttributeInterface* other) const override {
@@ -70,7 +69,7 @@ class HierarchicalPathAttribute : public ServerAddress::AttributeInterface {
 
 std::unique_ptr<ServerAddress::AttributeInterface>
 MakeHierarchicalPathAttribute(std::vector<std::string> path) {
-  return absl::make_unique<HierarchicalPathAttribute>(std::move(path));
+  return std::make_unique<HierarchicalPathAttribute>(std::move(path));
 }
 
 absl::StatusOr<HierarchicalAddressMap> MakeHierarchicalAddressMap(
@@ -89,7 +88,7 @@ absl::StatusOr<HierarchicalAddressMap> MakeHierarchicalAddressMap(
     ++it;
     if (it != path.end()) {
       std::vector<std::string> remaining_path(it, path.end());
-      new_attribute = absl::make_unique<HierarchicalPathAttribute>(
+      new_attribute = std::make_unique<HierarchicalPathAttribute>(
           std::move(remaining_path));
     }
     target_list.emplace_back(address.WithAttribute(

data/src/core/ext/filters/client_channel/lb_policy/child_policy_handler.cc

@@ -25,6 +25,7 @@
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
 
+#include <grpc/event_engine/event_engine.h>
 #include <grpc/impl/codegen/connectivity_state.h>
 #include <grpc/support/log.h>
 
@@ -107,6 +108,10 @@ class ChildPolicyHandler::Helper
     return parent_->channel_control_helper()->GetAuthority();
   }
 
+  grpc_event_engine::experimental::EventEngine* GetEventEngine() override {
+    return parent_->channel_control_helper()->GetEventEngine();
+  }
+
   void AddTraceEvent(TraceSeverity severity,
                      absl::string_view message) override {
     if (parent_->shutting_down_) return;

data/src/core/ext/filters/client_channel/lb_policy/grpclb/client_load_reporting_filter.cc

@@ -22,6 +22,8 @@
 
 #include <new>
 
+#include "absl/meta/type_traits.h"
+#include "absl/status/status.h"
 #include "absl/types/optional.h"
 
 #include <grpc/support/log.h>
@@ -36,7 +38,7 @@
 
 static grpc_error_handle clr_init_channel_elem(
     grpc_channel_element* /*elem*/, grpc_channel_element_args* /*args*/) {
-  return GRPC_ERROR_NONE;
+  return absl::OkStatus();
 }
 
 static void clr_destroy_channel_elem(grpc_channel_element* /*elem*/) {}
@@ -60,28 +62,27 @@ struct call_data {
 
 static void on_complete_for_send(void* arg, grpc_error_handle error) {
   call_data* calld = static_cast<call_data*>(arg);
-  if (GRPC_ERROR_IS_NONE(error)) {
+  if (error.ok()) {
     calld->send_initial_metadata_succeeded = true;
   }
   grpc_core::Closure::Run(DEBUG_LOCATION, calld->original_on_complete_for_send,
-                          GRPC_ERROR_REF(error));
+                          error);
 }
 
 static void recv_initial_metadata_ready(void* arg, grpc_error_handle error) {
   call_data* calld = static_cast<call_data*>(arg);
-  if (GRPC_ERROR_IS_NONE(error)) {
+  if (error.ok()) {
     calld->recv_initial_metadata_succeeded = true;
   }
   grpc_core::Closure::Run(DEBUG_LOCATION,
-                          calld->original_recv_initial_metadata_ready,
-                          GRPC_ERROR_REF(error));
+                          calld->original_recv_initial_metadata_ready, error);
 }
 
 static grpc_error_handle clr_init_call_elem(
     grpc_call_element* elem, const grpc_call_element_args* args) {
   GPR_ASSERT(args->context != nullptr);
   new (elem->call_data) call_data();
-  return GRPC_ERROR_NONE;
+  return absl::OkStatus();
 }
 
 static void clr_destroy_call_elem(grpc_call_element* elem,