diff --git a/BUILD b/BUILD
index bbde04674b3e4eef2fda34323ca75262b71267a2..54192514cc773da8a6c68192dde43fa0c7b96163 100644
--- a/BUILD
+++ b/BUILD
@@ -1027,7 +1027,7 @@ grpc_cc_library(
         "src/core/ext/transport/cronet/transport/cronet_transport.c",
     ],
     hdrs = [
-        "third_party/objective_c/Cronet/cronet_c_for_grpc.h",
+        "third_party/Cronet/bidirectional_stream_c.h",
     ],
     language = "c",
     public_hdrs = [
diff --git a/build.yaml b/build.yaml
index 44ef74370f6c76cad552b36fbd6412848120b23b..eaf64e860f1a11b62a83bd781f5161807fa25ee8 100644
--- a/build.yaml
+++ b/build.yaml
@@ -684,7 +684,7 @@ filegroups:
   - include/grpc/grpc_security.h
   - include/grpc/grpc_security_constants.h
   headers:
-  - third_party/objective_c/Cronet/cronet_c_for_grpc.h
+  - third_party/Cronet/bidirectional_stream_c.h
   src:
   - src/core/ext/transport/cronet/client/secure/cronet_channel_create.c
   - src/core/ext/transport/cronet/transport/cronet_api_dummy.c
diff --git a/src/core/ext/transport/cronet/client/secure/cronet_channel_create.c b/src/core/ext/transport/cronet/client/secure/cronet_channel_create.c
index df1acddcc08ae95a0f17de333f429e6cb5419aa5..477cf07f45dbf81144b1c5c0b7dd298460c34817 100644
--- a/src/core/ext/transport/cronet/client/secure/cronet_channel_create.c
+++ b/src/core/ext/transport/cronet/client/secure/cronet_channel_create.c
@@ -60,7 +60,7 @@ GRPCAPI grpc_channel *grpc_cronet_secure_channel_create(
   ct->host = gpr_malloc(strlen(target) + 1);
   strcpy(ct->host, target);
   gpr_log(GPR_DEBUG,
-          "grpc_create_cronet_transport: cronet_engine = %p, target=%s", engine,
+          "grpc_create_cronet_transport: stream_engine = %p, target=%s", engine,
           ct->host);
 
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
diff --git a/src/core/ext/transport/cronet/transport/cronet_api_dummy.c b/src/core/ext/transport/cronet/transport/cronet_api_dummy.c
index 687026c9fde99af4d164103a2bf90c56e7e10ceb..74327a421425399f825951f5b26f6f561d280e70 100644
--- a/src/core/ext/transport/cronet/transport/cronet_api_dummy.c
+++ b/src/core/ext/transport/cronet/transport/cronet_api_dummy.c
@@ -38,48 +38,46 @@ library, so we can build it in all environments */
 
 #include <grpc/support/log.h>
 
-#include "third_party/objective_c/Cronet/cronet_c_for_grpc.h"
+#include "third_party/Cronet/bidirectional_stream_c.h"
 
 #ifdef GRPC_COMPILE_WITH_CRONET
 /* link with the real CRONET library in the build system */
 #else
 /* Dummy implementation of cronet API just to test for build-ability */
-cronet_bidirectional_stream* cronet_bidirectional_stream_create(
-    cronet_engine* engine, void* annotation,
-    cronet_bidirectional_stream_callback* callback) {
+bidirectional_stream* bidirectional_stream_create(
+    stream_engine* engine, void* annotation,
+    bidirectional_stream_callback* callback) {
   GPR_ASSERT(0);
   return NULL;
 }
 
-int cronet_bidirectional_stream_destroy(cronet_bidirectional_stream* stream) {
+int bidirectional_stream_destroy(bidirectional_stream* stream) {
   GPR_ASSERT(0);
   return 0;
 }
 
-int cronet_bidirectional_stream_start(
-    cronet_bidirectional_stream* stream, const char* url, int priority,
-    const char* method, const cronet_bidirectional_stream_header_array* headers,
-    bool end_of_stream) {
+int bidirectional_stream_start(bidirectional_stream* stream, const char* url,
+                               int priority, const char* method,
+                               const bidirectional_stream_header_array* headers,
+                               bool end_of_stream) {
   GPR_ASSERT(0);
   return 0;
 }
 
-int cronet_bidirectional_stream_read(cronet_bidirectional_stream* stream,
-                                     char* buffer, int capacity) {
+int bidirectional_stream_read(bidirectional_stream* stream, char* buffer,
+                              int capacity) {
   GPR_ASSERT(0);
   return 0;
 }
 
-int cronet_bidirectional_stream_write(cronet_bidirectional_stream* stream,
-                                      const char* buffer, int count,
-                                      bool end_of_stream) {
+int bidirectional_stream_write(bidirectional_stream* stream, const char* buffer,
+                               int count, bool end_of_stream) {
   GPR_ASSERT(0);
   return 0;
 }
 
-int cronet_bidirectional_stream_cancel(cronet_bidirectional_stream* stream) {
+void bidirectional_stream_cancel(bidirectional_stream* stream) {
   GPR_ASSERT(0);
-  return 0;
 }
 
 #endif /* GRPC_COMPILE_WITH_CRONET */
diff --git a/src/core/ext/transport/cronet/transport/cronet_transport.c b/src/core/ext/transport/cronet/transport/cronet_transport.c
index 296c40632498e09b52971cb0f3c13ff4f5def488..b080408565fad34cf68479e407966991412365be 100644
--- a/src/core/ext/transport/cronet/transport/cronet_transport.c
+++ b/src/core/ext/transport/cronet/transport/cronet_transport.c
@@ -49,7 +49,7 @@
 #include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/lib/transport/static_metadata.h"
 #include "src/core/lib/transport/transport_impl.h"
-#include "third_party/objective_c/Cronet/cronet_c_for_grpc.h"
+#include "third_party/Cronet/bidirectional_stream_c.h"
 
 #define GRPC_HEADER_SIZE_IN_BYTES 5
 
@@ -86,19 +86,18 @@ enum e_op_id {
 
 /* Cronet callbacks. See cronet_c_for_grpc.h for documentation for each. */
 
-static void on_request_headers_sent(cronet_bidirectional_stream *);
+static void on_request_headers_sent(bidirectional_stream *);
 static void on_response_headers_received(
-    cronet_bidirectional_stream *,
-    const cronet_bidirectional_stream_header_array *, const char *);
-static void on_write_completed(cronet_bidirectional_stream *, const char *);
-static void on_read_completed(cronet_bidirectional_stream *, char *, int);
+    bidirectional_stream *, const bidirectional_stream_header_array *,
+    const char *);
+static void on_write_completed(bidirectional_stream *, const char *);
+static void on_read_completed(bidirectional_stream *, char *, int);
 static void on_response_trailers_received(
-    cronet_bidirectional_stream *,
-    const cronet_bidirectional_stream_header_array *);
-static void on_succeeded(cronet_bidirectional_stream *);
-static void on_failed(cronet_bidirectional_stream *, int);
-static void on_canceled(cronet_bidirectional_stream *);
-static cronet_bidirectional_stream_callback cronet_callbacks = {
+    bidirectional_stream *, const bidirectional_stream_header_array *);
+static void on_succeeded(bidirectional_stream *);
+static void on_failed(bidirectional_stream *, int);
+static void on_canceled(bidirectional_stream *);
+static bidirectional_stream_callback cronet_callbacks = {
     on_request_headers_sent,
     on_response_headers_received,
     on_read_completed,
@@ -111,7 +110,7 @@ static cronet_bidirectional_stream_callback cronet_callbacks = {
 /* Cronet transport object */
 struct grpc_cronet_transport {
   grpc_transport base; /* must be first element in this structure */
-  cronet_engine *engine;
+  stream_engine *engine;
   char *host;
 };
 typedef struct grpc_cronet_transport grpc_cronet_transport;
@@ -176,8 +175,8 @@ struct stream_obj {
   grpc_transport_stream_op *curr_op;
   grpc_cronet_transport curr_ct;
   grpc_stream *curr_gs;
-  cronet_bidirectional_stream *cbs;
-  cronet_bidirectional_stream_header_array header_array;
+  bidirectional_stream *cbs;
+  bidirectional_stream_header_array header_array;
 
   /* Stream level state. Some state will be tracked both at stream and stream_op
    * level */
@@ -344,11 +343,11 @@ static void execute_from_storage(stream_obj *s) {
 /*
   Cronet callback
 */
-static void on_failed(cronet_bidirectional_stream *stream, int net_error) {
+static void on_failed(bidirectional_stream *stream, int net_error) {
   CRONET_LOG(GPR_DEBUG, "on_failed(%p, %d)", stream, net_error);
   stream_obj *s = (stream_obj *)stream->annotation;
   gpr_mu_lock(&s->mu);
-  cronet_bidirectional_stream_destroy(s->cbs);
+  bidirectional_stream_destroy(s->cbs);
   s->state.state_callback_received[OP_FAILED] = true;
   s->cbs = NULL;
   if (s->header_array.headers) {
@@ -367,11 +366,11 @@ static void on_failed(cronet_bidirectional_stream *stream, int net_error) {
 /*
   Cronet callback
 */
-static void on_canceled(cronet_bidirectional_stream *stream) {
+static void on_canceled(bidirectional_stream *stream) {
   CRONET_LOG(GPR_DEBUG, "on_canceled(%p)", stream);
   stream_obj *s = (stream_obj *)stream->annotation;
   gpr_mu_lock(&s->mu);
-  cronet_bidirectional_stream_destroy(s->cbs);
+  bidirectional_stream_destroy(s->cbs);
   s->state.state_callback_received[OP_CANCELED] = true;
   s->cbs = NULL;
   if (s->header_array.headers) {
@@ -390,11 +389,11 @@ static void on_canceled(cronet_bidirectional_stream *stream) {
 /*
   Cronet callback
 */
-static void on_succeeded(cronet_bidirectional_stream *stream) {
+static void on_succeeded(bidirectional_stream *stream) {
   CRONET_LOG(GPR_DEBUG, "on_succeeded(%p)", stream);
   stream_obj *s = (stream_obj *)stream->annotation;
   gpr_mu_lock(&s->mu);
-  cronet_bidirectional_stream_destroy(s->cbs);
+  bidirectional_stream_destroy(s->cbs);
   s->state.state_callback_received[OP_SUCCEEDED] = true;
   s->cbs = NULL;
   free_read_buffer(s);
@@ -405,7 +404,7 @@ static void on_succeeded(cronet_bidirectional_stream *stream) {
 /*
   Cronet callback
 */
-static void on_request_headers_sent(cronet_bidirectional_stream *stream) {
+static void on_request_headers_sent(bidirectional_stream *stream) {
   CRONET_LOG(GPR_DEBUG, "W: on_request_headers_sent(%p)", stream);
   stream_obj *s = (stream_obj *)stream->annotation;
   gpr_mu_lock(&s->mu);
@@ -424,8 +423,8 @@ static void on_request_headers_sent(cronet_bidirectional_stream *stream) {
   Cronet callback
 */
 static void on_response_headers_received(
-    cronet_bidirectional_stream *stream,
-    const cronet_bidirectional_stream_header_array *headers,
+    bidirectional_stream *stream,
+    const bidirectional_stream_header_array *headers,
     const char *negotiated_protocol) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   CRONET_LOG(GPR_DEBUG, "R: on_response_headers_received(%p, %p, %s)", stream,
@@ -451,9 +450,9 @@ static void on_response_headers_received(
     s->state.rs.read_buffer = s->state.rs.grpc_header_bytes;
     s->state.rs.received_bytes = 0;
     s->state.rs.remaining_bytes = GRPC_HEADER_SIZE_IN_BYTES;
-    CRONET_LOG(GPR_DEBUG, "cronet_bidirectional_stream_read(%p)", s->cbs);
-    cronet_bidirectional_stream_read(s->cbs, s->state.rs.read_buffer,
-                                     s->state.rs.remaining_bytes);
+    CRONET_LOG(GPR_DEBUG, "bidirectional_stream_read(%p)", s->cbs);
+    bidirectional_stream_read(s->cbs, s->state.rs.read_buffer,
+                              s->state.rs.remaining_bytes);
   }
   gpr_mu_unlock(&s->mu);
   grpc_exec_ctx_finish(&exec_ctx);
@@ -463,8 +462,7 @@ static void on_response_headers_received(
 /*
   Cronet callback
 */
-static void on_write_completed(cronet_bidirectional_stream *stream,
-                               const char *data) {
+static void on_write_completed(bidirectional_stream *stream, const char *data) {
   stream_obj *s = (stream_obj *)stream->annotation;
   CRONET_LOG(GPR_DEBUG, "W: on_write_completed(%p, %s)", stream, data);
   gpr_mu_lock(&s->mu);
@@ -480,7 +478,7 @@ static void on_write_completed(cronet_bidirectional_stream *stream,
 /*
   Cronet callback
 */
-static void on_read_completed(cronet_bidirectional_stream *stream, char *data,
+static void on_read_completed(bidirectional_stream *stream, char *data,
                               int count) {
   stream_obj *s = (stream_obj *)stream->annotation;
   CRONET_LOG(GPR_DEBUG, "R: on_read_completed(%p, %p, %d)", stream, data,
@@ -488,16 +486,16 @@ static void on_read_completed(cronet_bidirectional_stream *stream, char *data,
   gpr_mu_lock(&s->mu);
   s->state.state_callback_received[OP_RECV_MESSAGE] = true;
   if (count > 0 && s->state.flush_read) {
-    CRONET_LOG(GPR_DEBUG, "cronet_bidirectional_stream_read(%p)", s->cbs);
-    cronet_bidirectional_stream_read(s->cbs, s->state.rs.read_buffer, 4096);
+    CRONET_LOG(GPR_DEBUG, "bidirectional_stream_read(%p)", s->cbs);
+    bidirectional_stream_read(s->cbs, s->state.rs.read_buffer, 4096);
     gpr_mu_unlock(&s->mu);
   } else if (count > 0) {
     s->state.rs.received_bytes += count;
     s->state.rs.remaining_bytes -= count;
     if (s->state.rs.remaining_bytes > 0) {
-      CRONET_LOG(GPR_DEBUG, "cronet_bidirectional_stream_read(%p)", s->cbs);
+      CRONET_LOG(GPR_DEBUG, "bidirectional_stream_read(%p)", s->cbs);
       s->state.state_op_done[OP_READ_REQ_MADE] = true;
-      cronet_bidirectional_stream_read(
+      bidirectional_stream_read(
           s->cbs, s->state.rs.read_buffer + s->state.rs.received_bytes,
           s->state.rs.remaining_bytes);
       gpr_mu_unlock(&s->mu);
@@ -520,8 +518,8 @@ static void on_read_completed(cronet_bidirectional_stream *stream, char *data,
   Cronet callback
 */
 static void on_response_trailers_received(
-    cronet_bidirectional_stream *stream,
-    const cronet_bidirectional_stream_header_array *trailers) {
+    bidirectional_stream *stream,
+    const bidirectional_stream_header_array *trailers) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   CRONET_LOG(GPR_DEBUG, "R: on_response_trailers_received(%p,%p)", stream,
              trailers);
@@ -551,9 +549,9 @@ static void on_response_trailers_received(
   if (!s->state.state_op_done[OP_SEND_TRAILING_METADATA] &&
       !(s->state.state_op_done[OP_CANCEL_ERROR] ||
         s->state.state_callback_received[OP_FAILED])) {
-    CRONET_LOG(GPR_DEBUG, "cronet_bidirectional_stream_write (%p, 0)", s->cbs);
+    CRONET_LOG(GPR_DEBUG, "bidirectional_stream_write (%p, 0)", s->cbs);
     s->state.state_callback_received[OP_SEND_MESSAGE] = false;
-    cronet_bidirectional_stream_write(s->cbs, "", 0, true);
+    bidirectional_stream_write(s->cbs, "", 0, true);
     s->state.state_op_done[OP_SEND_TRAILING_METADATA] = true;
 
     gpr_mu_unlock(&s->mu);
@@ -594,7 +592,7 @@ static void create_grpc_frame(grpc_slice_buffer *write_slice_buffer,
 */
 static void convert_metadata_to_cronet_headers(
     grpc_linked_mdelem *head, const char *host, char **pp_url,
-    cronet_bidirectional_stream_header **pp_headers, size_t *p_num_headers,
+    bidirectional_stream_header **pp_headers, size_t *p_num_headers,
     const char **method) {
   grpc_linked_mdelem *curr = head;
   /* Walk the linked list and get number of header fields */
@@ -605,9 +603,9 @@ static void convert_metadata_to_cronet_headers(
   }
   /* Allocate enough memory. It is freed in the on_request_headers_sent callback
    */
-  cronet_bidirectional_stream_header *headers =
-      (cronet_bidirectional_stream_header *)gpr_malloc(
-          sizeof(cronet_bidirectional_stream_header) * num_headers_available);
+  bidirectional_stream_header *headers =
+      (bidirectional_stream_header *)gpr_malloc(
+          sizeof(bidirectional_stream_header) * num_headers_available);
   *pp_headers = headers;
 
   /* Walk the linked list again, this time copying the header fields.
@@ -833,9 +831,9 @@ static enum e_op_result execute_stream_op(grpc_exec_ctx *exec_ctx,
      * on_failed */
     GPR_ASSERT(s->cbs == NULL);
     GPR_ASSERT(!stream_state->state_op_done[OP_SEND_INITIAL_METADATA]);
-    s->cbs = cronet_bidirectional_stream_create(s->curr_ct.engine, s->curr_gs,
-                                                &cronet_callbacks);
-    CRONET_LOG(GPR_DEBUG, "%p = cronet_bidirectional_stream_create()", s->cbs);
+    s->cbs = bidirectional_stream_create(s->curr_ct.engine, s->curr_gs,
+                                         &cronet_callbacks);
+    CRONET_LOG(GPR_DEBUG, "%p = bidirectional_stream_create()", s->cbs);
     char *url = NULL;
     const char *method = "POST";
     s->header_array.headers = NULL;
@@ -843,10 +841,8 @@ static enum e_op_result execute_stream_op(grpc_exec_ctx *exec_ctx,
         stream_op->send_initial_metadata->list.head, s->curr_ct.host, &url,
         &s->header_array.headers, &s->header_array.count, &method);
     s->header_array.capacity = s->header_array.count;
-    CRONET_LOG(GPR_DEBUG, "cronet_bidirectional_stream_start(%p, %s)", s->cbs,
-               url);
-    cronet_bidirectional_stream_start(s->cbs, url, 0, method, &s->header_array,
-                                      false);
+    CRONET_LOG(GPR_DEBUG, "bidirectional_stream_start(%p, %s)", s->cbs, url);
+    bidirectional_stream_start(s->cbs, url, 0, method, &s->header_array, false);
     stream_state->state_op_done[OP_SEND_INITIAL_METADATA] = true;
     result = ACTION_TAKEN_WITH_CALLBACK;
   } else if (stream_op->recv_initial_metadata &&
@@ -897,11 +893,11 @@ static enum e_op_result execute_stream_op(grpc_exec_ctx *exec_ctx,
         size_t write_buffer_size;
         create_grpc_frame(&write_slice_buffer, &stream_state->ws.write_buffer,
                           &write_buffer_size);
-        CRONET_LOG(GPR_DEBUG, "cronet_bidirectional_stream_write (%p, %p)",
-                   s->cbs, stream_state->ws.write_buffer);
+        CRONET_LOG(GPR_DEBUG, "bidirectional_stream_write (%p, %p)", s->cbs,
+                   stream_state->ws.write_buffer);
         stream_state->state_callback_received[OP_SEND_MESSAGE] = false;
-        cronet_bidirectional_stream_write(s->cbs, stream_state->ws.write_buffer,
-                                          (int)write_buffer_size, false);
+        bidirectional_stream_write(s->cbs, stream_state->ws.write_buffer,
+                                   (int)write_buffer_size, false);
         result = ACTION_TAKEN_WITH_CALLBACK;
       } else {
         result = NO_ACTION_POSSIBLE;
@@ -949,11 +945,11 @@ static enum e_op_result execute_stream_op(grpc_exec_ctx *exec_ctx,
           GPR_ASSERT(stream_state->rs.read_buffer);
           stream_state->rs.remaining_bytes = stream_state->rs.length_field;
           stream_state->rs.received_bytes = 0;
-          CRONET_LOG(GPR_DEBUG, "cronet_bidirectional_stream_read(%p)", s->cbs);
+          CRONET_LOG(GPR_DEBUG, "bidirectional_stream_read(%p)", s->cbs);
           stream_state->state_op_done[OP_READ_REQ_MADE] =
               true; /* Indicates that at least one read request has been made */
-          cronet_bidirectional_stream_read(s->cbs, stream_state->rs.read_buffer,
-                                           stream_state->rs.remaining_bytes);
+          bidirectional_stream_read(s->cbs, stream_state->rs.read_buffer,
+                                    stream_state->rs.remaining_bytes);
           result = ACTION_TAKEN_WITH_CALLBACK;
         } else {
           stream_state->rs.remaining_bytes = 0;
@@ -974,11 +970,11 @@ static enum e_op_result execute_stream_op(grpc_exec_ctx *exec_ctx,
         stream_state->rs.read_buffer = stream_state->rs.grpc_header_bytes;
         stream_state->rs.remaining_bytes = GRPC_HEADER_SIZE_IN_BYTES;
         stream_state->rs.received_bytes = 0;
-        CRONET_LOG(GPR_DEBUG, "cronet_bidirectional_stream_read(%p)", s->cbs);
+        CRONET_LOG(GPR_DEBUG, "bidirectional_stream_read(%p)", s->cbs);
         stream_state->state_op_done[OP_READ_REQ_MADE] =
             true; /* Indicates that at least one read request has been made */
-        cronet_bidirectional_stream_read(s->cbs, stream_state->rs.read_buffer,
-                                         stream_state->rs.remaining_bytes);
+        bidirectional_stream_read(s->cbs, stream_state->rs.read_buffer,
+                                  stream_state->rs.remaining_bytes);
         result = ACTION_TAKEN_WITH_CALLBACK;
       } else {
         result = NO_ACTION_POSSIBLE;
@@ -1008,9 +1004,9 @@ static enum e_op_result execute_stream_op(grpc_exec_ctx *exec_ctx,
       stream_state->rs.received_bytes = 0;
       stream_state->rs.remaining_bytes = GRPC_HEADER_SIZE_IN_BYTES;
       stream_state->rs.length_field_received = false;
-      CRONET_LOG(GPR_DEBUG, "cronet_bidirectional_stream_read(%p)", s->cbs);
-      cronet_bidirectional_stream_read(s->cbs, stream_state->rs.read_buffer,
-                                       stream_state->rs.remaining_bytes);
+      CRONET_LOG(GPR_DEBUG, "bidirectional_stream_read(%p)", s->cbs);
+      bidirectional_stream_read(s->cbs, stream_state->rs.read_buffer,
+                                stream_state->rs.remaining_bytes);
       result = ACTION_TAKEN_NO_CALLBACK;
     }
   } else if (stream_op->recv_trailing_metadata &&
@@ -1033,10 +1029,9 @@ static enum e_op_result execute_stream_op(grpc_exec_ctx *exec_ctx,
       result = NO_ACTION_POSSIBLE;
       CRONET_LOG(GPR_DEBUG, "Stream is either cancelled or failed.");
     } else {
-      CRONET_LOG(GPR_DEBUG, "cronet_bidirectional_stream_write (%p, 0)",
-                 s->cbs);
+      CRONET_LOG(GPR_DEBUG, "bidirectional_stream_write (%p, 0)", s->cbs);
       stream_state->state_callback_received[OP_SEND_MESSAGE] = false;
-      cronet_bidirectional_stream_write(s->cbs, "", 0, true);
+      bidirectional_stream_write(s->cbs, "", 0, true);
       result = ACTION_TAKEN_WITH_CALLBACK;
     }
     stream_state->state_op_done[OP_SEND_TRAILING_METADATA] = true;
@@ -1044,9 +1039,9 @@ static enum e_op_result execute_stream_op(grpc_exec_ctx *exec_ctx,
              op_can_be_run(stream_op, stream_state, &oas->state,
                            OP_CANCEL_ERROR)) {
     CRONET_LOG(GPR_DEBUG, "running: %p  OP_CANCEL_ERROR", oas);
-    CRONET_LOG(GPR_DEBUG, "W: cronet_bidirectional_stream_cancel(%p)", s->cbs);
+    CRONET_LOG(GPR_DEBUG, "W: bidirectional_stream_cancel(%p)", s->cbs);
     if (s->cbs) {
-      cronet_bidirectional_stream_cancel(s->cbs);
+      bidirectional_stream_cancel(s->cbs);
       result = ACTION_TAKEN_WITH_CALLBACK;
     } else {
       result = ACTION_TAKEN_NO_CALLBACK;
@@ -1143,18 +1138,17 @@ static void perform_stream_op(grpc_exec_ctx *exec_ctx, grpc_transport *gt,
       header_has_authority(op->send_initial_metadata->list.head)) {
     /* Cronet does not support :authority header field. We cancel the call when
        this field is present in metadata */
-    cronet_bidirectional_stream_header_array header_array;
-    cronet_bidirectional_stream_header *header;
-    cronet_bidirectional_stream cbs;
+    bidirectional_stream_header_array header_array;
+    bidirectional_stream_header *header;
+    bidirectional_stream cbs;
     CRONET_LOG(GPR_DEBUG,
                ":authority header is provided but not supported;"
                " cancel operations");
     /* Notify application that operation is cancelled by forging trailers */
     header_array.count = 1;
     header_array.capacity = 1;
-    header_array.headers =
-        gpr_malloc(sizeof(cronet_bidirectional_stream_header));
-    header = (cronet_bidirectional_stream_header *)header_array.headers;
+    header_array.headers = gpr_malloc(sizeof(bidirectional_stream_header));
+    header = (bidirectional_stream_header *)header_array.headers;
     header->key = "grpc-status";
     header->value = "1"; /* Return status GRPC_STATUS_CANCELLED */
     cbs.annotation = (void *)s;
diff --git a/src/objective-c/GRPCClient/GRPCCall+Cronet.h b/src/objective-c/GRPCClient/GRPCCall+Cronet.h
index 2d8f7ac8fb9b3482ac851b68514d5e2692685494..b9d286c929ac729d42a91831f754c5b9d3782099 100644
--- a/src/objective-c/GRPCClient/GRPCCall+Cronet.h
+++ b/src/objective-c/GRPCClient/GRPCCall+Cronet.h
@@ -43,13 +43,13 @@
 /**
  * This method should be called before issuing the first RPC. It should be
  * called only once. Create an instance of Cronet engine in your app elsewhere
- * and pass the instance pointer in the cronet_engine parameter. Once set,
+ * and pass the instance pointer in the stream_engine parameter. Once set,
  * all subsequent RPCs will use Cronet transport. The method is not thread
  * safe.
  */
-+(void)useCronetWithEngine:(cronet_engine *)engine;
++(void)useCronetWithEngine:(stream_engine *)engine;
 
-+(cronet_engine *)cronetEngine;
++(stream_engine *)cronetEngine;
 
 +(BOOL)isUsingCronet;
 
diff --git a/src/objective-c/GRPCClient/GRPCCall+Cronet.m b/src/objective-c/GRPCClient/GRPCCall+Cronet.m
index 76ca1a2537c8048ed7dd34b7765aa89981783679..0e3598fb87d25697debab31b7dd90506b60d6f48 100644
--- a/src/objective-c/GRPCClient/GRPCCall+Cronet.m
+++ b/src/objective-c/GRPCClient/GRPCCall+Cronet.m
@@ -35,16 +35,16 @@
 
 #ifdef GRPC_COMPILE_WITH_CRONET
 static BOOL useCronet = NO;
-static cronet_engine *globalCronetEngine;
+static stream_engine *globalCronetEngine;
 
 @implementation GRPCCall (Cronet)
 
-+ (void)useCronetWithEngine:(cronet_engine *)engine {
++ (void)useCronetWithEngine:(stream_engine *)engine {
   useCronet = YES;
   globalCronetEngine = engine;
 }
 
-+ (cronet_engine *)cronetEngine {
++ (stream_engine *)cronetEngine {
   return globalCronetEngine;
 }
 
diff --git a/src/objective-c/GRPCClient/private/GRPCChannel.m b/src/objective-c/GRPCClient/private/GRPCChannel.m
index e49aceefe18aed7f791398939b47a4671879f204..2397c929f7011d58b1f9180cfe0ce155e1192798 100644
--- a/src/objective-c/GRPCClient/private/GRPCChannel.m
+++ b/src/objective-c/GRPCClient/private/GRPCChannel.m
@@ -108,7 +108,7 @@ static grpc_channel_args *BuildChannelArgs(NSDictionary *dictionary) {
 
 #ifdef GRPC_COMPILE_WITH_CRONET
 - (instancetype)initWithHost:(NSString *)host
-                cronetEngine:(cronet_engine *)cronetEngine
+                cronetEngine:(stream_engine *)cronetEngine
                  channelArgs:(NSDictionary *)channelArgs {
   if (!host) {
     [NSException raise:NSInvalidArgumentException format:@"host argument missing"];
@@ -163,7 +163,7 @@ static grpc_channel_args *BuildChannelArgs(NSDictionary *dictionary) {
 #ifdef GRPC_COMPILE_WITH_CRONET
 + (GRPCChannel *)secureCronetChannelWithHost:(NSString *)host
                                  channelArgs:(NSDictionary *)channelArgs {
-  cronet_engine *engine = [GRPCCall cronetEngine];
+  stream_engine *engine = [GRPCCall cronetEngine];
   if (!engine) {
     [NSException raise:NSInvalidArgumentException
                 format:@"cronet_engine is NULL. Set it first."];
diff --git a/src/objective-c/tests/CoreCronetEnd2EndTests/CoreCronetEnd2EndTests.m b/src/objective-c/tests/CoreCronetEnd2EndTests/CoreCronetEnd2EndTests.m
index 4ba7badd866131c5c761949ea9e3c820c70988f3..01eea52ef39cb3bc74caaf0e2f85c9eb90bee3dc 100644
--- a/src/objective-c/tests/CoreCronetEnd2EndTests/CoreCronetEnd2EndTests.m
+++ b/src/objective-c/tests/CoreCronetEnd2EndTests/CoreCronetEnd2EndTests.m
@@ -94,7 +94,7 @@ static void process_auth_failure(void *state, grpc_auth_context *ctx,
 
 static void cronet_init_client_secure_fullstack(grpc_end2end_test_fixture *f,
                                                 grpc_channel_args *client_args,
-                                                cronet_engine *cronetEngine) {
+                                                stream_engine *cronetEngine) {
   fullstack_secure_fixture_data *ffd = f->fixture_data;
   f->client = grpc_cronet_secure_channel_create(cronetEngine, ffd->localaddr,
                                                 client_args, NULL);
@@ -124,7 +124,7 @@ static void chttp2_tear_down_secure_fullstack(grpc_end2end_test_fixture *f) {
 
 static void cronet_init_client_simple_ssl_secure_fullstack(
     grpc_end2end_test_fixture *f, grpc_channel_args *client_args) {
-  cronet_engine *cronetEngine = [Cronet getGlobalEngine];
+  stream_engine *cronetEngine = [Cronet getGlobalEngine];
 
   grpc_channel_args *new_client_args = grpc_channel_args_copy(client_args);
   cronet_init_client_secure_fullstack(f, new_client_args, cronetEngine);
diff --git a/third_party/Cronet/bidirectional_stream_c.h b/third_party/Cronet/bidirectional_stream_c.h
new file mode 100644
index 0000000000000000000000000000000000000000..ffb235ae87461b7f2bfda7bd112a545c788cef07
--- /dev/null
+++ b/third_party/Cronet/bidirectional_stream_c.h
@@ -0,0 +1,246 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef COMPONENTS_GRPC_SUPPORT_INCLUDE_BIDIRECTIONAL_STREAM_C_H_
+#define COMPONENTS_GRPC_SUPPORT_INCLUDE_BIDIRECTIONAL_STREAM_C_H_
+
+#if defined(WIN32)
+#define GRPC_SUPPORT_EXPORT
+#else
+#define GRPC_SUPPORT_EXPORT __attribute__((visibility("default")))
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stddef.h>
+
+/* Engine API. */
+
+/* Opaque object representing a Bidirectional stream creating engine. Created
+ * and configured outside of this API to facilitate sharing with other
+ * components */
+typedef struct stream_engine {
+  void* obj;
+  void* annotation;
+} stream_engine;
+
+/* Bidirectional Stream API */
+
+/* Opaque object representing Bidirectional Stream. */
+typedef struct bidirectional_stream {
+  void* obj;
+  void* annotation;
+} bidirectional_stream;
+
+/* A single request or response header element. */
+typedef struct bidirectional_stream_header {
+  const char* key;
+  const char* value;
+} bidirectional_stream_header;
+
+/* Array of request or response headers or trailers. */
+typedef struct bidirectional_stream_header_array {
+  size_t count;
+  size_t capacity;
+  bidirectional_stream_header* headers;
+} bidirectional_stream_header_array;
+
+/* Set of callbacks used to receive callbacks from bidirectional stream. */
+typedef struct bidirectional_stream_callback {
+  /* Invoked when the stream is ready for reading and writing.
+   * Consumer may call bidirectional_stream_read() to start reading data.
+   * Consumer may call bidirectional_stream_write() to start writing
+   * data.
+   */
+  void (*on_stream_ready)(bidirectional_stream* stream);
+
+  /* Invoked when initial response headers are received.
+   * Consumer must call bidirectional_stream_read() to start reading.
+   * Consumer may call bidirectional_stream_write() to start writing or
+   * close the stream. Contents of |headers| is valid for duration of the call.
+   */
+  void (*on_response_headers_received)(
+      bidirectional_stream* stream,
+      const bidirectional_stream_header_array* headers,
+      const char* negotiated_protocol);
+
+  /* Invoked when data is read into the buffer passed to
+   * bidirectional_stream_read(). Only part of the buffer may be
+   * populated. To continue reading, call bidirectional_stream_read().
+   * It may be invoked after on_response_trailers_received()}, if there was
+   * pending read data before trailers were received.
+   *
+   * If |bytes_read| is 0, it means the remote side has signaled that it will
+   * send no more data; future calls to bidirectional_stream_read()
+   * will result in the on_data_read() callback or on_succeded() callback if
+   * bidirectional_stream_write() was invoked with end_of_stream set to
+   * true.
+   */
+  void (*on_read_completed)(bidirectional_stream* stream,
+                            char* data,
+                            int bytes_read);
+
+  /**
+   * Invoked when all data passed to bidirectional_stream_write() is
+   * sent. To continue writing, call bidirectional_stream_write().
+   */
+  void (*on_write_completed)(bidirectional_stream* stream, const char* data);
+
+  /* Invoked when trailers are received before closing the stream. Only invoked
+   * when server sends trailers, which it may not. May be invoked while there is
+   * read data remaining in local buffer. Contents of |trailers| is valid for
+   * duration of the call.
+   */
+  void (*on_response_trailers_received)(
+      bidirectional_stream* stream,
+      const bidirectional_stream_header_array* trailers);
+
+  /**
+   * Invoked when there is no data to be read or written and the stream is
+   * closed successfully remotely and locally. Once invoked, no further callback
+   * methods will be invoked.
+   */
+  void (*on_succeded)(bidirectional_stream* stream);
+
+  /**
+   * Invoked if the stream failed for any reason after
+   * bidirectional_stream_start(). HTTP/2 error codes are
+   * mapped to chrome net error codes. Once invoked, no further callback methods
+   * will be invoked.
+   */
+  void (*on_failed)(bidirectional_stream* stream, int net_error);
+
+  /**
+   * Invoked if the stream was canceled via
+   * bidirectional_stream_cancel(). Once invoked, no further callback
+   * methods will be invoked.
+   */
+  void (*on_canceled)(bidirectional_stream* stream);
+} bidirectional_stream_callback;
+
+/* Creates a new stream object that uses |engine| and |callback|. All stream
+ * tasks are performed asynchronously on the |engine| network thread. |callback|
+ * methods are invoked synchronously on the |engine| network thread, but must
+ * not run tasks on the current thread to prevent blocking networking operations
+ * and causing exceptions during shutdown. The |annotation| is stored in
+ * bidirectional stream for arbitrary use by application.
+ *
+ * Returned |bidirectional_stream*| is owned by the caller, and must be
+ * destroyed using |bidirectional_stream_destroy|.
+ *
+ * Both |calback| and |engine| must remain valid until stream is destroyed.
+ */
+GRPC_SUPPORT_EXPORT
+bidirectional_stream* bidirectional_stream_create(
+    stream_engine* engine,
+    void* annotation,
+    bidirectional_stream_callback* callback);
+
+/* TBD: The following methods return int. Should it be a custom type? */
+
+/* Destroys stream object. Destroy could be called from any thread, including
+ * network thread, but is posted, so |stream| is valid until calling task is
+ * complete.
+ */
+GRPC_SUPPORT_EXPORT
+int bidirectional_stream_destroy(bidirectional_stream* stream);
+
+/**
+ * Disables or enables auto flush. By default, data is flushed after
+ * every bidirectional_stream_write(). If the auto flush is disabled,
+ * the client should explicitly call bidirectional_stream_flush to flush
+ * the data.
+ */
+GRPC_SUPPORT_EXPORT void bidirectional_stream_disable_auto_flush(
+    bidirectional_stream* stream,
+    bool disable_auto_flush);
+
+/**
+ * Delays sending request headers until bidirectional_stream_flush()
+ * is called. This flag is currently only respected when QUIC is negotiated.
+ * When true, QUIC will send request header frame along with data frame(s)
+ * as a single packet when possible.
+ */
+GRPC_SUPPORT_EXPORT
+void bidirectional_stream_delay_request_headers_until_flush(
+    bidirectional_stream* stream,
+    bool delay_headers_until_flush);
+
+/* Starts the stream by sending request to |url| using |method| and |headers|.
+ * If |end_of_stream| is true, then no data is expected to be written. The
+ * |method| is HTTP verb, with PUT having a special meaning to mark idempotent
+ * request, which could use QUIC 0-RTT.
+ */
+GRPC_SUPPORT_EXPORT
+int bidirectional_stream_start(bidirectional_stream* stream,
+                               const char* url,
+                               int priority,
+                               const char* method,
+                               const bidirectional_stream_header_array* headers,
+                               bool end_of_stream);
+
+/* Reads response data into |buffer| of |capacity| length. Must only be called
+ * at most once in response to each invocation of the
+ * on_stream_ready()/on_response_headers_received() and on_read_completed()
+ * methods of the bidirectional_stream_callback.
+ * Each call will result in an invocation of the callback's
+ * on_read_completed() method if data is read, or its on_failed() method if
+ * there's an error. The callback's on_succeeded() method is also invoked if
+ * there is no more data to read and |end_of_stream| was previously sent.
+ */
+GRPC_SUPPORT_EXPORT
+int bidirectional_stream_read(bidirectional_stream* stream,
+                              char* buffer,
+                              int capacity);
+
+/* Writes request data from |buffer| of |buffer_length| length. If auto flush is
+ * disabled, data will be sent only after bidirectional_stream_flush() is
+ * called.
+ * Each call will result in an invocation the callback's on_write_completed()
+ * method if data is sent, or its on_failed() method if there's an error.
+ * The callback's on_succeeded() method is also invoked if |end_of_stream| is
+ * set and all response data has been read.
+ */
+GRPC_SUPPORT_EXPORT
+int bidirectional_stream_write(bidirectional_stream* stream,
+                               const char* buffer,
+                               int buffer_length,
+                               bool end_of_stream);
+
+/**
+ * Flushes pending writes. This method should not be called before invocation of
+ * on_stream_ready() method of the bidirectional_stream_callback.
+ * For each previously called bidirectional_stream_write()
+ * a corresponding on_write_completed() callback will be invoked when the buffer
+ * is sent.
+ */
+GRPC_SUPPORT_EXPORT
+void bidirectional_stream_flush(bidirectional_stream* stream);
+
+/* Cancels the stream. Can be called at any time after
+ * bidirectional_stream_start(). The on_canceled() method of
+ * bidirectional_stream_callback will be invoked when cancelation
+ * is complete and no further callback methods will be invoked. If the
+ * stream has completed or has not started, calling
+ * bidirectional_stream_cancel() has no effect and on_canceled() will not
+ * be invoked. At most one callback method may be invoked after
+ * bidirectional_stream_cancel() has completed.
+ */
+GRPC_SUPPORT_EXPORT
+void bidirectional_stream_cancel(bidirectional_stream* stream);
+
+/* Returns true if the |stream| was successfully started and is now done
+ * (succeeded, canceled, or failed).
+ * Returns false if the |stream| stream is not yet started or is in progress.
+ */
+GRPC_SUPPORT_EXPORT
+bool bidirectional_stream_is_done(bidirectional_stream* stream);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // COMPONENTS_GRPC_SUPPORT_INCLUDE_BIDIRECTIONAL_STREAM_H_
diff --git a/third_party/objective_c/Cronet/cronet_c_for_grpc.h b/third_party/objective_c/Cronet/cronet_c_for_grpc.h
deleted file mode 100644
index 15a511aebd0b3d751b4f13127d8c51b289a89b95..0000000000000000000000000000000000000000
--- a/third_party/objective_c/Cronet/cronet_c_for_grpc.h
+++ /dev/null
@@ -1,202 +0,0 @@
-// Copyright 2016 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef COMPONENTS_CRONET_IOS_CRONET_C_FOR_GRPC_H_
-#define COMPONENTS_CRONET_IOS_CRONET_C_FOR_GRPC_H_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include <stddef.h>
-
-/* Cronet Engine API. */
-
-/* Opaque object representing Cronet Engine. Created and configured outside
- * of this API to facilitate sharing with other components */
-typedef struct cronet_engine { void* obj; } cronet_engine;
-
-void cronet_engine_add_quic_hint(cronet_engine* engine,
-                                 const char* host,
-                                 int port,
-                                 int alternate_port);
-
-/* Cronet Bidirectional Stream API */
-
-/* Opaque object representing Cronet Bidirectional Stream. */
-typedef struct cronet_bidirectional_stream {
-  void* obj;
-  void* annotation;
-} cronet_bidirectional_stream;
-
-/* A single request or response header element. */
-typedef struct cronet_bidirectional_stream_header {
-  const char* key;
-  const char* value;
-} cronet_bidirectional_stream_header;
-
-/* Array of request or response headers or trailers. */
-typedef struct cronet_bidirectional_stream_header_array {
-  size_t count;
-  size_t capacity;
-  cronet_bidirectional_stream_header* headers;
-} cronet_bidirectional_stream_header_array;
-
-/* Set of callbacks used to receive callbacks from bidirectional stream. */
-typedef struct cronet_bidirectional_stream_callback {
-  /* Invoked when request headers are sent. Indicates that stream has initiated
-   * the request. Consumer may call cronet_bidirectional_stream_write() to start
-   * writing data.
-   */
-  void (*on_request_headers_sent)(cronet_bidirectional_stream* stream);
-
-  /* Invoked when initial response headers are received.
-   * Consumer must call cronet_bidirectional_stream_read() to start reading.
-   * Consumer may call cronet_bidirectional_stream_write() to start writing or
-   * close the stream. Contents of |headers| is valid for duration of the call.
-   */
-  void (*on_response_headers_received)(
-      cronet_bidirectional_stream* stream,
-      const cronet_bidirectional_stream_header_array* headers,
-      const char* negotiated_protocol);
-
-  /* Invoked when data is read into the buffer passed to
-   * cronet_bidirectional_stream_read(). Only part of the buffer may be
-   * populated. To continue reading, call cronet_bidirectional_stream_read().
-   * It may be invoked after on_response_trailers_received()}, if there was
-   * pending read data before trailers were received.
-   *
-   * If count is 0, it means the remote side has signaled that it will send no
-   * more data; future calls to cronet_bidirectional_stream_read() will result
-   * in the on_data_read() callback or on_succeded() callback if
-   * cronet_bidirectional_stream_write() was invoked with end_of_stream set to
-   * true.
-   */
-  void (*on_read_completed)(cronet_bidirectional_stream* stream,
-                            char* data,
-                            int count);
-
-  /**
-   * Invoked when all data passed to cronet_bidirectional_stream_write() is
-   * sent.
-   * To continue writing, call cronet_bidirectional_stream_write().
-   */
-  void (*on_write_completed)(cronet_bidirectional_stream* stream,
-                             const char* data);
-
-  /* Invoked when trailers are received before closing the stream. Only invoked
-   * when server sends trailers, which it may not. May be invoked while there is
-   * read data remaining in local buffer. Contents of |trailers| is valid for
-   * duration of the call.
-   */
-  void (*on_response_trailers_received)(
-      cronet_bidirectional_stream* stream,
-      const cronet_bidirectional_stream_header_array* trailers);
-
-  /**
-   * Invoked when there is no data to be read or written and the stream is
-   * closed successfully remotely and locally. Once invoked, no further callback
-   * methods will be invoked.
-   */
-  void (*on_succeded)(cronet_bidirectional_stream* stream);
-
-  /**
-   * Invoked if the stream failed for any reason after
-   * cronet_bidirectional_stream_start(). HTTP/2 error codes are
-   * mapped to chrome net error codes. Once invoked, no further callback methods
-   * will be invoked.
-   */
-  void (*on_failed)(cronet_bidirectional_stream* stream, int net_error);
-
-  /**
-   * Invoked if the stream was canceled via
-   * cronet_bidirectional_stream_cancel(). Once invoked, no further callback
-   * methods will be invoked.
-   */
-  void (*on_canceled)(cronet_bidirectional_stream* stream);
-} cronet_bidirectional_stream_callback;
-
-/* Create a new stream object that uses |engine| and |callback|. All stream
- * tasks are performed asynchronously on the |engine| network thread. |callback|
- * methods are invoked synchronously on the |engine| network thread, but must
- * not run tasks on the current thread to prevent blocking networking operations
- * and causing exceptions during shutdown. The |annotation| is stored in
- * bidirectional stream for arbitrary use by application.
- *
- * Returned |cronet_bidirectional_stream*| is owned by the caller, and must be
- * destroyed using |cronet_bidirectional_stream_destroy|.
- *
- * Both |calback| and |engine| must remain valid until stream is destroyed.
- */
-cronet_bidirectional_stream* cronet_bidirectional_stream_create(
-    cronet_engine* engine,
-    void* annotation,
-    cronet_bidirectional_stream_callback* callback);
-
-/* TBD: The following methods return int. Should it be a custom type? */
-
-/* Destroy stream object. Destroy could be called from any thread, including
- * network thread, but is posted, so |stream| is valid until calling task is
- * complete.
- */
-int cronet_bidirectional_stream_destroy(cronet_bidirectional_stream* stream);
-
-/* Start the stream by sending request to |url| using |method| and |headers|. If
- * |end_of_stream| is true, then no data is expected to be written.
- */
-int cronet_bidirectional_stream_start(
-    cronet_bidirectional_stream* stream,
-    const char* url,
-    int priority,
-    const char* method,
-    const cronet_bidirectional_stream_header_array* headers,
-    bool end_of_stream);
-
-/* Read response data into |buffer| of |capacity| length. Must only be called at
- * most once in response to each invocation of the
- * on_response_headers_received() and on_read_completed() methods of the
- * cronet_bidirectional_stream_callback.
- * Each call will result in an invocation of one of the callback's
- * on_read_completed  method if data is read, its on_succeeded() method if
- * the stream is closed, or its on_failed() method if there's an error.
- */
-int cronet_bidirectional_stream_read(cronet_bidirectional_stream* stream,
-                                     char* buffer,
-                                     int capacity);
-
-/* Read response data into |buffer| of |capacity| length. Must only be called at
- * most once in response to each invocation of the
- * on_response_headers_received() and on_read_completed() methods of the
- * cronet_bidirectional_stream_callback.
- * Each call will result in an invocation of one of the callback's
- * on_read_completed  method if data is read, its on_succeeded() method if
- * the stream is closed, or its on_failed() method if there's an error.
- */
-int cronet_bidirectional_stream_write(cronet_bidirectional_stream* stream,
-                                      const char* buffer,
-                                      int count,
-                                      bool end_of_stream);
-
-/* Cancels the stream. Can be called at any time after
- * cronet_bidirectional_stream_start(). The on_canceled() method of
- * cronet_bidirectional_stream_callback will be invoked when cancelation
- * is complete and no further callback methods will be invoked. If the
- * stream has completed or has not started, calling
- * cronet_bidirectional_stream_cancel() has no effect and on_canceled() will not
- * be  invoked. At most one callback method may be invoked after
- * cronet_bidirectional_stream_cancel() has completed.
- */
-int cronet_bidirectional_stream_cancel(cronet_bidirectional_stream* stream);
-
-/* Returns true if the |stream| was successfully started and is now done
- * (succeeded, canceled, or failed).
- * Returns false if the |stream| stream is not yet started or is in progress.
- */
-bool cronet_bidirectional_stream_is_done(cronet_bidirectional_stream* stream);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // COMPONENTS_CRONET_IOS_CRONET_C_FOR_GRPC_H_
diff --git a/tools/run_tests/generated/sources_and_headers.json b/tools/run_tests/generated/sources_and_headers.json
index 90b88d7d6e9e8b0e3dbb7be70398a4dcba6a242d..c57b17611be473c2f0ea384e9f3b8cc41e5fe472 100644
--- a/tools/run_tests/generated/sources_and_headers.json
+++ b/tools/run_tests/generated/sources_and_headers.json
@@ -7658,7 +7658,7 @@
       "include/grpc/grpc_cronet.h", 
       "include/grpc/grpc_security.h", 
       "include/grpc/grpc_security_constants.h", 
-      "third_party/objective_c/Cronet/cronet_c_for_grpc.h"
+      "third_party/Cronet/bidirectional_stream_c.h"
     ], 
     "is_filegroup": true, 
     "language": "c",