grpc 1.68.1 → 1.69.0.pre1

data/src/core/lib/security/context/security_context.h

@@ -33,7 +33,9 @@
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/security/credentials/credentials.h"  // IWYU pragma: keep
+#include "src/core/lib/surface/connection_context.h"
 #include "src/core/util/debug_location.h"
+#include "src/core/util/orphanable.h"
 #include "src/core/util/ref_counted.h"
 #include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/useful.h"
@@ -77,6 +79,7 @@ struct grpc_auth_context
     if (chained_ != nullptr) {
       peer_identity_property_name_ = chained_->peer_identity_property_name_;
     }
+    connection_context_ = grpc_core::ConnectionContext::Create();
   }
 
   ~grpc_auth_context() {
@@ -98,6 +101,10 @@ struct grpc_auth_context
   const grpc_auth_context* chained() const { return chained_.get(); }
   const grpc_auth_property_array& properties() const { return properties_; }
 
+  grpc_core::ConnectionContext* connection_context() const {
+    return connection_context_.get();
+  }
+
   bool is_authenticated() const {
     return peer_identity_property_name_ != nullptr;
   }
@@ -120,6 +127,7 @@ struct grpc_auth_context
   grpc_auth_property_array properties_;
   const char* peer_identity_property_name_ = nullptr;
   std::unique_ptr<Extension> extension_;
+  grpc_core::OrphanablePtr<grpc_core::ConnectionContext> connection_context_;
 };
 
 // --- grpc_security_context_extension ---

data/src/core/lib/security/credentials/channel_creds_registry_init.cc

@@ -29,7 +29,7 @@
 #include <utility>
 
 #include "absl/strings/string_view.h"
-#include "src/core/lib/config/core_configuration.h"
+#include "src/core/config/core_configuration.h"
 #include "src/core/lib/security/credentials/channel_creds_registry.h"
 #include "src/core/lib/security/credentials/credentials.h"
 #include "src/core/lib/security/credentials/fake/fake_credentials.h"

data/src/core/lib/security/credentials/external/external_account_credentials.cc

@@ -229,15 +229,16 @@ void ExternalAccountCredentials::ExternalFetchRequest::ExchangeToken(
         }
         body_parts.push_back(
             absl::StrFormat("scope=%s", UrlEncode(scope).c_str()));
-        Json::Object addtional_options_json_object;
+        Json::Object additional_options_json_object;
         if (options().client_id.empty() && options().client_secret.empty()) {
-          addtional_options_json_object["userProject"] =
+          additional_options_json_object["userProject"] =
               Json::FromString(options().workforce_pool_user_project);
         }
-        Json addtional_options_json =
-            Json::FromObject(std::move(addtional_options_json_object));
+        Json additional_options_json =
+            Json::FromObject(std::move(additional_options_json_object));
         body_parts.push_back(absl::StrFormat(
-            "options=%s", UrlEncode(JsonDump(addtional_options_json)).c_str()));
+            "options=%s",
+            UrlEncode(JsonDump(additional_options_json)).c_str()));
         std::string body = absl::StrJoin(body_parts, "&");
         request.body = const_cast<char*>(body.c_str());
         request.body_length = body.size();

data/src/core/lib/security/credentials/fake/fake_credentials.h

@@ -82,7 +82,7 @@ grpc_server_credentials* grpc_fake_transport_security_server_credentials_create(
 // For LB channels:
 //     "backend_target_1,backend_target_2,...;lb_target_1,lb_target_2,..."
 // For regular channels:
-//     "backend_taget_1,backend_target_2,..."
+//     "backend_target_1,backend_target_2,..."
 //
 // That is to say, LB channels have a heading list of LB targets separated from
 // the list of backend targets by a semicolon. For non-LB channels, only the

data/src/core/lib/security/credentials/google_default/google_default_credentials.cc

@@ -143,7 +143,7 @@ grpc_google_default_channel_credentials::create_security_connector(
           ? alts_creds_->create_security_connector(call_creds, target, args)
           : ssl_creds_->create_security_connector(call_creds, target, args);
   // grpclb-specific channel args are removed from the channel args set
-  // to ensure backends and fallback adresses will have the same set of channel
+  // to ensure backends and fallback addresses will have the same set of channel
   // args. By doing that, it guarantees the connections to backends will not be
   // torn down and re-connected when switching in and out of fallback mode.
   //

data/src/core/lib/security/credentials/jwt/jwt_verifier.cc

@@ -325,7 +325,7 @@ grpc_jwt_verifier_status grpc_jwt_claims_check(const grpc_jwt_claims* claims,
     return GRPC_JWT_VERIFIER_TIME_CONSTRAINT_FAILURE;
   }
 
-  // This should be probably up to the upper layer to decide but let's harcode
+  // This should be probably up to the upper layer to decide but let's hardcode
   // the 99% use case here for email issuers, where the JWT must be self
   // issued.
   if (grpc_jwt_issuer_email_domain(claims->iss) != nullptr &&

data/src/core/lib/security/credentials/token_fetcher/token_fetcher_credentials.cc

@@ -58,8 +58,8 @@ void TokenFetcherCredentials::Token::AddTokenToClientInitialMetadata(
 //
 
 TokenFetcherCredentials::FetchState::BackoffTimer::BackoffTimer(
-    RefCountedPtr<FetchState> fetch_state)
-    : fetch_state_(std::move(fetch_state)) {
+    RefCountedPtr<FetchState> fetch_state, absl::Status status)
+    : fetch_state_(std::move(fetch_state)), status_(status) {
   const Duration delay = fetch_state_->backoff_.NextAttemptDelay();
   GRPC_TRACE_LOG(token_fetcher_credentials, INFO)
       << "[TokenFetcherCredentials " << fetch_state_->creds_.get()
@@ -100,24 +100,13 @@ void TokenFetcherCredentials::FetchState::BackoffTimer::OnTimer() {
       << "[TokenFetcherCredentials " << fetch_state_->creds_.get()
       << "]: fetch_state=" << fetch_state_.get() << " backoff_timer=" << this
       << ": backoff timer fired";
-  if (fetch_state_->queued_calls_.empty()) {
-    // If there are no pending calls when the timer fires, then orphan
-    // the FetchState object.  Note that this drops the backoff state,
-    // but that's probably okay, because if we didn't have any pending
-    // calls during the backoff period, we probably won't see any
-    // immediately now either.
-    GRPC_TRACE_LOG(token_fetcher_credentials, INFO)
-        << "[TokenFetcherCredentials " << fetch_state_->creds_.get()
-        << "]: fetch_state=" << fetch_state_.get() << " backoff_timer=" << this
-        << ": no pending calls, clearing state";
-    fetch_state_->creds_->fetch_state_.reset();
-  } else {
-    // If there are pending calls, then start a new fetch attempt.
-    GRPC_TRACE_LOG(token_fetcher_credentials, INFO)
-        << "[TokenFetcherCredentials " << fetch_state_->creds_.get()
-        << "]: fetch_state=" << fetch_state_.get() << " backoff_timer=" << this
-        << ": starting new fetch attempt";
-    fetch_state_->StartFetchAttempt();
+  auto* self_ptr =
+      absl::get_if<OrphanablePtr<BackoffTimer>>(&fetch_state_->state_);
+  // This condition should always be true, but check to be defensive.
+  if (self_ptr != nullptr && self_ptr->get() == this) {
+    // Reset pointer in fetch_state_, so that subsequent RPCs know that
+    // we're no longer in backoff and they can trigger a new fetch.
+    self_ptr->reset();
   }
 }
 
@@ -145,6 +134,14 @@ void TokenFetcherCredentials::FetchState::Orphan() {
   Unref();
 }
 
+absl::Status TokenFetcherCredentials::FetchState::status() const {
+  auto* backoff_ptr = absl::get_if<OrphanablePtr<BackoffTimer>>(&state_);
+  if (backoff_ptr == nullptr || *backoff_ptr == nullptr) {
+    return absl::OkStatus();
+  }
+  return (*backoff_ptr)->status();
+}
+
 void TokenFetcherCredentials::FetchState::StartFetchAttempt() {
   GRPC_TRACE_LOG(token_fetcher_credentials, INFO)
       << "[TokenFetcherCredentials " << creds_.get()
@@ -182,7 +179,8 @@ void TokenFetcherCredentials::FetchState::TokenFetchComplete(
         << "]: fetch_state=" << this
         << ": token fetch failed: " << token.status();
     // If failed, start backoff timer.
-    state_ = OrphanablePtr<BackoffTimer>(new BackoffTimer(Ref()));
+    state_ =
+        OrphanablePtr<BackoffTimer>(new BackoffTimer(Ref(), token.status()));
   }
   ResumeQueuedCalls(std::move(token));
 }
@@ -204,7 +202,6 @@ void TokenFetcherCredentials::FetchState::ResumeQueuedCalls(
 RefCountedPtr<TokenFetcherCredentials::QueuedCall>
 TokenFetcherCredentials::FetchState::QueueCall(
     ClientMetadataHandle initial_metadata) {
-  // Add call to pending list.
   auto queued_call = MakeRefCounted<QueuedCall>();
   queued_call->waker = GetContext<Activity>()->MakeNonOwningWaker();
   queued_call->pollent = GetContext<grpc_polling_entity>();
@@ -212,6 +209,11 @@ TokenFetcherCredentials::FetchState::QueueCall(
       queued_call->pollent, grpc_polling_entity_pollset_set(&creds_->pollent_));
   queued_call->md = std::move(initial_metadata);
   queued_calls_.insert(queued_call);
+  // If backoff has expired since the last attempt, trigger a new one.
+  auto* backoff_ptr = absl::get_if<OrphanablePtr<BackoffTimer>>(&state_);
+  if (backoff_ptr != nullptr && backoff_ptr->get() == nullptr) {
+    StartFetchAttempt();
+  }
   return queued_call;
 }
 
@@ -267,6 +269,11 @@ TokenFetcherCredentials::GetRequestMetadata(
       token_->AddTokenToClientInitialMetadata(*initial_metadata);
       return Immediate(std::move(initial_metadata));
     }
+    // If we're in backoff, fail the call.
+    if (fetch_state_ != nullptr) {
+      absl::Status status = fetch_state_->status();
+      if (!status.ok()) return Immediate(std::move(status));
+    }
     // If we don't have a cached token, this call will need to be queued.
     GRPC_TRACE_LOG(token_fetcher_credentials, INFO)
         << "[TokenFetcherCredentials " << this

data/src/core/lib/security/credentials/token_fetcher/token_fetcher_credentials.h

@@ -111,13 +111,16 @@ class TokenFetcherCredentials : public grpc_call_credentials {
     // annotations.
     void Orphan() override ABSL_NO_THREAD_SAFETY_ANALYSIS;
 
+    // Returns non-OK when we're in backoff.
+    absl::Status status() const;
+
     RefCountedPtr<QueuedCall> QueueCall(ClientMetadataHandle initial_metadata)
         ABSL_EXCLUSIVE_LOCKS_REQUIRED(&TokenFetcherCredentials::mu_);
 
    private:
     class BackoffTimer : public InternallyRefCounted<BackoffTimer> {
      public:
-      explicit BackoffTimer(RefCountedPtr<FetchState> fetch_state)
+      BackoffTimer(RefCountedPtr<FetchState> fetch_state, absl::Status status)
           ABSL_EXCLUSIVE_LOCKS_REQUIRED(&TokenFetcherCredentials::mu_);
 
       // Disabling thread safety annotations, since Orphan() is called
@@ -125,10 +128,13 @@ class TokenFetcherCredentials : public grpc_call_credentials {
       // annotations.
       void Orphan() override ABSL_NO_THREAD_SAFETY_ANALYSIS;
 
+      absl::Status status() const { return status_; }
+
      private:
       void OnTimer();
 
       RefCountedPtr<FetchState> fetch_state_;
+      const absl::Status status_;
       absl::optional<grpc_event_engine::experimental::EventEngine::TaskHandle>
           timer_handle_ ABSL_GUARDED_BY(&TokenFetcherCredentials::mu_);
     };

data/src/core/lib/security/security_connector/load_system_roots_supported.cc

@@ -34,7 +34,7 @@
 #include <unistd.h>
 
 #include "absl/log/log.h"
-#include "src/core/lib/config/config_vars.h"
+#include "src/core/config/config_vars.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/security/security_connector/load_system_roots.h"
 #include "src/core/lib/security/security_connector/load_system_roots_supported.h"

data/src/core/lib/security/security_connector/ssl_utils.cc

@@ -38,9 +38,9 @@
 #include "absl/strings/match.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_split.h"
+#include "src/core/config/config_vars.h"
 #include "src/core/ext/transport/chttp2/alpn/alpn.h"
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/config/config_vars.h"
 #include "src/core/lib/security/context/security_context.h"
 #include "src/core/lib/security/security_connector/load_system_roots.h"
 #include "src/core/tsi/ssl_transport_security.h"

data/src/core/lib/security/security_connector/ssl_utils.h

@@ -48,7 +48,7 @@ grpc_error_handle grpc_ssl_check_alpn(const tsi_peer* peer);
 // Check peer name information returned from SSL handshakes.
 grpc_error_handle grpc_ssl_check_peer_name(absl::string_view peer_name,
                                            const tsi_peer* peer);
-// Compare targer_name information extracted from SSL security connectors.
+// Compare target_name information extracted from SSL security connectors.
 int grpc_ssl_cmp_target_name(absl::string_view target_name,
                              absl::string_view other_target_name,
                              absl::string_view overridden_target_name,

data/src/core/lib/slice/slice_buffer.cc

@@ -441,6 +441,7 @@ void grpc_slice_buffer_copy_first_into_buffer(grpc_slice_buffer* src, size_t n,
 template <bool allow_inline>
 void grpc_slice_buffer_trim_end_impl(grpc_slice_buffer* sb, size_t n,
                                      grpc_slice_buffer* garbage) {
+  if (n == 0) return;
   CHECK(n <= sb->length);
   sb->length -= n;
   for (;;) {

data/src/core/lib/surface/call_utils.h

@@ -95,6 +95,10 @@ class PublishToAppEncoder {
     Append(LbTokenMetadata::key(), slice);
   }
 
+  void Encode(W3CTraceParentMetadata, const Slice& slice) {
+    Append(W3CTraceParentMetadata::key(), slice);
+  }
+
  private:
   void Append(absl::string_view key, int64_t value) {
     Append(StaticSlice::FromStaticString(key).c_slice(),

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

@@ -24,8 +24,8 @@
 #include "src/core/channelz/channelz.h"
 #include "src/core/client_channel/client_channel.h"
 #include "src/core/client_channel/direct_channel.h"
+#include "src/core/config/core_configuration.h"
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/experiments/experiments.h"
 #include "src/core/lib/surface/channel.h"
 #include "src/core/lib/surface/channel_stack_type.h"

data/src/core/lib/surface/channel_init.h

@@ -230,7 +230,7 @@ class ChannelInit {
     // Exactly one terminal filter will be added at the end of each filter
     // stack.
     // If multiple are defined they are tried in registration order, and the
-    // first terminal filter whos predicates succeed is selected.
+    // first terminal filter whose predicates succeed is selected.
     FilterRegistration& Terminal() {
       terminal_ = true;
       return *this;

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

@@ -162,7 +162,6 @@ void ClientCall::CancelWithError(grpc_error_handle error) {
             "CancelWithError", [self = WeakRefAsSubclass<ClientCall>(),
                                 error = std::move(error)]() mutable {
               self->started_call_initiator_.Cancel(std::move(error));
-              return Empty{};
             });
         return;
       default:
@@ -184,6 +183,7 @@ void ClientCall::CancelWithError(grpc_error_handle error) {
 
 template <typename Batch>
 void ClientCall::ScheduleCommittedBatch(Batch batch) {
+  GRPC_LATENT_SEE_INNER_SCOPE("ClientCall::ScheduleCommittedBatch");
   auto cur_state = call_state_.load(std::memory_order_acquire);
   while (true) {
     switch (cur_state) {
@@ -192,7 +192,9 @@ void ClientCall::ScheduleCommittedBatch(Batch batch) {
         auto pending = std::make_unique<UnorderedStart>();
         pending->start_pending_batch = [this,
                                         batch = std::move(batch)]() mutable {
-          started_call_initiator_.SpawnInfallible("batch", std::move(batch));
+          started_call_initiator_.SpawnInfallible(
+              "batch",
+              GRPC_LATENT_SEE_PROMISE("ClientCallBatch", std::move(batch)));
         };
         while (true) {
           pending->next = reinterpret_cast<UnorderedStart*>(cur_state);
@@ -212,7 +214,9 @@ void ClientCall::ScheduleCommittedBatch(Batch batch) {
         }
       }
       case kStarted:
-        started_call_initiator_.SpawnInfallible("batch", std::move(batch));
+        started_call_initiator_.SpawnInfallible(
+            "batch",
+            GRPC_LATENT_SEE_PROMISE("ClientCallBatch", std::move(batch)));
         return;
       case kCancelled:
         return;
@@ -220,7 +224,9 @@ void ClientCall::ScheduleCommittedBatch(Batch batch) {
   }
 }
 
-void ClientCall::StartCall(const grpc_op& send_initial_metadata_op) {
+Party::WakeupHold ClientCall::StartCall(
+    const grpc_op& send_initial_metadata_op) {
+  GRPC_LATENT_SEE_INNER_SCOPE("ClientCall::StartCall");
   auto cur_state = call_state_.load(std::memory_order_acquire);
   CToMetadata(send_initial_metadata_op.data.send_initial_metadata.metadata,
               send_initial_metadata_op.data.send_initial_metadata.count,
@@ -229,44 +235,51 @@ void ClientCall::StartCall(const grpc_op& send_initial_metadata_op) {
                                  *send_initial_metadata_);
   auto call = MakeCallPair(std::move(send_initial_metadata_), arena()->Ref());
   started_call_initiator_ = std::move(call.initiator);
-  while (true) {
-    GRPC_TRACE_LOG(call, INFO)
-        << DebugTag() << "StartCall " << GRPC_DUMP_ARGS(cur_state);
-    switch (cur_state) {
-      case kUnstarted:
-        if (call_state_.compare_exchange_strong(cur_state, kStarted,
-                                                std::memory_order_acq_rel,
-                                                std::memory_order_acquire)) {
-          call_destination_->StartCall(std::move(call.handler));
-          return;
-        }
-        break;
-      case kStarted:
-        Crash("StartCall called twice");  // probably we crash earlier...
-      case kCancelled:
-        return;
-      default: {  // UnorderedStart
-        if (call_state_.compare_exchange_strong(cur_state, kStarted,
-                                                std::memory_order_acq_rel,
-                                                std::memory_order_acquire)) {
-          call_destination_->StartCall(std::move(call.handler));
-          auto unordered_start = reinterpret_cast<UnorderedStart*>(cur_state);
-          while (unordered_start->next != nullptr) {
-            unordered_start->start_pending_batch();
-            auto next = unordered_start->next;
-            delete unordered_start;
-            unordered_start = next;
-          }
-          return;
+  Party::WakeupHold wakeup_hold{started_call_initiator_.party()};
+  while (!StartCallMaybeUpdateState(cur_state, call.handler)) {
+  }
+  return wakeup_hold;
+}
+
+bool ClientCall::StartCallMaybeUpdateState(uintptr_t& cur_state,
+                                           UnstartedCallHandler& handler) {
+  GRPC_TRACE_LOG(call, INFO)
+      << DebugTag() << "StartCall " << GRPC_DUMP_ARGS(cur_state);
+  switch (cur_state) {
+    case kUnstarted:
+      if (call_state_.compare_exchange_strong(cur_state, kStarted,
+                                              std::memory_order_acq_rel,
+                                              std::memory_order_acquire)) {
+        call_destination_->StartCall(std::move(handler));
+        return true;
+      }
+      return false;
+    case kStarted:
+      Crash("StartCall called twice");  // probably we crash earlier...
+    case kCancelled:
+      return true;
+    default: {  // UnorderedStart
+      if (call_state_.compare_exchange_strong(cur_state, kStarted,
+                                              std::memory_order_acq_rel,
+                                              std::memory_order_acquire)) {
+        call_destination_->StartCall(std::move(handler));
+        auto unordered_start = reinterpret_cast<UnorderedStart*>(cur_state);
+        while (unordered_start->next != nullptr) {
+          unordered_start->start_pending_batch();
+          auto next = unordered_start->next;
+          delete unordered_start;
+          unordered_start = next;
         }
-        break;
+        return true;
       }
+      return false;
     }
   }
 }
 
 void ClientCall::CommitBatch(const grpc_op* ops, size_t nops, void* notify_tag,
                              bool is_notify_tag_closure) {
+  GRPC_LATENT_SEE_INNER_SCOPE("ClientCall::CommitBatch");
   if (nops == 1 && ops[0].op == GRPC_OP_SEND_INITIAL_METADATA) {
     StartCall(ops[0]);
     EndOpImmediately(cq_, notify_tag, is_notify_tag_closure);
@@ -325,8 +338,9 @@ void ClientCall::CommitBatch(const grpc_op* ops, size_t nops, void* notify_tag,
   auto primary_ops = AllOk<StatusFlag>(
       TrySeq(std::move(send_message), std::move(send_close_from_client)),
       TrySeq(std::move(recv_initial_metadata), std::move(recv_message)));
+  Party::WakeupHold wakeup_hold;
   if (const grpc_op* op = op_index.op(GRPC_OP_SEND_INITIAL_METADATA)) {
-    StartCall(*op);
+    wakeup_hold = StartCall(*op);
   }
   if (const grpc_op* op = op_index.op(GRPC_OP_RECV_STATUS_ON_CLIENT)) {
     auto out_status = op->data.recv_status_on_client.status;

data/src/core/lib/surface/client_call.h

@@ -128,7 +128,15 @@ class ClientCall final
                    bool is_notify_tag_closure);
   template <typename Batch>
   void ScheduleCommittedBatch(Batch batch);
-  void StartCall(const grpc_op& send_initial_metadata_op);
+  Party::WakeupHold StartCall(const grpc_op& send_initial_metadata_op);
+  // Attempt to start the call and send handler down the stack; returns true if
+  // state was updated, false otherwise (with cur_state updated to the new
+  // current state).
+  // If this function returns false, it's guaranteed that handler is not
+  // touched.
+  // Should be called repeatedly until it returns true.
+  bool StartCallMaybeUpdateState(uintptr_t& cur_state,
+                                 UnstartedCallHandler& handler);
 
   std::string DebugTag() { return absl::StrFormat("CLIENT_CALL[%p]: ", this); }
 

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

@@ -999,7 +999,7 @@ static grpc_event cq_next(grpc_completion_queue* cq, gpr_timespec deadline,
       break;
     } else {
       // If c == NULL it means either the queue is empty OR in an transient
-      // inconsistent state. If it is the latter, we shold do a 0-timeout poll
+      // inconsistent state. If it is the latter, we should do a 0-timeout poll
       // so that the thread comes back quickly from poll to make a second
       // attempt at popping. Not doing this can potentially deadlock this
       // thread forever (if the deadline is infinity)

data/src/core/lib/surface/completion_queue.h

@@ -62,7 +62,7 @@ void grpc_cq_internal_unref(grpc_completion_queue* cq);
 #endif
 
 // Flag that an operation is beginning: the completion channel will not finish
-// shutdown until a corrensponding grpc_cq_end_* call is made.
+// shutdown until a corresponding grpc_cq_end_* call is made.
 // \a tag is currently used only in debug builds. Return true on success, and
 // false if completion_queue has been shutdown.
 bool grpc_cq_begin_op(grpc_completion_queue* cq, void* tag);

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

@@ -0,0 +1,77 @@
+//
+//
+// Copyright 2024 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
+
+#include "src/core/lib/surface/connection_context.h"
+
+#include <grpc/support/alloc.h>
+#include <grpc/support/port_platform.h>
+
+#include <cstddef>
+
+#include "src/core/util/alloc.h"
+#include "src/core/util/orphanable.h"
+
+namespace grpc_core {
+
+namespace {
+
+void* ConnectionContextStorage() {
+  size_t base_size = sizeof(ConnectionContext) +
+                     GPR_ROUND_UP_TO_ALIGNMENT_SIZE(
+                         connection_context_detail::
+                             BaseConnectionContextPropertiesTraits::Size());
+  static constexpr size_t alignment =
+      (GPR_CACHELINE_SIZE > GPR_MAX_ALIGNMENT &&
+       GPR_CACHELINE_SIZE % GPR_MAX_ALIGNMENT == 0)
+          ? GPR_CACHELINE_SIZE
+          : GPR_MAX_ALIGNMENT;
+  return gpr_malloc_aligned(base_size, alignment);
+}
+
+}  // namespace
+
+OrphanablePtr<ConnectionContext> ConnectionContext::Create() {
+  void* p = ConnectionContextStorage();
+  return OrphanablePtr<ConnectionContext>(new (p) ConnectionContext());
+}
+
+ConnectionContext::ConnectionContext() {
+  for (size_t i = 0;
+       i < connection_context_detail::BaseConnectionContextPropertiesTraits::
+               NumProperties();
+       ++i) {
+    registered_properties()[i] = nullptr;
+  }
+}
+
+void ConnectionContext::Orphan() {
+  this->~ConnectionContext();
+  gpr_free_aligned(const_cast<ConnectionContext*>(this));
+}
+
+ConnectionContext::~ConnectionContext() {
+  for (size_t i = 0;
+       i < connection_context_detail::BaseConnectionContextPropertiesTraits::
+               NumProperties();
+       ++i) {
+    connection_context_detail::BaseConnectionContextPropertiesTraits::Destroy(
+        i, registered_properties()[i]);
+  }
+}
+
+}  // namespace grpc_core