Initial interface change

src/core/transport/stream_op.h

@@ -55,9 +55,7 @@ typedef enum grpc_stream_op_code {
   GRPC_OP_BEGIN_MESSAGE,
   /* Add a slice of data to the current message/metadata element/status.
      Must not overflow the forward declared length. */
-  GRPC_OP_SLICE,
-  /* Call some function once this operation has passed flow control. */
-  GRPC_OP_FLOW_CTL_CB
+  GRPC_OP_SLICE
 } grpc_stream_op_code;
 
 /* Arguments for GRPC_OP_BEGIN */
@@ -68,12 +66,6 @@ typedef struct grpc_begin_message {
   gpr_uint32 flags;
 } grpc_begin_message;
 
-/* Arguments for GRPC_OP_FLOW_CTL_CB */
-typedef struct grpc_flow_ctl_cb {
-  void (*cb)(void *arg, grpc_op_error error);
-  void *arg;
-} grpc_flow_ctl_cb;
-
 typedef struct grpc_linked_mdelem {
   grpc_mdelem *md;
   struct grpc_linked_mdelem *next;
@@ -129,7 +121,6 @@ typedef struct grpc_stream_op {
     grpc_begin_message begin_message;
     grpc_metadata_batch metadata;
     gpr_slice slice;
-    grpc_flow_ctl_cb flow_ctl_cb;
   } data;
 } grpc_stream_op;
 

src/core/transport/transport.h

@@ -62,24 +62,6 @@ typedef enum grpc_stream_state {
 
 /* Callbacks made from the transport to the upper layers of grpc. */
 struct grpc_transport_callbacks {
-  /* Allocate a buffer to receive data into.
-     It's safe to call grpc_slice_new() to do this, but performance minded
-     proxies may want to carefully place data into optimal locations for
-     transports.
-     This function must return a valid, non-empty slice.
-
-     Arguments:
-       user_data - the transport user data set at transport creation time
-       transport - the grpc_transport instance making this call
-       stream    - the grpc_stream instance the buffer will be used for, or
-                   NULL if this is not known
-       size_hint - how big of a buffer would the transport optimally like?
-                   the actual returned buffer can be smaller or larger than
-                   size_hint as the implementation finds convenient */
-  struct gpr_slice (*alloc_recv_buffer)(void *user_data,
-                                        grpc_transport *transport,
-                                        grpc_stream *stream, size_t size_hint);
-
   /* Initialize a new stream on behalf of the transport.
      Must result in a call to
      grpc_transport_init_stream(transport, ..., request) in the same call
@@ -96,31 +78,6 @@ struct grpc_transport_callbacks {
   void (*accept_stream)(void *user_data, grpc_transport *transport,
                         const void *server_data);
 
-  /* Process a set of stream ops that have been received by the transport.
-     Called by network threads, so must be careful not to block on network
-     activity.
-
-     If final_state == GRPC_STREAM_CLOSED, the upper layers should arrange to
-     call grpc_transport_destroy_stream.
-
-     Ownership of any objects contained in ops is transferred to the callee.
-
-     Arguments:
-       user_data   - the transport user data set at transport creation time
-       transport   - the grpc_transport instance making this call
-       stream      - the stream this data was received for
-       ops         - stream operations that are part of this batch
-       ops_count   - the number of stream operations in this batch
-       final_state - the state of the stream as of the final operation in this
-                     batch */
-  void (*recv_batch)(void *user_data, grpc_transport *transport,
-                     grpc_stream *stream, grpc_stream_op *ops, size_t ops_count,
-                     grpc_stream_state final_state);
-
-  /* The transport received a goaway */
-  void (*goaway)(void *user_data, grpc_transport *transport,
-                 grpc_status_code status, gpr_slice debug);
-
   /* The transport has been closed */
   void (*closed)(void *user_data, grpc_transport *transport);
 };
@@ -169,6 +126,21 @@ void grpc_transport_destroy_stream(grpc_transport *transport,
 void grpc_transport_set_allow_window_updates(grpc_transport *transport,
                                              grpc_stream *stream, int allow);
 
+/* Transport op: a set of operations to perform on a transport */
+typedef struct grpc_transport_op {
+  grpc_stream_op_buffer *send_ops;
+  int is_last_send;
+  void (*on_done_send)(void *user_data, int success);
+  void *send_user_data;
+
+  grpc_stream_op_buffer *recv_ops;
+  grpc_stream_state *recv_state;
+  void (*on_done_recv)(void *user_data, int success);
+  void *recv_user_data;
+
+  grpc_pollset *bind_pollset;
+} grpc_transport_op;
+
 /* Send a batch of operations on a transport
 
    Takes ownership of any objects contained in ops.
@@ -177,13 +149,9 @@ void grpc_transport_set_allow_window_updates(grpc_transport *transport,
      transport - the transport on which to initiate the stream
      stream    - the stream on which to send the operations. This must be
                  non-NULL and previously initialized by the same transport.
-     ops       - an array of operations to apply to the stream - can be NULL
-                 if ops_count == 0.
-     ops_count - the number of elements in ops
-     is_last   - is this the last batch of operations to be sent out */
-void grpc_transport_send_batch(grpc_transport *transport, grpc_stream *stream,
-                               grpc_stream_op *ops, size_t ops_count,
-                               int is_last);
+     op        - a grpc_transport_op specifying the op to perform */
+void grpc_transport_perform_op(grpc_transport *transport, grpc_stream *stream,
+                               grpc_transport_op *op);
 
 /* Send a ping on a transport