grpc 1.7.3 → 1.8.0

data/src/core/lib/surface/server.h

@@ -24,34 +24,42 @@
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/transport/transport.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 extern const grpc_channel_filter grpc_server_top_filter;
 
 /** Lightweight tracing of server channel state */
-extern grpc_tracer_flag grpc_server_channel_trace;
+extern grpc_core::TraceFlag grpc_server_channel_trace;
 
 /* Add a listener to the server: when the server starts, it will call start,
    and when it shuts down, it will call destroy */
 void grpc_server_add_listener(
-    grpc_exec_ctx *exec_ctx, grpc_server *server, void *listener,
-    void (*start)(grpc_exec_ctx *exec_ctx, grpc_server *server, void *arg,
-                  grpc_pollset **pollsets, size_t npollsets),
-    void (*destroy)(grpc_exec_ctx *exec_ctx, grpc_server *server, void *arg,
-                    grpc_closure *on_done));
+    grpc_exec_ctx* exec_ctx, grpc_server* server, void* listener,
+    void (*start)(grpc_exec_ctx* exec_ctx, grpc_server* server, void* arg,
+                  grpc_pollset** pollsets, size_t npollsets),
+    void (*destroy)(grpc_exec_ctx* exec_ctx, grpc_server* server, void* arg,
+                    grpc_closure* on_done));
 
 /* Setup a transport - creates a channel stack, binds the transport to the
    server */
-void grpc_server_setup_transport(grpc_exec_ctx *exec_ctx, grpc_server *server,
-                                 grpc_transport *transport,
-                                 grpc_pollset *accepting_pollset,
-                                 const grpc_channel_args *args);
+void grpc_server_setup_transport(grpc_exec_ctx* exec_ctx, grpc_server* server,
+                                 grpc_transport* transport,
+                                 grpc_pollset* accepting_pollset,
+                                 const grpc_channel_args* args);
 
-const grpc_channel_args *grpc_server_get_channel_args(grpc_server *server);
+const grpc_channel_args* grpc_server_get_channel_args(grpc_server* server);
 
-int grpc_server_has_open_connections(grpc_server *server);
+int grpc_server_has_open_connections(grpc_server* server);
 
 /* Do not call this before grpc_server_start. Returns the pollsets and the
  * number of pollsets via 'pollsets' and 'pollset_count'. */
-void grpc_server_get_pollsets(grpc_server *server, grpc_pollset ***pollsets,
-                              size_t *pollset_count);
+void grpc_server_get_pollsets(grpc_server* server, grpc_pollset*** pollsets,
+                              size_t* pollset_count);
+
+#ifdef __cplusplus
+}
+#endif
 
 #endif /* GRPC_CORE_LIB_SURFACE_SERVER_H */

data/src/core/lib/surface/{validate_metadata.c → validate_metadata.cc}

@@ -26,18 +26,19 @@
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/slice/slice_string_helpers.h"
+#include "src/core/lib/surface/validate_metadata.h"
 
-static grpc_error *conforms_to(grpc_slice slice, const uint8_t *legal_bits,
-                               const char *err_desc) {
-  const uint8_t *p = GRPC_SLICE_START_PTR(slice);
-  const uint8_t *e = GRPC_SLICE_END_PTR(slice);
+static grpc_error* conforms_to(grpc_slice slice, const uint8_t* legal_bits,
+                               const char* err_desc) {
+  const uint8_t* p = GRPC_SLICE_START_PTR(slice);
+  const uint8_t* e = GRPC_SLICE_END_PTR(slice);
   for (; p != e; p++) {
     int idx = *p;
     int byte = idx / 8;
     int bit = idx % 8;
     if ((legal_bits[byte] & (1 << bit)) == 0) {
-      char *dump = grpc_dump_slice(slice, GPR_DUMP_HEX | GPR_DUMP_ASCII);
-      grpc_error *error = grpc_error_set_str(
+      char* dump = grpc_dump_slice(slice, GPR_DUMP_HEX | GPR_DUMP_ASCII);
+      grpc_error* error = grpc_error_set_str(
           grpc_error_set_int(GRPC_ERROR_CREATE_FROM_COPIED_STRING(err_desc),
                              GRPC_ERROR_INT_OFFSET,
                              p - GRPC_SLICE_START_PTR(slice)),
@@ -49,13 +50,13 @@ static grpc_error *conforms_to(grpc_slice slice, const uint8_t *legal_bits,
   return GRPC_ERROR_NONE;
 }
 
-static int error2int(grpc_error *error) {
+static int error2int(grpc_error* error) {
   int r = (error == GRPC_ERROR_NONE);
   GRPC_ERROR_UNREF(error);
   return r;
 }
 
-grpc_error *grpc_validate_header_key_is_legal(grpc_slice slice) {
+grpc_error* grpc_validate_header_key_is_legal(grpc_slice slice) {
   static const uint8_t legal_header_bits[256 / 8] = {
       0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0xff, 0x03, 0x00, 0x00, 0x00,
       0x80, 0xfe, 0xff, 0xff, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@@ -75,7 +76,7 @@ int grpc_header_key_is_legal(grpc_slice slice) {
   return error2int(grpc_validate_header_key_is_legal(slice));
 }
 
-grpc_error *grpc_validate_header_nonbin_value_is_legal(grpc_slice slice) {
+grpc_error* grpc_validate_header_nonbin_value_is_legal(grpc_slice slice) {
   static const uint8_t legal_header_bits[256 / 8] = {
       0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
       0xff, 0xff, 0xff, 0xff, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

data/src/core/lib/surface/validate_metadata.h

@@ -22,7 +22,15 @@
 #include <grpc/slice.h>
 #include "src/core/lib/iomgr/error.h"
 
-grpc_error *grpc_validate_header_key_is_legal(grpc_slice slice);
-grpc_error *grpc_validate_header_nonbin_value_is_legal(grpc_slice slice);
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+grpc_error* grpc_validate_header_key_is_legal(grpc_slice slice);
+grpc_error* grpc_validate_header_nonbin_value_is_legal(grpc_slice slice);
+
+#ifdef __cplusplus
+}
+#endif
 
 #endif /* GRPC_CORE_LIB_SURFACE_VALIDATE_METADATA_H */

data/src/core/lib/surface/{version.c → version.cc}

@@ -21,6 +21,6 @@
 
 #include <grpc/grpc.h>
 
-const char *grpc_version_string(void) { return "5.0.0"; }
+const char* grpc_version_string(void) { return "5.0.0"; }
 
-const char *grpc_g_stands_for(void) { return "gambit"; }
+const char* grpc_g_stands_for(void) { return "generous"; }

data/src/core/lib/transport/bdp_estimator.cc

@@ -0,0 +1,84 @@
+/*
+ *
+ * Copyright 2016 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include "src/core/lib/transport/bdp_estimator.h"
+
+#include <inttypes.h>
+#include <stdlib.h>
+
+#include <grpc/support/useful.h>
+
+grpc_core::TraceFlag grpc_bdp_estimator_trace(false, "bdp_estimator");
+
+namespace grpc_core {
+
+BdpEstimator::BdpEstimator(const char* name)
+    : ping_state_(PingState::UNSCHEDULED),
+      accumulator_(0),
+      estimate_(65536),
+      ping_start_time_(gpr_time_0(GPR_CLOCK_MONOTONIC)),
+      inter_ping_delay_(100.0),  // start at 100ms
+      stable_estimate_count_(0),
+      bw_est_(0),
+      name_(name) {}
+
+grpc_millis BdpEstimator::CompletePing(grpc_exec_ctx* exec_ctx) {
+  gpr_timespec now = gpr_now(GPR_CLOCK_MONOTONIC);
+  gpr_timespec dt_ts = gpr_time_sub(now, ping_start_time_);
+  double dt = (double)dt_ts.tv_sec + 1e-9 * (double)dt_ts.tv_nsec;
+  double bw = dt > 0 ? ((double)accumulator_ / dt) : 0;
+  int start_inter_ping_delay = inter_ping_delay_;
+  if (grpc_bdp_estimator_trace.enabled()) {
+    gpr_log(GPR_DEBUG,
+            "bdp[%s]:complete acc=%" PRId64 " est=%" PRId64
+            " dt=%lf bw=%lfMbs bw_est=%lfMbs",
+            name_, accumulator_, estimate_, dt, bw / 125000.0,
+            bw_est_ / 125000.0);
+  }
+  GPR_ASSERT(ping_state_ == PingState::STARTED);
+  if (accumulator_ > 2 * estimate_ / 3 && bw > bw_est_) {
+    estimate_ = GPR_MAX(accumulator_, estimate_ * 2);
+    bw_est_ = bw;
+    if (grpc_bdp_estimator_trace.enabled()) {
+      gpr_log(GPR_DEBUG, "bdp[%s]: estimate increased to %" PRId64, name_,
+              estimate_);
+    }
+    inter_ping_delay_ /= 2;  // if the ping estimate changes,
+                             // exponentially get faster at probing
+  } else if (inter_ping_delay_ < 10000) {
+    stable_estimate_count_++;
+    if (stable_estimate_count_ >= 2) {
+      inter_ping_delay_ +=
+          100 +
+          (int)(rand() * 100.0 / RAND_MAX);  // if the ping estimate is steady,
+                                             // slowly ramp down the probe time
+    }
+  }
+  if (start_inter_ping_delay != inter_ping_delay_) {
+    stable_estimate_count_ = 0;
+    if (grpc_bdp_estimator_trace.enabled()) {
+      gpr_log(GPR_DEBUG, "bdp[%s]:update_inter_time to %dms", name_,
+              inter_ping_delay_);
+    }
+  }
+  ping_state_ = PingState::UNSCHEDULED;
+  accumulator_ = 0;
+  return grpc_exec_ctx_now(exec_ctx) + inter_ping_delay_;
+}
+
+}  // namespace grpc_core

data/src/core/lib/transport/bdp_estimator.h

@@ -19,51 +19,76 @@
 #ifndef GRPC_CORE_LIB_TRANSPORT_BDP_ESTIMATOR_H
 #define GRPC_CORE_LIB_TRANSPORT_BDP_ESTIMATOR_H
 
-#include <grpc/support/time.h>
+#include <grpc/support/port_platform.h>
+
+#include <inttypes.h>
 #include <stdbool.h>
 #include <stdint.h>
+
+#include <grpc/support/log.h>
+#include <grpc/support/time.h>
+
 #include "src/core/lib/debug/trace.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
+
+extern grpc_core::TraceFlag grpc_bdp_estimator_trace;
+
+namespace grpc_core {
+
+class BdpEstimator {
+ public:
+  explicit BdpEstimator(const char* name);
+  ~BdpEstimator() {}
+
+  int64_t EstimateBdp() const { return estimate_; }
+  double EstimateBandwidth() const { return bw_est_; }
+
+  void AddIncomingBytes(int64_t num_bytes) { accumulator_ += num_bytes; }
+
+  // Schedule a ping: call in response to receiving a true from
+  // grpc_bdp_estimator_add_incoming_bytes once a ping has been scheduled by a
+  // transport (but not necessarily started)
+  void SchedulePing() {
+    if (grpc_bdp_estimator_trace.enabled()) {
+      gpr_log(GPR_DEBUG, "bdp[%s]:sched acc=%" PRId64 " est=%" PRId64, name_,
+              accumulator_, estimate_);
+    }
+    GPR_ASSERT(ping_state_ == PingState::UNSCHEDULED);
+    ping_state_ = PingState::SCHEDULED;
+    accumulator_ = 0;
+  }
+
+  // Start a ping: call after calling grpc_bdp_estimator_schedule_ping and
+  // once
+  // the ping is on the wire
+  void StartPing() {
+    if (grpc_bdp_estimator_trace.enabled()) {
+      gpr_log(GPR_DEBUG, "bdp[%s]:start acc=%" PRId64 " est=%" PRId64, name_,
+              accumulator_, estimate_);
+    }
+    GPR_ASSERT(ping_state_ == PingState::SCHEDULED);
+    ping_state_ = PingState::STARTED;
+    accumulator_ = 0;
+    ping_start_time_ = gpr_now(GPR_CLOCK_MONOTONIC);
+  }
+
+  // Completes a previously started ping, returns when to schedule the next one
+  grpc_millis CompletePing(grpc_exec_ctx* exec_ctx);
+
+ private:
+  enum class PingState { UNSCHEDULED, SCHEDULED, STARTED };
+
+  PingState ping_state_;
+  int64_t accumulator_;
+  int64_t estimate_;
+  // when was the current ping started?
+  gpr_timespec ping_start_time_;
+  int inter_ping_delay_;
+  int stable_estimate_count_;
+  double bw_est_;
+  const char* name_;
+};
 
-#define GRPC_BDP_SAMPLES 16
-#define GRPC_BDP_MIN_SAMPLES_FOR_ESTIMATE 3
-
-extern grpc_tracer_flag grpc_bdp_estimator_trace;
-
-typedef enum {
-  GRPC_BDP_PING_UNSCHEDULED,
-  GRPC_BDP_PING_SCHEDULED,
-  GRPC_BDP_PING_STARTED
-} grpc_bdp_estimator_ping_state;
-
-typedef struct grpc_bdp_estimator {
-  grpc_bdp_estimator_ping_state ping_state;
-  int64_t accumulator;
-  int64_t estimate;
-  gpr_timespec ping_start_time;
-  double bw_est;
-  const char *name;
-} grpc_bdp_estimator;
-
-void grpc_bdp_estimator_init(grpc_bdp_estimator *estimator, const char *name);
-
-// Returns true if a reasonable estimate could be obtained
-bool grpc_bdp_estimator_get_estimate(const grpc_bdp_estimator *estimator,
-                                     int64_t *estimate);
-// Tracks new bytes read.
-bool grpc_bdp_estimator_get_bw(const grpc_bdp_estimator *estimator, double *bw);
-// Returns true if the user should schedule a ping
-void grpc_bdp_estimator_add_incoming_bytes(grpc_bdp_estimator *estimator,
-                                           int64_t num_bytes);
-// Returns true if the user should schedule a ping
-bool grpc_bdp_estimator_need_ping(const grpc_bdp_estimator *estimator);
-// Schedule a ping: call in response to receiving a true from
-// grpc_bdp_estimator_add_incoming_bytes once a ping has been scheduled by a
-// transport (but not necessarily started)
-void grpc_bdp_estimator_schedule_ping(grpc_bdp_estimator *estimator);
-// Start a ping: call after calling grpc_bdp_estimator_schedule_ping and once
-// the ping is on the wire
-void grpc_bdp_estimator_start_ping(grpc_bdp_estimator *estimator);
-// Completes a previously started ping
-void grpc_bdp_estimator_complete_ping(grpc_bdp_estimator *estimator);
+}  // namespace grpc_core
 
 #endif /* GRPC_CORE_LIB_TRANSPORT_BDP_ESTIMATOR_H */

data/src/core/lib/transport/{byte_stream.c → byte_stream.cc}

@@ -25,45 +25,45 @@
 
 #include "src/core/lib/slice/slice_internal.h"
 
-bool grpc_byte_stream_next(grpc_exec_ctx *exec_ctx,
-                           grpc_byte_stream *byte_stream, size_t max_size_hint,
-                           grpc_closure *on_complete) {
+bool grpc_byte_stream_next(grpc_exec_ctx* exec_ctx,
+                           grpc_byte_stream* byte_stream, size_t max_size_hint,
+                           grpc_closure* on_complete) {
   return byte_stream->vtable->next(exec_ctx, byte_stream, max_size_hint,
                                    on_complete);
 }
 
-grpc_error *grpc_byte_stream_pull(grpc_exec_ctx *exec_ctx,
-                                  grpc_byte_stream *byte_stream,
-                                  grpc_slice *slice) {
+grpc_error* grpc_byte_stream_pull(grpc_exec_ctx* exec_ctx,
+                                  grpc_byte_stream* byte_stream,
+                                  grpc_slice* slice) {
   return byte_stream->vtable->pull(exec_ctx, byte_stream, slice);
 }
 
-void grpc_byte_stream_shutdown(grpc_exec_ctx *exec_ctx,
-                               grpc_byte_stream *byte_stream,
-                               grpc_error *error) {
+void grpc_byte_stream_shutdown(grpc_exec_ctx* exec_ctx,
+                               grpc_byte_stream* byte_stream,
+                               grpc_error* error) {
   byte_stream->vtable->shutdown(exec_ctx, byte_stream, error);
 }
 
-void grpc_byte_stream_destroy(grpc_exec_ctx *exec_ctx,
-                              grpc_byte_stream *byte_stream) {
+void grpc_byte_stream_destroy(grpc_exec_ctx* exec_ctx,
+                              grpc_byte_stream* byte_stream) {
   byte_stream->vtable->destroy(exec_ctx, byte_stream);
 }
 
 // grpc_slice_buffer_stream
 
-static bool slice_buffer_stream_next(grpc_exec_ctx *exec_ctx,
-                                     grpc_byte_stream *byte_stream,
+static bool slice_buffer_stream_next(grpc_exec_ctx* exec_ctx,
+                                     grpc_byte_stream* byte_stream,
                                      size_t max_size_hint,
-                                     grpc_closure *on_complete) {
-  grpc_slice_buffer_stream *stream = (grpc_slice_buffer_stream *)byte_stream;
+                                     grpc_closure* on_complete) {
+  grpc_slice_buffer_stream* stream = (grpc_slice_buffer_stream*)byte_stream;
   GPR_ASSERT(stream->cursor < stream->backing_buffer->count);
   return true;
 }
 
-static grpc_error *slice_buffer_stream_pull(grpc_exec_ctx *exec_ctx,
-                                            grpc_byte_stream *byte_stream,
-                                            grpc_slice *slice) {
-  grpc_slice_buffer_stream *stream = (grpc_slice_buffer_stream *)byte_stream;
+static grpc_error* slice_buffer_stream_pull(grpc_exec_ctx* exec_ctx,
+                                            grpc_byte_stream* byte_stream,
+                                            grpc_slice* slice) {
+  grpc_slice_buffer_stream* stream = (grpc_slice_buffer_stream*)byte_stream;
   if (stream->shutdown_error != GRPC_ERROR_NONE) {
     return GRPC_ERROR_REF(stream->shutdown_error);
   }
@@ -74,17 +74,17 @@ static grpc_error *slice_buffer_stream_pull(grpc_exec_ctx *exec_ctx,
   return GRPC_ERROR_NONE;
 }
 
-static void slice_buffer_stream_shutdown(grpc_exec_ctx *exec_ctx,
-                                         grpc_byte_stream *byte_stream,
-                                         grpc_error *error) {
-  grpc_slice_buffer_stream *stream = (grpc_slice_buffer_stream *)byte_stream;
+static void slice_buffer_stream_shutdown(grpc_exec_ctx* exec_ctx,
+                                         grpc_byte_stream* byte_stream,
+                                         grpc_error* error) {
+  grpc_slice_buffer_stream* stream = (grpc_slice_buffer_stream*)byte_stream;
   GRPC_ERROR_UNREF(stream->shutdown_error);
   stream->shutdown_error = error;
 }
 
-static void slice_buffer_stream_destroy(grpc_exec_ctx *exec_ctx,
-                                        grpc_byte_stream *byte_stream) {
-  grpc_slice_buffer_stream *stream = (grpc_slice_buffer_stream *)byte_stream;
+static void slice_buffer_stream_destroy(grpc_exec_ctx* exec_ctx,
+                                        grpc_byte_stream* byte_stream) {
+  grpc_slice_buffer_stream* stream = (grpc_slice_buffer_stream*)byte_stream;
   grpc_slice_buffer_reset_and_unref_internal(exec_ctx, stream->backing_buffer);
   GRPC_ERROR_UNREF(stream->shutdown_error);
 }
@@ -93,8 +93,8 @@ static const grpc_byte_stream_vtable slice_buffer_stream_vtable = {
     slice_buffer_stream_next, slice_buffer_stream_pull,
     slice_buffer_stream_shutdown, slice_buffer_stream_destroy};
 
-void grpc_slice_buffer_stream_init(grpc_slice_buffer_stream *stream,
-                                   grpc_slice_buffer *slice_buffer,
+void grpc_slice_buffer_stream_init(grpc_slice_buffer_stream* stream,
+                                   grpc_slice_buffer* slice_buffer,
                                    uint32_t flags) {
   GPR_ASSERT(slice_buffer->length <= UINT32_MAX);
   stream->base.length = (uint32_t)slice_buffer->length;
@@ -107,33 +107,33 @@ void grpc_slice_buffer_stream_init(grpc_slice_buffer_stream *stream,
 
 // grpc_caching_byte_stream
 
-void grpc_byte_stream_cache_init(grpc_byte_stream_cache *cache,
-                                 grpc_byte_stream *underlying_stream) {
+void grpc_byte_stream_cache_init(grpc_byte_stream_cache* cache,
+                                 grpc_byte_stream* underlying_stream) {
   cache->underlying_stream = underlying_stream;
   grpc_slice_buffer_init(&cache->cache_buffer);
 }
 
-void grpc_byte_stream_cache_destroy(grpc_exec_ctx *exec_ctx,
-                                    grpc_byte_stream_cache *cache) {
+void grpc_byte_stream_cache_destroy(grpc_exec_ctx* exec_ctx,
+                                    grpc_byte_stream_cache* cache) {
   grpc_byte_stream_destroy(exec_ctx, cache->underlying_stream);
   grpc_slice_buffer_destroy_internal(exec_ctx, &cache->cache_buffer);
 }
 
-static bool caching_byte_stream_next(grpc_exec_ctx *exec_ctx,
-                                     grpc_byte_stream *byte_stream,
+static bool caching_byte_stream_next(grpc_exec_ctx* exec_ctx,
+                                     grpc_byte_stream* byte_stream,
                                      size_t max_size_hint,
-                                     grpc_closure *on_complete) {
-  grpc_caching_byte_stream *stream = (grpc_caching_byte_stream *)byte_stream;
+                                     grpc_closure* on_complete) {
+  grpc_caching_byte_stream* stream = (grpc_caching_byte_stream*)byte_stream;
   if (stream->shutdown_error != GRPC_ERROR_NONE) return true;
   if (stream->cursor < stream->cache->cache_buffer.count) return true;
   return grpc_byte_stream_next(exec_ctx, stream->cache->underlying_stream,
                                max_size_hint, on_complete);
 }
 
-static grpc_error *caching_byte_stream_pull(grpc_exec_ctx *exec_ctx,
-                                            grpc_byte_stream *byte_stream,
-                                            grpc_slice *slice) {
-  grpc_caching_byte_stream *stream = (grpc_caching_byte_stream *)byte_stream;
+static grpc_error* caching_byte_stream_pull(grpc_exec_ctx* exec_ctx,
+                                            grpc_byte_stream* byte_stream,
+                                            grpc_slice* slice) {
+  grpc_caching_byte_stream* stream = (grpc_caching_byte_stream*)byte_stream;
   if (stream->shutdown_error != GRPC_ERROR_NONE) {
     return GRPC_ERROR_REF(stream->shutdown_error);
   }
@@ -143,7 +143,7 @@ static grpc_error *caching_byte_stream_pull(grpc_exec_ctx *exec_ctx,
     ++stream->cursor;
     return GRPC_ERROR_NONE;
   }
-  grpc_error *error =
+  grpc_error* error =
       grpc_byte_stream_pull(exec_ctx, stream->cache->underlying_stream, slice);
   if (error == GRPC_ERROR_NONE) {
     ++stream->cursor;
@@ -153,18 +153,18 @@ static grpc_error *caching_byte_stream_pull(grpc_exec_ctx *exec_ctx,
   return error;
 }
 
-static void caching_byte_stream_shutdown(grpc_exec_ctx *exec_ctx,
-                                         grpc_byte_stream *byte_stream,
-                                         grpc_error *error) {
-  grpc_caching_byte_stream *stream = (grpc_caching_byte_stream *)byte_stream;
+static void caching_byte_stream_shutdown(grpc_exec_ctx* exec_ctx,
+                                         grpc_byte_stream* byte_stream,
+                                         grpc_error* error) {
+  grpc_caching_byte_stream* stream = (grpc_caching_byte_stream*)byte_stream;
   GRPC_ERROR_UNREF(stream->shutdown_error);
   stream->shutdown_error = GRPC_ERROR_REF(error);
   grpc_byte_stream_shutdown(exec_ctx, stream->cache->underlying_stream, error);
 }
 
-static void caching_byte_stream_destroy(grpc_exec_ctx *exec_ctx,
-                                        grpc_byte_stream *byte_stream) {
-  grpc_caching_byte_stream *stream = (grpc_caching_byte_stream *)byte_stream;
+static void caching_byte_stream_destroy(grpc_exec_ctx* exec_ctx,
+                                        grpc_byte_stream* byte_stream) {
+  grpc_caching_byte_stream* stream = (grpc_caching_byte_stream*)byte_stream;
   GRPC_ERROR_UNREF(stream->shutdown_error);
 }
 
@@ -172,8 +172,8 @@ static const grpc_byte_stream_vtable caching_byte_stream_vtable = {
     caching_byte_stream_next, caching_byte_stream_pull,
     caching_byte_stream_shutdown, caching_byte_stream_destroy};
 
-void grpc_caching_byte_stream_init(grpc_caching_byte_stream *stream,
-                                   grpc_byte_stream_cache *cache) {
+void grpc_caching_byte_stream_init(grpc_caching_byte_stream* stream,
+                                   grpc_byte_stream_cache* cache) {
   memset(stream, 0, sizeof(*stream));
   stream->base.length = cache->underlying_stream->length;
   stream->base.flags = cache->underlying_stream->flags;
@@ -182,6 +182,6 @@ void grpc_caching_byte_stream_init(grpc_caching_byte_stream *stream,
   stream->shutdown_error = GRPC_ERROR_NONE;
 }
 
-void grpc_caching_byte_stream_reset(grpc_caching_byte_stream *stream) {
+void grpc_caching_byte_stream_reset(grpc_caching_byte_stream* stream) {
   stream->cursor = 0;
 }