Merge branch 'master' into config-isolation

1 files changed, 53 insertions, 21 deletions

diff --git a/include/grpcpp/impl/codegen/rpc_service_method.h b/include/grpcpp/impl/codegen/rpc_service_method.h
index 5cf88e216f..f465c5fc2f 100644
--- a/include/grpcpp/impl/codegen/rpc_service_method.h
+++ b/include/grpcpp/impl/codegen/rpc_service_method.h
@@ -40,17 +40,41 @@ class MethodHandler {
  public:
   virtual ~MethodHandler() {}
   struct HandlerParameter {
-    HandlerParameter(Call* c, ServerContext* context, grpc_byte_buffer* req)
-        : call(c), server_context(context) {
-      request.set_buffer(req);
-    }
-    ~HandlerParameter() { request.Release(); }
+    /// Constructor for HandlerParameter
+    ///
+    /// \param c : the gRPC Call structure for this server call
+    /// \param context : the ServerContext structure for this server call
+    /// \param req : the request payload, if appropriate for this RPC
+    /// \param req_status : the request status after any interceptors have run
+    /// \param rpc_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, ServerContext* context, void* req,
+                     Status req_status, std::function<void()> requester)
+        : call(c),
+          server_context(context),
+          request(req),
+          status(req_status),
+          call_requester(std::move(requester)) {}
+    ~HandlerParameter() {}
     Call* call;
     ServerContext* server_context;
-    // Handler required to destroy these contents
-    ByteBuffer request;
+    void* request;
+    Status status;
+    std::function<void()> call_requester;
   };
   virtual void RunHandler(const HandlerParameter& param) = 0;
+
+  /* Returns a pointer to the deserialized request. \a status reflects the
+     result of deserialization. This pointer and the status should be filled in
+     a HandlerParameter and passed to RunHandler. It is illegal to access the
+     pointer after calling RunHandler. Ownership of the deserialized request is
+     retained by the handler. Returns nullptr if deserialization failed. */
+  virtual void* Deserialize(grpc_call* call, grpc_byte_buffer* req,
+                            Status* status) {
+    GPR_CODEGEN_ASSERT(req == nullptr);
+    return nullptr;
+  }
 };
 
 /// Server side rpc method class
@@ -61,25 +85,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.
@@ -88,24 +116,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:
-        return "unset";
-      case AsyncType::ASYNC:
+      case ApiType::SYNC:
+        return "sync";
+      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");
     }