diff --git a/include/grpcpp/generic/generic_stub_impl.h b/include/grpcpp/generic/generic_stub_impl.h
index e670fcaa6541e7f2005ab22d85e4b130706b5bc6..72d2989ceb65928f9d73bdc90ae72789d37ed868 100644
--- a/include/grpcpp/generic/generic_stub_impl.h
+++ b/include/grpcpp/generic/generic_stub_impl.h
@@ -28,8 +28,6 @@
#include <grpcpp/support/client_callback_impl.h>
#include <grpcpp/support/status.h>
-#include <functional>
-
namespace grpc {
typedef ::grpc_impl::ClientAsyncReaderWriter<ByteBuffer, ByteBuffer>
@@ -92,15 +90,15 @@ class GenericStub final {
void UnaryCall(grpc_impl::ClientContext* context,
const grpc::string& method, const grpc::ByteBuffer* request,
grpc::ByteBuffer* response,
- grpc_impl::experimental::ClientUnaryReactor* reactor);
+ grpc_impl::ClientUnaryReactor* reactor);
/// Setup a call to a named method \a method using \a context and tied to
/// \a reactor . Like any other bidi streaming RPC, it will not be activated
/// until StartCall is invoked on its reactor.
void PrepareBidiStreamingCall(
grpc_impl::ClientContext* context, const grpc::string& method,
- grpc_impl::experimental::ClientBidiReactor<grpc::ByteBuffer,
- grpc::ByteBuffer>* reactor);
+ grpc_impl::ClientBidiReactor<grpc::ByteBuffer, grpc::ByteBuffer>*
+ reactor);
private:
GenericStub* stub_;
diff --git a/include/grpcpp/impl/codegen/async_generic_service.h b/include/grpcpp/impl/codegen/async_generic_service.h
index 934f619a4464ae45eaff8b65e6e7e2356813279a..8515e0031a9b0340fbdd1d8f4d7398480181721d 100644
--- a/include/grpcpp/impl/codegen/async_generic_service.h
+++ b/include/grpcpp/impl/codegen/async_generic_service.h
@@ -93,10 +93,10 @@ namespace experimental {
/// invoked on a CallbackGenericService. It is just a ServerBidi reactor with
/// ByteBuffer arguments.
using ServerGenericBidiReactor =
- ::grpc_impl::experimental::ServerBidiReactor<ByteBuffer, ByteBuffer>;
+ ::grpc_impl::ServerBidiReactor<ByteBuffer, ByteBuffer>;
class GenericCallbackServerContext final
- : public ::grpc_impl::experimental::CallbackServerContext {
+ : public ::grpc_impl::CallbackServerContext {
public:
const grpc::string& method() const { return method_; }
const grpc::string& host() const { return host_; }
@@ -108,7 +108,7 @@ class GenericCallbackServerContext final
void Clear() {
method_.clear();
host_.clear();
- ::grpc_impl::experimental::CallbackServerContext::Clear();
+ ::grpc_impl::CallbackServerContext::Clear();
}
grpc::string method_;
@@ -143,7 +143,7 @@ class CallbackGenericService {
Handler() {
return new ::grpc_impl::internal::CallbackBidiHandler<ByteBuffer,
ByteBuffer>(
- [this](::grpc_impl::experimental::CallbackServerContext* ctx) {
+ [this](::grpc_impl::CallbackServerContext* ctx) {
return CreateReactor(static_cast<GenericCallbackServerContext*>(ctx));
});
}
diff --git a/include/grpcpp/impl/codegen/client_callback.h b/include/grpcpp/impl/codegen/client_callback.h
index 9d183725b574ce30e39bf6ad192519774a2748d4..7893a6ff3bad836cd970895d76b4a9e3418e9d8f 100644
--- a/include/grpcpp/impl/codegen/client_callback.h
+++ b/include/grpcpp/impl/codegen/client_callback.h
@@ -25,30 +25,25 @@ namespace grpc {
namespace experimental {
template <class Response>
-using ClientCallbackReader =
- ::grpc_impl::experimental::ClientCallbackReader<Response>;
+using ClientCallbackReader = ::grpc_impl::ClientCallbackReader<Response>;
template <class Request>
-using ClientCallbackWriter =
- ::grpc_impl::experimental::ClientCallbackWriter<Request>;
+using ClientCallbackWriter = ::grpc_impl::ClientCallbackWriter<Request>;
template <class Request, class Response>
using ClientCallbackReaderWriter =
- ::grpc_impl::experimental::ClientCallbackReaderWriter<Request, Response>;
+ ::grpc_impl::ClientCallbackReaderWriter<Request, Response>;
template <class Response>
-using ClientReadReactor =
- ::grpc_impl::experimental::ClientReadReactor<Response>;
+using ClientReadReactor = ::grpc_impl::ClientReadReactor<Response>;
template <class Request>
-using ClientWriteReactor =
- ::grpc_impl::experimental::ClientWriteReactor<Request>;
+using ClientWriteReactor = ::grpc_impl::ClientWriteReactor<Request>;
template <class Request, class Response>
-using ClientBidiReactor =
- ::grpc_impl::experimental::ClientBidiReactor<Request, Response>;
+using ClientBidiReactor = ::grpc_impl::ClientBidiReactor<Request, Response>;
-typedef ::grpc_impl::experimental::ClientUnaryReactor ClientUnaryReactor;
+typedef ::grpc_impl::ClientUnaryReactor ClientUnaryReactor;
} // namespace experimental
} // namespace grpc
diff --git a/include/grpcpp/impl/codegen/client_callback_impl.h b/include/grpcpp/impl/codegen/client_callback_impl.h
index 7d421326999f924d28e3885a749d5a73f4c32b88..1a2bae1b5dbb21ddf68710040d171f20a31963f6 100644
--- a/include/grpcpp/impl/codegen/client_callback_impl.h
+++ b/include/grpcpp/impl/codegen/client_callback_impl.h
@@ -103,8 +103,6 @@ class CallbackUnaryCallImpl {
};
} // namespace internal
-namespace experimental {
-
// Forward declarations
template <class Request, class Response>
class ClientBidiReactor;
@@ -404,8 +402,6 @@ inline void ClientCallbackUnary::BindReactor(ClientUnaryReactor* reactor) {
reactor->BindCall(this);
}
-} // namespace experimental
-
namespace internal {
// Forward declare factory classes for friendship
@@ -418,7 +414,7 @@ class ClientCallbackWriterFactory;
template <class Request, class Response>
class ClientCallbackReaderWriterImpl
- : public experimental::ClientCallbackReaderWriter<Request, Response> {
+ : public ClientCallbackReaderWriter<Request, Response> {
public:
// always allocated against a call arena, no memory free required
static void operator delete(void* /*ptr*/, std::size_t size) {
@@ -562,9 +558,9 @@ class ClientCallbackReaderWriterImpl
private:
friend class ClientCallbackReaderWriterFactory<Request, Response>;
- ClientCallbackReaderWriterImpl(
- grpc::internal::Call call, ::grpc_impl::ClientContext* context,
- experimental::ClientBidiReactor<Request, Response>* reactor)
+ ClientCallbackReaderWriterImpl(grpc::internal::Call call,
+ ::grpc_impl::ClientContext* context,
+ ClientBidiReactor<Request, Response>* reactor)
: context_(context),
call_(call),
reactor_(reactor),
@@ -574,7 +570,7 @@ class ClientCallbackReaderWriterImpl
::grpc_impl::ClientContext* const context_;
grpc::internal::Call call_;
- experimental::ClientBidiReactor<Request, Response>* const reactor_;
+ ClientBidiReactor<Request, Response>* const reactor_;
grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata,
grpc::internal::CallOpRecvInitialMetadata>
@@ -612,11 +608,10 @@ class ClientCallbackReaderWriterImpl
template <class Request, class Response>
class ClientCallbackReaderWriterFactory {
public:
- static void Create(
- ::grpc::ChannelInterface* channel,
- const ::grpc::internal::RpcMethod& method,
- ::grpc_impl::ClientContext* context,
- experimental::ClientBidiReactor<Request, Response>* reactor) {
+ static void Create(::grpc::ChannelInterface* channel,
+ const ::grpc::internal::RpcMethod& method,
+ ::grpc_impl::ClientContext* context,
+ ClientBidiReactor<Request, Response>* reactor) {
grpc::internal::Call call =
channel->CreateCall(method, context, channel->CallbackCQ());
@@ -629,8 +624,7 @@ class ClientCallbackReaderWriterFactory {
};
template <class Response>
-class ClientCallbackReaderImpl
- : public experimental::ClientCallbackReader<Response> {
+class ClientCallbackReaderImpl : public ClientCallbackReader<Response> {
public:
// always allocated against a call arena, no memory free required
static void operator delete(void* /*ptr*/, std::size_t size) {
@@ -716,7 +710,7 @@ class ClientCallbackReaderImpl
ClientCallbackReaderImpl(::grpc::internal::Call call,
::grpc_impl::ClientContext* context,
Request* request,
- experimental::ClientReadReactor<Response>* reactor)
+ ClientReadReactor<Response>* reactor)
: context_(context), call_(call), reactor_(reactor) {
this->BindReactor(reactor);
// TODO(vjpai): don't assert
@@ -726,7 +720,7 @@ class ClientCallbackReaderImpl
::grpc_impl::ClientContext* const context_;
grpc::internal::Call call_;
- experimental::ClientReadReactor<Response>* const reactor_;
+ ClientReadReactor<Response>* const reactor_;
grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata,
grpc::internal::CallOpSendMessage,
@@ -757,7 +751,7 @@ class ClientCallbackReaderFactory {
const ::grpc::internal::RpcMethod& method,
::grpc_impl::ClientContext* context,
const Request* request,
- experimental::ClientReadReactor<Response>* reactor) {
+ ClientReadReactor<Response>* reactor) {
grpc::internal::Call call =
channel->CreateCall(method, context, channel->CallbackCQ());
@@ -769,8 +763,7 @@ class ClientCallbackReaderFactory {
};
template <class Request>
-class ClientCallbackWriterImpl
- : public experimental::ClientCallbackWriter<Request> {
+class ClientCallbackWriterImpl : public ClientCallbackWriter<Request> {
public:
// always allocated against a call arena, no memory free required
static void operator delete(void* /*ptr*/, std::size_t size) {
@@ -896,7 +889,7 @@ class ClientCallbackWriterImpl
ClientCallbackWriterImpl(::grpc::internal::Call call,
::grpc_impl::ClientContext* context,
Response* response,
- experimental::ClientWriteReactor<Request>* reactor)
+ ClientWriteReactor<Request>* reactor)
: context_(context),
call_(call),
reactor_(reactor),
@@ -908,7 +901,7 @@ class ClientCallbackWriterImpl
::grpc_impl::ClientContext* const context_;
grpc::internal::Call call_;
- experimental::ClientWriteReactor<Request>* const reactor_;
+ ClientWriteReactor<Request>* const reactor_;
grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata,
grpc::internal::CallOpRecvInitialMetadata>
@@ -947,7 +940,7 @@ class ClientCallbackWriterFactory {
static void Create(::grpc::ChannelInterface* channel,
const ::grpc::internal::RpcMethod& method,
::grpc_impl::ClientContext* context, Response* response,
- experimental::ClientWriteReactor<Request>* reactor) {
+ ClientWriteReactor<Request>* reactor) {
grpc::internal::Call call =
channel->CreateCall(method, context, channel->CallbackCQ());
@@ -958,7 +951,7 @@ class ClientCallbackWriterFactory {
}
};
-class ClientCallbackUnaryImpl final : public experimental::ClientCallbackUnary {
+class ClientCallbackUnaryImpl final : public ClientCallbackUnary {
public:
// always allocated against a call arena, no memory free required
static void operator delete(void* /*ptr*/, std::size_t size) {
@@ -1015,8 +1008,7 @@ class ClientCallbackUnaryImpl final : public experimental::ClientCallbackUnary {
template <class Request, class Response>
ClientCallbackUnaryImpl(::grpc::internal::Call call,
::grpc_impl::ClientContext* context, Request* request,
- Response* response,
- experimental::ClientUnaryReactor* reactor)
+ Response* response, ClientUnaryReactor* reactor)
: context_(context), call_(call), reactor_(reactor) {
this->BindReactor(reactor);
// TODO(vjpai): don't assert
@@ -1028,7 +1020,7 @@ class ClientCallbackUnaryImpl final : public experimental::ClientCallbackUnary {
::grpc_impl::ClientContext* const context_;
grpc::internal::Call call_;
- experimental::ClientUnaryReactor* const reactor_;
+ ClientUnaryReactor* const reactor_;
grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata,
grpc::internal::CallOpSendMessage,
@@ -1055,7 +1047,7 @@ class ClientCallbackUnaryFactory {
const ::grpc::internal::RpcMethod& method,
::grpc_impl::ClientContext* context,
const Request* request, Response* response,
- experimental::ClientUnaryReactor* reactor) {
+ ClientUnaryReactor* reactor) {
grpc::internal::Call call =
channel->CreateCall(method, context, channel->CallbackCQ());
diff --git a/include/grpcpp/impl/codegen/client_context_impl.h b/include/grpcpp/impl/codegen/client_context_impl.h
index 48a02dbd4cb7e50ab77ec38bd45a1b21fc7345fa..b8e90722b255e14e74548da6101b261f90049713 100644
--- a/include/grpcpp/impl/codegen/client_context_impl.h
+++ b/include/grpcpp/impl/codegen/client_context_impl.h
@@ -107,10 +107,8 @@ class ClientAsyncReaderWriter;
template <class R>
class ClientAsyncResponseReader;
-namespace experimental {
class ServerContextBase;
class CallbackServerContext;
-} // namespace experimental
/// Options for \a ClientContext::FromServerContext specifying which traits from
/// the \a ServerContext to propagate (copy) from it into a new \a
@@ -202,7 +200,7 @@ class ClientContext {
const grpc_impl::ServerContext& server_context,
PropagationOptions options = PropagationOptions());
static std::unique_ptr<ClientContext> FromCallbackServerContext(
- const grpc_impl::experimental::CallbackServerContext& server_context,
+ const grpc_impl::CallbackServerContext& server_context,
PropagationOptions options = PropagationOptions());
/// Add the (\a meta_key, \a meta_value) pair to the metadata associated with
@@ -484,7 +482,7 @@ class ClientContext {
void SendCancelToInterceptors();
static std::unique_ptr<ClientContext> FromInternalServerContext(
- const grpc_impl::experimental::ServerContextBase& server_context,
+ const grpc_impl::ServerContextBase& server_context,
PropagationOptions options);
bool initial_metadata_received_;
diff --git a/include/grpcpp/impl/codegen/completion_queue_impl.h b/include/grpcpp/impl/codegen/completion_queue_impl.h
index 04b9300e032952be36612a5b59d374138e5232d5..4549aa3719477be1a78cc57a49a4bb193c59fedc 100644
--- a/include/grpcpp/impl/codegen/completion_queue_impl.h
+++ b/include/grpcpp/impl/codegen/completion_queue_impl.h
@@ -56,9 +56,7 @@ template <class R>
class ServerReader;
template <class W>
class ServerWriter;
-namespace experimental {
class ServerContextBase;
-} // namespace experimental
namespace internal {
template <class W, class R>
class ServerReaderWriterBody;
@@ -277,7 +275,7 @@ class CompletionQueue : private ::grpc::GrpcLibraryCodegen {
template <::grpc::StatusCode code>
friend class ::grpc_impl::internal::ErrorMethodHandler;
friend class ::grpc_impl::Server;
- friend class ::grpc_impl::experimental::ServerContextBase;
+ friend class ::grpc_impl::ServerContextBase;
friend class ::grpc::ServerInterface;
template <class InputMessage, class OutputMessage>
friend class ::grpc::internal::BlockingUnaryCallImpl;
diff --git a/include/grpcpp/impl/codegen/method_handler_impl.h b/include/grpcpp/impl/codegen/method_handler_impl.h
index c7545fdcc13d0424c00806dd4e91c2c124cd2d8e..6368b63e1ab1d809fd34157707c4b8b375a84f9b 100644
--- a/include/grpcpp/impl/codegen/method_handler_impl.h
+++ b/include/grpcpp/impl/codegen/method_handler_impl.h
@@ -345,8 +345,7 @@ template <::grpc::StatusCode code>
class ErrorMethodHandler : public ::grpc::internal::MethodHandler {
public:
template <class T>
- static void FillOps(::grpc_impl::experimental::ServerContextBase* context,
- T* ops) {
+ static void FillOps(::grpc_impl::ServerContextBase* context, T* ops) {
::grpc::Status status(code, "");
if (!context->sent_initial_metadata_) {
ops->SendInitialMetadata(&context->initial_metadata_,
diff --git a/include/grpcpp/impl/codegen/rpc_service_method.h b/include/grpcpp/impl/codegen/rpc_service_method.h
index 7c5b8bf0c331e62b37124fc05a149be096322aed..da0e5b60b20e595bb67f45a9ed9cc8a219f68c42 100644
--- a/include/grpcpp/impl/codegen/rpc_service_method.h
+++ b/include/grpcpp/impl/codegen/rpc_service_method.h
@@ -32,9 +32,7 @@
#include <grpcpp/impl/codegen/status.h>
namespace grpc_impl {
-namespace experimental {
class ServerContextBase;
-}
} // namespace grpc_impl
namespace grpc {
@@ -54,8 +52,7 @@ class MethodHandler {
/// \param requester : used only by the callback API. It is a function
/// called by the RPC Controller to request another RPC (and also
/// to set up the state required to make that request possible)
- HandlerParameter(Call* c,
- ::grpc_impl::experimental::ServerContextBase* context,
+ HandlerParameter(Call* c, ::grpc_impl::ServerContextBase* context,
void* req, Status req_status, void* handler_data,
std::function<void()> requester)
: call(c),
@@ -66,7 +63,7 @@ class MethodHandler {
call_requester(std::move(requester)) {}
~HandlerParameter() {}
Call* const call;
- ::grpc_impl::experimental::ServerContextBase* const server_context;
+ ::grpc_impl::ServerContextBase* const server_context;
void* const request;
const Status status;
void* const internal_data;
diff --git a/include/grpcpp/impl/codegen/server_callback.h b/include/grpcpp/impl/codegen/server_callback.h
index d33a224da2c34480600a617342ffbd1bdc3d60a9..3ddd8f6f81de4ff965bcb30caf945a633e7dbc0c 100644
--- a/include/grpcpp/impl/codegen/server_callback.h
+++ b/include/grpcpp/impl/codegen/server_callback.h
@@ -24,17 +24,15 @@
namespace grpc {
namespace experimental {
template <class Request>
-using ServerReadReactor = ::grpc_impl::experimental::ServerReadReactor<Request>;
+using ServerReadReactor = ::grpc_impl::ServerReadReactor<Request>;
template <class Response>
-using ServerWriteReactor =
- ::grpc_impl::experimental::ServerWriteReactor<Response>;
+using ServerWriteReactor = ::grpc_impl::ServerWriteReactor<Response>;
template <class Request, class Response>
-using ServerBidiReactor =
- ::grpc_impl::experimental::ServerBidiReactor<Request, Response>;
+using ServerBidiReactor = ::grpc_impl::ServerBidiReactor<Request, Response>;
-using ServerUnaryReactor = ::grpc_impl::experimental::ServerUnaryReactor;
+using ServerUnaryReactor = ::grpc_impl::ServerUnaryReactor;
} // namespace experimental
} // namespace grpc
diff --git a/include/grpcpp/impl/codegen/server_callback_handlers.h b/include/grpcpp/impl/codegen/server_callback_handlers.h
index 32d19d765fa04d363286d3ccb407cff9db37d51f..7752864175d502437352cef34b2208e7a270e3ae 100644
--- a/include/grpcpp/impl/codegen/server_callback_handlers.h
+++ b/include/grpcpp/impl/codegen/server_callback_handlers.h
@@ -31,9 +31,8 @@ template <class RequestType, class ResponseType>
class CallbackUnaryHandler : public ::grpc::internal::MethodHandler {
public:
explicit CallbackUnaryHandler(
- std::function<experimental::ServerUnaryReactor*(
- ::grpc_impl::experimental::CallbackServerContext*, const RequestType*,
- ResponseType*)>
+ std::function<ServerUnaryReactor*(::grpc_impl::CallbackServerContext*,
+ const RequestType*, ResponseType*)>
get_reactor)
: get_reactor_(std::move(get_reactor)) {}
@@ -53,18 +52,17 @@ class CallbackUnaryHandler : public ::grpc::internal::MethodHandler {
auto* call = new (::grpc::g_core_codegen_interface->grpc_call_arena_alloc(
param.call->call(), sizeof(ServerCallbackUnaryImpl)))
ServerCallbackUnaryImpl(
- static_cast<::grpc_impl::experimental::CallbackServerContext*>(
+ static_cast<::grpc_impl::CallbackServerContext*>(
param.server_context),
param.call, allocator_state, std::move(param.call_requester));
param.server_context->BeginCompletionOp(
param.call, [call](bool) { call->MaybeDone(); }, call);
- experimental::ServerUnaryReactor* reactor = nullptr;
+ ServerUnaryReactor* reactor = nullptr;
if (param.status.ok()) {
- reactor = ::grpc::internal::CatchingReactorGetter<
- experimental::ServerUnaryReactor>(
+ reactor = ::grpc::internal::CatchingReactorGetter<ServerUnaryReactor>(
get_reactor_,
- static_cast<::grpc_impl::experimental::CallbackServerContext*>(
+ static_cast<::grpc_impl::CallbackServerContext*>(
param.server_context),
call->request(), call->response());
}
@@ -110,14 +108,13 @@ class CallbackUnaryHandler : public ::grpc::internal::MethodHandler {
}
private:
- std::function<experimental::ServerUnaryReactor*(
- ::grpc_impl::experimental::CallbackServerContext*, const RequestType*,
- ResponseType*)>
+ std::function<ServerUnaryReactor*(::grpc_impl::CallbackServerContext*,
+ const RequestType*, ResponseType*)>
get_reactor_;
::grpc::experimental::MessageAllocator<RequestType, ResponseType>*
allocator_ = nullptr;
- class ServerCallbackUnaryImpl : public experimental::ServerCallbackUnary {
+ class ServerCallbackUnaryImpl : public ServerCallbackUnary {
public:
void Finish(::grpc::Status s) override {
finish_tag_.Set(
@@ -168,8 +165,7 @@ class CallbackUnaryHandler : public ::grpc::internal::MethodHandler {
friend class CallbackUnaryHandler<RequestType, ResponseType>;
ServerCallbackUnaryImpl(
- ::grpc_impl::experimental::CallbackServerContext* ctx,
- ::grpc::internal::Call* call,
+ ::grpc_impl::CallbackServerContext* ctx, ::grpc::internal::Call* call,
::grpc::experimental::MessageHolder<RequestType, ResponseType>*
allocator_state,
std::function<void()> call_requester)
@@ -184,7 +180,7 @@ class CallbackUnaryHandler : public ::grpc::internal::MethodHandler {
/// operations), maybe calls OnCancel if possible/needed, and maybe marks
/// the completion of the RPC. This should be the last component of the
/// handler.
- void SetupReactor(experimental::ServerUnaryReactor* reactor) {
+ void SetupReactor(ServerUnaryReactor* reactor) {
reactor_.store(reactor, std::memory_order_relaxed);
this->BindReactor(reactor);
this->MaybeCallOnCancel(reactor);
@@ -219,7 +215,7 @@ class CallbackUnaryHandler : public ::grpc::internal::MethodHandler {
finish_ops_;
::grpc::internal::CallbackWithSuccessTag finish_tag_;
- ::grpc_impl::experimental::CallbackServerContext* const ctx_;
+ ::grpc_impl::CallbackServerContext* const ctx_;
::grpc::internal::Call call_;
::grpc::experimental::MessageHolder<RequestType, ResponseType>* const
allocator_state_;
@@ -234,7 +230,7 @@ class CallbackUnaryHandler : public ::grpc::internal::MethodHandler {
// change after that and it only gets used by actions caused, directly or
// indirectly, by that setup. This comment also applies to the reactor_
// variables of the other streaming objects in this file.
- std::atomic<experimental::ServerUnaryReactor*> reactor_;
+ std::atomic<ServerUnaryReactor*> reactor_;
// callbacks_outstanding_ follows a refcount pattern
std::atomic<intptr_t> callbacks_outstanding_{
3}; // reserve for start, Finish, and CompletionOp
@@ -245,8 +241,8 @@ template <class RequestType, class ResponseType>
class CallbackClientStreamingHandler : public ::grpc::internal::MethodHandler {
public:
explicit CallbackClientStreamingHandler(
- std::function<experimental::ServerReadReactor<RequestType>*(
- ::grpc_impl::experimental::CallbackServerContext*, ResponseType*)>
+ std::function<ServerReadReactor<RequestType>*(
+ ::grpc_impl::CallbackServerContext*, ResponseType*)>
get_reactor)
: get_reactor_(std::move(get_reactor)) {}
void RunHandler(const HandlerParameter& param) final {
@@ -256,18 +252,18 @@ class CallbackClientStreamingHandler : public ::grpc::internal::MethodHandler {
auto* reader = new (::grpc::g_core_codegen_interface->grpc_call_arena_alloc(
param.call->call(), sizeof(ServerCallbackReaderImpl)))
ServerCallbackReaderImpl(
- static_cast<::grpc_impl::experimental::CallbackServerContext*>(
+ static_cast<::grpc_impl::CallbackServerContext*>(
param.server_context),
param.call, std::move(param.call_requester));
param.server_context->BeginCompletionOp(
param.call, [reader](bool) { reader->MaybeDone(); }, reader);
- experimental::ServerReadReactor<RequestType>* reactor = nullptr;
+ ServerReadReactor<RequestType>* reactor = nullptr;
if (param.status.ok()) {
reactor = ::grpc::internal::CatchingReactorGetter<
- experimental::ServerReadReactor<RequestType>>(
+ ServerReadReactor<RequestType>>(
get_reactor_,
- static_cast<::grpc_impl::experimental::CallbackServerContext*>(
+ static_cast<::grpc_impl::CallbackServerContext*>(
param.server_context),
reader->response());
}
@@ -284,12 +280,11 @@ class CallbackClientStreamingHandler : public ::grpc::internal::MethodHandler {
}
private:
- std::function<experimental::ServerReadReactor<RequestType>*(
- ::grpc_impl::experimental::CallbackServerContext*, ResponseType*)>
+ std::function<ServerReadReactor<RequestType>*(
+ ::grpc_impl::CallbackServerContext*, ResponseType*)>
get_reactor_;
- class ServerCallbackReaderImpl
- : public experimental::ServerCallbackReader<RequestType> {
+ class ServerCallbackReaderImpl : public ServerCallbackReader<RequestType> {
public:
void Finish(::grpc::Status s) override {
finish_tag_.Set(call_.call(), [this](bool) { MaybeDone(); }, &finish_ops_,
@@ -342,12 +337,12 @@ class CallbackClientStreamingHandler : public ::grpc::internal::MethodHandler {
private:
friend class CallbackClientStreamingHandler<RequestType, ResponseType>;
- ServerCallbackReaderImpl(
- ::grpc_impl::experimental::CallbackServerContext* ctx,
- ::grpc::internal::Call* call, std::function<void()> call_requester)
+ ServerCallbackReaderImpl(::grpc_impl::CallbackServerContext* ctx,
+ ::grpc::internal::Call* call,
+ std::function<void()> call_requester)
: ctx_(ctx), call_(*call), call_requester_(std::move(call_requester)) {}
- void SetupReactor(experimental::ServerReadReactor<RequestType>* reactor) {
+ void SetupReactor(ServerReadReactor<RequestType>* reactor) {
reactor_.store(reactor, std::memory_order_relaxed);
read_tag_.Set(call_.call(),
[this](bool ok) {
@@ -393,12 +388,12 @@ class CallbackClientStreamingHandler : public ::grpc::internal::MethodHandler {
read_ops_;
::grpc::internal::CallbackWithSuccessTag read_tag_;
- ::grpc_impl::experimental::CallbackServerContext* const ctx_;
+ ::grpc_impl::CallbackServerContext* const ctx_;
::grpc::internal::Call call_;
ResponseType resp_;
std::function<void()> call_requester_;
// The memory ordering of reactor_ follows ServerCallbackUnaryImpl.
- std::atomic<experimental::ServerReadReactor<RequestType>*> reactor_;
+ std::atomic<ServerReadReactor<RequestType>*> reactor_;
// callbacks_outstanding_ follows a refcount pattern
std::atomic<intptr_t> callbacks_outstanding_{
3}; // reserve for OnStarted, Finish, and CompletionOp
@@ -409,9 +404,8 @@ template <class RequestType, class ResponseType>
class CallbackServerStreamingHandler : public ::grpc::internal::MethodHandler {
public:
explicit CallbackServerStreamingHandler(
- std::function<experimental::ServerWriteReactor<ResponseType>*(
- ::grpc_impl::experimental::CallbackServerContext*,
- const RequestType*)>
+ std::function<ServerWriteReactor<ResponseType>*(
+ ::grpc_impl::CallbackServerContext*, const RequestType*)>
get_reactor)
: get_reactor_(std::move(get_reactor)) {}
void RunHandler(const HandlerParameter& param) final {
@@ -421,19 +415,19 @@ class CallbackServerStreamingHandler : public ::grpc::internal::MethodHandler {
auto* writer = new (::grpc::g_core_codegen_interface->grpc_call_arena_alloc(
param.call->call(), sizeof(ServerCallbackWriterImpl)))
ServerCallbackWriterImpl(
- static_cast<::grpc_impl::experimental::CallbackServerContext*>(
+ static_cast<::grpc_impl::CallbackServerContext*>(
param.server_context),
param.call, static_cast<RequestType*>(param.request),
std::move(param.call_requester));
param.server_context->BeginCompletionOp(
param.call, [writer](bool) { writer->MaybeDone(); }, writer);
- experimental::ServerWriteReactor<ResponseType>* reactor = nullptr;
+ ServerWriteReactor<ResponseType>* reactor = nullptr;
if (param.status.ok()) {
reactor = ::grpc::internal::CatchingReactorGetter<
- experimental::ServerWriteReactor<ResponseType>>(
+ ServerWriteReactor<ResponseType>>(
get_reactor_,
- static_cast<::grpc_impl::experimental::CallbackServerContext*>(
+ static_cast<::grpc_impl::CallbackServerContext*>(
param.server_context),
writer->request());
}
@@ -466,12 +460,11 @@ class CallbackServerStreamingHandler : public ::grpc::internal::MethodHandler {
}
private:
- std::function<experimental::ServerWriteReactor<ResponseType>*(
- ::grpc_impl::experimental::CallbackServerContext*, const RequestType*)>
+ std::function<ServerWriteReactor<ResponseType>*(
+ ::grpc_impl::CallbackServerContext*, const RequestType*)>
get_reactor_;
- class ServerCallbackWriterImpl
- : public experimental::ServerCallbackWriter<ResponseType> {
+ class ServerCallbackWriterImpl : public ServerCallbackWriter<ResponseType> {
public:
void Finish(::grpc::Status s) override {
finish_tag_.Set(call_.call(), [this](bool) { MaybeDone(); }, &finish_ops_,
@@ -543,16 +536,16 @@ class CallbackServerStreamingHandler : public ::grpc::internal::MethodHandler {
private:
friend class CallbackServerStreamingHandler<RequestType, ResponseType>;
- ServerCallbackWriterImpl(
- ::grpc_impl::experimental::CallbackServerContext* ctx,
- ::grpc::internal::Call* call, const RequestType* req,
- std::function<void()> call_requester)
+ ServerCallbackWriterImpl(::grpc_impl::CallbackServerContext* ctx,
+ ::grpc::internal::Call* call,
+ const RequestType* req,
+ std::function<void()> call_requester)
: ctx_(ctx),
call_(*call),
req_(req),
call_requester_(std::move(call_requester)) {}
- void SetupReactor(experimental::ServerWriteReactor<ResponseType>* reactor) {
+ void SetupReactor(ServerWriteReactor<ResponseType>* reactor) {
reactor_.store(reactor, std::memory_order_relaxed);
write_tag_.Set(
call_.call(),
@@ -598,12 +591,12 @@ class CallbackServerStreamingHandler : public ::grpc::internal::MethodHandler {
write_ops_;
::grpc::internal::CallbackWithSuccessTag write_tag_;
- ::grpc_impl::experimental::CallbackServerContext* const ctx_;
+ ::grpc_impl::CallbackServerContext* const ctx_;
::grpc::internal::Call call_;
const RequestType* req_;
std::function<void()> call_requester_;
// The memory ordering of reactor_ follows ServerCallbackUnaryImpl.
- std::atomic<experimental::ServerWriteReactor<ResponseType>*> reactor_;
+ std::atomic<ServerWriteReactor<ResponseType>*> reactor_;
// callbacks_outstanding_ follows a refcount pattern
std::atomic<intptr_t> callbacks_outstanding_{
3}; // reserve for OnStarted, Finish, and CompletionOp
@@ -614,8 +607,8 @@ template <class RequestType, class ResponseType>
class CallbackBidiHandler : public ::grpc::internal::MethodHandler {
public:
explicit CallbackBidiHandler(
- std::function<experimental::ServerBidiReactor<RequestType, ResponseType>*(
- ::grpc_impl::experimental::CallbackServerContext*)>
+ std::function<ServerBidiReactor<RequestType, ResponseType>*(
+ ::grpc_impl::CallbackServerContext*)>
get_reactor)
: get_reactor_(std::move(get_reactor)) {}
void RunHandler(const HandlerParameter& param) final {
@@ -624,20 +617,18 @@ class CallbackBidiHandler : public ::grpc::internal::MethodHandler {
auto* stream = new (::grpc::g_core_codegen_interface->grpc_call_arena_alloc(
param.call->call(), sizeof(ServerCallbackReaderWriterImpl)))
ServerCallbackReaderWriterImpl(
- static_cast<::grpc_impl::experimental::CallbackServerContext*>(
+ static_cast<::grpc_impl::CallbackServerContext*>(
param.server_context),
param.call, std::move(param.call_requester));
param.server_context->BeginCompletionOp(
param.call, [stream](bool) { stream->MaybeDone(); }, stream);
- experimental::ServerBidiReactor<RequestType, ResponseType>* reactor =
- nullptr;
+ ServerBidiReactor<RequestType, ResponseType>* reactor = nullptr;
if (param.status.ok()) {
reactor = ::grpc::internal::CatchingReactorGetter<
- experimental::ServerBidiReactor<RequestType, ResponseType>>(
- get_reactor_,
- static_cast<::grpc_impl::experimental::CallbackServerContext*>(
- param.server_context));
+ ServerBidiReactor<RequestType, ResponseType>>(
+ get_reactor_, static_cast<::grpc_impl::CallbackServerContext*>(
+ param.server_context));
}
if (reactor == nullptr) {
@@ -653,13 +644,12 @@ class CallbackBidiHandler : public ::grpc::internal::MethodHandler {
}
private:
- std::function<experimental::ServerBidiReactor<RequestType, ResponseType>*(
- ::grpc_impl::experimental::CallbackServerContext*)>
+ std::function<ServerBidiReactor<RequestType, ResponseType>*(
+ ::grpc_impl::CallbackServerContext*)>
get_reactor_;
class ServerCallbackReaderWriterImpl
- : public experimental::ServerCallbackReaderWriter<RequestType,
- ResponseType> {
+ : public ServerCallbackReaderWriter<RequestType, ResponseType> {
public:
void Finish(::grpc::Status s) override {
finish_tag_.Set(call_.call(), [this](bool) { MaybeDone(); }, &finish_ops_,
@@ -736,13 +726,12 @@ class CallbackBidiHandler : public ::grpc::internal::MethodHandler {
private:
friend class CallbackBidiHandler<RequestType, ResponseType>;
- ServerCallbackReaderWriterImpl(
- ::grpc_impl::experimental::CallbackServerContext* ctx,
- ::grpc::internal::Call* call, std::function<void()> call_requester)
+ ServerCallbackReaderWriterImpl(::grpc_impl::CallbackServerContext* ctx,
+ ::grpc::internal::Call* call,
+ std::function<void()> call_requester)
: ctx_(ctx), call_(*call), call_requester_(std::move(call_requester)) {}
- void SetupReactor(
- experimental::ServerBidiReactor<RequestType, ResponseType>* reactor) {
+ void SetupReactor(ServerBidiReactor<RequestType, ResponseType>* reactor) {
reactor_.store(reactor, std::memory_order_relaxed);
write_tag_.Set(
call_.call(),
@@ -796,12 +785,11 @@ class CallbackBidiHandler : public ::grpc::internal::MethodHandler {
read_ops_;
::grpc::internal::CallbackWithSuccessTag read_tag_;
- ::grpc_impl::experimental::CallbackServerContext* const ctx_;
+ ::grpc_impl::CallbackServerContext* const ctx_;
::grpc::internal::Call call_;
std::function<void()> call_requester_;
// The memory ordering of reactor_ follows ServerCallbackUnaryImpl.
- std::atomic<experimental::ServerBidiReactor<RequestType, ResponseType>*>
- reactor_;
+ std::atomic<ServerBidiReactor<RequestType, ResponseType>*> reactor_;
// callbacks_outstanding_ follows a refcount pattern
std::atomic<intptr_t> callbacks_outstanding_{
3}; // reserve for OnStarted, Finish, and CompletionOp
diff --git a/include/grpcpp/impl/codegen/server_callback_impl.h b/include/grpcpp/impl/codegen/server_callback_impl.h
index 4e899f51ec2647617c841768c0a18484b0ad8352..ccdcb6a55f64a55d2c9b625da9ea292b79573633 100644
--- a/include/grpcpp/impl/codegen/server_callback_impl.h
+++ b/include/grpcpp/impl/codegen/server_callback_impl.h
@@ -136,8 +136,6 @@ class DefaultMessageHolder
} // namespace internal
-namespace experimental {
-
// Forward declarations
class ServerUnaryReactor;
template <class Request>
@@ -723,8 +721,6 @@ class ServerUnaryReactor : public internal::ServerReactor {
::grpc::Status status_wanted_ /* GUARDED_BY(writer_mu_) */;
};
-} // namespace experimental
-
namespace internal {
template <class Base>
@@ -734,17 +730,15 @@ class FinishOnlyReactor : public Base {
void OnDone() override { this->~FinishOnlyReactor(); }
};
-using UnimplementedUnaryReactor =
- FinishOnlyReactor<experimental::ServerUnaryReactor>;
+using UnimplementedUnaryReactor = FinishOnlyReactor<ServerUnaryReactor>;
template <class Request>
-using UnimplementedReadReactor =
- FinishOnlyReactor<experimental::ServerReadReactor<Request>>;
+using UnimplementedReadReactor = FinishOnlyReactor<ServerReadReactor<Request>>;
template <class Response>
using UnimplementedWriteReactor =
- FinishOnlyReactor<experimental::ServerWriteReactor<Response>>;
+ FinishOnlyReactor<ServerWriteReactor<Response>>;
template <class Request, class Response>
using UnimplementedBidiReactor =
- FinishOnlyReactor<experimental::ServerBidiReactor<Request, Response>>;
+ FinishOnlyReactor<ServerBidiReactor<Request, Response>>;
} // namespace internal
} // namespace grpc_impl
diff --git a/include/grpcpp/impl/codegen/server_context.h b/include/grpcpp/impl/codegen/server_context.h
index 0976d8df923e5e67b4344edcef44d1213002d13e..b04a4cea19ecdee732f8e0aa7ec9e4e2a9e66328 100644
--- a/include/grpcpp/impl/codegen/server_context.h
+++ b/include/grpcpp/impl/codegen/server_context.h
@@ -27,8 +27,8 @@ typedef ::grpc_impl::ServerContext ServerContext;
namespace experimental {
-typedef ::grpc_impl::experimental::ServerContextBase ServerContextBase;
-typedef ::grpc_impl::experimental::CallbackServerContext CallbackServerContext;
+typedef ::grpc_impl::ServerContextBase ServerContextBase;
+typedef ::grpc_impl::CallbackServerContext CallbackServerContext;
} // namespace experimental
} // namespace grpc
diff --git a/include/grpcpp/impl/codegen/server_context_impl.h b/include/grpcpp/impl/codegen/server_context_impl.h
index 47ac70e0fcb5b6793a701d4a738e7f13fc98967f..25673c638119ae161c75f29bab0c9d08fd557266 100644
--- a/include/grpcpp/impl/codegen/server_context_impl.h
+++ b/include/grpcpp/impl/codegen/server_context_impl.h
@@ -112,7 +112,6 @@ class DefaultReactorTestPeer;
} // namespace grpc
namespace grpc_impl {
-namespace experimental {
/// Base class of ServerContext. Experimental until callback API is final.
class ServerContextBase {
@@ -297,7 +296,7 @@ class ServerContextBase {
/// from the method handler.
///
/// WARNING: This is experimental API and could be changed or removed.
- ::grpc_impl::experimental::ServerUnaryReactor* DefaultReactor() {
+ ::grpc_impl::ServerUnaryReactor* DefaultReactor() {
auto reactor = &default_reactor_;
default_reactor_used_.store(true, std::memory_order_relaxed);
return reactor;
@@ -415,7 +414,7 @@ class ServerContextBase {
::grpc::experimental::ServerRpcInfo* rpc_info_;
::grpc::experimental::RpcAllocatorState* message_allocator_state_ = nullptr;
- class Reactor : public experimental::ServerUnaryReactor {
+ class Reactor : public ServerUnaryReactor {
public:
void OnCancel() override {}
void OnDone() override {}
@@ -434,8 +433,7 @@ class ServerContextBase {
}
::grpc::Status test_status() const { return test_unary_->status(); }
- class TestServerCallbackUnary
- : public ::grpc_impl::experimental::ServerCallbackUnary {
+ class TestServerCallbackUnary : public ::grpc_impl::ServerCallbackUnary {
public:
TestServerCallbackUnary(ServerContextBase* ctx,
std::function<void(::grpc::Status)> func)
@@ -460,7 +458,7 @@ class ServerContextBase {
return reactor_;
}
- ::grpc_impl::experimental::ServerUnaryReactor* const reactor_;
+ ::grpc_impl::ServerUnaryReactor* const reactor_;
std::atomic_bool status_set_{false};
::grpc::Status status_;
const std::function<void(::grpc::Status s)> func_;
@@ -471,8 +469,6 @@ class ServerContextBase {
std::unique_ptr<TestServerCallbackUnary> test_unary_;
};
-} // namespace experimental
-
/// A ServerContext or CallbackServerContext allows the code implementing a
/// service handler to:
///
@@ -489,48 +485,46 @@ class ServerContextBase {
/// to a \a grpc::ServerBuilder, via \a ServerBuilder::AddChannelArgument.
///
/// \warning ServerContext instances should \em not be reused across rpcs.
-class ServerContext : public experimental::ServerContextBase {
+class ServerContext : public ServerContextBase {
public:
ServerContext() {} // for async calls
- using experimental::ServerContextBase::AddInitialMetadata;
- using experimental::ServerContextBase::AddTrailingMetadata;
- using experimental::ServerContextBase::IsCancelled;
- using experimental::ServerContextBase::SetLoadReportingCosts;
- using experimental::ServerContextBase::TryCancel;
- using experimental::ServerContextBase::auth_context;
- using experimental::ServerContextBase::c_call;
- using experimental::ServerContextBase::census_context;
- using experimental::ServerContextBase::client_metadata;
- using experimental::ServerContextBase::compression_algorithm;
- using experimental::ServerContextBase::compression_level;
- using experimental::ServerContextBase::compression_level_set;
- using experimental::ServerContextBase::deadline;
- using experimental::ServerContextBase::peer;
- using experimental::ServerContextBase::raw_deadline;
- using experimental::ServerContextBase::set_compression_algorithm;
- using experimental::ServerContextBase::set_compression_level;
+ using ServerContextBase::AddInitialMetadata;
+ using ServerContextBase::AddTrailingMetadata;
+ using ServerContextBase::IsCancelled;
+ using ServerContextBase::SetLoadReportingCosts;
+ using ServerContextBase::TryCancel;
+ using ServerContextBase::auth_context;
+ using ServerContextBase::c_call;
+ using ServerContextBase::census_context;
+ using ServerContextBase::client_metadata;
+ using ServerContextBase::compression_algorithm;
+ using ServerContextBase::compression_level;
+ using ServerContextBase::compression_level_set;
+ using ServerContextBase::deadline;
+ using ServerContextBase::peer;
+ using ServerContextBase::raw_deadline;
+ using ServerContextBase::set_compression_algorithm;
+ using ServerContextBase::set_compression_level;
// Sync/CQ-based Async ServerContext only
- using experimental::ServerContextBase::AsyncNotifyWhenDone;
+ using ServerContextBase::AsyncNotifyWhenDone;
private:
// Constructor for internal use by server only
friend class ::grpc_impl::Server;
ServerContext(gpr_timespec deadline, grpc_metadata_array* arr)
- : experimental::ServerContextBase(deadline, arr) {}
+ : ServerContextBase(deadline, arr) {}
// CallbackServerContext only
- using experimental::ServerContextBase::DefaultReactor;
- using experimental::ServerContextBase::GetRpcAllocatorState;
+ using ServerContextBase::DefaultReactor;
+ using ServerContextBase::GetRpcAllocatorState;
/// Prevent copying.
ServerContext(const ServerContext&) = delete;
ServerContext& operator=(const ServerContext&) = delete;
};
-namespace experimental {
-
class CallbackServerContext : public ServerContextBase {
public:
/// Public constructors are for direct use only by mocking tests. In practice,
@@ -568,21 +562,19 @@ class CallbackServerContext : public ServerContextBase {
CallbackServerContext& operator=(const CallbackServerContext&) = delete;
};
-} // namespace experimental
} // namespace grpc_impl
-static_assert(std::is_base_of<::grpc_impl::experimental::ServerContextBase,
+static_assert(std::is_base_of<::grpc_impl::ServerContextBase,
::grpc_impl::ServerContext>::value,
"improper base class");
-static_assert(
- std::is_base_of<::grpc_impl::experimental::ServerContextBase,
- ::grpc_impl::experimental::CallbackServerContext>::value,
- "improper base class");
-static_assert(sizeof(::grpc_impl::experimental::ServerContextBase) ==
+static_assert(std::is_base_of<::grpc_impl::ServerContextBase,
+ ::grpc_impl::CallbackServerContext>::value,
+ "improper base class");
+static_assert(sizeof(::grpc_impl::ServerContextBase) ==
sizeof(::grpc_impl::ServerContext),
"wrong size");
-static_assert(sizeof(::grpc_impl::experimental::ServerContextBase) ==
- sizeof(::grpc_impl::experimental::CallbackServerContext),
+static_assert(sizeof(::grpc_impl::ServerContextBase) ==
+ sizeof(::grpc_impl::CallbackServerContext),
"wrong size");
#endif // GRPCPP_IMPL_CODEGEN_SERVER_CONTEXT_IMPL_H
diff --git a/include/grpcpp/impl/codegen/server_interceptor.h b/include/grpcpp/impl/codegen/server_interceptor.h
index 66c4417aec1fe6dc6aeefbe4d1a732d6b4c88bf4..cee6869f208aa0b2cd9f918ca7c99ca9dded36d9 100644
--- a/include/grpcpp/impl/codegen/server_interceptor.h
+++ b/include/grpcpp/impl/codegen/server_interceptor.h
@@ -27,9 +27,7 @@
#include <grpcpp/impl/codegen/string_ref.h>
namespace grpc_impl {
-namespace experimental {
class ServerContextBase;
-}
} // namespace grpc_impl
namespace grpc {
@@ -82,7 +80,7 @@ class ServerRpcInfo {
/// Return a pointer to the underlying ServerContext structure associated
/// with the RPC to support features that apply to it
- grpc_impl::experimental::ServerContextBase* server_context() { return ctx_; }
+ grpc_impl::ServerContextBase* server_context() { return ctx_; }
private:
static_assert(Type::UNARY ==
@@ -98,8 +96,8 @@ class ServerRpcInfo {
static_cast<Type>(internal::RpcMethod::BIDI_STREAMING),
"violated expectation about Type enum");
- ServerRpcInfo(grpc_impl::experimental::ServerContextBase* ctx,
- const char* method, internal::RpcMethod::RpcType type)
+ ServerRpcInfo(grpc_impl::ServerContextBase* ctx, const char* method,
+ internal::RpcMethod::RpcType type)
: ctx_(ctx), method_(method), type_(static_cast<Type>(type)) {}
// Runs interceptor at pos \a pos.
@@ -129,14 +127,14 @@ class ServerRpcInfo {
}
}
- grpc_impl::experimental::ServerContextBase* ctx_ = nullptr;
+ grpc_impl::ServerContextBase* ctx_ = nullptr;
const char* method_ = nullptr;
const Type type_;
std::atomic<intptr_t> ref_{1};
std::vector<std::unique_ptr<experimental::Interceptor>> interceptors_;
friend class internal::InterceptorBatchMethodsImpl;
- friend class grpc_impl::experimental::ServerContextBase;
+ friend class grpc_impl::ServerContextBase;
};
} // namespace experimental
diff --git a/src/cpp/client/client_context.cc b/src/cpp/client/client_context.cc
index 563c3e83a6122d917a62ece0cab6cbe1eddaa128..6865758142a1b2b4c0ea645eceeb1b84731b7272 100644
--- a/src/cpp/client/client_context.cc
+++ b/src/cpp/client/client_context.cc
@@ -89,8 +89,7 @@ void ClientContext::set_credentials(
}
std::unique_ptr<ClientContext> ClientContext::FromInternalServerContext(
- const grpc_impl::experimental::ServerContextBase& context,
- PropagationOptions options) {
+ const grpc_impl::ServerContextBase& context, PropagationOptions options) {
std::unique_ptr<ClientContext> ctx(new ClientContext);
ctx->propagate_from_call_ = context.call_;
ctx->propagation_options_ = options;
@@ -104,7 +103,7 @@ std::unique_ptr<ClientContext> ClientContext::FromServerContext(
}
std::unique_ptr<ClientContext> ClientContext::FromCallbackServerContext(
- const grpc_impl::experimental::CallbackServerContext& server_context,
+ const grpc_impl::CallbackServerContext& server_context,
PropagationOptions options) {
return FromInternalServerContext(server_context, options);
}
diff --git a/src/cpp/client/generic_stub.cc b/src/cpp/client/generic_stub.cc
index e7d3df7a49770449aa206747b026006a22137142..7175b34a0107da5e4c25d8f9178c874e4bfe1540 100644
--- a/src/cpp/client/generic_stub.cc
+++ b/src/cpp/client/generic_stub.cc
@@ -80,8 +80,7 @@ void GenericStub::experimental_type::UnaryCall(
void GenericStub::experimental_type::PrepareBidiStreamingCall(
grpc::ClientContext* context, const grpc::string& method,
- experimental::ClientBidiReactor<grpc::ByteBuffer, grpc::ByteBuffer>*
- reactor) {
+ ClientBidiReactor<grpc::ByteBuffer, grpc::ByteBuffer>* reactor) {
internal::ClientCallbackReaderWriterFactory<
grpc::ByteBuffer,
grpc::ByteBuffer>::Create(stub_->channel_.get(),
diff --git a/src/cpp/server/server_context.cc b/src/cpp/server/server_context.cc
index 983a51b5d49c93789e732417cdb48da52acd64df..590a3d59c4d6819e29281358f5e9243c848c63d0 100644
--- a/src/cpp/server/server_context.cc
+++ b/src/cpp/server/server_context.cc
@@ -36,7 +36,6 @@
#include "src/core/lib/surface/call.h"
namespace grpc_impl {
-namespace experimental {
// CompletionOp
@@ -379,5 +378,4 @@ void ServerContextBase::SetLoadReportingCosts(
}
}
-} // namespace experimental
} // namespace grpc_impl