src compiles

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

@@ -913,7 +913,7 @@ void GrpcLb::BalancerCallState::MaybeSendClientLoadReport(void* arg,
                                                           grpc_error* error) {
   BalancerCallState* lb_calld = static_cast<BalancerCallState*>(arg);
   lb_calld->grpclb_policy()->combiner()->Run(
-      GRPC_CLOSURE_INIT(&client_load_report_closure_,
+      GRPC_CLOSURE_INIT(&lb_calld->client_load_report_closure_,
                         MaybeSendClientLoadReportLocked, lb_calld, nullptr),
       GRPC_ERROR_REF(error));
 }
@@ -998,8 +998,8 @@ void GrpcLb::BalancerCallState::ClientLoadReportDone(void* arg,
                                                      grpc_error* error) {
   BalancerCallState* lb_calld = static_cast<BalancerCallState*>(arg);
   lb_calld->grpclb_policy()->combiner()->Run(
-      GRPC_CLOSURE_INIT(&client_load_report_closure_, ClientLoadReportDone,
-                        this, nullptr),
+      GRPC_CLOSURE_INIT(&lb_calld->client_load_report_closure_,
+                        ClientLoadReportDone, lb_calld, nullptr),
       GRPC_ERROR_REF(error));
 }
 
@@ -1020,8 +1020,8 @@ void GrpcLb::BalancerCallState::OnInitialRequestSent(void* arg,
                                                      grpc_error* error) {
   BalancerCallState* lb_calld = static_cast<BalancerCallState*>(arg);
   lb_calld->grpclb_policy()->combiner()->Run(
-      GRPC_CLOSURE_INIT(&lb_on_initial_request_sent_,
-                        OnInitialRequestSentLocked, this, nullptr),
+      GRPC_CLOSURE_INIT(&lb_calld->lb_on_initial_request_sent_,
+                        OnInitialRequestSentLocked, lb_calld, nullptr),
       GRPC_ERROR_REF(error));
 }
 
@@ -1044,8 +1044,8 @@ void GrpcLb::BalancerCallState::OnBalancerMessageReceived(void* arg,
                                                           grpc_error* error) {
   BalancerCallState* lb_calld = static_cast<BalancerCallState*>(arg);
   lb_calld->grpclb_policy()->combiner()->Run(
-      GRPC_CLOSURE_INIT(&lb_on_balancer_message_received_,
-                        OnBalancerMessageReceivedLocked, this, nullptr),
+      GRPC_CLOSURE_INIT(&lb_calld->lb_on_balancer_message_received_,
+                        OnBalancerMessageReceivedLocked, lb_calld, nullptr),
       GRPC_ERROR_REF(error));
 }
 
@@ -1184,9 +1184,9 @@ void GrpcLb::BalancerCallState::OnBalancerMessageReceivedLocked(
     op.flags = 0;
     op.reserved = nullptr;
     // Reuse the "OnBalancerMessageReceivedLocked" ref taken in StartQuery().
-    GRPC_CLOSURE_INIT(&lb_on_balancer_message_received_,
+    GRPC_CLOSURE_INIT(&lb_calld->lb_on_balancer_message_received_,
                       GrpcLb::BalancerCallState::OnBalancerMessageReceived,
-                      this, grpc_schedule_on_exec_ctx);
+                      lb_calld, grpc_schedule_on_exec_ctx);
     const grpc_call_error call_error = grpc_call_start_batch_and_execute(
         lb_calld->lb_call_, &op, 1,
         &lb_calld->lb_on_balancer_message_received_);
@@ -1196,12 +1196,13 @@ void GrpcLb::BalancerCallState::OnBalancerMessageReceivedLocked(
   }
 }
 
-void GrpcLb::BalancerCallState::OnBalancerStatusReceivedLocked(
-    void* arg, grpc_error* error) {
+void GrpcLb::BalancerCallState::OnBalancerStatusReceived(void* arg,
+                                                         grpc_error* error) {
   BalancerCallState* lb_calld = static_cast<BalancerCallState*>(arg);
   lb_calld->grpclb_policy()->combiner()->Run(
-      GRPC_CLOSURE_INIT(&lb_on_balancer_status_received_,
-                        OnBalancerStatusReceivedLocked, this, nullptr));
+      GRPC_CLOSURE_INIT(&lb_calld->lb_on_balancer_status_received_,
+                        OnBalancerStatusReceivedLocked, lb_calld, nullptr),
+      GRPC_ERROR_REF(error));
 }
 
 void GrpcLb::BalancerCallState::OnBalancerStatusReceivedLocked(
@@ -1539,14 +1540,15 @@ void GrpcLb::OnBalancerChannelConnectivityChanged(void* arg,
                                                   grpc_error* error) {
   GrpcLb* self = static_cast<GrpcLb*>(arg);
   self->combiner()->Run(
-      GRPC_CLOSURE_INIT(&lb_channel_on_connectivity_changed_,
+      GRPC_CLOSURE_INIT(&self->lb_channel_on_connectivity_changed_,
                         &GrpcLb::OnBalancerChannelConnectivityChangedLocked,
-                        this, nullptr),
+                        self, nullptr),
       GRPC_ERROR_REF(error));
 }
 
 void GrpcLb::OnBalancerChannelConnectivityChangedLocked(void* arg,
                                                         grpc_error* error) {
+  GrpcLb* self = static_cast<GrpcLb*>(arg);
   if (!self->shutting_down_ && self->fallback_at_startup_checks_pending_) {
     if (self->lb_channel_connectivity_ != GRPC_CHANNEL_TRANSIENT_FAILURE) {
       // Not in TRANSIENT_FAILURE.  Renew connectivity watch.
@@ -1555,7 +1557,7 @@ void GrpcLb::OnBalancerChannelConnectivityChangedLocked(void* arg,
               grpc_channel_get_channel_stack(self->lb_channel_));
       GPR_ASSERT(client_channel_elem->filter == &grpc_client_channel_filter);
       GRPC_CLOSURE_INIT(&self->lb_channel_on_connectivity_changed_,
-                        &GrpcLb::OnBalancerChannelConnectivityChanged, this,
+                        &GrpcLb::OnBalancerChannelConnectivityChanged, self,
                         grpc_schedule_on_exec_ctx);
       grpc_client_channel_watch_connectivity_state(
           client_channel_elem,
@@ -1635,8 +1637,9 @@ void GrpcLb::StartBalancerCallRetryTimerLocked() {
 void GrpcLb::OnBalancerCallRetryTimer(void* arg, grpc_error* error) {
   GrpcLb* grpclb_policy = static_cast<GrpcLb*>(arg);
   grpclb_policy->combiner()->Run(
-      GRPC_CLOSURE_INIT(&lb_on_call_retry_,
-                        &GrpcLb::OnBalancerCallRetryTimerLocked, this, nullptr),
+      GRPC_CLOSURE_INIT(&grpclb_policy->lb_on_call_retry_,
+                        &GrpcLb::OnBalancerCallRetryTimerLocked, grpclb_policy,
+                        nullptr),
       GRPC_ERROR_REF(error));
 }
 
@@ -1676,11 +1679,11 @@ void GrpcLb::MaybeEnterFallbackModeAfterStartup() {
   }
 }
 
-void GrpcLb::OnFallbackTimerLocked(void* arg, grpc_error* error) {
+void GrpcLb::OnFallbackTimer(void* arg, grpc_error* error) {
   GrpcLb* grpclb_policy = static_cast<GrpcLb*>(arg);
   grpclb_policy->combiner()->Run(
-      GRPC_CLOSURE_INIT(&lb_on_fallback_, &GrpcLb::OnFallbackTimerLocked, this,
-                        nullptr),
+      GRPC_CLOSURE_INIT(&grpclb_policy->lb_on_fallback_,
+                        &GrpcLb::OnFallbackTimerLocked, grpclb_policy, nullptr),
       GRPC_ERROR_REF(error));
 }
 

src/core/ext/filters/client_channel/lb_policy/xds/xds.cc

@@ -826,8 +826,8 @@ void XdsLb::MaybeCancelFallbackAtStartupChecks() {
 void XdsLb::OnFallbackTimer(void* arg, grpc_error* error) {
   XdsLb* xdslb_policy = static_cast<XdsLb*>(arg);
   xdslb_policy->combiner()->Run(
-      GRPC_CLOSURE_INIT(&lb_on_fallback_, &XdsLb::OnFallbackTimerLocked, this,
-                        nullptr),
+      GRPC_CLOSURE_INIT(&xdslb_policy->lb_on_fallback_,
+                        &XdsLb::OnFallbackTimerLocked, xdslb_policy, nullptr),
       GRPC_ERROR_REF(error));
 }
 
@@ -1366,9 +1366,9 @@ void XdsLb::PriorityList::LocalityMap::UpdateConnectivityStateLocked() {
 void XdsLb::PriorityList::LocalityMap::OnDelayedRemovalTimer(
     void* arg, grpc_error* error) {
   LocalityMap* self = static_cast<LocalityMap*>(arg);
-  self->xds_policy_->combiner->Run(
-      GRPC_CLOSURE_INIT(&on_delayed_removal_timer_, OnDelayedRemovalTimerLocked,
-                        this, nullptr),
+  self->xds_policy_->combiner()->Run(
+      GRPC_CLOSURE_INIT(&self->on_delayed_removal_timer_,
+                        OnDelayedRemovalTimerLocked, self, nullptr),
       GRPC_ERROR_REF(error));
 }
 
@@ -1406,7 +1406,7 @@ void XdsLb::PriorityList::LocalityMap::OnFailoverTimer(void* arg,
                                                        grpc_error* error) {
   LocalityMap* self = static_cast<LocalityMap*>(arg);
   self->xds_policy_->combiner()->Run(
-      GRPC_CLOSURE_INIT(&on_failover_timer_, OnFailoverTimerLocked, this,
+      GRPC_CLOSURE_INIT(&self->on_failover_timer_, OnFailoverTimerLocked, self,
                         nullptr),
       GRPC_ERROR_REF(error));
 }
@@ -1665,8 +1665,8 @@ void XdsLb::PriorityList::LocalityMap::Locality::OnDelayedRemovalTimer(
     void* arg, grpc_error* error) {
   Locality* self = static_cast<Locality*>(arg);
   self->xds_policy()->combiner()->Run(
-      GRPC_CLOSURE_INIT(&on_delayed_removal_timer_, OnDelayedRemovalTimerLocked,
-                        this, nullptr),
+      GRPC_CLOSURE_INIT(&self->on_delayed_removal_timer_,
+                        OnDelayedRemovalTimerLocked, self, nullptr),
       GRPC_ERROR_REF(error));
 }
 

src/core/ext/filters/client_channel/resolver/dns/c_ares/dns_resolver_ares.cc

@@ -201,8 +201,8 @@ void AresDnsResolver::ShutdownLocked() {
 
 void AresDnsResolver::OnNextResolution(void* arg, grpc_error* error) {
   AresDnsResolver* r = static_cast<AresDnsResolver*>(arg);
-  r->combiner()->Run(GRPC_CLOSURE_INIT(&on_next_resolution_,
-                                       OnNextResolutionLocked, this, nullptr),
+  r->combiner()->Run(GRPC_CLOSURE_INIT(&r->on_next_resolution_,
+                                       OnNextResolutionLocked, r, nullptr),
                      GRPC_ERROR_REF(error));
 }
 
@@ -326,7 +326,7 @@ char* ChooseServiceConfig(char* service_config_choice_json,
 void AresDnsResolver::OnResolved(void* arg, grpc_error* error) {
   AresDnsResolver* r = static_cast<AresDnsResolver*>(arg);
   r->combiner()->Run(
-      GRPC_CLOSURE_INIT(&on_resolved_, OnResolvedLocked, this, nullptr),
+      GRPC_CLOSURE_INIT(&r->on_resolved_, OnResolvedLocked, r, nullptr),
       GRPC_ERROR_REF(error));
 }
 
@@ -386,7 +386,7 @@ void AresDnsResolver::OnResolvedLocked(void* arg, grpc_error* error) {
     } else {
       GRPC_CARES_TRACE_LOG("resolver:%p retrying immediately", r);
     }
-    GRPC_CLOSURE_INIT(&r->on_next_resolution_, OnNextResolution, this,
+    GRPC_CLOSURE_INIT(&r->on_next_resolution_, OnNextResolution, r,
                       grpc_schedule_on_exec_ctx);
     grpc_timer_init(&r->next_resolution_timer_, next_try,
                     &r->on_next_resolution_);
@@ -415,7 +415,7 @@ void AresDnsResolver::MaybeStartResolvingLocked() {
       // new closure API is done, find a way to track this ref with the timer
       // callback as part of the type system.
       Ref(DEBUG_LOCATION, "next_resolution_timer_cooldown").release();
-      GRPC_CLOSURE_INIT(&r->on_next_resolution_, OnNextResolution, this,
+      GRPC_CLOSURE_INIT(&on_next_resolution_, OnNextResolution, this,
                         grpc_schedule_on_exec_ctx);
       grpc_timer_init(&next_resolution_timer_,
                       ExecCtx::Get()->Now() + ms_until_next_resolution,

src/core/ext/filters/client_channel/resolver/dns/c_ares/grpc_ares_ev_driver.cc

@@ -67,7 +67,7 @@ struct grpc_ares_ev_driver {
   gpr_refcount refs;
 
   /** combiner to synchronize c-ares and I/O callbacks on */
-  Combiner* combiner;
+  grpc_core::Combiner* combiner;
   /** a list of grpc_fd that this event driver is currently using. */
   fd_node* fds;
   /** is this event driver currently working? */
@@ -146,7 +146,7 @@ void (*grpc_ares_test_only_inject_config)(ares_channel channel) =
 grpc_error* grpc_ares_ev_driver_create_locked(grpc_ares_ev_driver** ev_driver,
                                               grpc_pollset_set* pollset_set,
                                               int query_timeout_ms,
-                                              Combiner* combiner,
+                                              grpc_core::Combiner* combiner,
                                               grpc_ares_request* request) {
   *ev_driver = grpc_core::New<grpc_ares_ev_driver>();
   ares_options opts;
@@ -465,7 +465,7 @@ void grpc_ares_ev_driver_start_locked(grpc_ares_ev_driver* ev_driver) {
         "%" PRId64 " ms",
         ev_driver->request, ev_driver, timeout);
     grpc_ares_ev_driver_ref(ev_driver);
-    GRPC_CLOSURE_INIT(&(*ev_driver)->on_timeout_locked, on_timeout, *ev_driver,
+    GRPC_CLOSURE_INIT(&ev_driver->on_timeout_locked, on_timeout, ev_driver,
                       grpc_schedule_on_exec_ctx);
     grpc_timer_init(&ev_driver->query_timeout, timeout,
                     &ev_driver->on_timeout_locked);

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

@@ -43,7 +43,7 @@ ares_channel* grpc_ares_ev_driver_get_channel_locked(
 grpc_error* grpc_ares_ev_driver_create_locked(grpc_ares_ev_driver** ev_driver,
                                               grpc_pollset_set* pollset_set,
                                               int query_timeout_ms,
-                                              Combiner* combiner,
+                                              grpc_core::Combiner* combiner,
                                               grpc_ares_request* request);
 
 /* Called back when all DNS lookups have completed. */

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

@@ -350,7 +350,7 @@ done:
 void grpc_dns_lookup_ares_continue_after_check_localhost_and_ip_literals_locked(
     grpc_ares_request* r, const char* dns_server, const char* name,
     const char* default_port, grpc_pollset_set* interested_parties,
-    bool check_grpclb, int query_timeout_ms, Combiner* combiner) {
+    bool check_grpclb, int query_timeout_ms, grpc_core::Combiner* combiner) {
   grpc_error* error = GRPC_ERROR_NONE;
   grpc_ares_hostbyname_request* hr = nullptr;
   ares_channel* channel = nullptr;
@@ -590,7 +590,7 @@ static grpc_ares_request* grpc_dns_lookup_ares_locked_impl(
     grpc_pollset_set* interested_parties, grpc_closure* on_done,
     grpc_core::UniquePtr<grpc_core::ServerAddressList>* addrs,
     bool check_grpclb, char** service_config_json, int query_timeout_ms,
-    Combiner* combiner) {
+    grpc_core::Combiner* combiner) {
   grpc_ares_request* r =
       static_cast<grpc_ares_request*>(gpr_zalloc(sizeof(grpc_ares_request)));
   r->ev_driver = nullptr;
@@ -633,7 +633,7 @@ grpc_ares_request* (*grpc_dns_lookup_ares_locked)(
     grpc_pollset_set* interested_parties, grpc_closure* on_done,
     grpc_core::UniquePtr<grpc_core::ServerAddressList>* addrs,
     bool check_grpclb, char** service_config_json, int query_timeout_ms,
-    Combiner* combiner) = grpc_dns_lookup_ares_locked_impl;
+    grpc_core::Combiner* combiner) = grpc_dns_lookup_ares_locked_impl;
 
 static void grpc_cancel_ares_request_locked_impl(grpc_ares_request* r) {
   GPR_ASSERT(r != nullptr);
@@ -674,7 +674,7 @@ void grpc_ares_cleanup(void) {}
 
 typedef struct grpc_resolve_address_ares_request {
   /* combiner that queries and related callbacks run under */
-  Combiner* combiner;
+  grpc_core::Combiner* combiner;
   /** the pointer to receive the resolved addresses */
   grpc_resolved_addresses** addrs_out;
   /** currently resolving addresses */
@@ -694,14 +694,6 @@ typedef struct grpc_resolve_address_ares_request {
   grpc_ares_request* ares_request = nullptr;
 } grpc_resolve_address_ares_request;
 
-static void on_dns_lookup_done(void* arg, grpc_error* error) {
-  grpc_resolve_address_ares_request* r =
-      static_cast<grpc_resolve_address_ares_request*>(arg);
-  r->combiner->Run(GRPC_CLOSURE_INIT(&r->on_dns_lookup_done_locked,
-                                     on_dns_lookup_done_locked, r, nullptr),
-                   GRPC_ERROR_REF(error));
-}
-
 static void on_dns_lookup_done_locked(void* arg, grpc_error* error) {
   grpc_resolve_address_ares_request* r =
       static_cast<grpc_resolve_address_ares_request*>(arg);
@@ -727,6 +719,14 @@ static void on_dns_lookup_done_locked(void* arg, grpc_error* error) {
   grpc_core::Delete(r);
 }
 
+static void on_dns_lookup_done(void* arg, grpc_error* error) {
+  grpc_resolve_address_ares_request* r =
+      static_cast<grpc_resolve_address_ares_request*>(arg);
+  r->combiner->Run(GRPC_CLOSURE_INIT(&r->on_dns_lookup_done_locked,
+                                     on_dns_lookup_done_locked, r, nullptr),
+                   GRPC_ERROR_REF(error));
+}
+
 static void grpc_resolve_address_invoke_dns_lookup_ares_locked(
     void* arg, grpc_error* unused_error) {
   grpc_resolve_address_ares_request* r =

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

@@ -65,7 +65,7 @@ extern grpc_ares_request* (*grpc_dns_lookup_ares_locked)(
     grpc_pollset_set* interested_parties, grpc_closure* on_done,
     grpc_core::UniquePtr<grpc_core::ServerAddressList>* addresses,
     bool check_grpclb, char** service_config_json, int query_timeout_ms,
-    Combiner* combiner);
+    grpc_core::Combiner* combiner);
 
 /* Cancel the pending grpc_ares_request \a request */
 extern void (*grpc_cancel_ares_request_locked)(grpc_ares_request* request);

src/core/ext/filters/client_channel/resolver/dns/native/dns_resolver.cc

@@ -151,8 +151,7 @@ void NativeDnsResolver::OnNextResolution(void* arg, grpc_error* error) {
   NativeDnsResolver* r = static_cast<NativeDnsResolver*>(arg);
   r->combiner()->Run(
       GRPC_CLOSURE_INIT(&r->on_next_resolution_,
-                        NativeDnsResolver::OnNextResolutionLocked, this,
-                        nullptr),
+                        NativeDnsResolver::OnNextResolutionLocked, r, nullptr),
       GRPC_ERROR_REF(error));
 }
 
@@ -168,9 +167,9 @@ void NativeDnsResolver::OnNextResolutionLocked(void* arg, grpc_error* error) {
 void NativeDnsResolver::OnResolved(void* arg, grpc_error* error) {
   NativeDnsResolver* r = static_cast<NativeDnsResolver*>(arg);
   r->combiner()->Run(
-      GRPC_CLOSURE_INIT(&on_resolved_, NativeDnsResolver::OnResolvedLocked,
-                        this, nullptr),
-      GRPC_ERROR_REF(error))
+      GRPC_CLOSURE_INIT(&r->on_resolved_, NativeDnsResolver::OnResolvedLocked,
+                        r, nullptr),
+      GRPC_ERROR_REF(error));
 }
 
 void NativeDnsResolver::OnResolvedLocked(void* arg, grpc_error* error) {
@@ -217,7 +216,7 @@ void NativeDnsResolver::OnResolvedLocked(void* arg, grpc_error* error) {
       gpr_log(GPR_DEBUG, "retrying immediately");
     }
     GRPC_CLOSURE_INIT(&r->on_next_resolution_,
-                      NativeDnsResolver::OnNextResolution, this,
+                      NativeDnsResolver::OnNextResolution, r,
                       grpc_schedule_on_exec_ctx);
     grpc_timer_init(&r->next_resolution_timer_, next_try,
                     &r->on_next_resolution_);

src/core/ext/filters/client_channel/xds/xds_client.cc

@@ -516,7 +516,8 @@ void XdsClient::ChannelState::RetryableCall<T>::OnRetryTimer(
     void* arg, grpc_error* error) {
   RetryableCall* calld = static_cast<RetryableCall*>(arg);
   calld->chand_->xds_client()->combiner()->Run(
-      GRPC_CLOSURE_INIT(&on_retry_timer_, OnRetryTimerLocked, this, nullptr),
+      GRPC_CLOSURE_INIT(&calld->on_retry_timer_, OnRetryTimerLocked, calld,
+                        nullptr),
       GRPC_ERROR_REF(error));
 }
 
@@ -660,8 +661,8 @@ void XdsClient::ChannelState::AdsCallState::OnResponseReceived(
     void* arg, grpc_error* error) {
   AdsCallState* ads_calld = static_cast<AdsCallState*>(arg);
   ads_calld->xds_client()->combiner_->Run(
-      GRPC_CLOSURE_INIT(&on_response_received_, OnResponseReceivedLocked, this,
-                        nullptr),
+      GRPC_CLOSURE_INIT(&ads_calld->on_response_received_,
+                        OnResponseReceivedLocked, ads_calld, nullptr),
       GRPC_ERROR_REF(error));
   ;
 }
@@ -813,8 +814,8 @@ void XdsClient::ChannelState::AdsCallState::OnStatusReceived(
     void* arg, grpc_error* error) {
   AdsCallState* ads_calld = static_cast<AdsCallState*>(arg);
   ads_calld->xds_client()->combiner_->Run(
-      GRPC_CLOSURE_INIT(&on_status_received_, OnStatusReceivedLocked, this,
-                        nullptr),
+      GRPC_CLOSURE_INIT(&ads_calld->on_status_received_, OnStatusReceivedLocked,
+                        ads_calld, nullptr),
       GRPC_ERROR_REF(error));
 }
 
@@ -874,8 +875,8 @@ void XdsClient::ChannelState::LrsCallState::Reporter::OnNextReportTimer(
     void* arg, grpc_error* error) {
   Reporter* self = static_cast<Reporter*>(arg);
   self->xds_client()->combiner()->Run(
-      GRPC_CLOSURE_INIT(&on_next_report_timer_, OnNextReportTimerLocked, this,
-                        nullptr),
+      GRPC_CLOSURE_INIT(&self->on_next_report_timer_, OnNextReportTimerLocked,
+                        self, nullptr),
       GRPC_ERROR_REF(error));
 }
 
@@ -934,7 +935,8 @@ void XdsClient::ChannelState::LrsCallState::Reporter::OnReportDone(
     void* arg, grpc_error* error) {
   Reporter* self = static_cast<Reporter*>(arg);
   self->xds_client()->combiner_->Run(
-      GRPC_CLOSURE_INIT(&on_report_done_, OnReportDoneLocked, this, nullptr),
+      GRPC_CLOSURE_INIT(&self->on_report_done_, OnReportDoneLocked, self,
+                        nullptr),
       GRPC_ERROR_REF(error));
 }
 
@@ -1102,8 +1104,8 @@ void XdsClient::ChannelState::LrsCallState::OnInitialRequestSent(
     void* arg, grpc_error* error) {
   LrsCallState* lrs_calld = static_cast<LrsCallState*>(arg);
   lrs_calld->xds_client()->combiner_->Run(
-      GRPC_CLOSURE_INIT(&on_initial_request_sent_, OnInitialRequestSentLocked,
-                        this, nullptr),
+      GRPC_CLOSURE_INIT(&lrs_calld->on_initial_request_sent_,
+                        OnInitialRequestSentLocked, lrs_calld, nullptr),
       GRPC_ERROR_REF(error));
 }
 
@@ -1121,8 +1123,8 @@ void XdsClient::ChannelState::LrsCallState::OnResponseReceived(
     void* arg, grpc_error* error) {
   LrsCallState* lrs_calld = static_cast<LrsCallState*>(arg);
   lrs_calld->xds_client()->combiner_->Run(
-      GRPC_CLOSURE_INIT(&on_response_received_, OnResponseReceivedLocked, this,
-                        nullptr),
+      GRPC_CLOSURE_INIT(&lrs_calld->on_response_received_,
+                        OnResponseReceivedLocked, lrs_calld, nullptr),
       GRPC_ERROR_REF(error));
 }
 
@@ -1209,8 +1211,8 @@ void XdsClient::ChannelState::LrsCallState::OnResponseReceivedLocked(
   op.reserved = nullptr;
   GPR_ASSERT(lrs_calld->call_ != nullptr);
   // Reuse the "OnResponseReceivedLocked" ref taken in ctor.
-  GRPC_CLOSURE_INIT(&on_response_received_, OnResponseReceived, this,
-                    grpc_schedule_on_exec_ctx);
+  GRPC_CLOSURE_INIT(&lrs_calld->on_response_received_, OnResponseReceived,
+                    lrs_calld, grpc_schedule_on_exec_ctx);
   const grpc_call_error call_error = grpc_call_start_batch_and_execute(
       lrs_calld->call_, &op, 1, &lrs_calld->on_response_received_);
   GPR_ASSERT(GRPC_CALL_OK == call_error);
@@ -1220,8 +1222,8 @@ void XdsClient::ChannelState::LrsCallState::OnStatusReceived(
     void* arg, grpc_error* error) {
   LrsCallState* lrs_calld = static_cast<LrsCallState*>(arg);
   lrs_calld->xds_client()->combiner_->Run(
-      GRPC_CLOSURE_INIT(&on_status_received_, OnStatusReceivedLocked, this,
-                        nullptr),
+      GRPC_CLOSURE_INIT(&lrs_calld->on_status_received_, OnStatusReceivedLocked,
+                        lrs_calld, nullptr),
       GRPC_ERROR_REF(error));
 }