grpc 1.52.0.pre2 → 1.53.0.pre2

data/src/core/ext/filters/client_channel/resolver/dns/c_ares/grpc_ares_ev_driver.h

@@ -16,8 +16,8 @@
 //
 //
 
-#ifndef GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_DNS_C_ARES_GRPC_ARES_EV_DRIVER_H
-#define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_DNS_C_ARES_GRPC_ARES_EV_DRIVER_H
+#ifndef GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_DNS_C_ARES_GRPC_ARES_EV_DRIVER_H
+#define GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_DNS_C_ARES_GRPC_ARES_EV_DRIVER_H
 
 #include <grpc/support/port_platform.h>
 
@@ -87,4 +87,4 @@ std::unique_ptr<GrpcPolledFdFactory> NewGrpcPolledFdFactory(Mutex* mu);
 
 }  // namespace grpc_core
 
-#endif  // GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_DNS_C_ARES_GRPC_ARES_EV_DRIVER_H
+#endif  // GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_DNS_C_ARES_GRPC_ARES_EV_DRIVER_H

data/src/core/ext/filters/client_channel/resolver/dns/c_ares/grpc_ares_ev_driver_windows.cc

@@ -747,7 +747,12 @@ class SockToPolledFdMap {
           protocol);
       return s;
     }
-    grpc_tcp_set_non_block(s);
+    grpc_error_handle error = grpc_tcp_set_non_block(s);
+    if (!error.ok()) {
+      GRPC_CARES_TRACE_LOG("WSAIoctl failed with error: %s",
+                           StatusToString(error).c_str());
+      return INVALID_SOCKET;
+    }
     GrpcPolledFdWindows* polled_fd =
         new GrpcPolledFdWindows(s, map->mu_, af, type);
     GRPC_CARES_TRACE_LOG(

data/src/core/ext/filters/client_channel/resolver/dns/c_ares/grpc_ares_wrapper.cc

@@ -19,6 +19,7 @@
 #include <grpc/support/port_platform.h>
 
 #include <algorithm>
+#include <initializer_list>
 #include <vector>
 
 #include "absl/strings/string_view.h"
@@ -453,8 +454,6 @@ static void grpc_ares_notify_on_event_locked(grpc_ares_ev_driver* ev_driver)
                                ev_driver->request,
                                fdn->grpc_polled_fd->GetName());
           grpc_ares_ev_driver_ref(ev_driver);
-          GRPC_CLOSURE_INIT(&fdn->write_closure, on_writable, fdn,
-                            grpc_schedule_on_exec_ctx);
           GRPC_CLOSURE_INIT(&fdn->write_closure, on_writable, fdn,
                             grpc_schedule_on_exec_ctx);
           fdn->grpc_polled_fd->RegisterForOnWriteableLocked(

data/src/core/ext/filters/client_channel/resolver/dns/c_ares/grpc_ares_wrapper.h

@@ -16,8 +16,8 @@
 //
 //
 
-#ifndef GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_DNS_C_ARES_GRPC_ARES_WRAPPER_H
-#define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_DNS_C_ARES_GRPC_ARES_WRAPPER_H
+#ifndef GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_DNS_C_ARES_GRPC_ARES_WRAPPER_H
+#define GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_DNS_C_ARES_GRPC_ARES_WRAPPER_H
 
 #include <grpc/support/port_platform.h>
 
@@ -133,4 +133,4 @@ void grpc_cares_wrapper_address_sorting_sort(
 // Exposed in this header for C-core tests only
 extern void (*grpc_ares_test_only_inject_config)(ares_channel channel);
 
-#endif  // GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_DNS_C_ARES_GRPC_ARES_WRAPPER_H
+#endif  // GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_DNS_C_ARES_GRPC_ARES_WRAPPER_H

data/src/core/ext/filters/client_channel/resolver/dns/dns_resolver_selection.h

@@ -16,8 +16,8 @@
 //
 //
 
-#ifndef GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_DNS_DNS_RESOLVER_SELECTION_H
-#define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_DNS_DNS_RESOLVER_SELECTION_H
+#ifndef GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_DNS_DNS_RESOLVER_SELECTION_H
+#define GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_DNS_DNS_RESOLVER_SELECTION_H
 
 #include <grpc/support/port_platform.h>
 
@@ -26,4 +26,4 @@
 
 GPR_GLOBAL_CONFIG_DECLARE_STRING(grpc_dns_resolver);
 
-#endif  // GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_DNS_DNS_RESOLVER_SELECTION_H
+#endif  // GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_DNS_DNS_RESOLVER_SELECTION_H

data/src/core/ext/filters/client_channel/resolver/fake/fake_resolver.h

@@ -14,8 +14,8 @@
 // limitations under the License.
 //
 
-#ifndef GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_FAKE_FAKE_RESOLVER_H
-#define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_FAKE_FAKE_RESOLVER_H
+#ifndef GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_FAKE_FAKE_RESOLVER_H
+#define GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_FAKE_FAKE_RESOLVER_H
 
 #include <grpc/support/port_platform.h>
 
@@ -107,4 +107,4 @@ class FakeResolverResponseGenerator
 
 }  // namespace grpc_core
 
-#endif  // GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_FAKE_FAKE_RESOLVER_H
+#endif  // GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_FAKE_FAKE_RESOLVER_H

data/src/core/ext/filters/client_channel/resolver/google_c2p/google_c2p_resolver.cc

@@ -19,6 +19,7 @@
 #include <string.h>
 
 #include <cstdint>
+#include <initializer_list>
 #include <memory>
 #include <random>
 #include <string>

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

@@ -14,8 +14,8 @@
 // limitations under the License.
 //
 
-#ifndef GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_POLLING_RESOLVER_H
-#define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_POLLING_RESOLVER_H
+#ifndef GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_POLLING_RESOLVER_H
+#define GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_POLLING_RESOLVER_H
 
 #include <grpc/support/port_platform.h>
 
@@ -118,4 +118,4 @@ class PollingResolver : public Resolver {
 
 }  // namespace grpc_core
 
-#endif  // GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_POLLING_RESOLVER_H
+#endif  // GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_POLLING_RESOLVER_H

data/src/core/ext/filters/client_channel/resolver/xds/xds_resolver.cc

@@ -21,6 +21,7 @@
 
 #include <algorithm>
 #include <cstdint>
+#include <initializer_list>
 #include <map>
 #include <memory>
 #include <string>
@@ -75,7 +76,6 @@
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/gprpp/work_serializer.h"
-#include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/iomgr_fwd.h"
 #include "src/core/lib/iomgr/pollset_set.h"
 #include "src/core/lib/resolver/resolver.h"
@@ -688,11 +688,8 @@ XdsResolver::XdsConfigSelector::GetCallConfig(GetCallConfigArgs args) {
       [&](const std::vector<
           XdsRouteConfigResource::Route::RouteAction::ClusterWeight>&
           /*weighted_clusters*/) {
-        const uint32_t key =
-            rand() %
-            entry
-                .weighted_cluster_state[entry.weighted_cluster_state.size() - 1]
-                .range_end;
+        const uint32_t key = absl::Uniform<uint32_t>(
+            absl::BitGen(), 0, entry.weighted_cluster_state.back().range_end);
         // Find the index in weighted clusters corresponding to key.
         size_t mid = 0;
         size_t start_index = 0;
@@ -777,7 +774,6 @@ XdsResolver::XdsConfigSelector::GetCallConfig(GetCallConfigArgs args) {
 //
 
 void XdsResolver::StartLocked() {
-  grpc_error_handle error;
   auto xds_client = GrpcXdsClient::GetOrCreate(args_, "xds resolver");
   if (!xds_client.ok()) {
     gpr_log(GPR_ERROR,

data/src/core/ext/filters/client_channel/resolver/xds/xds_resolver.h

@@ -14,8 +14,8 @@
 // limitations under the License.
 //
 
-#ifndef GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_XDS_XDS_RESOLVER_H
-#define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_XDS_XDS_RESOLVER_H
+#ifndef GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_XDS_XDS_RESOLVER_H
+#define GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_XDS_XDS_RESOLVER_H
 
 #include <grpc/support/port_platform.h>
 
@@ -27,4 +27,4 @@ UniqueTypeName XdsClusterAttributeTypeName();
 
 }  // namespace grpc_core
 
-#endif  // GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_XDS_XDS_RESOLVER_H
+#endif  // GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_XDS_XDS_RESOLVER_H

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

@@ -168,36 +168,33 @@ class RetryFilter {
                              const grpc_channel_info* /*info*/) {}
 
  private:
-  static size_t GetMaxPerRpcRetryBufferSize(const grpc_channel_args* args) {
-    return static_cast<size_t>(grpc_channel_args_find_integer(
-        args, GRPC_ARG_PER_RPC_RETRY_BUFFER_SIZE,
-        {DEFAULT_PER_RPC_RETRY_BUFFER_SIZE, 0, INT_MAX}));
+  static size_t GetMaxPerRpcRetryBufferSize(const ChannelArgs& args) {
+    return Clamp(args.GetInt(GRPC_ARG_PER_RPC_RETRY_BUFFER_SIZE)
+                     .value_or(DEFAULT_PER_RPC_RETRY_BUFFER_SIZE),
+                 0, INT_MAX);
   }
 
-  RetryFilter(const grpc_channel_args* args, grpc_error_handle* error)
-      : client_channel_(grpc_channel_args_find_pointer<ClientChannel>(
-            args, GRPC_ARG_CLIENT_CHANNEL)),
+  RetryFilter(const ChannelArgs& args, grpc_error_handle* error)
+      : client_channel_(args.GetObject<ClientChannel>()),
         per_rpc_retry_buffer_size_(GetMaxPerRpcRetryBufferSize(args)),
         service_config_parser_index_(
             internal::RetryServiceConfigParser::ParserIndex()) {
     // Get retry throttling parameters from service config.
-    auto* service_config = grpc_channel_args_find_pointer<ServiceConfig>(
-        args, GRPC_ARG_SERVICE_CONFIG_OBJ);
+    auto* service_config = args.GetObject<ServiceConfig>();
     if (service_config == nullptr) return;
     const auto* config = static_cast<const RetryGlobalConfig*>(
         service_config->GetGlobalParsedConfig(
             RetryServiceConfigParser::ParserIndex()));
     if (config == nullptr) return;
     // Get server name from target URI.
-    const char* server_uri =
-        grpc_channel_args_find_string(args, GRPC_ARG_SERVER_URI);
-    if (server_uri == nullptr) {
+    auto server_uri = args.GetString(GRPC_ARG_SERVER_URI);
+    if (!server_uri.has_value()) {
       *error = GRPC_ERROR_CREATE(
           "server URI channel arg missing or wrong type in client channel "
           "filter");
       return;
     }
-    absl::StatusOr<URI> uri = URI::Parse(server_uri);
+    absl::StatusOr<URI> uri = URI::Parse(*server_uri);
     if (!uri.ok() || uri->path().empty()) {
       *error =
           GRPC_ERROR_CREATE("could not extract server name from target URI");

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

@@ -14,8 +14,8 @@
 // limitations under the License.
 //
 
-#ifndef GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RETRY_FILTER_H
-#define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RETRY_FILTER_H
+#ifndef GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RETRY_FILTER_H
+#define GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RETRY_FILTER_H
 
 #include <grpc/support/port_platform.h>
 
@@ -28,4 +28,4 @@ extern const grpc_channel_filter kRetryFilterVtable;
 
 }  // namespace grpc_core
 
-#endif  // GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RETRY_FILTER_H
+#endif  // GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RETRY_FILTER_H

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

@@ -14,8 +14,8 @@
 // limitations under the License.
 //
 
-#ifndef GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RETRY_SERVICE_CONFIG_H
-#define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RETRY_SERVICE_CONFIG_H
+#ifndef GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RETRY_SERVICE_CONFIG_H
+#define GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RETRY_SERVICE_CONFIG_H
 
 #include <grpc/support/port_platform.h>
 
@@ -102,4 +102,4 @@ class RetryServiceConfigParser : public ServiceConfigParser::Parser {
 }  // namespace internal
 }  // namespace grpc_core
 
-#endif  // GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RETRY_SERVICE_CONFIG_H
+#endif  // GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RETRY_SERVICE_CONFIG_H

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

@@ -16,8 +16,8 @@
 //
 //
 
-#ifndef GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RETRY_THROTTLE_H
-#define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RETRY_THROTTLE_H
+#ifndef GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RETRY_THROTTLE_H
+#define GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RETRY_THROTTLE_H
 
 #include <grpc/support/port_platform.h>
 
@@ -89,4 +89,4 @@ class ServerRetryThrottleMap {
 }  // namespace internal
 }  // namespace grpc_core
 
-#endif  // GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RETRY_THROTTLE_H
+#endif  // GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RETRY_THROTTLE_H

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

@@ -54,11 +54,11 @@ class ServiceConfigChannelArgChannelData {
  public:
   explicit ServiceConfigChannelArgChannelData(
       const grpc_channel_element_args* args) {
-    const char* service_config_str = grpc_channel_args_find_string(
-        args->channel_args, GRPC_ARG_SERVICE_CONFIG);
-    if (service_config_str != nullptr) {
+    auto service_config_str =
+        args->channel_args.GetOwnedString(GRPC_ARG_SERVICE_CONFIG);
+    if (service_config_str.has_value()) {
       auto service_config = ServiceConfigImpl::Create(
-          ChannelArgs::FromC(args->channel_args), service_config_str);
+          args->channel_args, service_config_str->c_str());
       if (!service_config.ok()) {
         gpr_log(GPR_ERROR, "%s", service_config.status().ToString().c_str());
       } else {

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

@@ -879,6 +879,7 @@ void Subchannel::OnConnectingFinished(void* arg, grpc_error_handle error) {
 
 void Subchannel::OnConnectingFinishedLocked(grpc_error_handle error) {
   if (shutdown_) {
+    connecting_result_.Reset();
     return;
   }
   // If we didn't get a transport or we fail to publish it, report
@@ -926,12 +927,15 @@ bool Subchannel::PublishTransportLocked() {
   absl::StatusOr<RefCountedPtr<grpc_channel_stack>> stk = builder.Build();
   if (!stk.ok()) {
     auto error = absl_status_to_grpc_error(stk.status());
-    grpc_transport_destroy(connecting_result_.transport);
+    connecting_result_.Reset();
     gpr_log(GPR_ERROR,
             "subchannel %p %s: error initializing subchannel stack: %s", this,
             key_.ToString().c_str(), StatusToString(error).c_str());
     return false;
   }
+  // Release the ownership since it is now owned by the connected filter in the
+  // channel stack (published).
+  connecting_result_.transport = nullptr;
   RefCountedPtr<channelz::SocketNode> socket =
       std::move(connecting_result_.socket_node);
   connecting_result_.Reset();

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

@@ -14,8 +14,8 @@
 // limitations under the License.
 //
 
-#ifndef GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_SUBCHANNEL_H
-#define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_SUBCHANNEL_H
+#ifndef GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_SUBCHANNEL_H
+#define GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_SUBCHANNEL_H
 
 #include <grpc/support/port_platform.h>
 
@@ -409,4 +409,4 @@ class Subchannel : public DualRefCounted<Subchannel> {
 
 }  // namespace grpc_core
 
-#endif  // GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_SUBCHANNEL_H
+#endif  // GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_SUBCHANNEL_H

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

@@ -14,8 +14,8 @@
 // limitations under the License.
 //
 
-#ifndef GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_SUBCHANNEL_INTERFACE_INTERNAL_H
-#define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_SUBCHANNEL_INTERFACE_INTERNAL_H
+#ifndef GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_SUBCHANNEL_INTERFACE_INTERNAL_H
+#define GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_SUBCHANNEL_INTERFACE_INTERNAL_H
 
 #include <grpc/support/port_platform.h>
 
@@ -35,4 +35,4 @@ class InternalSubchannelDataWatcherInterface
 
 }  // namespace grpc_core
 
-#endif  // GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_SUBCHANNEL_INTERFACE_INTERNAL_H
+#endif  // GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_SUBCHANNEL_INTERFACE_INTERNAL_H

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

@@ -16,8 +16,8 @@
 //
 //
 
-#ifndef GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_SUBCHANNEL_POOL_INTERFACE_H
-#define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_SUBCHANNEL_POOL_INTERFACE_H
+#ifndef GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_SUBCHANNEL_POOL_INTERFACE_H
+#define GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_SUBCHANNEL_POOL_INTERFACE_H
 
 #include <grpc/support/port_platform.h>
 
@@ -97,4 +97,4 @@ class SubchannelPoolInterface : public RefCounted<SubchannelPoolInterface> {
 
 }  // namespace grpc_core
 
-#endif  // GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_SUBCHANNEL_POOL_INTERFACE_H
+#endif  // GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_SUBCHANNEL_POOL_INTERFACE_H

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

@@ -14,8 +14,8 @@
 // limitations under the License.
 //
 
-#ifndef GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_SUBCHANNEL_STREAM_CLIENT_H
-#define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_SUBCHANNEL_STREAM_CLIENT_H
+#ifndef GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_SUBCHANNEL_STREAM_CLIENT_H
+#define GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_SUBCHANNEL_STREAM_CLIENT_H
 
 #include <grpc/support/port_platform.h>
 
@@ -219,4 +219,4 @@ class SubchannelStreamClient
 
 }  // namespace grpc_core
 
-#endif  // GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_SUBCHANNEL_STREAM_CLIENT_H
+#endif  // GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_SUBCHANNEL_STREAM_CLIENT_H

data/src/core/ext/filters/deadline/deadline_filter.cc

@@ -51,9 +51,8 @@ namespace grpc_core {
 // Allocated on the call arena.
 class TimerState {
  public:
-  TimerState(grpc_call_element* elem, Timestamp deadline) : elem_(elem) {
-    grpc_deadline_state* deadline_state =
-        static_cast<grpc_deadline_state*>(elem_->call_data);
+  TimerState(grpc_deadline_state* deadline_state, Timestamp deadline)
+      : deadline_state_(deadline_state) {
     GRPC_CALL_STACK_REF(deadline_state->call_stack, "DeadlineTimerState");
     GRPC_CLOSURE_INIT(&closure_, TimerCallback, this, nullptr);
     grpc_timer_init(&timer_, deadline, &closure_);
@@ -66,11 +65,10 @@ class TimerState {
   // filter stack.  Yields the call combiner when the batch returns.
   static void YieldCallCombiner(void* arg, grpc_error_handle /*ignored*/) {
     TimerState* self = static_cast<TimerState*>(arg);
-    grpc_deadline_state* deadline_state =
-        static_cast<grpc_deadline_state*>(self->elem_->call_data);
-    GRPC_CALL_COMBINER_STOP(deadline_state->call_combiner,
+    GRPC_CALL_COMBINER_STOP(self->deadline_state_->call_combiner,
                             "got on_complete from cancel_stream batch");
-    GRPC_CALL_STACK_UNREF(deadline_state->call_stack, "DeadlineTimerState");
+    GRPC_CALL_STACK_UNREF(self->deadline_state_->call_stack,
+                          "DeadlineTimerState");
   }
 
   // This is called via the call combiner, so access to deadline_state is
@@ -81,26 +79,26 @@ class TimerState {
         GRPC_CLOSURE_INIT(&self->closure_, YieldCallCombiner, self, nullptr));
     batch->cancel_stream = true;
     batch->payload->cancel_stream.cancel_error = error;
-    self->elem_->filter->start_transport_stream_op_batch(self->elem_, batch);
+    grpc_call_element* elem = self->deadline_state_->elem;
+    elem->filter->start_transport_stream_op_batch(elem, batch);
   }
 
   // Timer callback.
   static void TimerCallback(void* arg, grpc_error_handle error) {
     TimerState* self = static_cast<TimerState*>(arg);
-    grpc_deadline_state* deadline_state =
-        static_cast<grpc_deadline_state*>(self->elem_->call_data);
     if (error != absl::CancelledError()) {
       error = grpc_error_set_int(GRPC_ERROR_CREATE("Deadline Exceeded"),
                                  StatusIntProperty::kRpcStatus,
                                  GRPC_STATUS_DEADLINE_EXCEEDED);
-      deadline_state->call_combiner->Cancel(error);
+      self->deadline_state_->call_combiner->Cancel(error);
       GRPC_CLOSURE_INIT(&self->closure_, SendCancelOpInCallCombiner, self,
                         nullptr);
-      GRPC_CALL_COMBINER_START(deadline_state->call_combiner, &self->closure_,
-                               error,
+      GRPC_CALL_COMBINER_START(self->deadline_state_->call_combiner,
+                               &self->closure_, error,
                                "deadline exceeded -- sending cancel_stream op");
     } else {
-      GRPC_CALL_STACK_UNREF(deadline_state->call_stack, "DeadlineTimerState");
+      GRPC_CALL_STACK_UNREF(self->deadline_state_->call_stack,
+                            "DeadlineTimerState");
     }
   }
 
@@ -111,7 +109,7 @@ class TimerState {
   // need to call the dtor only after both (a) the timer callback
   // finishes and (b) the filter sees the call completion and attempts
   // to cancel the timer.
-  grpc_call_element* elem_;
+  grpc_deadline_state* deadline_state_;
   grpc_timer timer_;
   grpc_closure closure_;
 };
@@ -125,14 +123,13 @@ class TimerState {
 // Starts the deadline timer.
 // This is called via the call combiner, so access to deadline_state is
 // synchronized.
-static void start_timer_if_needed(grpc_call_element* elem,
+static void start_timer_if_needed(grpc_deadline_state* deadline_state,
                                   grpc_core::Timestamp deadline) {
   if (deadline == grpc_core::Timestamp::InfFuture()) return;
-  grpc_deadline_state* deadline_state =
-      static_cast<grpc_deadline_state*>(elem->call_data);
   GPR_ASSERT(deadline_state->timer_state == nullptr);
   deadline_state->timer_state =
-      deadline_state->arena->New<grpc_core::TimerState>(elem, deadline);
+      deadline_state->arena->New<grpc_core::TimerState>(deadline_state,
+                                                        deadline);
 }
 
 // Cancels the deadline timer.
@@ -170,21 +167,22 @@ static void inject_recv_trailing_metadata_ready(
 // Callback and associated state for starting the timer after call stack
 // initialization has been completed.
 struct start_timer_after_init_state {
-  start_timer_after_init_state(grpc_call_element* elem,
+  start_timer_after_init_state(grpc_deadline_state* deadline_state,
                                grpc_core::Timestamp deadline)
-      : elem(elem), deadline(deadline) {}
-  ~start_timer_after_init_state() { start_timer_if_needed(elem, deadline); }
+      : deadline_state(deadline_state), deadline(deadline) {}
+  ~start_timer_after_init_state() {
+    start_timer_if_needed(deadline_state, deadline);
+  }
 
   bool in_call_combiner = false;
-  grpc_call_element* elem;
+  grpc_deadline_state* deadline_state;
   grpc_core::Timestamp deadline;
   grpc_closure closure;
 };
 static void start_timer_after_init(void* arg, grpc_error_handle error) {
   struct start_timer_after_init_state* state =
       static_cast<struct start_timer_after_init_state*>(arg);
-  grpc_deadline_state* deadline_state =
-      static_cast<grpc_deadline_state*>(state->elem->call_data);
+  grpc_deadline_state* deadline_state = state->deadline_state;
   if (!state->in_call_combiner) {
     // We are initially called without holding the call combiner, so we
     // need to bounce ourselves into it.
@@ -201,7 +199,8 @@ static void start_timer_after_init(void* arg, grpc_error_handle error) {
 grpc_deadline_state::grpc_deadline_state(grpc_call_element* elem,
                                          const grpc_call_element_args& args,
                                          grpc_core::Timestamp deadline)
-    : call_stack(args.call_stack),
+    : elem(elem),
+      call_stack(args.call_stack),
       call_combiner(args.call_combiner),
       arena(args.arena) {
   // Deadline will always be infinite on servers, so the timer will only be
@@ -215,7 +214,7 @@ grpc_deadline_state::grpc_deadline_state(grpc_call_element* elem,
     // create a closure to start the timer, and we schedule that closure
     // to be run after call stack initialization is done.
     struct start_timer_after_init_state* state =
-        new start_timer_after_init_state(elem, deadline);
+        new start_timer_after_init_state(this, deadline);
     GRPC_CLOSURE_INIT(&state->closure, start_timer_after_init, state,
                       grpc_schedule_on_exec_ctx);
     grpc_core::ExecCtx::Run(DEBUG_LOCATION, &state->closure, absl::OkStatus());
@@ -224,18 +223,14 @@ grpc_deadline_state::grpc_deadline_state(grpc_call_element* elem,
 
 grpc_deadline_state::~grpc_deadline_state() { cancel_timer_if_needed(this); }
 
-void grpc_deadline_state_reset(grpc_call_element* elem,
+void grpc_deadline_state_reset(grpc_deadline_state* deadline_state,
                                grpc_core::Timestamp new_deadline) {
-  grpc_deadline_state* deadline_state =
-      static_cast<grpc_deadline_state*>(elem->call_data);
   cancel_timer_if_needed(deadline_state);
-  start_timer_if_needed(elem, new_deadline);
+  start_timer_if_needed(deadline_state, new_deadline);
 }
 
 void grpc_deadline_state_client_start_transport_stream_op_batch(
-    grpc_call_element* elem, grpc_transport_stream_op_batch* op) {
-  grpc_deadline_state* deadline_state =
-      static_cast<grpc_deadline_state*>(elem->call_data);
+    grpc_deadline_state* deadline_state, grpc_transport_stream_op_batch* op) {
   if (op->cancel_stream) {
     cancel_timer_if_needed(deadline_state);
   } else {
@@ -261,14 +256,9 @@ static grpc_error_handle deadline_init_channel_elem(
 // Destructor for channel_data.  Used for both client and server filters.
 static void deadline_destroy_channel_elem(grpc_channel_element* /*elem*/) {}
 
-// Call data used for both client and server filter.
-typedef struct base_call_data {
-  grpc_deadline_state deadline_state;
-} base_call_data;
-
 // Additional call data used only for the server filter.
-typedef struct server_call_data {
-  base_call_data base;  // Must be first.
+struct server_call_data {
+  grpc_deadline_state deadline_state;  // Must be first.
   // The closure for receiving initial metadata.
   grpc_closure recv_initial_metadata_ready;
   // Received initial metadata batch.
@@ -276,7 +266,7 @@ typedef struct server_call_data {
   // The original recv_initial_metadata_ready closure, which we chain to
   // after our own closure is invoked.
   grpc_closure* next_recv_initial_metadata_ready;
-} server_call_data;
+};
 
 // Constructor for call_data.  Used for both client and server filters.
 static grpc_error_handle deadline_init_call_elem(
@@ -297,7 +287,8 @@ static void deadline_destroy_call_elem(
 // Method for starting a call op for client filter.
 static void deadline_client_start_transport_stream_op_batch(
     grpc_call_element* elem, grpc_transport_stream_op_batch* op) {
-  grpc_deadline_state_client_start_transport_stream_op_batch(elem, op);
+  grpc_deadline_state_client_start_transport_stream_op_batch(
+      static_cast<grpc_deadline_state*>(elem->call_data), op);
   // Chain to next filter.
   grpc_call_next_op(elem, op);
 }
@@ -307,8 +298,9 @@ static void recv_initial_metadata_ready(void* arg, grpc_error_handle error) {
   grpc_call_element* elem = static_cast<grpc_call_element*>(arg);
   server_call_data* calld = static_cast<server_call_data*>(elem->call_data);
   start_timer_if_needed(
-      elem, calld->recv_initial_metadata->get(grpc_core::GrpcTimeoutMetadata())
-                .value_or(grpc_core::Timestamp::InfFuture()));
+      &calld->deadline_state,
+      calld->recv_initial_metadata->get(grpc_core::GrpcTimeoutMetadata())
+          .value_or(grpc_core::Timestamp::InfFuture()));
   // Invoke the next callback.
   grpc_core::Closure::Run(DEBUG_LOCATION,
                           calld->next_recv_initial_metadata_ready, error);
@@ -319,7 +311,7 @@ static void deadline_server_start_transport_stream_op_batch(
     grpc_call_element* elem, grpc_transport_stream_op_batch* op) {
   server_call_data* calld = static_cast<server_call_data*>(elem->call_data);
   if (op->cancel_stream) {
-    cancel_timer_if_needed(&calld->base.deadline_state);
+    cancel_timer_if_needed(&calld->deadline_state);
   } else {
     // If we're receiving initial metadata, we need to get the deadline
     // from the recv_initial_metadata_ready callback.  So we inject our
@@ -341,7 +333,7 @@ static void deadline_server_start_transport_stream_op_batch(
     // the client never sends trailing metadata, because this is the
     // hook that tells us when the call is complete on the server side.
     if (op->recv_trailing_metadata) {
-      inject_recv_trailing_metadata_ready(&calld->base.deadline_state, op);
+      inject_recv_trailing_metadata_ready(&calld->deadline_state, op);
     }
   }
   // Chain to next filter.
@@ -355,7 +347,7 @@ const grpc_channel_filter grpc_client_deadline_filter = {
       return next_promise_factory(std::move(call_args));
     },
     grpc_channel_next_op,
-    sizeof(base_call_data),
+    sizeof(grpc_deadline_state),
     deadline_init_call_elem,
     grpc_call_stack_ignore_set_pollset_or_pollset_set,
     deadline_destroy_call_elem,