1 files changed, 28 insertions, 15 deletions

diff --git a/include/grpcpp/impl/codegen/rpc_service_method.h b/include/grpcpp/impl/codegen/rpc_service_method.h
index e77f4046a3..44d9b8ad63 100644
--- a/include/grpcpp/impl/codegen/rpc_service_method.h
+++ b/include/grpcpp/impl/codegen/rpc_service_method.h
@@ -41,13 +41,18 @@ class MethodHandler {
   virtual ~MethodHandler() {}
   struct HandlerParameter {
     HandlerParameter(Call* c, ServerContext* context, void* req,
-                     Status req_status)
-        : call(c), server_context(context), request(req), status(req_status) {}
+                     Status req_status, std::function<void()> renew)
+        : call(c),
+          server_context(context),
+          request(req),
+          status(req_status),
+          renewer(std::move(renew)) {}
     ~HandlerParameter() {}
     Call* call;
     ServerContext* server_context;
     void* request;
     Status status;
+    std::function<void()> renewer;
   };
   virtual void RunHandler(const HandlerParameter& param) = 0;
 
@@ -71,25 +76,29 @@ class RpcServiceMethod : public RpcMethod {
                    MethodHandler* handler)
       : RpcMethod(name, type),
         server_tag_(nullptr),
-        async_type_(AsyncType::UNSET),
+        api_type_(ApiType::SYNC),
         handler_(handler) {}
 
-  enum class AsyncType {
-    UNSET,
+  enum class ApiType {
+    SYNC,
     ASYNC,
     RAW,
+    CALL_BACK,  // not CALLBACK because that is reserved in Windows
+    RAW_CALL_BACK,
   };
 
   void set_server_tag(void* tag) { server_tag_ = tag; }
   void* server_tag() const { return server_tag_; }
   /// if MethodHandler is nullptr, then this is an async method
   MethodHandler* handler() const { return handler_.get(); }
+  ApiType api_type() const { return api_type_; }
   void SetHandler(MethodHandler* handler) { handler_.reset(handler); }
-  void SetServerAsyncType(RpcServiceMethod::AsyncType type) {
-    if (async_type_ == AsyncType::UNSET) {
+  void SetServerApiType(RpcServiceMethod::ApiType type) {
+    if ((api_type_ == ApiType::SYNC) &&
+        (type == ApiType::ASYNC || type == ApiType::RAW)) {
       // this marks this method as async
       handler_.reset();
-    } else {
+    } else if (api_type_ != ApiType::SYNC) {
       // this is not an error condition, as it allows users to declare a server
       // like WithRawMethod_foo<AsyncService>. However since it
       // overwrites behavior, it should be logged.
@@ -98,24 +107,28 @@ class RpcServiceMethod : public RpcMethod {
           "You are marking method %s as '%s', even though it was "
           "previously marked '%s'. This behavior will overwrite the original "
           "behavior. If you expected this then ignore this message.",
-          name(), TypeToString(async_type_), TypeToString(type));
+          name(), TypeToString(api_type_), TypeToString(type));
     }
-    async_type_ = type;
+    api_type_ = type;
   }
 
  private:
   void* server_tag_;
-  AsyncType async_type_;
+  ApiType api_type_;
   std::unique_ptr<MethodHandler> handler_;
 
-  const char* TypeToString(RpcServiceMethod::AsyncType type) {
+  const char* TypeToString(RpcServiceMethod::ApiType type) {
     switch (type) {
-      case AsyncType::UNSET:
+      case ApiType::SYNC:
         return "unset";
-      case AsyncType::ASYNC:
+      case ApiType::ASYNC:
         return "async";
-      case AsyncType::RAW:
+      case ApiType::RAW:
         return "raw";
+      case ApiType::CALL_BACK:
+        return "callback";
+      case ApiType::RAW_CALL_BACK:
+        return "raw_callback";
       default:
         GPR_UNREACHABLE_CODE(return "unknown");
     }