[server_global_callbacks_ownership] Cleanup experiment (grpc#40797)

Closes grpc#40797

COPYBARA_INTEGRATE_REVIEW=grpc#40797 from yashykt:CleanupServerGlobalCallbacks 31ea23b
PiperOrigin-RevId: 813627130

Author: yashykt

bazel/experiments.bzl

@@ -276,11 +276,6 @@
       "event_engine_listener",
       "event_engine_secure_endpoint",
     ]
-- name: server_global_callbacks_ownership
-  description: If set, server global callbacks ownership is fixed to not be owned by gRPC.
-  expiry: 2025/09/30
-  owner: yashkt@google.com
-  test_tags: []
 - name: sleep_promise_exec_ctx_removal
   description: If set, polling the sleep promise does not rely on the ExecCtx.
   expiry: 2026/02/01

src/core/lib/experiments/experiments.cc

@@ -86,8 +86,6 @@
   default: false
 - name: schedule_cancellation_over_write
   default: false
-- name: server_global_callbacks_ownership
-  default: true
 - name: sleep_promise_exec_ctx_removal
   default: false
 - name: sleep_use_non_owning_waker

src/core/lib/experiments/experiments.h

@@ -109,14 +109,8 @@ Server::GlobalCallbacks* g_raw_callbacks = nullptr;
 gpr_once g_once_init_callbacks = GPR_ONCE_INIT;
 
 void InitGlobalCallbacks() {
-  if (grpc_core::IsServerGlobalCallbacksOwnershipEnabled()) {
-    if (!g_raw_callbacks) {
-      g_raw_callbacks = new DefaultGlobalCallbacks;
-    }
-  } else {
-    if (!g_callbacks) {
-      g_callbacks = std::make_shared<DefaultGlobalCallbacks>();
-    }
+  if (!g_raw_callbacks) {
+    g_raw_callbacks = new DefaultGlobalCallbacks;
   }
 }
 
@@ -423,8 +417,7 @@ class Server::SyncRequest final : public grpc::internal::CompletionQueueTag {
     return true;
   }
 
-  void Run(const std::shared_ptr<GlobalCallbacks>& global_callbacks,
-           bool resources) {
+  void Run(bool resources) {
     ctx_.Init(deadline_, &request_metadata_);
     wrapped_call_.Init(
         call_, server_, &cq_, server_->max_receive_message_size(),
@@ -435,9 +428,6 @@ class Server::SyncRequest final : public grpc::internal::CompletionQueueTag {
     ctx_->ctx.cq_ = &cq_;
     request_metadata_.count = 0;
 
-    if (!grpc_core::IsServerGlobalCallbacksOwnershipEnabled()) {
-      global_callbacks_ = global_callbacks;
-    }
     resources_ = resources;
 
     interceptor_methods_.SetCall(&*wrapped_call_);
@@ -473,21 +463,13 @@ class Server::SyncRequest final : public grpc::internal::CompletionQueueTag {
 
   void ContinueRunAfterInterception() {
     ctx_->ctx.BeginCompletionOp(&*wrapped_call_, nullptr, nullptr);
-    if (grpc_core::IsServerGlobalCallbacksOwnershipEnabled()) {
-      g_raw_callbacks->PreSynchronousRequest(&ctx_->ctx);
-    } else {
-      global_callbacks_->PreSynchronousRequest(&ctx_->ctx);
-    }
+    g_raw_callbacks->PreSynchronousRequest(&ctx_->ctx);
     auto* handler = resources_ ? method_->handler()
                                : server_->resource_exhausted_handler_.get();
     handler->RunHandler(grpc::internal::MethodHandler::HandlerParameter(
         &*wrapped_call_, &ctx_->ctx, deserialized_request_, request_status_,
         nullptr, nullptr));
-    if (grpc_core::IsServerGlobalCallbacksOwnershipEnabled()) {
-      g_raw_callbacks->PostSynchronousRequest(&ctx_->ctx);
-    } else {
-      global_callbacks_->PostSynchronousRequest(&ctx_->ctx);
-    }
+    g_raw_callbacks->PostSynchronousRequest(&ctx_->ctx);
 
     cq_.Shutdown();
 
@@ -542,7 +524,6 @@ class Server::SyncRequest final : public grpc::internal::CompletionQueueTag {
   grpc_byte_buffer* request_payload_ = nullptr;
   grpc::CompletionQueue cq_;
   grpc::Status request_status_;
-  std::shared_ptr<GlobalCallbacks> global_callbacks_;
   bool resources_;
   void* deserialized_request_ = nullptr;
   grpc::internal::InterceptorBatchMethodsImpl interceptor_methods_;
@@ -805,14 +786,12 @@ const char* Server::CallbackRequest<
 class Server::SyncRequestThreadManager : public grpc::ThreadManager {
  public:
   SyncRequestThreadManager(Server* server, grpc::CompletionQueue* server_cq,
-                           std::shared_ptr<GlobalCallbacks> global_callbacks,
                            grpc_resource_quota* rq, int min_pollers,
                            int max_pollers, int cq_timeout_msec)
       : ThreadManager("SyncServer", rq, min_pollers, max_pollers),
         server_(server),
         server_cq_(server_cq),
-        cq_timeout_msec_(cq_timeout_msec),
-        global_callbacks_(std::move(global_callbacks)) {}
+        cq_timeout_msec_(cq_timeout_msec) {}
 
   WorkStatus PollForWork(void** tag, bool* ok) override {
     *tag = nullptr;
@@ -843,7 +822,7 @@ class Server::SyncRequestThreadManager : public grpc::ThreadManager {
     GRPC_DCHECK_NE(sync_req, nullptr);
     GRPC_DCHECK(ok);
 
-    sync_req->Run(global_callbacks_, resources);
+    sync_req->Run(resources);
   }
 
   void AddSyncMethod(grpc::internal::RpcServiceMethod* method, void* tag) {
@@ -899,7 +878,6 @@ class Server::SyncRequestThreadManager : public grpc::ThreadManager {
   int cq_timeout_msec_;
   bool has_sync_method_ = false;
   std::unique_ptr<grpc::internal::RpcServiceMethod> unknown_method_;
-  std::shared_ptr<Server::GlobalCallbacks> global_callbacks_;
 };
 
 Server::Server(
@@ -927,12 +905,7 @@ Server::Server(
       health_check_service_disabled_(false),
       server_metric_recorder_(server_metric_recorder) {
   gpr_once_init(&grpc::g_once_init_callbacks, grpc::InitGlobalCallbacks);
-  if (grpc_core::IsServerGlobalCallbacksOwnershipEnabled()) {
-    g_raw_callbacks->UpdateArguments(args);
-  } else {
-    global_callbacks_ = grpc::g_callbacks;
-    global_callbacks_->UpdateArguments(args);
-  }
+  g_raw_callbacks->UpdateArguments(args);
 
   if (sync_server_cqs_ != nullptr) {
     bool default_rq_created = false;
@@ -944,9 +917,9 @@ Server::Server(
     }
 
     for (const auto& it : *sync_server_cqs_) {
-      sync_req_mgrs_.emplace_back(new SyncRequestThreadManager(
-          this, it.get(), global_callbacks_, server_rq, min_pollers,
-          max_pollers, sync_cq_timeout_msec));
+      sync_req_mgrs_.emplace_back(
+          new SyncRequestThreadManager(this, it.get(), server_rq, min_pollers,
+                                       max_pollers, sync_cq_timeout_msec));
     }
 
     if (default_rq_created) {
@@ -1017,15 +990,9 @@ Server::~Server() {
 }
 
 void Server::SetGlobalCallbacks(GlobalCallbacks* callbacks) {
-  if (grpc_core::IsServerGlobalCallbacksOwnershipEnabled()) {
-    GRPC_CHECK(!g_raw_callbacks);
-    GRPC_CHECK(callbacks);
-    g_raw_callbacks = callbacks;
-  } else {
-    GRPC_CHECK(!g_callbacks);
-    GRPC_CHECK(callbacks);
-    g_callbacks.reset(callbacks);
-  }
+  GRPC_CHECK(!g_raw_callbacks);
+  GRPC_CHECK(callbacks);
+  g_raw_callbacks = callbacks;
 }
 
 grpc_server* Server::c_server() { return server_; }
@@ -1152,11 +1119,7 @@ int Server::AddListeningPort(const std::string& addr,
                              grpc::ServerCredentials* creds) {
   GRPC_CHECK(!started_);
   int port = creds->AddPortToServer(addr, server_);
-  if (grpc_core::IsServerGlobalCallbacksOwnershipEnabled()) {
-    g_raw_callbacks->AddPort(this, addr, creds, port);
-  } else {
-    global_callbacks_->AddPort(this, addr, creds, port);
-  }
+  g_raw_callbacks->AddPort(this, addr, creds, port);
   return port;
 }
 
@@ -1189,11 +1152,7 @@ void Server::UnrefAndWaitLocked() {
 
 void Server::Start(grpc::ServerCompletionQueue** cqs, size_t num_cqs) {
   GRPC_CHECK(!started_);
-  if (grpc_core::IsServerGlobalCallbacksOwnershipEnabled()) {
-    g_raw_callbacks->PreServerStart(this);
-  } else {
-    g_callbacks->PreServerStart(this);
-  }
+  g_raw_callbacks->PreServerStart(this);
   started_ = true;
 
   // Only create default health check service when user did not provide an