grpc 1.24.0 → 1.25.0.pre1

data/src/core/lib/surface/server.cc

@@ -34,9 +34,9 @@
 #include "src/core/lib/channel/channelz.h"
 #include "src/core/lib/channel/connected_channel.h"
 #include "src/core/lib/debug/stats.h"
-#include "src/core/lib/gpr/mpscq.h"
 #include "src/core/lib/gpr/spinlock.h"
 #include "src/core/lib/gpr/string.h"
+#include "src/core/lib/gprpp/mpscq.h"
 #include "src/core/lib/iomgr/executor.h"
 #include "src/core/lib/iomgr/iomgr.h"
 #include "src/core/lib/slice/slice_internal.h"
@@ -50,6 +50,8 @@
 
 grpc_core::TraceFlag grpc_server_channel_trace(false, "server_channel");
 
+using grpc_core::LockedMultiProducerSingleConsumerQueue;
+
 static void server_on_recv_initial_metadata(void* ptr, grpc_error* error);
 static void server_recv_trailing_metadata_ready(void* user_data,
                                                 grpc_error* error);
@@ -70,7 +72,9 @@ enum requested_call_type { BATCH_CALL, REGISTERED_CALL };
 struct registered_method;
 
 struct requested_call {
-  gpr_mpscq_node request_link; /* must be first */
+  grpc_core::ManualConstructor<
+      grpc_core::MultiProducerSingleConsumerQueue::Node>
+      mpscq_node;
   requested_call_type type;
   size_t cq_idx;
   void* tag;
@@ -95,13 +99,12 @@ struct channel_registered_method {
   registered_method* server_registered_method;
   uint32_t flags;
   bool has_host;
-  grpc_slice method;
-  grpc_slice host;
+  grpc_core::ExternallyManagedSlice method;
+  grpc_core::ExternallyManagedSlice host;
 };
 
 struct channel_data {
   grpc_server* server;
-  grpc_connectivity_state connectivity_state;
   grpc_channel* channel;
   size_t cq_idx;
   /* linked list of all channels on a server */
@@ -111,7 +114,6 @@ struct channel_data {
   uint32_t registered_method_slots;
   uint32_t registered_method_max_probes;
   grpc_closure finish_destroy_channel_closure;
-  grpc_closure channel_connectivity_changed;
   intptr_t channelz_socket_uuid;
 };
 
@@ -198,7 +200,7 @@ struct request_matcher {
   grpc_server* server;
   call_data* pending_head;
   call_data* pending_tail;
-  gpr_locked_mpscq* requests_per_cq;
+  LockedMultiProducerSingleConsumerQueue* requests_per_cq;
 };
 
 struct registered_method {
@@ -350,17 +352,17 @@ static void channel_broadcaster_shutdown(channel_broadcaster* cb,
 static void request_matcher_init(request_matcher* rm, grpc_server* server) {
   rm->server = server;
   rm->pending_head = rm->pending_tail = nullptr;
-  rm->requests_per_cq = static_cast<gpr_locked_mpscq*>(
+  rm->requests_per_cq = static_cast<LockedMultiProducerSingleConsumerQueue*>(
       gpr_malloc(sizeof(*rm->requests_per_cq) * server->cq_count));
   for (size_t i = 0; i < server->cq_count; i++) {
-    gpr_locked_mpscq_init(&rm->requests_per_cq[i]);
+    new (&rm->requests_per_cq[i]) LockedMultiProducerSingleConsumerQueue();
   }
 }
 
 static void request_matcher_destroy(request_matcher* rm) {
   for (size_t i = 0; i < rm->server->cq_count; i++) {
-    GPR_ASSERT(gpr_locked_mpscq_pop(&rm->requests_per_cq[i]) == nullptr);
-    gpr_locked_mpscq_destroy(&rm->requests_per_cq[i]);
+    GPR_ASSERT(rm->requests_per_cq[i].Pop() == nullptr);
+    rm->requests_per_cq[i].~LockedMultiProducerSingleConsumerQueue();
   }
   gpr_free(rm->requests_per_cq);
 }
@@ -389,7 +391,7 @@ static void request_matcher_kill_requests(grpc_server* server,
   requested_call* rc;
   for (size_t i = 0; i < server->cq_count; i++) {
     while ((rc = reinterpret_cast<requested_call*>(
-                gpr_locked_mpscq_pop(&rm->requests_per_cq[i]))) != nullptr) {
+                rm->requests_per_cq[i].Pop())) != nullptr) {
       fail_call(server, i, rc, GRPC_ERROR_REF(error));
     }
   }
@@ -454,7 +456,7 @@ static void finish_destroy_channel(void* cd, grpc_error* error) {
   server_unref(server);
 }
 
-static void destroy_channel(channel_data* chand, grpc_error* error) {
+static void destroy_channel(channel_data* chand) {
   if (is_channel_orphaned(chand)) return;
   GPR_ASSERT(chand->server != nullptr);
   orphan_channel(chand);
@@ -463,12 +465,9 @@ static void destroy_channel(channel_data* chand, grpc_error* error) {
   GRPC_CLOSURE_INIT(&chand->finish_destroy_channel_closure,
                     finish_destroy_channel, chand, grpc_schedule_on_exec_ctx);
 
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_server_channel_trace) &&
-      error != GRPC_ERROR_NONE) {
-    const char* msg = grpc_error_string(error);
-    gpr_log(GPR_INFO, "Disconnected client: %s", msg);
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_server_channel_trace)) {
+    gpr_log(GPR_INFO, "Disconnected client");
   }
-  GRPC_ERROR_UNREF(error);
 
   grpc_transport_op* op =
       grpc_make_transport_op(&chand->finish_destroy_channel_closure);
@@ -534,8 +533,8 @@ static void publish_new_rpc(void* arg, grpc_error* error) {
 
   for (size_t i = 0; i < server->cq_count; i++) {
     size_t cq_idx = (chand->cq_idx + i) % server->cq_count;
-    requested_call* rc = reinterpret_cast<requested_call*>(
-        gpr_locked_mpscq_try_pop(&rm->requests_per_cq[cq_idx]));
+    requested_call* rc =
+        reinterpret_cast<requested_call*>(rm->requests_per_cq[cq_idx].TryPop());
     if (rc == nullptr) {
       continue;
     } else {
@@ -556,8 +555,8 @@ static void publish_new_rpc(void* arg, grpc_error* error) {
   // added to the pending list.
   for (size_t i = 0; i < server->cq_count; i++) {
     size_t cq_idx = (chand->cq_idx + i) % server->cq_count;
-    requested_call* rc = reinterpret_cast<requested_call*>(
-        gpr_locked_mpscq_pop(&rm->requests_per_cq[cq_idx]));
+    requested_call* rc =
+        reinterpret_cast<requested_call*>(rm->requests_per_cq[cq_idx].Pop());
     if (rc == nullptr) {
       continue;
     } else {
@@ -631,8 +630,8 @@ static void start_new_rpc(grpc_call_element* elem) {
                                       chand->registered_method_slots];
       if (rm->server_registered_method == nullptr) break;
       if (!rm->has_host) continue;
-      if (!grpc_slice_eq(rm->host, calld->host)) continue;
-      if (!grpc_slice_eq(rm->method, calld->path)) continue;
+      if (rm->host != calld->host) continue;
+      if (rm->method != calld->path) continue;
       if ((rm->flags & GRPC_INITIAL_METADATA_IDEMPOTENT_REQUEST) &&
           0 == (calld->recv_initial_metadata_flags &
                 GRPC_INITIAL_METADATA_IDEMPOTENT_REQUEST)) {
@@ -649,7 +648,7 @@ static void start_new_rpc(grpc_call_element* elem) {
                                       chand->registered_method_slots];
       if (rm->server_registered_method == nullptr) break;
       if (rm->has_host) continue;
-      if (!grpc_slice_eq(rm->method, calld->path)) continue;
+      if (rm->method != calld->path) continue;
       if ((rm->flags & GRPC_INITIAL_METADATA_IDEMPOTENT_REQUEST) &&
           0 == (calld->recv_initial_metadata_flags &
                 GRPC_INITIAL_METADATA_IDEMPOTENT_REQUEST)) {
@@ -887,43 +886,25 @@ static void accept_stream(void* cd, grpc_transport* transport,
   grpc_call_start_batch_and_execute(call, &op, 1, &calld->got_initial_metadata);
 }
 
-static void channel_connectivity_changed(void* cd, grpc_error* error) {
-  channel_data* chand = static_cast<channel_data*>(cd);
-  grpc_server* server = chand->server;
-  if (chand->connectivity_state != GRPC_CHANNEL_SHUTDOWN) {
-    grpc_transport_op* op = grpc_make_transport_op(nullptr);
-    op->on_connectivity_state_change = &chand->channel_connectivity_changed;
-    op->connectivity_state = &chand->connectivity_state;
-    grpc_channel_next_op(grpc_channel_stack_element(
-                             grpc_channel_get_channel_stack(chand->channel), 0),
-                         op);
-  } else {
-    gpr_mu_lock(&server->mu_global);
-    destroy_channel(chand, GRPC_ERROR_REF(error));
-    gpr_mu_unlock(&server->mu_global);
-    GRPC_CHANNEL_INTERNAL_UNREF(chand->channel, "connectivity");
-  }
-}
-
-static grpc_error* init_call_elem(grpc_call_element* elem,
-                                  const grpc_call_element_args* args) {
+static grpc_error* server_init_call_elem(grpc_call_element* elem,
+                                         const grpc_call_element_args* args) {
   channel_data* chand = static_cast<channel_data*>(elem->channel_data);
   server_ref(chand->server);
   new (elem->call_data) call_data(elem, *args);
   return GRPC_ERROR_NONE;
 }
 
-static void destroy_call_elem(grpc_call_element* elem,
-                              const grpc_call_final_info* final_info,
-                              grpc_closure* ignored) {
+static void server_destroy_call_elem(grpc_call_element* elem,
+                                     const grpc_call_final_info* final_info,
+                                     grpc_closure* ignored) {
   call_data* calld = static_cast<call_data*>(elem->call_data);
   calld->~call_data();
   channel_data* chand = static_cast<channel_data*>(elem->channel_data);
   server_unref(chand->server);
 }
 
-static grpc_error* init_channel_elem(grpc_channel_element* elem,
-                                     grpc_channel_element_args* args) {
+static grpc_error* server_init_channel_elem(grpc_channel_element* elem,
+                                            grpc_channel_element_args* args) {
   channel_data* chand = static_cast<channel_data*>(elem->channel_data);
   GPR_ASSERT(args->is_first);
   GPR_ASSERT(!args->is_last);
@@ -931,21 +912,23 @@ static grpc_error* init_channel_elem(grpc_channel_element* elem,
   chand->channel = nullptr;
   chand->next = chand->prev = chand;
   chand->registered_methods = nullptr;
-  chand->connectivity_state = GRPC_CHANNEL_IDLE;
-  GRPC_CLOSURE_INIT(&chand->channel_connectivity_changed,
-                    channel_connectivity_changed, chand,
-                    grpc_schedule_on_exec_ctx);
   return GRPC_ERROR_NONE;
 }
 
-static void destroy_channel_elem(grpc_channel_element* elem) {
+static void server_destroy_channel_elem(grpc_channel_element* elem) {
   size_t i;
   channel_data* chand = static_cast<channel_data*>(elem->channel_data);
   if (chand->registered_methods) {
     for (i = 0; i < chand->registered_method_slots; i++) {
       grpc_slice_unref_internal(chand->registered_methods[i].method);
+      GPR_DEBUG_ASSERT(chand->registered_methods[i].method.refcount ==
+                           &grpc_core::kNoopRefcount ||
+                       chand->registered_methods[i].method.refcount == nullptr);
       if (chand->registered_methods[i].has_host) {
         grpc_slice_unref_internal(chand->registered_methods[i].host);
+        GPR_DEBUG_ASSERT(chand->registered_methods[i].host.refcount ==
+                             &grpc_core::kNoopRefcount ||
+                         chand->registered_methods[i].host.refcount == nullptr);
       }
     }
     gpr_free(chand->registered_methods);
@@ -970,12 +953,12 @@ const grpc_channel_filter grpc_server_top_filter = {
     server_start_transport_stream_op_batch,
     grpc_channel_next_op,
     sizeof(call_data),
-    init_call_elem,
+    server_init_call_elem,
     grpc_call_stack_ignore_set_pollset_or_pollset_set,
-    destroy_call_elem,
+    server_destroy_call_elem,
     sizeof(channel_data),
-    init_channel_elem,
-    destroy_channel_elem,
+    server_init_channel_elem,
+    server_destroy_channel_elem,
     grpc_channel_next_get_info,
     "server",
 };
@@ -1145,6 +1128,31 @@ void grpc_server_get_pollsets(grpc_server* server, grpc_pollset*** pollsets,
   *pollsets = server->pollsets;
 }
 
+class ConnectivityWatcher
+    : public grpc_core::AsyncConnectivityStateWatcherInterface {
+ public:
+  explicit ConnectivityWatcher(channel_data* chand) : chand_(chand) {
+    GRPC_CHANNEL_INTERNAL_REF(chand_->channel, "connectivity");
+  }
+
+  ~ConnectivityWatcher() {
+    GRPC_CHANNEL_INTERNAL_UNREF(chand_->channel, "connectivity");
+  }
+
+ private:
+  void OnConnectivityStateChange(grpc_connectivity_state new_state) override {
+    // Don't do anything until we are being shut down.
+    if (new_state != GRPC_CHANNEL_SHUTDOWN) return;
+    // Shut down channel.
+    grpc_server* server = chand_->server;
+    gpr_mu_lock(&server->mu_global);
+    destroy_channel(chand_);
+    gpr_mu_unlock(&server->mu_global);
+  }
+
+  channel_data* chand_;
+};
+
 void grpc_server_setup_transport(
     grpc_server* s, grpc_transport* transport, grpc_pollset* accepting_pollset,
     const grpc_channel_args* args,
@@ -1200,18 +1208,13 @@ void grpc_server_setup_transport(
     chand->registered_methods =
         static_cast<channel_registered_method*>(gpr_zalloc(alloc));
     for (rm = s->registered_methods; rm; rm = rm->next) {
-      grpc_slice host;
-      bool has_host;
-      grpc_slice method;
-      if (rm->host != nullptr) {
-        host = grpc_slice_from_static_string(rm->host);
-        has_host = true;
-      } else {
-        has_host = false;
+      grpc_core::ExternallyManagedSlice host;
+      grpc_core::ExternallyManagedSlice method(rm->method);
+      const bool has_host = rm->host != nullptr;
+      if (has_host) {
+        host = grpc_core::ExternallyManagedSlice(rm->host);
       }
-      method = grpc_slice_from_static_string(rm->method);
-      hash = GRPC_MDSTR_KV_HASH(has_host ? grpc_slice_hash_internal(host) : 0,
-                                grpc_slice_hash_internal(method));
+      hash = GRPC_MDSTR_KV_HASH(has_host ? host.Hash() : 0, method.Hash());
       for (probes = 0; chand->registered_methods[(hash + probes) % slots]
                            .server_registered_method != nullptr;
            probes++)
@@ -1237,13 +1240,12 @@ void grpc_server_setup_transport(
   chand->next->prev = chand->prev->next = chand;
   gpr_mu_unlock(&s->mu_global);
 
-  GRPC_CHANNEL_INTERNAL_REF(channel, "connectivity");
   op = grpc_make_transport_op(nullptr);
   op->set_accept_stream = true;
   op->set_accept_stream_fn = accept_stream;
   op->set_accept_stream_user_data = chand;
-  op->on_connectivity_state_change = &chand->channel_connectivity_changed;
-  op->connectivity_state = &chand->connectivity_state;
+  op->start_connectivity_watch.reset(
+      grpc_core::New<ConnectivityWatcher>(chand));
   if (gpr_atm_acq_load(&s->shutdown_flag) != 0) {
     op->disconnect_with_error =
         GRPC_ERROR_CREATE_FROM_STATIC_STRING("Server shutdown");
@@ -1430,13 +1432,12 @@ static grpc_call_error queue_call_request(grpc_server* server, size_t cq_idx,
       rm = &rc->data.registered.method->matcher;
       break;
   }
-  if (gpr_locked_mpscq_push(&rm->requests_per_cq[cq_idx], &rc->request_link)) {
+  if (rm->requests_per_cq[cq_idx].Push(rc->mpscq_node.get())) {
     /* this was the first queued request: we need to lock and start
        matching calls */
     gpr_mu_lock(&server->mu_call);
     while ((calld = rm->pending_head) != nullptr) {
-      rc = reinterpret_cast<requested_call*>(
-          gpr_locked_mpscq_pop(&rm->requests_per_cq[cq_idx]));
+      rc = reinterpret_cast<requested_call*>(rm->requests_per_cq[cq_idx].Pop());
       if (rc == nullptr) break;
       rm->pending_head = calld->pending_next;
       gpr_mu_unlock(&server->mu_call);

data/src/core/lib/surface/version.cc

@@ -25,4 +25,4 @@
 
 const char* grpc_version_string(void) { return "8.0.0"; }
 
-const char* grpc_g_stands_for(void) { return "ganges"; }
+const char* grpc_g_stands_for(void) { return "game"; }

data/src/core/lib/transport/byte_stream.h

@@ -22,7 +22,6 @@
 #include <grpc/support/port_platform.h>
 
 #include <grpc/slice_buffer.h>
-#include "src/core/lib/gprpp/abstract.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/iomgr/closure.h"
 
@@ -45,14 +44,13 @@ class ByteStream : public Orphanable {
   //
   // max_size_hint can be set as a hint as to the maximum number
   // of bytes that would be acceptable to read.
-  virtual bool Next(size_t max_size_hint,
-                    grpc_closure* on_complete) GRPC_ABSTRACT;
+  virtual bool Next(size_t max_size_hint, grpc_closure* on_complete) = 0;
 
   // Returns the next slice in the byte stream when it is available, as
   // indicated by Next().
   //
   // Once a slice is returned into *slice, it is owned by the caller.
-  virtual grpc_error* Pull(grpc_slice* slice) GRPC_ABSTRACT;
+  virtual grpc_error* Pull(grpc_slice* slice) = 0;
 
   // Shuts down the byte stream.
   //
@@ -61,15 +59,13 @@ class ByteStream : public Orphanable {
   //
   // The next call to Pull() (if any) will return the error passed to
   // Shutdown().
-  virtual void Shutdown(grpc_error* error) GRPC_ABSTRACT;
+  virtual void Shutdown(grpc_error* error) = 0;
 
   uint32_t length() const { return length_; }
   uint32_t flags() const { return flags_; }
 
   void set_flags(uint32_t flags) { flags_ = flags; }
 
-  GRPC_ABSTRACT_BASE_CLASS
-
  protected:
   ByteStream(uint32_t length, uint32_t flags)
       : length_(length), flags_(flags) {}

data/src/core/lib/transport/connectivity_state.cc

@@ -26,9 +26,14 @@
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
 
-grpc_core::TraceFlag grpc_connectivity_state_trace(false, "connectivity_state");
+#include "src/core/lib/iomgr/combiner.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
 
-const char* grpc_connectivity_state_name(grpc_connectivity_state state) {
+namespace grpc_core {
+
+TraceFlag grpc_connectivity_state_trace(false, "connectivity_state");
+
+const char* ConnectivityStateName(grpc_connectivity_state state) {
   switch (state) {
     case GRPC_CHANNEL_IDLE:
       return "IDLE";
@@ -44,122 +49,131 @@ const char* grpc_connectivity_state_name(grpc_connectivity_state state) {
   GPR_UNREACHABLE_CODE(return "UNKNOWN");
 }
 
-void grpc_connectivity_state_init(grpc_connectivity_state_tracker* tracker,
-                                  grpc_connectivity_state init_state,
-                                  const char* name) {
-  gpr_atm_no_barrier_store(&tracker->current_state_atm, init_state);
-  tracker->watchers = nullptr;
-  tracker->name = gpr_strdup(name);
-}
-
-void grpc_connectivity_state_destroy(grpc_connectivity_state_tracker* tracker) {
-  grpc_error* error;
-  grpc_connectivity_state_watcher* w;
-  while ((w = tracker->watchers)) {
-    tracker->watchers = w->next;
+//
+// AsyncConnectivityStateWatcherInterface
+//
 
-    if (GRPC_CHANNEL_SHUTDOWN != *w->current) {
-      *w->current = GRPC_CHANNEL_SHUTDOWN;
-      error = GRPC_ERROR_NONE;
+// A fire-and-forget class to asynchronously deliver a connectivity
+// state notification to a watcher.
+class AsyncConnectivityStateWatcherInterface::Notifier {
+ public:
+  Notifier(RefCountedPtr<AsyncConnectivityStateWatcherInterface> watcher,
+           grpc_connectivity_state state, Combiner* combiner)
+      : watcher_(std::move(watcher)), state_(state) {
+    if (combiner != nullptr) {
+      combiner->Run(
+          GRPC_CLOSURE_INIT(&closure_, SendNotification, this, nullptr),
+          GRPC_ERROR_NONE);
     } else {
-      error =
-          GRPC_ERROR_CREATE_FROM_STATIC_STRING("Shutdown connectivity owner");
+      GRPC_CLOSURE_INIT(&closure_, SendNotification, this,
+                        grpc_schedule_on_exec_ctx);
+      GRPC_CLOSURE_SCHED(&closure_, GRPC_ERROR_NONE);
     }
-    GRPC_CLOSURE_SCHED(w->notify, error);
-    gpr_free(w);
   }
-  gpr_free(tracker->name);
-}
 
-grpc_connectivity_state grpc_connectivity_state_check(
-    grpc_connectivity_state_tracker* tracker) {
-  grpc_connectivity_state cur = static_cast<grpc_connectivity_state>(
-      gpr_atm_no_barrier_load(&tracker->current_state_atm));
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_connectivity_state_trace)) {
-    gpr_log(GPR_INFO, "CONWATCH: %p %s: get %s", tracker, tracker->name,
-            grpc_connectivity_state_name(cur));
+ private:
+  static void SendNotification(void* arg, grpc_error* ignored) {
+    Notifier* self = static_cast<Notifier*>(arg);
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_connectivity_state_trace)) {
+      gpr_log(GPR_INFO, "watcher %p: delivering async notification for %s",
+              self->watcher_.get(), ConnectivityStateName(self->state_));
+    }
+    self->watcher_->OnConnectivityStateChange(self->state_);
+    Delete(self);
   }
-  return cur;
+
+  RefCountedPtr<AsyncConnectivityStateWatcherInterface> watcher_;
+  const grpc_connectivity_state state_;
+  grpc_closure closure_;
+};
+
+void AsyncConnectivityStateWatcherInterface::Notify(
+    grpc_connectivity_state state) {
+  New<Notifier>(Ref(), state, combiner_);  // Deletes itself when done.
 }
 
-bool grpc_connectivity_state_has_watchers(
-    grpc_connectivity_state_tracker* connectivity_state) {
-  return connectivity_state->watchers != nullptr;
+//
+// ConnectivityStateTracker
+//
+
+ConnectivityStateTracker::~ConnectivityStateTracker() {
+  grpc_connectivity_state current_state = state_.Load(MemoryOrder::RELAXED);
+  if (current_state == GRPC_CHANNEL_SHUTDOWN) return;
+  for (const auto& p : watchers_) {
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_connectivity_state_trace)) {
+      gpr_log(GPR_INFO,
+              "ConnectivityStateTracker %s[%p]: notifying watcher %p: %s -> %s",
+              name_, this, p.first, ConnectivityStateName(current_state),
+              ConnectivityStateName(GRPC_CHANNEL_SHUTDOWN));
+    }
+    p.second->Notify(GRPC_CHANNEL_SHUTDOWN);
+  }
 }
 
-bool grpc_connectivity_state_notify_on_state_change(
-    grpc_connectivity_state_tracker* tracker, grpc_connectivity_state* current,
-    grpc_closure* notify) {
-  grpc_connectivity_state cur = static_cast<grpc_connectivity_state>(
-      gpr_atm_no_barrier_load(&tracker->current_state_atm));
+void ConnectivityStateTracker::AddWatcher(
+    grpc_connectivity_state initial_state,
+    OrphanablePtr<ConnectivityStateWatcherInterface> watcher) {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_connectivity_state_trace)) {
-    if (current == nullptr) {
-      gpr_log(GPR_INFO, "CONWATCH: %p %s: unsubscribe notify=%p", tracker,
-              tracker->name, notify);
-    } else {
-      gpr_log(GPR_INFO, "CONWATCH: %p %s: from %s [cur=%s] notify=%p", tracker,
-              tracker->name, grpc_connectivity_state_name(*current),
-              grpc_connectivity_state_name(cur), notify);
-    }
+    gpr_log(GPR_INFO, "ConnectivityStateTracker %s[%p]: add watcher %p", name_,
+            this, watcher.get());
   }
-  if (current == nullptr) {
-    grpc_connectivity_state_watcher* w = tracker->watchers;
-    if (w != nullptr && w->notify == notify) {
-      GRPC_CLOSURE_SCHED(notify, GRPC_ERROR_CANCELLED);
-      tracker->watchers = w->next;
-      gpr_free(w);
-      return false;
-    }
-    while (w != nullptr) {
-      grpc_connectivity_state_watcher* rm_candidate = w->next;
-      if (rm_candidate != nullptr && rm_candidate->notify == notify) {
-        GRPC_CLOSURE_SCHED(notify, GRPC_ERROR_CANCELLED);
-        w->next = w->next->next;
-        gpr_free(rm_candidate);
-        return false;
-      }
-      w = w->next;
-    }
-    return false;
-  } else {
-    if (cur != *current) {
-      *current = cur;
-      GRPC_CLOSURE_SCHED(notify, GRPC_ERROR_NONE);
-    } else {
-      grpc_connectivity_state_watcher* w =
-          static_cast<grpc_connectivity_state_watcher*>(gpr_malloc(sizeof(*w)));
-      w->current = current;
-      w->notify = notify;
-      w->next = tracker->watchers;
-      tracker->watchers = w;
+  grpc_connectivity_state current_state = state_.Load(MemoryOrder::RELAXED);
+  if (initial_state != current_state) {
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_connectivity_state_trace)) {
+      gpr_log(GPR_INFO,
+              "ConnectivityStateTracker %s[%p]: notifying watcher %p: %s -> %s",
+              name_, this, watcher.get(), ConnectivityStateName(initial_state),
+              ConnectivityStateName(current_state));
     }
-    return cur == GRPC_CHANNEL_IDLE;
+    watcher->Notify(current_state);
+  }
+  // If we're in state SHUTDOWN, don't add the watcher, so that it will
+  // be orphaned immediately.
+  if (current_state != GRPC_CHANNEL_SHUTDOWN) {
+    watchers_.insert(std::make_pair(watcher.get(), std::move(watcher)));
   }
 }
 
-void grpc_connectivity_state_set(grpc_connectivity_state_tracker* tracker,
-                                 grpc_connectivity_state state,
-                                 const char* reason) {
-  grpc_connectivity_state cur = static_cast<grpc_connectivity_state>(
-      gpr_atm_no_barrier_load(&tracker->current_state_atm));
-  grpc_connectivity_state_watcher* w;
+void ConnectivityStateTracker::RemoveWatcher(
+    ConnectivityStateWatcherInterface* watcher) {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_connectivity_state_trace)) {
-    gpr_log(GPR_INFO, "SET: %p %s: %s --> %s [%s]", tracker, tracker->name,
-            grpc_connectivity_state_name(cur),
-            grpc_connectivity_state_name(state), reason);
+    gpr_log(GPR_INFO, "ConnectivityStateTracker %s[%p]: remove watcher %p",
+            name_, this, watcher);
   }
-  if (cur == state) {
-    return;
+  watchers_.erase(watcher);
+}
+
+void ConnectivityStateTracker::SetState(grpc_connectivity_state state,
+                                        const char* reason) {
+  grpc_connectivity_state current_state = state_.Load(MemoryOrder::RELAXED);
+  if (state == current_state) return;
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_connectivity_state_trace)) {
+    gpr_log(GPR_INFO, "ConnectivityStateTracker %s[%p]: %s -> %s (%s)", name_,
+            this, ConnectivityStateName(current_state),
+            ConnectivityStateName(state), reason);
   }
-  GPR_ASSERT(cur != GRPC_CHANNEL_SHUTDOWN);
-  gpr_atm_no_barrier_store(&tracker->current_state_atm, state);
-  while ((w = tracker->watchers) != nullptr) {
-    *w->current = state;
-    tracker->watchers = w->next;
+  state_.Store(state, MemoryOrder::RELAXED);
+  for (const auto& p : watchers_) {
     if (GRPC_TRACE_FLAG_ENABLED(grpc_connectivity_state_trace)) {
-      gpr_log(GPR_INFO, "NOTIFY: %p %s: %p", tracker, tracker->name, w->notify);
+      gpr_log(GPR_INFO,
+              "ConnectivityStateTracker %s[%p]: notifying watcher %p: %s -> %s",
+              name_, this, p.first, ConnectivityStateName(current_state),
+              ConnectivityStateName(state));
     }
-    GRPC_CLOSURE_SCHED(w->notify, GRPC_ERROR_NONE);
-    gpr_free(w);
+    p.second->Notify(state);
   }
+  // If the new state is SHUTDOWN, orphan all of the watchers.  This
+  // avoids the need for the callers to explicitly cancel them.
+  if (state == GRPC_CHANNEL_SHUTDOWN) watchers_.clear();
 }
+
+grpc_connectivity_state ConnectivityStateTracker::state() const {
+  grpc_connectivity_state state = state_.Load(MemoryOrder::RELAXED);
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_connectivity_state_trace)) {
+    gpr_log(GPR_INFO, "ConnectivityStateTracker %s[%p]: get current state: %s",
+            name_, this, ConnectivityStateName(state));
+  }
+  return state;
+}
+
+}  // namespace grpc_core