Merge pull request #19449 from grpc/jtattermusch-patch-1

Make sure Grpc metapackage includes Grpc.Core.targets
diff --git a/include/grpcpp/generic/generic_stub_impl.h b/include/grpcpp/generic/generic_stub_impl.h
index 9041461..fdbc0d0 100644
--- a/include/grpcpp/generic/generic_stub_impl.h
+++ b/include/grpcpp/generic/generic_stub_impl.h
@@ -21,6 +21,7 @@
 
 #include <functional>
 
+#include <grpcpp/client_context.h>
 #include <grpcpp/support/async_stream.h>
 #include <grpcpp/support/async_unary_call.h>
 #include <grpcpp/support/byte_buffer.h>
diff --git a/include/grpcpp/impl/codegen/async_generic_service.h b/include/grpcpp/impl/codegen/async_generic_service.h
index 46d0912..d8e6f49 100644
--- a/include/grpcpp/impl/codegen/async_generic_service.h
+++ b/include/grpcpp/impl/codegen/async_generic_service.h
@@ -33,7 +33,7 @@
 typedef ServerAsyncReader<ByteBuffer, ByteBuffer> GenericServerAsyncReader;
 typedef ServerAsyncWriter<ByteBuffer> GenericServerAsyncWriter;
 
-class GenericServerContext final : public ServerContext {
+class GenericServerContext final : public ::grpc_impl::ServerContext {
  public:
   const grpc::string& method() const { return method_; }
   const grpc::string& host() const { return host_; }
@@ -99,7 +99,7 @@
   virtual void OnStarted(GenericServerContext* context) {}
 
  private:
-  void OnStarted(ServerContext* ctx) final {
+  void OnStarted(::grpc_impl::ServerContext* ctx) final {
     OnStarted(static_cast<GenericServerContext*>(ctx));
   }
 };
diff --git a/include/grpcpp/impl/codegen/async_stream.h b/include/grpcpp/impl/codegen/async_stream.h
index f957726..417dceb 100644
--- a/include/grpcpp/impl/codegen/async_stream.h
+++ b/include/grpcpp/impl/codegen/async_stream.h
@@ -22,7 +22,7 @@
 #include <grpcpp/impl/codegen/call.h>
 #include <grpcpp/impl/codegen/channel_interface.h>
 #include <grpcpp/impl/codegen/core_codegen_interface.h>
-#include <grpcpp/impl/codegen/server_context.h>
+#include <grpcpp/impl/codegen/server_context_impl.h>
 #include <grpcpp/impl/codegen/service_type.h>
 #include <grpcpp/impl/codegen/status.h>
 
@@ -181,8 +181,8 @@
   static ClientAsyncReader<R>* Create(ChannelInterface* channel,
                                       CompletionQueue* cq,
                                       const ::grpc::internal::RpcMethod& method,
-                                      ClientContext* context, const W& request,
-                                      bool start, void* tag) {
+                                      ::grpc_impl::ClientContext* context,
+                                      const W& request, bool start, void* tag) {
     ::grpc::internal::Call call = channel->CreateCall(method, context, cq);
     return new (g_core_codegen_interface->grpc_call_arena_alloc(
         call.call(), sizeof(ClientAsyncReader<R>)))
@@ -260,8 +260,9 @@
  private:
   friend class internal::ClientAsyncReaderFactory<R>;
   template <class W>
-  ClientAsyncReader(::grpc::internal::Call call, ClientContext* context,
-                    const W& request, bool start, void* tag)
+  ClientAsyncReader(::grpc::internal::Call call,
+                    ::grpc_impl::ClientContext* context, const W& request,
+                    bool start, void* tag)
       : context_(context), call_(call), started_(start) {
     // TODO(ctiller): don't assert
     GPR_CODEGEN_ASSERT(init_ops_.SendMessage(request).ok());
@@ -280,7 +281,7 @@
     call_.PerformOps(&init_ops_);
   }
 
-  ClientContext* context_;
+  ::grpc_impl::ClientContext* context_;
   ::grpc::internal::Call call_;
   bool started_;
   ::grpc::internal::CallOpSet<::grpc::internal::CallOpSendInitialMetadata,
@@ -329,8 +330,8 @@
   static ClientAsyncWriter<W>* Create(ChannelInterface* channel,
                                       CompletionQueue* cq,
                                       const ::grpc::internal::RpcMethod& method,
-                                      ClientContext* context, R* response,
-                                      bool start, void* tag) {
+                                      ::grpc_impl::ClientContext* context,
+                                      R* response, bool start, void* tag) {
     ::grpc::internal::Call call = channel->CreateCall(method, context, cq);
     return new (g_core_codegen_interface->grpc_call_arena_alloc(
         call.call(), sizeof(ClientAsyncWriter<W>)))
@@ -426,8 +427,9 @@
  private:
   friend class internal::ClientAsyncWriterFactory<W>;
   template <class R>
-  ClientAsyncWriter(::grpc::internal::Call call, ClientContext* context,
-                    R* response, bool start, void* tag)
+  ClientAsyncWriter(::grpc::internal::Call call,
+                    ::grpc_impl::ClientContext* context, R* response,
+                    bool start, void* tag)
       : context_(context), call_(call), started_(start) {
     finish_ops_.RecvMessage(response);
     finish_ops_.AllowNoMessage();
@@ -449,7 +451,7 @@
     }
   }
 
-  ClientContext* context_;
+  ::grpc_impl::ClientContext* context_;
   ::grpc::internal::Call call_;
   bool started_;
   ::grpc::internal::CallOpSet<::grpc::internal::CallOpRecvInitialMetadata>
@@ -493,8 +495,8 @@
   /// used to send to the server when starting the call.
   static ClientAsyncReaderWriter<W, R>* Create(
       ChannelInterface* channel, CompletionQueue* cq,
-      const ::grpc::internal::RpcMethod& method, ClientContext* context,
-      bool start, void* tag) {
+      const ::grpc::internal::RpcMethod& method,
+      ::grpc_impl::ClientContext* context, bool start, void* tag) {
     ::grpc::internal::Call call = channel->CreateCall(method, context, cq);
 
     return new (g_core_codegen_interface->grpc_call_arena_alloc(
@@ -599,8 +601,9 @@
 
  private:
   friend class internal::ClientAsyncReaderWriterFactory<W, R>;
-  ClientAsyncReaderWriter(::grpc::internal::Call call, ClientContext* context,
-                          bool start, void* tag)
+  ClientAsyncReaderWriter(::grpc::internal::Call call,
+                          ::grpc_impl::ClientContext* context, bool start,
+                          void* tag)
       : context_(context), call_(call), started_(start) {
     if (start) {
       StartCallInternal(tag);
@@ -620,7 +623,7 @@
     }
   }
 
-  ClientContext* context_;
+  ::grpc_impl::ClientContext* context_;
   ::grpc::internal::Call call_;
   bool started_;
   ::grpc::internal::CallOpSet<::grpc::internal::CallOpRecvInitialMetadata>
@@ -696,7 +699,7 @@
 template <class W, class R>
 class ServerAsyncReader final : public ServerAsyncReaderInterface<W, R> {
  public:
-  explicit ServerAsyncReader(ServerContext* ctx)
+  explicit ServerAsyncReader(::grpc_impl::ServerContext* ctx)
       : call_(nullptr, nullptr, nullptr), ctx_(ctx) {}
 
   /// See \a ServerAsyncStreamingInterface::SendInitialMetadata for semantics.
@@ -782,7 +785,7 @@
   void BindCall(::grpc::internal::Call* call) override { call_ = *call; }
 
   ::grpc::internal::Call call_;
-  ServerContext* ctx_;
+  ::grpc_impl::ServerContext* ctx_;
   ::grpc::internal::CallOpSet<::grpc::internal::CallOpSendInitialMetadata>
       meta_ops_;
   ::grpc::internal::CallOpSet<::grpc::internal::CallOpRecvMessage<R>> read_ops_;
@@ -843,7 +846,7 @@
 template <class W>
 class ServerAsyncWriter final : public ServerAsyncWriterInterface<W> {
  public:
-  explicit ServerAsyncWriter(ServerContext* ctx)
+  explicit ServerAsyncWriter(::grpc_impl::ServerContext* ctx)
       : call_(nullptr, nullptr, nullptr), ctx_(ctx) {}
 
   /// See \a ServerAsyncStreamingInterface::SendInitialMetadata for semantics.
@@ -940,7 +943,7 @@
   }
 
   ::grpc::internal::Call call_;
-  ServerContext* ctx_;
+  ::grpc_impl::ServerContext* ctx_;
   ::grpc::internal::CallOpSet<::grpc::internal::CallOpSendInitialMetadata>
       meta_ops_;
   ::grpc::internal::CallOpSet<::grpc::internal::CallOpSendInitialMetadata,
@@ -1009,7 +1012,7 @@
 class ServerAsyncReaderWriter final
     : public ServerAsyncReaderWriterInterface<W, R> {
  public:
-  explicit ServerAsyncReaderWriter(ServerContext* ctx)
+  explicit ServerAsyncReaderWriter(::grpc_impl::ServerContext* ctx)
       : call_(nullptr, nullptr, nullptr), ctx_(ctx) {}
 
   /// See \a ServerAsyncStreamingInterface::SendInitialMetadata for semantics.
@@ -1114,7 +1117,7 @@
   }
 
   ::grpc::internal::Call call_;
-  ServerContext* ctx_;
+  ::grpc_impl::ServerContext* ctx_;
   ::grpc::internal::CallOpSet<::grpc::internal::CallOpSendInitialMetadata>
       meta_ops_;
   ::grpc::internal::CallOpSet<::grpc::internal::CallOpRecvMessage<R>> read_ops_;
diff --git a/include/grpcpp/impl/codegen/async_unary_call.h b/include/grpcpp/impl/codegen/async_unary_call.h
index 4b97cf2..5da6a64 100644
--- a/include/grpcpp/impl/codegen/async_unary_call.h
+++ b/include/grpcpp/impl/codegen/async_unary_call.h
@@ -22,8 +22,8 @@
 #include <assert.h>
 #include <grpcpp/impl/codegen/call.h>
 #include <grpcpp/impl/codegen/channel_interface.h>
-#include <grpcpp/impl/codegen/client_context.h>
-#include <grpcpp/impl/codegen/server_context.h>
+#include <grpcpp/impl/codegen/client_context_impl.h>
+#include <grpcpp/impl/codegen/server_context_impl.h>
 #include <grpcpp/impl/codegen/service_type.h>
 #include <grpcpp/impl/codegen/status.h>
 
@@ -80,9 +80,9 @@
   /// used to send to the server when starting the call.
   template <class W>
   static ClientAsyncResponseReader<R>* Create(
-      ChannelInterface* channel, CompletionQueue* cq,
-      const ::grpc::internal::RpcMethod& method, ClientContext* context,
-      const W& request, bool start) {
+      ChannelInterface* channel, ::grpc_impl::CompletionQueue* cq,
+      const ::grpc::internal::RpcMethod& method,
+      ::grpc_impl::ClientContext* context, const W& request, bool start) {
     ::grpc::internal::Call call = channel->CreateCall(method, context, cq);
     return new (g_core_codegen_interface->grpc_call_arena_alloc(
         call.call(), sizeof(ClientAsyncResponseReader<R>)))
@@ -156,13 +156,14 @@
 
  private:
   friend class internal::ClientAsyncResponseReaderFactory<R>;
-  ClientContext* const context_;
+  ::grpc_impl::ClientContext* const context_;
   ::grpc::internal::Call call_;
   bool started_;
   bool initial_metadata_read_ = false;
 
   template <class W>
-  ClientAsyncResponseReader(::grpc::internal::Call call, ClientContext* context,
+  ClientAsyncResponseReader(::grpc::internal::Call call,
+                            ::grpc_impl::ClientContext* context,
                             const W& request, bool start)
       : context_(context), call_(call), started_(start) {
     // Bind the metadata at time of StartCallInternal but set up the rest here
@@ -199,7 +200,7 @@
 class ServerAsyncResponseWriter final
     : public internal::ServerAsyncStreamingInterface {
  public:
-  explicit ServerAsyncResponseWriter(ServerContext* ctx)
+  explicit ServerAsyncResponseWriter(::grpc_impl::ServerContext* ctx)
       : call_(nullptr, nullptr, nullptr), ctx_(ctx) {}
 
   /// See \a ServerAsyncStreamingInterface::SendInitialMetadata for semantics.
@@ -289,7 +290,7 @@
   void BindCall(::grpc::internal::Call* call) override { call_ = *call; }
 
   ::grpc::internal::Call call_;
-  ServerContext* ctx_;
+  ::grpc_impl::ServerContext* ctx_;
   ::grpc::internal::CallOpSet<::grpc::internal::CallOpSendInitialMetadata>
       meta_buf_;
   ::grpc::internal::CallOpSet<::grpc::internal::CallOpSendInitialMetadata,
diff --git a/include/grpcpp/impl/codegen/call_op_set.h b/include/grpcpp/impl/codegen/call_op_set.h
index c3ae6c4..d0958bb 100644
--- a/include/grpcpp/impl/codegen/call_op_set.h
+++ b/include/grpcpp/impl/codegen/call_op_set.h
@@ -31,7 +31,7 @@
 #include <grpcpp/impl/codegen/call.h>
 #include <grpcpp/impl/codegen/call_hook.h>
 #include <grpcpp/impl/codegen/call_op_set_interface.h>
-#include <grpcpp/impl/codegen/client_context.h>
+#include <grpcpp/impl/codegen/client_context_impl.h>
 #include <grpcpp/impl/codegen/completion_queue.h>
 #include <grpcpp/impl/codegen/completion_queue_tag.h>
 #include <grpcpp/impl/codegen/config.h>
@@ -697,7 +697,7 @@
  public:
   CallOpRecvInitialMetadata() : metadata_map_(nullptr) {}
 
-  void RecvInitialMetadata(ClientContext* context) {
+  void RecvInitialMetadata(::grpc_impl::ClientContext* context) {
     context->initial_metadata_received_ = true;
     metadata_map_ = &context->recv_initial_metadata_;
   }
@@ -746,7 +746,7 @@
   CallOpClientRecvStatus()
       : recv_status_(nullptr), debug_error_string_(nullptr) {}
 
-  void ClientRecvStatus(ClientContext* context, Status* status) {
+  void ClientRecvStatus(::grpc_impl::ClientContext* context, Status* status) {
     client_context_ = context;
     metadata_map_ = &client_context_->trailing_metadata_;
     recv_status_ = status;
@@ -807,7 +807,7 @@
 
  private:
   bool hijacked_ = false;
-  ClientContext* client_context_;
+  ::grpc_impl::ClientContext* client_context_;
   MetadataMap* metadata_map_;
   Status* recv_status_;
   const char* debug_error_string_;
diff --git a/include/grpcpp/impl/codegen/client_callback.h b/include/grpcpp/impl/codegen/client_callback.h
index 86d06b7..9441a48 100644
--- a/include/grpcpp/impl/codegen/client_callback.h
+++ b/include/grpcpp/impl/codegen/client_callback.h
@@ -44,8 +44,8 @@
 /// TODO(vjpai): Combine as much as possible with the blocking unary call code
 template <class InputMessage, class OutputMessage>
 void CallbackUnaryCall(ChannelInterface* channel, const RpcMethod& method,
-                       ClientContext* context, const InputMessage* request,
-                       OutputMessage* result,
+                       ::grpc_impl::ClientContext* context,
+                       const InputMessage* request, OutputMessage* result,
                        std::function<void(Status)> on_completion) {
   CallbackUnaryCallImpl<InputMessage, OutputMessage> x(
       channel, method, context, request, result, on_completion);
@@ -55,8 +55,8 @@
 class CallbackUnaryCallImpl {
  public:
   CallbackUnaryCallImpl(ChannelInterface* channel, const RpcMethod& method,
-                        ClientContext* context, const InputMessage* request,
-                        OutputMessage* result,
+                        ::grpc_impl::ClientContext* context,
+                        const InputMessage* request, OutputMessage* result,
                         std::function<void(Status)> on_completion) {
     CompletionQueue* cq = channel->CallbackCQ();
     GPR_CODEGEN_ASSERT(cq != nullptr);
@@ -550,7 +550,7 @@
   friend class ClientCallbackReaderWriterFactory<Request, Response>;
 
   ClientCallbackReaderWriterImpl(
-      Call call, ClientContext* context,
+      Call call, ::grpc_impl::ClientContext* context,
       ::grpc::experimental::ClientBidiReactor<Request, Response>* reactor)
       : context_(context),
         call_(call),
@@ -559,7 +559,7 @@
     this->BindReactor(reactor);
   }
 
-  ClientContext* const context_;
+  ::grpc_impl::ClientContext* const context_;
   Call call_;
   ::grpc::experimental::ClientBidiReactor<Request, Response>* const reactor_;
 
@@ -594,7 +594,7 @@
  public:
   static void Create(
       ChannelInterface* channel, const ::grpc::internal::RpcMethod& method,
-      ClientContext* context,
+      ::grpc_impl::ClientContext* context,
       ::grpc::experimental::ClientBidiReactor<Request, Response>* reactor) {
     Call call = channel->CreateCall(method, context, channel->CallbackCQ());
 
@@ -692,7 +692,7 @@
 
   template <class Request>
   ClientCallbackReaderImpl(
-      Call call, ClientContext* context, Request* request,
+      Call call, ::grpc_impl::ClientContext* context, Request* request,
       ::grpc::experimental::ClientReadReactor<Response>* reactor)
       : context_(context), call_(call), reactor_(reactor) {
     this->BindReactor(reactor);
@@ -701,7 +701,7 @@
     start_ops_.ClientSendClose();
   }
 
-  ClientContext* const context_;
+  ::grpc_impl::ClientContext* const context_;
   Call call_;
   ::grpc::experimental::ClientReadReactor<Response>* const reactor_;
 
@@ -729,7 +729,7 @@
   template <class Request>
   static void Create(
       ChannelInterface* channel, const ::grpc::internal::RpcMethod& method,
-      ClientContext* context, const Request* request,
+      ::grpc_impl::ClientContext* context, const Request* request,
       ::grpc::experimental::ClientReadReactor<Response>* reactor) {
     Call call = channel->CreateCall(method, context, channel->CallbackCQ());
 
@@ -866,7 +866,7 @@
 
   template <class Response>
   ClientCallbackWriterImpl(
-      Call call, ClientContext* context, Response* response,
+      Call call, ::grpc_impl::ClientContext* context, Response* response,
       ::grpc::experimental::ClientWriteReactor<Request>* reactor)
       : context_(context),
         call_(call),
@@ -877,7 +877,7 @@
     finish_ops_.AllowNoMessage();
   }
 
-  ClientContext* const context_;
+  ::grpc_impl::ClientContext* const context_;
   Call call_;
   ::grpc::experimental::ClientWriteReactor<Request>* const reactor_;
 
@@ -909,7 +909,7 @@
   template <class Response>
   static void Create(
       ChannelInterface* channel, const ::grpc::internal::RpcMethod& method,
-      ClientContext* context, Response* response,
+      ::grpc_impl::ClientContext* context, Response* response,
       ::grpc::experimental::ClientWriteReactor<Request>* reactor) {
     Call call = channel->CreateCall(method, context, channel->CallbackCQ());
 
@@ -976,8 +976,8 @@
   friend class ClientCallbackUnaryFactory;
 
   template <class Request, class Response>
-  ClientCallbackUnaryImpl(Call call, ClientContext* context, Request* request,
-                          Response* response,
+  ClientCallbackUnaryImpl(Call call, ::grpc_impl::ClientContext* context,
+                          Request* request, Response* response,
                           ::grpc::experimental::ClientUnaryReactor* reactor)
       : context_(context), call_(call), reactor_(reactor) {
     this->BindReactor(reactor);
@@ -988,7 +988,7 @@
     finish_ops_.AllowNoMessage();
   }
 
-  ClientContext* const context_;
+  ::grpc_impl::ClientContext* const context_;
   Call call_;
   ::grpc::experimental::ClientUnaryReactor* const reactor_;
 
@@ -1011,8 +1011,8 @@
   template <class Request, class Response>
   static void Create(ChannelInterface* channel,
                      const ::grpc::internal::RpcMethod& method,
-                     ClientContext* context, const Request* request,
-                     Response* response,
+                     ::grpc_impl::ClientContext* context,
+                     const Request* request, Response* response,
                      ::grpc::experimental::ClientUnaryReactor* reactor) {
     Call call = channel->CreateCall(method, context, channel->CallbackCQ());
 
diff --git a/include/grpcpp/impl/codegen/intercepted_channel.h b/include/grpcpp/impl/codegen/intercepted_channel.h
index cd0fcc0..bcdd89d 100644
--- a/include/grpcpp/impl/codegen/intercepted_channel.h
+++ b/include/grpcpp/impl/codegen/intercepted_channel.h
@@ -49,7 +49,7 @@
   InterceptedChannel(ChannelInterface* channel, size_t pos)
       : channel_(channel), interceptor_pos_(pos) {}
 
-  Call CreateCall(const RpcMethod& method, ClientContext* context,
+  Call CreateCall(const RpcMethod& method, ::grpc_impl::ClientContext* context,
                   ::grpc_impl::CompletionQueue* cq) override {
     return channel_->CreateCallInternal(method, context, cq, interceptor_pos_);
   }
diff --git a/include/grpcpp/impl/codegen/method_handler_impl.h b/include/grpcpp/impl/codegen/method_handler_impl.h
index dee1cb5..1903f89 100644
--- a/include/grpcpp/impl/codegen/method_handler_impl.h
+++ b/include/grpcpp/impl/codegen/method_handler_impl.h
@@ -52,10 +52,11 @@
 template <class ServiceType, class RequestType, class ResponseType>
 class RpcMethodHandler : public MethodHandler {
  public:
-  RpcMethodHandler(std::function<Status(ServiceType*, ServerContext*,
-                                        const RequestType*, ResponseType*)>
-                       func,
-                   ServiceType* service)
+  RpcMethodHandler(
+      std::function<Status(ServiceType*, ::grpc_impl::ServerContext*,
+                           const RequestType*, ResponseType*)>
+          func,
+      ServiceType* service)
       : func_(func), service_(service) {}
 
   void RunHandler(const HandlerParameter& param) final {
@@ -103,8 +104,8 @@
 
  private:
   /// Application provided rpc handler function.
-  std::function<Status(ServiceType*, ServerContext*, const RequestType*,
-                       ResponseType*)>
+  std::function<Status(ServiceType*, ::grpc_impl::ServerContext*,
+                       const RequestType*, ResponseType*)>
       func_;
   // The class the above handler function lives in.
   ServiceType* service_;
@@ -115,7 +116,7 @@
 class ClientStreamingHandler : public MethodHandler {
  public:
   ClientStreamingHandler(
-      std::function<Status(ServiceType*, ServerContext*,
+      std::function<Status(ServiceType*, ::grpc_impl::ServerContext*,
                            ServerReader<RequestType>*, ResponseType*)>
           func,
       ServiceType* service)
@@ -147,8 +148,8 @@
   }
 
  private:
-  std::function<Status(ServiceType*, ServerContext*, ServerReader<RequestType>*,
-                       ResponseType*)>
+  std::function<Status(ServiceType*, ::grpc_impl::ServerContext*,
+                       ServerReader<RequestType>*, ResponseType*)>
       func_;
   ServiceType* service_;
 };
@@ -158,8 +159,8 @@
 class ServerStreamingHandler : public MethodHandler {
  public:
   ServerStreamingHandler(
-      std::function<Status(ServiceType*, ServerContext*, const RequestType*,
-                           ServerWriter<ResponseType>*)>
+      std::function<Status(ServiceType*, ::grpc_impl::ServerContext*,
+                           const RequestType*, ServerWriter<ResponseType>*)>
           func,
       ServiceType* service)
       : func_(func), service_(service) {}
@@ -207,8 +208,8 @@
   }
 
  private:
-  std::function<Status(ServiceType*, ServerContext*, const RequestType*,
-                       ServerWriter<ResponseType>*)>
+  std::function<Status(ServiceType*, ::grpc_impl::ServerContext*,
+                       const RequestType*, ServerWriter<ResponseType>*)>
       func_;
   ServiceType* service_;
 };
@@ -224,7 +225,7 @@
 class TemplatedBidiStreamingHandler : public MethodHandler {
  public:
   TemplatedBidiStreamingHandler(
-      std::function<Status(ServerContext*, Streamer*)> func)
+      std::function<Status(::grpc_impl::ServerContext*, Streamer*)> func)
       : func_(func), write_needed_(WriteNeeded) {}
 
   void RunHandler(const HandlerParameter& param) final {
@@ -256,7 +257,7 @@
   }
 
  private:
-  std::function<Status(ServerContext*, Streamer*)> func_;
+  std::function<Status(::grpc_impl::ServerContext*, Streamer*)> func_;
   const bool write_needed_;
 };
 
@@ -266,7 +267,7 @@
           ServerReaderWriter<ResponseType, RequestType>, false> {
  public:
   BidiStreamingHandler(
-      std::function<Status(ServiceType*, ServerContext*,
+      std::function<Status(ServiceType*, ::grpc_impl::ServerContext*,
                            ServerReaderWriter<ResponseType, RequestType>*)>
           func,
       ServiceType* service)
@@ -281,7 +282,7 @@
           ServerUnaryStreamer<RequestType, ResponseType>, true> {
  public:
   explicit StreamedUnaryHandler(
-      std::function<Status(ServerContext*,
+      std::function<Status(::grpc_impl::ServerContext*,
                            ServerUnaryStreamer<RequestType, ResponseType>*)>
           func)
       : TemplatedBidiStreamingHandler<
@@ -294,7 +295,7 @@
           ServerSplitStreamer<RequestType, ResponseType>, false> {
  public:
   explicit SplitServerStreamingHandler(
-      std::function<Status(ServerContext*,
+      std::function<Status(::grpc_impl::ServerContext*,
                            ServerSplitStreamer<RequestType, ResponseType>*)>
           func)
       : TemplatedBidiStreamingHandler<
@@ -307,7 +308,7 @@
 class ErrorMethodHandler : public MethodHandler {
  public:
   template <class T>
-  static void FillOps(ServerContext* context, T* ops) {
+  static void FillOps(::grpc_impl::ServerContext* context, T* ops) {
     Status status(code, "");
     if (!context->sent_initial_metadata_) {
       ops->SendInitialMetadata(&context->initial_metadata_,
diff --git a/include/grpcpp/impl/codegen/server_interface.h b/include/grpcpp/impl/codegen/server_interface.h
index 9600e5f..6239b4c 100644
--- a/include/grpcpp/impl/codegen/server_interface.h
+++ b/include/grpcpp/impl/codegen/server_interface.h
@@ -26,7 +26,7 @@
 #include <grpcpp/impl/codegen/completion_queue_tag.h>
 #include <grpcpp/impl/codegen/core_codegen_interface.h>
 #include <grpcpp/impl/codegen/rpc_service_method.h>
-#include <grpcpp/impl/codegen/server_context.h>
+#include <grpcpp/impl/codegen/server_context_impl.h>
 
 namespace grpc_impl {
 
diff --git a/include/grpcpp/impl/codegen/sync_stream.h b/include/grpcpp/impl/codegen/sync_stream.h
index 0d3fdfc..9d030a1 100644
--- a/include/grpcpp/impl/codegen/sync_stream.h
+++ b/include/grpcpp/impl/codegen/sync_stream.h
@@ -21,10 +21,10 @@
 
 #include <grpcpp/impl/codegen/call.h>
 #include <grpcpp/impl/codegen/channel_interface.h>
-#include <grpcpp/impl/codegen/client_context.h>
+#include <grpcpp/impl/codegen/client_context_impl.h>
 #include <grpcpp/impl/codegen/completion_queue.h>
 #include <grpcpp/impl/codegen/core_codegen_interface.h>
-#include <grpcpp/impl/codegen/server_context.h>
+#include <grpcpp/impl/codegen/server_context_impl.h>
 #include <grpcpp/impl/codegen/service_type.h>
 #include <grpcpp/impl/codegen/status.h>
 
@@ -163,7 +163,8 @@
   template <class W>
   static ClientReader<R>* Create(ChannelInterface* channel,
                                  const ::grpc::internal::RpcMethod& method,
-                                 ClientContext* context, const W& request) {
+                                 ::grpc_impl::ClientContext* context,
+                                 const W& request) {
     return new ClientReader<R>(channel, method, context, request);
   }
 };
@@ -230,8 +231,8 @@
 
  private:
   friend class internal::ClientReaderFactory<R>;
-  ClientContext* context_;
-  CompletionQueue cq_;
+  ::grpc_impl::ClientContext* context_;
+  ::grpc_impl::CompletionQueue cq_;
   ::grpc::internal::Call call_;
 
   /// Block to create a stream and write the initial metadata and \a request
@@ -240,7 +241,7 @@
   template <class W>
   ClientReader(::grpc::ChannelInterface* channel,
                const ::grpc::internal::RpcMethod& method,
-               ClientContext* context, const W& request)
+               ::grpc_impl::ClientContext* context, const W& request)
       : context_(context),
         cq_(grpc_completion_queue_attributes{
             GRPC_CQ_CURRENT_VERSION, GRPC_CQ_PLUCK, GRPC_CQ_DEFAULT_POLLING,
@@ -281,7 +282,8 @@
   template <class R>
   static ClientWriter<W>* Create(::grpc::ChannelInterface* channel,
                                  const ::grpc::internal::RpcMethod& method,
-                                 ClientContext* context, R* response) {
+                                 ::grpc_impl::ClientContext* context,
+                                 R* response) {
     return new ClientWriter<W>(channel, method, context, response);
   }
 };
@@ -374,7 +376,7 @@
   template <class R>
   ClientWriter(ChannelInterface* channel,
                const ::grpc::internal::RpcMethod& method,
-               ClientContext* context, R* response)
+               ::grpc_impl::ClientContext* context, R* response)
       : context_(context),
         cq_(grpc_completion_queue_attributes{
             GRPC_CQ_CURRENT_VERSION, GRPC_CQ_PLUCK, GRPC_CQ_DEFAULT_POLLING,
@@ -393,12 +395,12 @@
     }
   }
 
-  ClientContext* context_;
+  ::grpc_impl::ClientContext* context_;
   ::grpc::internal::CallOpSet<::grpc::internal::CallOpRecvInitialMetadata,
                               ::grpc::internal::CallOpGenericRecvMessage,
                               ::grpc::internal::CallOpClientRecvStatus>
       finish_ops_;
-  CompletionQueue cq_;
+  ::grpc_impl::CompletionQueue cq_;
   ::grpc::internal::Call call_;
 };
 
@@ -431,7 +433,8 @@
  public:
   static ClientReaderWriter<W, R>* Create(
       ::grpc::ChannelInterface* channel,
-      const ::grpc::internal::RpcMethod& method, ClientContext* context) {
+      const ::grpc::internal::RpcMethod& method,
+      ::grpc_impl::ClientContext* context) {
     return new ClientReaderWriter<W, R>(channel, method, context);
   }
 };
@@ -539,8 +542,8 @@
  private:
   friend class internal::ClientReaderWriterFactory<W, R>;
 
-  ClientContext* context_;
-  CompletionQueue cq_;
+  ::grpc_impl::ClientContext* context_;
+  ::grpc_impl::CompletionQueue cq_;
   ::grpc::internal::Call call_;
 
   /// Block to create a stream and write the initial metadata and \a request
@@ -548,7 +551,7 @@
   /// used to send to the server when starting the call.
   ClientReaderWriter(::grpc::ChannelInterface* channel,
                      const ::grpc::internal::RpcMethod& method,
-                     ClientContext* context)
+                     ::grpc_impl::ClientContext* context)
       : context_(context),
         cq_(grpc_completion_queue_attributes{
             GRPC_CQ_CURRENT_VERSION, GRPC_CQ_PLUCK, GRPC_CQ_DEFAULT_POLLING,
@@ -607,12 +610,12 @@
 
  private:
   internal::Call* const call_;
-  ServerContext* const ctx_;
+  ::grpc_impl::ServerContext* const ctx_;
 
   template <class ServiceType, class RequestType, class ResponseType>
   friend class internal::ClientStreamingHandler;
 
-  ServerReader(internal::Call* call, ServerContext* ctx)
+  ServerReader(internal::Call* call, ::grpc_impl::ServerContext* ctx)
       : call_(call), ctx_(ctx) {}
 };
 
@@ -681,12 +684,12 @@
 
  private:
   internal::Call* const call_;
-  ServerContext* const ctx_;
+  ::grpc_impl::ServerContext* const ctx_;
 
   template <class ServiceType, class RequestType, class ResponseType>
   friend class internal::ServerStreamingHandler;
 
-  ServerWriter(internal::Call* call, ServerContext* ctx)
+  ServerWriter(internal::Call* call, ::grpc_impl::ServerContext* ctx)
       : call_(call), ctx_(ctx) {}
 };
 
@@ -701,7 +704,7 @@
 template <class W, class R>
 class ServerReaderWriterBody final {
  public:
-  ServerReaderWriterBody(Call* call, ServerContext* ctx)
+  ServerReaderWriterBody(Call* call, ::grpc_impl::ServerContext* ctx)
       : call_(call), ctx_(ctx) {}
 
   void SendInitialMetadata() {
@@ -759,7 +762,7 @@
 
  private:
   Call* const call_;
-  ServerContext* const ctx_;
+  ::grpc_impl::ServerContext* const ctx_;
 };
 
 }  // namespace internal
@@ -797,7 +800,7 @@
 
   friend class internal::TemplatedBidiStreamingHandler<ServerReaderWriter<W, R>,
                                                        false>;
-  ServerReaderWriter(internal::Call* call, ServerContext* ctx)
+  ServerReaderWriter(internal::Call* call, ::grpc_impl::ServerContext* ctx)
       : body_(call, ctx) {}
 };
 
@@ -865,7 +868,7 @@
 
   friend class internal::TemplatedBidiStreamingHandler<
       ServerUnaryStreamer<RequestType, ResponseType>, true>;
-  ServerUnaryStreamer(internal::Call* call, ServerContext* ctx)
+  ServerUnaryStreamer(internal::Call* call, ::grpc_impl::ServerContext* ctx)
       : body_(call, ctx), read_done_(false), write_done_(false) {}
 };
 
@@ -925,7 +928,7 @@
 
   friend class internal::TemplatedBidiStreamingHandler<
       ServerSplitStreamer<RequestType, ResponseType>, false>;
-  ServerSplitStreamer(internal::Call* call, ServerContext* ctx)
+  ServerSplitStreamer(internal::Call* call, ::grpc_impl::ServerContext* ctx)
       : body_(call, ctx), read_done_(false) {}
 };
 
diff --git a/include/grpcpp/impl/server_builder_plugin.h b/include/grpcpp/impl/server_builder_plugin.h
index 84a88f2..349995c 100644
--- a/include/grpcpp/impl/server_builder_plugin.h
+++ b/include/grpcpp/impl/server_builder_plugin.h
@@ -21,11 +21,11 @@
 
 #include <memory>
 
+#include <grpcpp/support/channel_arguments.h>
 #include <grpcpp/support/config.h>
 
 namespace grpc_impl {
 
-class ChannelArguments;
 class ServerBuilder;
 class ServerInitializer;
 }  // namespace grpc_impl
@@ -57,7 +57,7 @@
 
   /// UpdateChannelArguments will be called in ServerBuilder::BuildAndStart(),
   /// before the Server instance is created.
-  virtual void UpdateChannelArguments(grpc_impl::ChannelArguments* args) {}
+  virtual void UpdateChannelArguments(ChannelArguments* args) {}
 
   virtual bool has_sync_methods() const { return false; }
   virtual bool has_async_methods() const { return false; }
diff --git a/include/grpcpp/security/credentials.h b/include/grpcpp/security/credentials.h
index e924275..b124d3d 100644
--- a/include/grpcpp/security/credentials.h
+++ b/include/grpcpp/security/credentials.h
@@ -28,6 +28,7 @@
 typedef ::grpc_impl::SslCredentialsOptions SslCredentialsOptions;
 typedef ::grpc_impl::SecureCallCredentials SecureCallCredentials;
 typedef ::grpc_impl::SecureChannelCredentials SecureChannelCredentials;
+typedef ::grpc_impl::MetadataCredentialsPlugin MetadataCredentialsPlugin;
 
 static inline std::shared_ptr<grpc_impl::ChannelCredentials>
 GoogleDefaultCredentials() {
diff --git a/include/grpcpp/security/credentials_impl.h b/include/grpcpp/security/credentials_impl.h
index 29ba2075..34920a5 100644
--- a/include/grpcpp/security/credentials_impl.h
+++ b/include/grpcpp/security/credentials_impl.h
@@ -24,11 +24,11 @@
 #include <vector>
 
 #include <grpc/grpc_security_constants.h>
-#include <grpcpp/channel.h>
+#include <grpcpp/channel_impl.h>
 #include <grpcpp/impl/codegen/client_interceptor.h>
 #include <grpcpp/impl/codegen/grpc_library.h>
 #include <grpcpp/security/auth_context.h>
-#include <grpcpp/support/channel_arguments.h>
+#include <grpcpp/support/channel_arguments_impl.h>
 #include <grpcpp/support/status.h>
 #include <grpcpp/support/string_ref.h>
 
@@ -41,16 +41,16 @@
 class SecureCallCredentials;
 class SecureChannelCredentials;
 
-std::shared_ptr<::grpc::Channel> CreateCustomChannelImpl(
+std::shared_ptr<Channel> CreateCustomChannelImpl(
     const grpc::string& target,
     const std::shared_ptr<ChannelCredentials>& creds,
-    const grpc::ChannelArguments& args);
+    const ChannelArguments& args);
 
 namespace experimental {
-std::shared_ptr<::grpc::Channel> CreateCustomChannelWithInterceptors(
+std::shared_ptr<Channel> CreateCustomChannelWithInterceptors(
     const grpc::string& target,
     const std::shared_ptr<ChannelCredentials>& creds,
-    const grpc::ChannelArguments& args,
+    const ChannelArguments& args,
     std::vector<
         std::unique_ptr<grpc::experimental::ClientInterceptorFactoryInterface>>
         interceptor_creators);
@@ -75,27 +75,27 @@
   virtual SecureChannelCredentials* AsSecureCredentials() = 0;
 
  private:
-  friend std::shared_ptr<::grpc::Channel> CreateCustomChannelImpl(
+  friend std::shared_ptr<Channel> CreateCustomChannelImpl(
       const grpc::string& target,
       const std::shared_ptr<ChannelCredentials>& creds,
-      const grpc::ChannelArguments& args);
+      const ChannelArguments& args);
 
-  friend std::shared_ptr<::grpc::Channel>
+  friend std::shared_ptr<Channel>
   grpc_impl::experimental::CreateCustomChannelWithInterceptors(
       const grpc::string& target,
       const std::shared_ptr<ChannelCredentials>& creds,
-      const grpc::ChannelArguments& args,
+      const ChannelArguments& args,
       std::vector<std::unique_ptr<
           grpc::experimental::ClientInterceptorFactoryInterface>>
           interceptor_creators);
 
-  virtual std::shared_ptr<::grpc::Channel> CreateChannelImpl(
-      const grpc::string& target, const grpc::ChannelArguments& args) = 0;
+  virtual std::shared_ptr<Channel> CreateChannelImpl(
+      const grpc::string& target, const ChannelArguments& args) = 0;
 
   // This function should have been a pure virtual function, but it is
   // implemented as a virtual function so that it does not break API.
-  virtual std::shared_ptr<::grpc::Channel> CreateChannelWithInterceptors(
-      const grpc::string& target, const grpc::ChannelArguments& args,
+  virtual std::shared_ptr<Channel> CreateChannelWithInterceptors(
+      const grpc::string& target, const ChannelArguments& args,
       std::vector<std::unique_ptr<
           grpc::experimental::ClientInterceptorFactoryInterface>>
           interceptor_creators) {
diff --git a/include/grpcpp/server_impl.h b/include/grpcpp/server_impl.h
index b75012e..056f5f0 100644
--- a/include/grpcpp/server_impl.h
+++ b/include/grpcpp/server_impl.h
@@ -27,16 +27,16 @@
 
 #include <grpc/compression.h>
 #include <grpc/support/atm.h>
-#include <grpcpp/channel.h>
-#include <grpcpp/completion_queue.h>
+#include <grpcpp/channel_impl.h>
 #include <grpcpp/health_check_service_interface.h>
 #include <grpcpp/impl/call.h>
 #include <grpcpp/impl/codegen/client_interceptor.h>
+#include <grpcpp/impl/codegen/completion_queue_impl.h>
 #include <grpcpp/impl/codegen/grpc_library.h>
 #include <grpcpp/impl/codegen/server_interface.h>
 #include <grpcpp/impl/rpc_service_method.h>
 #include <grpcpp/security/server_credentials.h>
-#include <grpcpp/support/channel_arguments.h>
+#include <grpcpp/support/channel_arguments_impl.h>
 #include <grpcpp/support/config.h>
 #include <grpcpp/support/status.h>
 
@@ -80,7 +80,7 @@
    public:
     virtual ~GlobalCallbacks() {}
     /// Called before server is created.
-    virtual void UpdateArguments(grpc::ChannelArguments* args) {}
+    virtual void UpdateArguments(ChannelArguments* args) {}
     /// Called before application callback for each synchronous server request
     virtual void PreSynchronousRequest(grpc_impl::ServerContext* context) = 0;
     /// Called after application callback for each synchronous server request
@@ -108,8 +108,7 @@
   }
 
   /// Establish a channel for in-process communication
-  std::shared_ptr<::grpc::Channel> InProcessChannel(
-      const grpc::ChannelArguments& args);
+  std::shared_ptr<Channel> InProcessChannel(const ChannelArguments& args);
 
   /// NOTE: class experimental_type is not part of the public API of this class.
   /// TODO(yashykt): Integrate into public API when this is no longer
@@ -120,8 +119,8 @@
 
     /// Establish a channel for in-process communication with client
     /// interceptors
-    std::shared_ptr<::grpc::Channel> InProcessChannelWithInterceptors(
-        const grpc::ChannelArguments& args,
+    std::shared_ptr<Channel> InProcessChannelWithInterceptors(
+        const ChannelArguments& args,
         std::vector<std::unique_ptr<
             grpc::experimental::ClientInterceptorFactoryInterface>>
             interceptor_creators);
@@ -182,19 +181,18 @@
   ///
   /// \param sync_cq_timeout_msec The timeout to use when calling AsyncNext() on
   /// server completion queues passed via sync_server_cqs param.
-  Server(
-      int max_message_size, grpc::ChannelArguments* args,
-      std::shared_ptr<std::vector<std::unique_ptr<grpc::ServerCompletionQueue>>>
-          sync_server_cqs,
-      int min_pollers, int max_pollers, int sync_cq_timeout_msec,
-      std::vector<
-          std::shared_ptr<grpc::internal::ExternalConnectionAcceptorImpl>>
-          acceptors,
-      grpc_resource_quota* server_rq = nullptr,
-      std::vector<std::unique_ptr<
-          grpc::experimental::ServerInterceptorFactoryInterface>>
-          interceptor_creators = std::vector<std::unique_ptr<
-              grpc::experimental::ServerInterceptorFactoryInterface>>());
+  Server(int max_message_size, ChannelArguments* args,
+         std::shared_ptr<std::vector<std::unique_ptr<ServerCompletionQueue>>>
+             sync_server_cqs,
+         int min_pollers, int max_pollers, int sync_cq_timeout_msec,
+         std::vector<
+             std::shared_ptr<grpc::internal::ExternalConnectionAcceptorImpl>>
+             acceptors,
+         grpc_resource_quota* server_rq = nullptr,
+         std::vector<std::unique_ptr<
+             grpc::experimental::ServerInterceptorFactoryInterface>>
+             interceptor_creators = std::vector<std::unique_ptr<
+                 grpc::experimental::ServerInterceptorFactoryInterface>>());
 
   /// Start the server.
   ///
@@ -202,7 +200,7 @@
   /// caller is required to keep all completion queues live until the server is
   /// destroyed.
   /// \param num_cqs How many completion queues does \a cqs hold.
-  void Start(grpc::ServerCompletionQueue** cqs, size_t num_cqs) override;
+  void Start(ServerCompletionQueue** cqs, size_t num_cqs) override;
 
   grpc_server* server() override { return server_; }
 
@@ -283,7 +281,7 @@
     return max_receive_message_size_;
   }
 
-  grpc::CompletionQueue* CallbackCQ() override;
+  CompletionQueue* CallbackCQ() override;
 
   grpc_impl::ServerInitializer* initializer();
 
@@ -304,7 +302,7 @@
   /// The following completion queues are ONLY used in case of Sync API
   /// i.e. if the server has any services with sync methods. The server uses
   /// these completion queues to poll for new RPCs
-  std::shared_ptr<std::vector<std::unique_ptr<grpc::ServerCompletionQueue>>>
+  std::shared_ptr<std::vector<std::unique_ptr<ServerCompletionQueue>>>
       sync_server_cqs_;
 
   /// List of \a ThreadManager instances (one for each cq in
@@ -374,7 +372,7 @@
   // It is _not owned_ by the server; ownership belongs with its internal
   // shutdown callback tag (invoked when the CQ is fully shutdown).
   // It is protected by mu_
-  grpc::CompletionQueue* callback_cq_ = nullptr;
+  CompletionQueue* callback_cq_ = nullptr;
 };
 
 }  // namespace grpc_impl
diff --git a/src/compiler/cpp_generator.cc b/src/compiler/cpp_generator.cc
index 23e3bd5..358efe9 100644
--- a/src/compiler/cpp_generator.cc
+++ b/src/compiler/cpp_generator.cc
@@ -142,14 +142,17 @@
         "grpcpp/impl/codegen/async_stream.h",
         "grpcpp/impl/codegen/async_unary_call.h",
         "grpcpp/impl/codegen/client_callback.h",
+        "grpcpp/impl/codegen/client_context.h",
         "grpcpp/impl/codegen/method_handler_impl.h",
         "grpcpp/impl/codegen/proto_utils.h",
         "grpcpp/impl/codegen/rpc_method.h",
         "grpcpp/impl/codegen/server_callback.h",
+        "grpcpp/impl/codegen/server_context.h",
         "grpcpp/impl/codegen/service_type.h",
         "grpcpp/impl/codegen/status.h",
         "grpcpp/impl/codegen/stub_options.h",
-        "grpcpp/impl/codegen/sync_stream.h"};
+        "grpcpp/impl/codegen/sync_stream.h",
+    };
     std::vector<grpc::string> headers(headers_strs, array_end(headers_strs));
     PrintIncludes(printer.get(), headers, params.use_system_headers,
                   params.grpc_search_path);
diff --git a/src/core/lib/transport/metadata.h b/src/core/lib/transport/metadata.h
index 3cef031..4b96850 100644
--- a/src/core/lib/transport/metadata.h
+++ b/src/core/lib/transport/metadata.h
@@ -348,10 +348,11 @@
          free an interned md at any time: it's unsafe from this point on to
          access it so we read the hash now. */
       uint32_t hash = md->hash();
-      if (GPR_UNLIKELY(md->Unref())) {
 #ifndef NDEBUG
+      if (GPR_UNLIKELY(md->Unref(file, line))) {
         grpc_mdelem_on_final_unref(storage, md, hash, file, line);
 #else
+      if (GPR_UNLIKELY(md->Unref())) {
         grpc_mdelem_on_final_unref(storage, md, hash);
 #endif
       }
diff --git a/src/cpp/client/create_channel_internal.h b/src/cpp/client/create_channel_internal.h
index 3b201af..4abd4c3 100644
--- a/src/cpp/client/create_channel_internal.h
+++ b/src/cpp/client/create_channel_internal.h
@@ -21,6 +21,7 @@
 
 #include <memory>
 
+#include <grpcpp/channel.h>
 #include <grpcpp/impl/codegen/client_interceptor.h>
 #include <grpcpp/support/config.h>
 
diff --git a/src/cpp/client/insecure_credentials.cc b/src/cpp/client/insecure_credentials.cc
index dcbb56d..0556fa0 100644
--- a/src/cpp/client/insecure_credentials.cc
+++ b/src/cpp/client/insecure_credentials.cc
@@ -15,13 +15,11 @@
  * limitations under the License.
  *
  */
-
 #include <grpcpp/security/credentials.h>
 
 #include <grpc/grpc.h>
 #include <grpc/support/log.h>
 #include <grpcpp/channel.h>
-#include <grpcpp/security/credentials.h>
 #include <grpcpp/support/channel_arguments.h>
 #include <grpcpp/support/config.h>
 #include "src/cpp/client/create_channel_internal.h"
@@ -31,16 +29,16 @@
 namespace {
 class InsecureChannelCredentialsImpl final : public ChannelCredentials {
  public:
-  std::shared_ptr<::grpc::Channel> CreateChannelImpl(
-      const grpc::string& target, const grpc::ChannelArguments& args) override {
+  std::shared_ptr<Channel> CreateChannelImpl(
+      const grpc::string& target, const ChannelArguments& args) override {
     return CreateChannelWithInterceptors(
         target, args,
         std::vector<std::unique_ptr<
             grpc::experimental::ClientInterceptorFactoryInterface>>());
   }
 
-  std::shared_ptr<::grpc::Channel> CreateChannelWithInterceptors(
-      const grpc::string& target, const grpc::ChannelArguments& args,
+  std::shared_ptr<Channel> CreateChannelWithInterceptors(
+      const grpc::string& target, const ChannelArguments& args,
       std::vector<std::unique_ptr<
           grpc::experimental::ClientInterceptorFactoryInterface>>
           interceptor_creators) override {
diff --git a/src/cpp/client/secure_credentials.cc b/src/cpp/client/secure_credentials.cc
index 197112d..d73b3e0 100644
--- a/src/cpp/client/secure_credentials.cc
+++ b/src/cpp/client/secure_credentials.cc
@@ -36,17 +36,17 @@
   g_gli_initializer.summon();
 }
 
-std::shared_ptr<grpc::Channel> SecureChannelCredentials::CreateChannelImpl(
-    const grpc::string& target, const grpc::ChannelArguments& args) {
+std::shared_ptr<Channel> SecureChannelCredentials::CreateChannelImpl(
+    const grpc::string& target, const ChannelArguments& args) {
   return CreateChannelWithInterceptors(
       target, args,
       std::vector<std::unique_ptr<
           grpc::experimental::ClientInterceptorFactoryInterface>>());
 }
 
-std::shared_ptr<grpc::Channel>
+std::shared_ptr<Channel>
 SecureChannelCredentials::CreateChannelWithInterceptors(
-    const grpc::string& target, const grpc::ChannelArguments& args,
+    const grpc::string& target, const ChannelArguments& args,
     std::vector<
         std::unique_ptr<grpc::experimental::ClientInterceptorFactoryInterface>>
         interceptor_creators) {
@@ -209,7 +209,7 @@
   return nullptr;
 }
 
-std::shared_ptr<grpc_impl::CallCredentials> MetadataCredentialsFromPlugin(
+std::shared_ptr<CallCredentials> MetadataCredentialsFromPlugin(
     std::unique_ptr<MetadataCredentialsPlugin> plugin) {
   grpc::GrpcLibraryCodegen init;  // To call grpc_init().
   const char* type = plugin->GetType();
diff --git a/src/cpp/client/secure_credentials.h b/src/cpp/client/secure_credentials.h
index c4eef6c..dd379ca 100644
--- a/src/cpp/client/secure_credentials.h
+++ b/src/cpp/client/secure_credentials.h
@@ -39,14 +39,14 @@
   }
   grpc_channel_credentials* GetRawCreds() { return c_creds_; }
 
-  std::shared_ptr<::grpc::Channel> CreateChannelImpl(
-      const grpc::string& target, const grpc::ChannelArguments& args) override;
+  std::shared_ptr<Channel> CreateChannelImpl(
+      const grpc::string& target, const ChannelArguments& args) override;
 
   SecureChannelCredentials* AsSecureCredentials() override { return this; }
 
  private:
-  std::shared_ptr<::grpc::Channel> CreateChannelWithInterceptors(
-      const grpc::string& target, const grpc::ChannelArguments& args,
+  std::shared_ptr<Channel> CreateChannelWithInterceptors(
+      const grpc::string& target, const ChannelArguments& args,
       std::vector<std::unique_ptr<
           ::grpc::experimental::ClientInterceptorFactoryInterface>>
           interceptor_creators) override;
diff --git a/src/python/grpcio/grpc/_cython/_cygrpc/grpc_gevent.pxd.pxi b/src/python/grpcio/grpc/_cython/_cygrpc/grpc_gevent.pxd.pxi
index 59b3891..30fdf6a 100644
--- a/src/python/grpcio/grpc/_cython/_cygrpc/grpc_gevent.pxd.pxi
+++ b/src/python/grpcio/grpc/_cython/_cygrpc/grpc_gevent.pxd.pxi
@@ -44,12 +44,12 @@
     pass
 
   struct grpc_custom_resolver_vtable:
-    grpc_error* (*resolve)(char* host, char* port, grpc_resolved_addresses** res) except *
-    void (*resolve_async)(grpc_custom_resolver* resolver, char* host, char* port) except *
+    grpc_error* (*resolve)(char* host, char* port, grpc_resolved_addresses** res);
+    void (*resolve_async)(grpc_custom_resolver* resolver, char* host, char* port);
 
   void grpc_custom_resolve_callback(grpc_custom_resolver* resolver,
                                     grpc_resolved_addresses* result,
-                                    grpc_error* error)
+                                    grpc_error* error);
 
 cdef extern from "src/core/lib/iomgr/tcp_custom.h":
   struct grpc_custom_socket:
@@ -67,25 +67,25 @@
   ctypedef void (*grpc_custom_close_callback)(grpc_custom_socket* socket)
 
   struct grpc_socket_vtable:
-      grpc_error* (*init)(grpc_custom_socket* socket, int domain) except *
+      grpc_error* (*init)(grpc_custom_socket* socket, int domain);
       void (*connect)(grpc_custom_socket* socket, const grpc_sockaddr* addr,
-                      size_t len, grpc_custom_connect_callback cb) except *
-      void (*destroy)(grpc_custom_socket* socket) except *
-      void (*shutdown)(grpc_custom_socket* socket) except *
-      void (*close)(grpc_custom_socket* socket, grpc_custom_close_callback cb) except *
+                      size_t len, grpc_custom_connect_callback cb);
+      void (*destroy)(grpc_custom_socket* socket);
+      void (*shutdown)(grpc_custom_socket* socket);
+      void (*close)(grpc_custom_socket* socket, grpc_custom_close_callback cb);
       void (*write)(grpc_custom_socket* socket, grpc_slice_buffer* slices,
-                    grpc_custom_write_callback cb) except *
+                    grpc_custom_write_callback cb);
       void (*read)(grpc_custom_socket* socket, char* buffer, size_t length,
-                   grpc_custom_read_callback cb) except *
+                   grpc_custom_read_callback cb);
       grpc_error* (*getpeername)(grpc_custom_socket* socket,
-                                 const grpc_sockaddr* addr, int* len) except *
+                                 const grpc_sockaddr* addr, int* len);
       grpc_error* (*getsockname)(grpc_custom_socket* socket,
-                             const grpc_sockaddr* addr, int* len) except *
+                             const grpc_sockaddr* addr, int* len);
       grpc_error* (*bind)(grpc_custom_socket* socket, const grpc_sockaddr* addr,
-                          size_t len, int flags) except *
-      grpc_error* (*listen)(grpc_custom_socket* socket) except *
+                          size_t len, int flags);
+      grpc_error* (*listen)(grpc_custom_socket* socket);
       void (*accept)(grpc_custom_socket* socket, grpc_custom_socket* client,
-                     grpc_custom_accept_callback cb) except *
+                     grpc_custom_accept_callback cb);
 
 cdef extern from "src/core/lib/iomgr/timer_custom.h":
   struct grpc_custom_timer:
@@ -94,17 +94,17 @@
      # We don't care about the rest of the fields
 
   struct grpc_custom_timer_vtable:
-    void (*start)(grpc_custom_timer* t) except *
-    void (*stop)(grpc_custom_timer* t) except *
+    void (*start)(grpc_custom_timer* t);
+    void (*stop)(grpc_custom_timer* t);
 
-  void grpc_custom_timer_callback(grpc_custom_timer* t, grpc_error* error)
+  void grpc_custom_timer_callback(grpc_custom_timer* t, grpc_error* error);
 
 cdef extern from "src/core/lib/iomgr/pollset_custom.h":
   struct grpc_custom_poller_vtable:
-    void (*init)() except *
-    void (*poll)(size_t timeout_ms) except *
-    void (*kick)() except *
-    void (*shutdown)() except *
+    void (*init)()
+    void (*poll)(size_t timeout_ms)
+    void (*kick)()
+    void (*shutdown)()
 
 cdef extern from "src/core/lib/iomgr/iomgr_custom.h":
   void grpc_custom_iomgr_init(grpc_socket_vtable* socket,
diff --git a/src/python/grpcio/grpc/_cython/_cygrpc/grpc_gevent.pyx.pxi b/src/python/grpcio/grpc/_cython/_cygrpc/grpc_gevent.pyx.pxi
index f82fca2..a1618d0 100644
--- a/src/python/grpcio/grpc/_cython/_cygrpc/grpc_gevent.pyx.pxi
+++ b/src/python/grpcio/grpc/_cython/_cygrpc/grpc_gevent.pyx.pxi
@@ -56,7 +56,7 @@
   c_addr.len = length
   return grpc_sockaddr_get_uri_scheme(&c_addr) == b'ipv4'
 
-cdef grpc_resolved_addresses* tuples_to_resolvaddr(tups) except *:
+cdef grpc_resolved_addresses* tuples_to_resolvaddr(tups):
   cdef grpc_resolved_addresses* addresses
   tups_set = set((tup[4][0], tup[4][1]) for tup in tups)
   addresses = <grpc_resolved_addresses*> malloc(sizeof(grpc_resolved_addresses))
@@ -84,7 +84,7 @@
     self.c_buffer = NULL
     self.len = 0
 
-cdef grpc_error* socket_init(grpc_custom_socket* socket, int domain) except * with gil:
+cdef grpc_error* socket_init(grpc_custom_socket* socket, int domain) with gil:
   sw = SocketWrapper()
   sw.c_socket = socket
   sw.sockopts = []
@@ -112,7 +112,7 @@
 
 cdef void socket_connect(grpc_custom_socket* socket, const grpc_sockaddr* addr,
                          size_t addr_len,
-                         grpc_custom_connect_callback cb) except * with gil:
+                         grpc_custom_connect_callback cb) with gil:
   py_socket = None
   socket_wrapper = <SocketWrapper>socket.impl
   socket_wrapper.connect_cb = cb
@@ -125,10 +125,10 @@
   socket_wrapper.socket = py_socket
   _spawn_greenlet(socket_connect_async, socket_wrapper, addr_tuple)
 
-cdef void socket_destroy(grpc_custom_socket* socket) except * with gil:
+cdef void socket_destroy(grpc_custom_socket* socket) with gil:
   cpython.Py_DECREF(<SocketWrapper>socket.impl)
 
-cdef void socket_shutdown(grpc_custom_socket* socket) except * with gil:
+cdef void socket_shutdown(grpc_custom_socket* socket) with gil:
   try:
     (<SocketWrapper>socket.impl).socket.shutdown(gevent_socket.SHUT_RDWR)
   except IOError as io_error:
@@ -136,7 +136,7 @@
       raise io_error
 
 cdef void socket_close(grpc_custom_socket* socket,
-                       grpc_custom_close_callback cb) except * with gil:
+                       grpc_custom_close_callback cb) with gil:
   socket_wrapper = (<SocketWrapper>socket.impl)
   if socket_wrapper.socket is not None:
     socket_wrapper.socket.close()
@@ -176,7 +176,7 @@
   socket_write_async_cython(socket_wrapper, write_bytes)
 
 cdef void socket_write(grpc_custom_socket* socket, grpc_slice_buffer* buffer,
-                       grpc_custom_write_callback cb) except * with gil:
+                       grpc_custom_write_callback cb) with gil:
   cdef char* start
   sw = <SocketWrapper>socket.impl
   sw.write_cb = cb
@@ -204,7 +204,7 @@
   socket_read_async_cython(socket_wrapper)
 
 cdef void socket_read(grpc_custom_socket* socket, char* buffer,
-                      size_t length, grpc_custom_read_callback cb) except * with gil:
+                      size_t length, grpc_custom_read_callback cb) with gil:
   sw = <SocketWrapper>socket.impl
   sw.read_cb = cb
   sw.c_buffer = buffer
@@ -213,7 +213,7 @@
 
 cdef grpc_error* socket_getpeername(grpc_custom_socket* socket,
                                     const grpc_sockaddr* addr,
-                                    int* length) except * with gil:
+                                    int* length) with gil:
   cdef char* src_buf
   peer = (<SocketWrapper>socket.impl).socket.getpeername()
 
@@ -226,7 +226,7 @@
 
 cdef grpc_error* socket_getsockname(grpc_custom_socket* socket,
                                     const grpc_sockaddr* addr,
-                                    int* length) except * with gil:
+                                    int* length) with gil:
   cdef char* src_buf
   cdef grpc_resolved_address c_addr
   if (<SocketWrapper>socket.impl).socket is None:
@@ -245,7 +245,7 @@
 
 cdef grpc_error* socket_bind(grpc_custom_socket* socket,
                              const grpc_sockaddr* addr,
-                             size_t len, int flags) except * with gil:
+                             size_t len, int flags) with gil:
   addr_tuple = sockaddr_to_tuple(addr, len)
   try:
     try:
@@ -262,7 +262,7 @@
   else:
     return grpc_error_none()
 
-cdef grpc_error* socket_listen(grpc_custom_socket* socket) except * with gil:
+cdef grpc_error* socket_listen(grpc_custom_socket* socket) with gil:
   (<SocketWrapper>socket.impl).socket.listen(50)
   return grpc_error_none()
 
@@ -292,7 +292,7 @@
   accept_callback_cython(s)
 
 cdef void socket_accept(grpc_custom_socket* socket, grpc_custom_socket* client,
-                        grpc_custom_accept_callback cb) except * with gil:
+                        grpc_custom_accept_callback cb) with gil:
   sw = <SocketWrapper>socket.impl
   sw.accepting_socket = client
   sw.accept_cb = cb
@@ -322,7 +322,7 @@
 def socket_resolve_async_python(resolve_wrapper):
   socket_resolve_async_cython(resolve_wrapper)
 
-cdef void socket_resolve_async(grpc_custom_resolver* r, char* host, char* port) except * with gil:
+cdef void socket_resolve_async(grpc_custom_resolver* r, char* host, char* port) with gil:
   rw = ResolveWrapper()
   rw.c_resolver = r
   rw.c_host = host
@@ -330,7 +330,7 @@
   _spawn_greenlet(socket_resolve_async_python, rw)
 
 cdef grpc_error* socket_resolve(char* host, char* port,
-                                grpc_resolved_addresses** res) except * with gil:
+                                grpc_resolved_addresses** res) with gil:
     try:
       result = gevent_socket.getaddrinfo(host, port)
       res[0] = tuples_to_resolvaddr(result)
@@ -360,13 +360,13 @@
     self.event.set()
     self.timer.stop()
 
-cdef void timer_start(grpc_custom_timer* t) except * with gil:
+cdef void timer_start(grpc_custom_timer* t) with gil:
   timer = TimerWrapper(t.timeout_ms / 1000.0)
   timer.c_timer = t
   t.timer = <void*>timer
   timer.start()
 
-cdef void timer_stop(grpc_custom_timer* t) except * with gil:
+cdef void timer_stop(grpc_custom_timer* t) with gil:
   time_wrapper = <object>t.timer
   time_wrapper.stop()
 
@@ -374,16 +374,16 @@
 ### pollset implementation ###
 ###############################
 
-cdef void init_loop() except * with gil:
+cdef void init_loop() with gil:
   pass
 
-cdef void destroy_loop() except * with gil:
+cdef void destroy_loop() with gil:
   g_pool.join()
 
-cdef void kick_loop() except * with gil:
+cdef void kick_loop() with gil:
   g_event.set()
 
-cdef void run_loop(size_t timeout_ms) except * with gil:
+cdef void run_loop(size_t timeout_ms) with gil:
     timeout = timeout_ms / 1000.0
     if timeout_ms > 0:
       g_event.wait(timeout)
diff --git a/test/cpp/codegen/compiler_test_golden b/test/cpp/codegen/compiler_test_golden
index 64ab123..0359550 100644
--- a/test/cpp/codegen/compiler_test_golden
+++ b/test/cpp/codegen/compiler_test_golden
@@ -31,10 +31,12 @@
 #include <grpcpp/impl/codegen/async_stream.h>
 #include <grpcpp/impl/codegen/async_unary_call.h>
 #include <grpcpp/impl/codegen/client_callback.h>
+#include <grpcpp/impl/codegen/client_context.h>
 #include <grpcpp/impl/codegen/method_handler_impl.h>
 #include <grpcpp/impl/codegen/proto_utils.h>
 #include <grpcpp/impl/codegen/rpc_method.h>
 #include <grpcpp/impl/codegen/server_callback.h>
+#include <grpcpp/impl/codegen/server_context.h>
 #include <grpcpp/impl/codegen/service_type.h>
 #include <grpcpp/impl/codegen/status.h>
 #include <grpcpp/impl/codegen/stub_options.h>
diff --git a/test/cpp/qps/server.h b/test/cpp/qps/server.h
index 89b0e3a..2b82abc 100644
--- a/test/cpp/qps/server.h
+++ b/test/cpp/qps/server.h
@@ -21,6 +21,7 @@
 
 #include <grpc/support/cpu.h>
 #include <grpc/support/log.h>
+#include <grpcpp/channel.h>
 #include <grpcpp/resource_quota.h>
 #include <grpcpp/security/server_credentials.h>
 #include <grpcpp/server_builder.h>
diff --git a/test/cpp/util/create_test_channel.h b/test/cpp/util/create_test_channel.h
index 42564a3..2aacbc9 100644
--- a/test/cpp/util/create_test_channel.h
+++ b/test/cpp/util/create_test_channel.h
@@ -21,8 +21,10 @@
 
 #include <memory>
 
+#include <grpcpp/channel.h>
 #include <grpcpp/impl/codegen/client_interceptor.h>
 #include <grpcpp/security/credentials.h>
+#include <grpcpp/support/channel_arguments.h>
 
 namespace grpc_impl {
 
@@ -37,31 +39,31 @@
 
 }  // namespace testing
 
-std::shared_ptr<::grpc_impl::Channel> CreateTestChannel(
+std::shared_ptr<Channel> CreateTestChannel(
     const grpc::string& server, testing::transport_security security_type);
 
-std::shared_ptr<::grpc_impl::Channel> CreateTestChannel(
+std::shared_ptr<Channel> CreateTestChannel(
     const grpc::string& server, const grpc::string& override_hostname,
     testing::transport_security security_type, bool use_prod_roots);
 
-std::shared_ptr<::grpc_impl::Channel> CreateTestChannel(
+std::shared_ptr<Channel> CreateTestChannel(
     const grpc::string& server, const grpc::string& override_hostname,
     testing::transport_security security_type, bool use_prod_roots,
     const std::shared_ptr<CallCredentials>& creds);
 
-std::shared_ptr<::grpc_impl::Channel> CreateTestChannel(
+std::shared_ptr<Channel> CreateTestChannel(
     const grpc::string& server, const grpc::string& override_hostname,
     testing::transport_security security_type, bool use_prod_roots,
     const std::shared_ptr<CallCredentials>& creds,
     const ChannelArguments& args);
 
-std::shared_ptr<::grpc_impl::Channel> CreateTestChannel(
+std::shared_ptr<Channel> CreateTestChannel(
     const grpc::string& server, const grpc::string& cred_type,
     const grpc::string& override_hostname, bool use_prod_roots,
     const std::shared_ptr<CallCredentials>& creds,
     const ChannelArguments& args);
 
-std::shared_ptr<::grpc_impl::Channel> CreateTestChannel(
+std::shared_ptr<Channel> CreateTestChannel(
     const grpc::string& server, const grpc::string& credential_type,
     const std::shared_ptr<CallCredentials>& creds);