grpc 1.69.0 → 1.71.0

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

@@ -17,7 +17,8 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "absl/types/optional.h"
+#include <optional>
+
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/promise/activity.h"
 #include "src/core/lib/promise/poll.h"
@@ -110,6 +111,9 @@ class CallState {
   // Return true if server trailing metadata has been pushed *and* that push was
   // a cancellation.
   bool WasCancelledPushed() const;
+  // Resolves after server trailing metadata has been pushed, regardless of
+  // whether the call was cancelled.
+  Poll<Empty> PollServerTrailingMetadataWasPushed();
 
   /////////////////////////////////////////////////////////////////////////////
   // Debug
@@ -242,6 +246,7 @@ class CallState {
   }
   enum class ServerToClientPushState : uint16_t {
     kStart,
+    kPushedMessageWithoutInitialMetadata,
     kPushedServerInitialMetadata,
     kPushedServerInitialMetadataAndPushedMessage,
     kTrailersOnly,
@@ -254,6 +259,8 @@ class CallState {
     switch (state) {
       case ServerToClientPushState::kStart:
         return "Start";
+      case ServerToClientPushState::kPushedMessageWithoutInitialMetadata:
+        return "PushedMessageWithoutInitialMetadata";
       case ServerToClientPushState::kPushedServerInitialMetadata:
         return "PushedServerInitialMetadata";
       case ServerToClientPushState::
@@ -347,7 +354,8 @@ GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline void CallState::Start() {
     case ServerToClientPullState::kIdle:
     case ServerToClientPullState::kReading:
     case ServerToClientPullState::kProcessingServerToClientMessage:
-      LOG(FATAL) << "Start called twice";
+      LOG(FATAL) << "Start called twice; "
+                 << GRPC_DUMP_ARGS(server_to_client_pull_state_);
     case ServerToClientPullState::kTerminated:
       break;
   }
@@ -357,7 +365,8 @@ GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline void
 CallState::BeginPushClientToServerMessage() {
   GRPC_TRACE_LOG(call_state, INFO)
       << "[call_state] BeginPushClientToServerMessage: "
-      << GRPC_DUMP_ARGS(this, client_to_server_push_state_);
+      << GRPC_DUMP_ARGS(this, client_to_server_push_state_,
+                        client_to_server_push_waiter_);
   switch (client_to_server_push_state_) {
     case ClientToServerPushState::kIdle:
       client_to_server_push_state_ = ClientToServerPushState::kPushedMessage;
@@ -365,10 +374,12 @@ CallState::BeginPushClientToServerMessage() {
       break;
     case ClientToServerPushState::kPushedMessage:
     case ClientToServerPushState::kPushedMessageAndHalfClosed:
-      LOG(FATAL) << "PushClientToServerMessage called twice concurrently";
+      LOG(FATAL) << "PushClientToServerMessage called twice concurrently;"
+                 << GRPC_DUMP_ARGS(client_to_server_push_state_);
       break;
     case ClientToServerPushState::kPushedHalfClose:
-      LOG(FATAL) << "PushClientToServerMessage called after half-close";
+      LOG(FATAL) << "PushClientToServerMessage called after half-close; "
+                 << GRPC_DUMP_ARGS(client_to_server_push_state_);
       break;
     case ClientToServerPushState::kFinished:
       break;
@@ -409,7 +420,8 @@ CallState::ClientToServerHalfClose() {
       break;
     case ClientToServerPushState::kPushedHalfClose:
     case ClientToServerPushState::kPushedMessageAndHalfClosed:
-      LOG(FATAL) << "ClientToServerHalfClose called twice";
+      LOG(FATAL) << "ClientToServerHalfClose called twice;"
+                 << GRPC_DUMP_ARGS(client_to_server_push_state_);
       break;
     case ClientToServerPushState::kFinished:
       break;
@@ -430,7 +442,8 @@ CallState::BeginPullClientInitialMetadata() {
     case ClientToServerPullState::kIdle:
     case ClientToServerPullState::kReading:
     case ClientToServerPullState::kProcessingClientToServerMessage:
-      LOG(FATAL) << "BeginPullClientInitialMetadata called twice";
+      LOG(FATAL) << "BeginPullClientInitialMetadata called twice; "
+                 << GRPC_DUMP_ARGS(client_to_server_pull_state_);
       break;
     case ClientToServerPullState::kTerminated:
       break;
@@ -444,7 +457,8 @@ CallState::FinishPullClientInitialMetadata() {
       << GRPC_DUMP_ARGS(this, client_to_server_pull_state_);
   switch (client_to_server_pull_state_) {
     case ClientToServerPullState::kBegin:
-      LOG(FATAL) << "FinishPullClientInitialMetadata called before Begin";
+      LOG(FATAL) << "FinishPullClientInitialMetadata called before Begin; "
+                 << GRPC_DUMP_ARGS(client_to_server_pull_state_);
       break;
     case ClientToServerPullState::kProcessingClientInitialMetadata:
       client_to_server_pull_state_ = ClientToServerPullState::kIdle;
@@ -453,7 +467,8 @@ CallState::FinishPullClientInitialMetadata() {
     case ClientToServerPullState::kIdle:
     case ClientToServerPullState::kReading:
     case ClientToServerPullState::kProcessingClientToServerMessage:
-      LOG(FATAL) << "Out of order FinishPullClientInitialMetadata";
+      LOG(FATAL) << "Out of order FinishPullClientInitialMetadata"
+                 << GRPC_DUMP_ARGS(client_to_server_pull_state_);
       break;
     case ClientToServerPullState::kTerminated:
       break;
@@ -473,12 +488,13 @@ CallState::PollPullClientToServerMessageAvailable() {
     case ClientToServerPullState::kIdle:
       client_to_server_pull_state_ = ClientToServerPullState::kReading;
       client_to_server_pull_waiter_.Wake();
-      ABSL_FALLTHROUGH_INTENDED;
+      [[fallthrough]];
     case ClientToServerPullState::kReading:
       break;
     case ClientToServerPullState::kProcessingClientToServerMessage:
       LOG(FATAL) << "PollPullClientToServerMessageAvailable called while "
-                    "processing a message";
+                    "processing a message; "
+                 << GRPC_DUMP_ARGS(client_to_server_pull_state_);
       break;
     case ClientToServerPullState::kTerminated:
       return Failure{};
@@ -529,14 +545,20 @@ CallState::FinishPullClientToServerMessage() {
   switch (client_to_server_pull_state_) {
     case ClientToServerPullState::kBegin:
     case ClientToServerPullState::kProcessingClientInitialMetadata:
-      LOG(FATAL) << "FinishPullClientToServerMessage called before Begin";
+      LOG(FATAL) << "FinishPullClientToServerMessage called before Begin; "
+                 << GRPC_DUMP_ARGS(client_to_server_pull_state_,
+                                   client_to_server_push_state_);
       break;
     case ClientToServerPullState::kIdle:
-      LOG(FATAL) << "FinishPullClientToServerMessage called twice";
+      LOG(FATAL) << "FinishPullClientToServerMessage called twice; "
+                 << GRPC_DUMP_ARGS(client_to_server_pull_state_,
+                                   client_to_server_push_state_);
       break;
     case ClientToServerPullState::kReading:
       LOG(FATAL) << "FinishPullClientToServerMessage called before "
-                    "PollPullClientToServerMessageAvailable";
+                    "PollPullClientToServerMessageAvailable; "
+                 << GRPC_DUMP_ARGS(client_to_server_pull_state_,
+                                   client_to_server_push_state_);
       break;
     case ClientToServerPullState::kProcessingClientToServerMessage:
       client_to_server_pull_state_ = ClientToServerPullState::kIdle;
@@ -552,7 +574,9 @@ CallState::FinishPullClientToServerMessage() {
       break;
     case ClientToServerPushState::kIdle:
     case ClientToServerPushState::kPushedHalfClose:
-      LOG(FATAL) << "FinishPullClientToServerMessage called without a message";
+      LOG(FATAL) << "FinishPullClientToServerMessage called without a message; "
+                 << GRPC_DUMP_ARGS(client_to_server_pull_state_,
+                                   client_to_server_push_state_);
       break;
     case ClientToServerPushState::kPushedMessageAndHalfClosed:
       client_to_server_push_state_ = ClientToServerPushState::kPushedHalfClose;
@@ -573,9 +597,26 @@ CallState::PushServerInitialMetadata() {
       ServerTrailingMetadataState::kNotPushed) {
     return Failure{};
   }
-  CHECK_EQ(server_to_client_push_state_, ServerToClientPushState::kStart);
-  server_to_client_push_state_ =
-      ServerToClientPushState::kPushedServerInitialMetadata;
+  switch (server_to_client_push_state_) {
+    case ServerToClientPushState::kStart:
+      server_to_client_push_state_ =
+          ServerToClientPushState::kPushedServerInitialMetadata;
+      break;
+    case ServerToClientPushState::kPushedMessageWithoutInitialMetadata:
+      server_to_client_push_state_ =
+          ServerToClientPushState::kPushedServerInitialMetadataAndPushedMessage;
+      break;
+    case ServerToClientPushState::kPushedServerInitialMetadata:
+    case ServerToClientPushState::kPushedServerInitialMetadataAndPushedMessage:
+    case ServerToClientPushState::kTrailersOnly:
+    case ServerToClientPushState::kIdle:
+    case ServerToClientPushState::kPushedMessage:
+      LOG(FATAL) << "PushServerInitialMetadata called twice; "
+                 << GRPC_DUMP_ARGS(server_to_client_push_state_);
+      break;
+    case ServerToClientPushState::kFinished:
+      break;
+  }
   server_to_client_push_waiter_.Wake();
   return Success{};
 }
@@ -587,16 +628,18 @@ CallState::BeginPushServerToClientMessage() {
       << GRPC_DUMP_ARGS(this, server_to_client_push_state_);
   switch (server_to_client_push_state_) {
     case ServerToClientPushState::kStart:
-      LOG(FATAL) << "BeginPushServerToClientMessage called before "
-                    "PushServerInitialMetadata";
+      server_to_client_push_state_ =
+          ServerToClientPushState::kPushedMessageWithoutInitialMetadata;
       break;
     case ServerToClientPushState::kPushedServerInitialMetadata:
       server_to_client_push_state_ =
           ServerToClientPushState::kPushedServerInitialMetadataAndPushedMessage;
       break;
     case ServerToClientPushState::kPushedServerInitialMetadataAndPushedMessage:
+    case ServerToClientPushState::kPushedMessageWithoutInitialMetadata:
     case ServerToClientPushState::kPushedMessage:
-      LOG(FATAL) << "BeginPushServerToClientMessage called twice concurrently";
+      LOG(FATAL) << "BeginPushServerToClientMessage called twice concurrently; "
+                 << GRPC_DUMP_ARGS(server_to_client_push_state_);
       break;
     case ServerToClientPushState::kTrailersOnly:
       // Will fail in poll.
@@ -619,9 +662,11 @@ CallState::PollPushServerToClientMessage() {
     case ServerToClientPushState::kStart:
     case ServerToClientPushState::kPushedServerInitialMetadata:
       LOG(FATAL) << "PollPushServerToClientMessage called before "
-                 << "PushServerInitialMetadata";
+                 << "PushServerInitialMetadata; "
+                 << GRPC_DUMP_ARGS(server_to_client_push_state_);
     case ServerToClientPushState::kTrailersOnly:
       return false;
+    case ServerToClientPushState::kPushedMessageWithoutInitialMetadata:
     case ServerToClientPushState::kPushedMessage:
     case ServerToClientPushState::kPushedServerInitialMetadataAndPushedMessage:
       return server_to_client_push_waiter_.pending();
@@ -640,7 +685,7 @@ CallState::PushServerTrailingMetadata(bool cancel) {
       << GRPC_DUMP_ARGS(this, cancel, server_trailing_metadata_state_,
                         server_to_client_push_state_,
                         client_to_server_push_state_,
-                        server_trailing_metadata_waiter_.DebugString());
+                        server_trailing_metadata_waiter_);
   if (server_trailing_metadata_state_ !=
       ServerTrailingMetadataState::kNotPushed) {
     return false;
@@ -657,6 +702,7 @@ CallState::PushServerTrailingMetadata(bool cancel) {
     case ServerToClientPushState::kPushedServerInitialMetadata:
     case ServerToClientPushState::kPushedServerInitialMetadataAndPushedMessage:
     case ServerToClientPushState::kPushedMessage:
+    case ServerToClientPushState::kPushedMessageWithoutInitialMetadata:
       if (cancel) {
         server_to_client_push_state_ = ServerToClientPushState::kFinished;
         server_to_client_push_waiter_.Wake();
@@ -717,7 +763,9 @@ CallState::PollPullServerInitialMetadataAvailable() {
     case ServerToClientPullState::kIdle:
     case ServerToClientPullState::kReading:
     case ServerToClientPullState::kProcessingServerToClientMessage:
-      LOG(FATAL) << "PollPullServerInitialMetadataAvailable called twice";
+      LOG(FATAL) << "PollPullServerInitialMetadataAvailable called twice; "
+                 << GRPC_DUMP_ARGS(server_to_client_pull_state_,
+                                   server_to_client_push_state_);
     case ServerToClientPullState::kTerminated:
       return false;
   }
@@ -727,6 +775,7 @@ CallState::PollPullServerInitialMetadataAvailable() {
       << server_to_client_pull_state_;
   switch (server_to_client_push_state_) {
     case ServerToClientPushState::kStart:
+    case ServerToClientPushState::kPushedMessageWithoutInitialMetadata:
       return server_to_client_push_waiter_.pending();
     case ServerToClientPushState::kPushedServerInitialMetadata:
     case ServerToClientPushState::kPushedServerInitialMetadataAndPushedMessage:
@@ -739,7 +788,9 @@ CallState::PollPullServerInitialMetadataAvailable() {
     case ServerToClientPushState::kIdle:
     case ServerToClientPushState::kPushedMessage:
       LOG(FATAL)
-          << "PollPullServerInitialMetadataAvailable after metadata processed";
+          << "PollPullServerInitialMetadataAvailable after metadata processed; "
+          << GRPC_DUMP_ARGS(server_to_client_pull_state_,
+                            server_to_client_push_state_);
     case ServerToClientPushState::kFinished:
       server_to_client_pull_state_ = ServerToClientPullState::kTerminated;
       server_to_client_pull_waiter_.Wake();
@@ -775,7 +826,9 @@ CallState::FinishPullServerInitialMetadata() {
     case ServerToClientPullState::kIdle:
     case ServerToClientPullState::kReading:
     case ServerToClientPullState::kProcessingServerToClientMessage:
-      LOG(FATAL) << "Out of order FinishPullServerInitialMetadata";
+      LOG(FATAL) << "Out of order FinishPullServerInitialMetadata; "
+                 << GRPC_DUMP_ARGS(server_to_client_pull_state_,
+                                   server_to_client_push_state_);
     case ServerToClientPullState::kTerminated:
       return;
   }
@@ -784,8 +837,11 @@ CallState::FinishPullServerInitialMetadata() {
       << server_to_client_pull_state_;
   switch (server_to_client_push_state_) {
     case ServerToClientPushState::kStart:
+    case ServerToClientPushState::kPushedMessageWithoutInitialMetadata:
       LOG(FATAL) << "FinishPullServerInitialMetadata called before initial "
-                    "metadata consumed";
+                    "metadata consumed; "
+                 << GRPC_DUMP_ARGS(server_to_client_pull_state_,
+                                   server_to_client_push_state_);
     case ServerToClientPushState::kPushedServerInitialMetadata:
       server_to_client_push_state_ = ServerToClientPushState::kIdle;
       server_to_client_push_waiter_.Wake();
@@ -798,7 +854,9 @@ CallState::FinishPullServerInitialMetadata() {
     case ServerToClientPushState::kPushedMessage:
     case ServerToClientPushState::kTrailersOnly:
     case ServerToClientPushState::kFinished:
-      LOG(FATAL) << "FinishPullServerInitialMetadata called twice";
+      LOG(FATAL) << "FinishPullServerInitialMetadata called twice; "
+                 << GRPC_DUMP_ARGS(server_to_client_pull_state_,
+                                   server_to_client_push_state_);
   }
 }
 
@@ -822,7 +880,7 @@ CallState::PollPullServerToClientMessageAvailable() {
       return server_to_client_pull_waiter_.pending();
     case ServerToClientPullState::kStarted:
       server_to_client_pull_state_ = ServerToClientPullState::kStartedReading;
-      ABSL_FALLTHROUGH_INTENDED;
+      [[fallthrough]];
     case ServerToClientPullState::kStartedReading:
       if (server_to_client_push_state_ ==
           ServerToClientPushState::kTrailersOnly) {
@@ -832,18 +890,21 @@ CallState::PollPullServerToClientMessageAvailable() {
     case ServerToClientPullState::kIdle:
       server_to_client_pull_state_ = ServerToClientPullState::kReading;
       server_to_client_pull_waiter_.Wake();
-      ABSL_FALLTHROUGH_INTENDED;
+      [[fallthrough]];
     case ServerToClientPullState::kReading:
       break;
     case ServerToClientPullState::kProcessingServerToClientMessage:
       LOG(FATAL) << "PollPullServerToClientMessageAvailable called while "
-                    "processing a message";
+                    "processing a message; "
+                 << GRPC_DUMP_ARGS(server_to_client_pull_state_,
+                                   server_to_client_push_state_);
     case ServerToClientPullState::kTerminated:
       return Failure{};
   }
   DCHECK_EQ(server_to_client_pull_state_, ServerToClientPullState::kReading);
   switch (server_to_client_push_state_) {
     case ServerToClientPushState::kStart:
+    case ServerToClientPushState::kPushedMessageWithoutInitialMetadata:
     case ServerToClientPushState::kPushedServerInitialMetadata:
     case ServerToClientPushState::kPushedServerInitialMetadataAndPushedMessage:
       return server_to_client_push_waiter_.pending();
@@ -907,13 +968,19 @@ CallState::FinishPullServerToClientMessage() {
     case ServerToClientPullState::kStartedReading:
     case ServerToClientPullState::kProcessingServerInitialMetadata:
     case ServerToClientPullState::kProcessingServerInitialMetadataReading:
-      LOG(FATAL)
-          << "FinishPullServerToClientMessage called before metadata available";
+      LOG(FATAL) << "FinishPullServerToClientMessage called before metadata "
+                    "available; "
+                 << GRPC_DUMP_ARGS(server_to_client_pull_state_,
+                                   server_to_client_push_state_);
     case ServerToClientPullState::kIdle:
-      LOG(FATAL) << "FinishPullServerToClientMessage called twice";
+      LOG(FATAL) << "FinishPullServerToClientMessage called twice; "
+                 << GRPC_DUMP_ARGS(server_to_client_pull_state_,
+                                   server_to_client_push_state_);
     case ServerToClientPullState::kReading:
       LOG(FATAL) << "FinishPullServerToClientMessage called before "
-                 << "PollPullServerToClientMessageAvailable";
+                 << "PollPullServerToClientMessageAvailable; "
+                 << GRPC_DUMP_ARGS(server_to_client_pull_state_,
+                                   server_to_client_push_state_);
     case ServerToClientPullState::kProcessingServerToClientMessage:
       server_to_client_pull_state_ = ServerToClientPullState::kIdle;
       server_to_client_pull_waiter_.Wake();
@@ -922,20 +989,27 @@ CallState::FinishPullServerToClientMessage() {
       break;
   }
   switch (server_to_client_push_state_) {
+    case ServerToClientPushState::kPushedMessageWithoutInitialMetadata:
     case ServerToClientPushState::kPushedServerInitialMetadataAndPushedMessage:
     case ServerToClientPushState::kPushedServerInitialMetadata:
     case ServerToClientPushState::kStart:
       LOG(FATAL) << "FinishPullServerToClientMessage called before initial "
-                    "metadata consumed";
+                    "metadata consumed; "
+                 << GRPC_DUMP_ARGS(server_to_client_pull_state_,
+                                   server_to_client_push_state_);
     case ServerToClientPushState::kTrailersOnly:
       LOG(FATAL) << "FinishPullServerToClientMessage called after "
-                    "PushServerTrailingMetadata";
+                    "PushServerTrailingMetadata; "
+                 << GRPC_DUMP_ARGS(server_to_client_pull_state_,
+                                   server_to_client_push_state_);
     case ServerToClientPushState::kPushedMessage:
       server_to_client_push_state_ = ServerToClientPushState::kIdle;
       server_to_client_push_waiter_.Wake();
       break;
     case ServerToClientPushState::kIdle:
-      LOG(FATAL) << "FinishPullServerToClientMessage called without a message";
+      LOG(FATAL) << "FinishPullServerToClientMessage called without a message; "
+                 << GRPC_DUMP_ARGS(server_to_client_pull_state_,
+                                   server_to_client_push_state_);
     case ServerToClientPushState::kFinished:
       break;
   }
@@ -945,10 +1019,9 @@ GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline Poll<Empty>
 CallState::PollServerTrailingMetadataAvailable() {
   GRPC_TRACE_LOG(call_state, INFO)
       << "[call_state] PollServerTrailingMetadataAvailable: "
-      << GRPC_DUMP_ARGS(this, server_to_client_pull_state_,
-                        server_to_client_push_state_,
-                        server_trailing_metadata_state_,
-                        server_trailing_metadata_waiter_.DebugString());
+      << GRPC_DUMP_ARGS(
+             this, server_to_client_pull_state_, server_to_client_push_state_,
+             server_trailing_metadata_state_, server_trailing_metadata_waiter_);
   switch (server_to_client_pull_state_) {
     case ServerToClientPullState::kProcessingServerInitialMetadata:
     case ServerToClientPullState::kProcessingServerToClientMessage:
@@ -966,7 +1039,8 @@ CallState::PollServerTrailingMetadataAvailable() {
               ServerTrailingMetadataState::kNotPushed) {
             break;  // Ready for processing
           }
-          ABSL_FALLTHROUGH_INTENDED;
+          [[fallthrough]];
+        case ServerToClientPushState::kPushedMessageWithoutInitialMetadata:
         case ServerToClientPushState::kPushedServerInitialMetadata:
         case ServerToClientPushState::
             kPushedServerInitialMetadataAndPushedMessage:
@@ -1001,7 +1075,9 @@ CallState::PollServerTrailingMetadataAvailable() {
     case ServerTrailingMetadataState::kNotPushed:
     case ServerTrailingMetadataState::kPulled:
     case ServerTrailingMetadataState::kPulledCancel:
-      LOG(FATAL) << "PollServerTrailingMetadataAvailable completed twice";
+      LOG(FATAL) << "PollServerTrailingMetadataAvailable completed twice; "
+                 << GRPC_DUMP_ARGS(server_to_client_pull_state_,
+                                   server_trailing_metadata_state_);
   }
   return Empty{};
 }
@@ -1027,12 +1103,11 @@ CallState::PollWasCancelled() {
       << GRPC_DUMP_ARGS(this, server_trailing_metadata_state_);
   switch (server_trailing_metadata_state_) {
     case ServerTrailingMetadataState::kNotPushed:
-    case ServerTrailingMetadataState::kPushed:
-    case ServerTrailingMetadataState::kPushedCancel: {
       return server_trailing_metadata_waiter_.pending();
-    }
+    case ServerTrailingMetadataState::kPushed:
     case ServerTrailingMetadataState::kPulled:
       return false;
+    case ServerTrailingMetadataState::kPushedCancel:
     case ServerTrailingMetadataState::kPulledCancel:
       return true;
   }
@@ -1056,6 +1131,24 @@ GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline bool CallState::WasCancelledPushed()
   Crash("Unreachable");
 }
 
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline Poll<Empty>
+CallState::PollServerTrailingMetadataWasPushed() {
+  GRPC_TRACE_LOG(call_state, INFO)
+      << "[call_state] PollWasCancelled: "
+      << GRPC_DUMP_ARGS(this, server_trailing_metadata_state_);
+  switch (server_trailing_metadata_state_) {
+    case ServerTrailingMetadataState::kNotPushed: {
+      return server_trailing_metadata_waiter_.pending();
+    }
+    case ServerTrailingMetadataState::kPushed:
+    case ServerTrailingMetadataState::kPushedCancel:
+    case ServerTrailingMetadataState::kPulled:
+    case ServerTrailingMetadataState::kPulledCancel:
+      return Empty{};
+  }
+  Crash("Unreachable");
+}
+
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_LIB_TRANSPORT_CALL_STATE_H

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

@@ -59,8 +59,7 @@ class AsyncConnectivityStateWatcherInterface::Notifier {
       : watcher_(std::move(watcher)), state_(state), status_(status) {
     if (work_serializer != nullptr) {
       work_serializer->Run(
-          [this]() { SendNotification(this, absl::OkStatus()); },
-          DEBUG_LOCATION);
+          [this]() { SendNotification(this, absl::OkStatus()); });
     } else {
       GRPC_CLOSURE_INIT(&closure_, SendNotification, this,
                         grpc_schedule_on_exec_ctx);
@@ -101,13 +100,13 @@ ConnectivityStateTracker::~ConnectivityStateTracker() {
   grpc_connectivity_state current_state =
       state_.load(std::memory_order_relaxed);
   if (current_state == GRPC_CHANNEL_SHUTDOWN) return;
-  for (const auto& p : watchers_) {
+  for (const auto& watcher : watchers_) {
     GRPC_TRACE_LOG(connectivity_state, INFO)
         << "ConnectivityStateTracker " << name_ << "[" << this
-        << "]: notifying watcher " << p.first << ": "
+        << "]: notifying watcher " << watcher.get() << ": "
         << ConnectivityStateName(current_state) << " -> "
         << ConnectivityStateName(GRPC_CHANNEL_SHUTDOWN);
-    p.second->Notify(GRPC_CHANNEL_SHUTDOWN, absl::Status());
+    watcher->Notify(GRPC_CHANNEL_SHUTDOWN, absl::Status());
   }
 }
 
@@ -130,7 +129,7 @@ void ConnectivityStateTracker::AddWatcher(
   // 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)));
+    watchers_.insert(std::move(watcher));
   }
 }
 
@@ -155,13 +154,13 @@ void ConnectivityStateTracker::SetState(grpc_connectivity_state state,
       << status.ToString() << ")";
   state_.store(state, std::memory_order_relaxed);
   status_ = status;
-  for (const auto& p : watchers_) {
+  for (const auto& watcher : watchers_) {
     GRPC_TRACE_LOG(connectivity_state, INFO)
         << "ConnectivityStateTracker " << name_ << "[" << this
-        << "]: notifying watcher " << p.first << ": "
+        << "]: notifying watcher " << watcher.get() << ": "
         << ConnectivityStateName(current_state) << " -> "
         << ConnectivityStateName(state);
-    p.second->Notify(state, status);
+    watcher->Notify(state, status);
   }
   // If the new state is SHUTDOWN, orphan all of the watchers.  This
   // avoids the need for the callers to explicitly cancel them.

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

@@ -27,6 +27,7 @@
 #include <memory>
 #include <utility>
 
+#include "absl/container/flat_hash_set.h"
 #include "absl/status/status.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/util/orphanable.h"
@@ -132,10 +133,7 @@ class ConnectivityStateTracker {
   const char* name_;
   std::atomic<grpc_connectivity_state> state_{grpc_connectivity_state()};
   absl::Status status_;
-  // TODO(roth): Once we can use C++-14 heterogeneous lookups, this can
-  // be a set instead of a map.
-  std::map<ConnectivityStateWatcherInterface*,
-           OrphanablePtr<ConnectivityStateWatcherInterface>>
+  absl::flat_hash_set<OrphanablePtr<ConnectivityStateWatcherInterface>>
       watchers_;
 };
 

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

@@ -19,8 +19,10 @@
 #ifndef GRPC_SRC_CORE_LIB_TRANSPORT_HTTP2_ERRORS_H
 #define GRPC_SRC_CORE_LIB_TRANSPORT_HTTP2_ERRORS_H
 
+#include <cstdint>
+
 // error codes for RST_STREAM from http2 draft 14 section 7
-typedef enum {
+enum grpc_http2_error_code : uint32_t {
   GRPC_HTTP2_NO_ERROR = 0x0,
   GRPC_HTTP2_PROTOCOL_ERROR = 0x1,
   GRPC_HTTP2_INTERNAL_ERROR = 0x2,
@@ -35,7 +37,7 @@ typedef enum {
   GRPC_HTTP2_ENHANCE_YOUR_CALM = 0xb,
   GRPC_HTTP2_INADEQUATE_SECURITY = 0xc,
   // force use of a default clause
-  GRPC_HTTP2__ERROR_DO_NOT_USE = -1
-} grpc_http2_error_code;
+  GRPC_HTTP2__ERROR_DO_NOT_USE = 0xffffffffu
+};
 
 #endif  // GRPC_SRC_CORE_LIB_TRANSPORT_HTTP2_ERRORS_H

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

@@ -18,6 +18,7 @@
 
 #include <cstddef>
 
+#include "src/core/lib/debug/trace.h"
 #include "src/core/lib/transport/call_destination.h"
 #include "src/core/lib/transport/call_filters.h"
 #include "src/core/lib/transport/call_spine.h"
@@ -44,6 +45,13 @@ CallInitiator HijackedCall::MakeCallWithMetadata(
   return std::move(call.initiator);
 }
 
+CallInitiator Interceptor::MakeChildCall(ClientMetadataHandle metadata,
+                                         RefCountedPtr<Arena> arena) {
+  auto call = MakeCallPair(std::move(metadata), arena);
+  wrapped_destination_->StartCall(std::move(call.handler));
+  return std::move(call.initiator);
+}
+
 namespace {
 class CallStarter final : public UnstartedCallDestination {
  public: