Merge github.com:google/grpc into nogo

131 files changed, 959 insertions, 1226 deletions

diff --git a/src/compiler/cpp_generator.cc b/src/compiler/cpp_generator.cc
index 43a04be931..1116049806 100644
--- a/src/compiler/cpp_generator.cc
+++ b/src/compiler/cpp_generator.cc
@@ -43,13 +43,11 @@ namespace grpc_cpp_generator {
 namespace {
 
 bool NoStreaming(const google::protobuf::MethodDescriptor* method) {
-  return !method->client_streaming() &&
-         !method->server_streaming();
+  return !method->client_streaming() && !method->server_streaming();
 }
 
 bool ClientOnlyStreaming(const google::protobuf::MethodDescriptor* method) {
-  return method->client_streaming() &&
-         !method->server_streaming();
+  return method->client_streaming() && !method->server_streaming();
 }
 
 bool ServerOnlyStreaming(const google::protobuf::MethodDescriptor* method) {
@@ -57,8 +55,7 @@ bool ServerOnlyStreaming(const google::protobuf::MethodDescriptor* method) {
 }
 
 bool BidiStreaming(const google::protobuf::MethodDescriptor* method) {
-  return method->client_streaming() &&
-         method->server_streaming();
+  return method->client_streaming() && method->server_streaming();
 }
 
 bool HasClientOnlyStreaming(const google::protobuf::FileDescriptor* file) {
@@ -132,8 +129,8 @@ string GetSourceIncludes() {
 }
 
 void PrintHeaderClientMethod(google::protobuf::io::Printer* printer,
-                       const google::protobuf::MethodDescriptor* method,
-                       map<string, string>* vars) {
+                             const google::protobuf::MethodDescriptor* method,
+                             map<string, string>* vars) {
   (*vars)["Method"] = method->name();
   (*vars)["Request"] =
       grpc_cpp_generator::ClassName(method->input_type(), true);
@@ -204,8 +201,9 @@ void PrintHeaderService(google::protobuf::io::Printer* printer,
   printer->Indent();
 
   // Client side
-  printer->Print("class Stub : public ::grpc::InternalStub {\n"
-                 " public:\n");
+  printer->Print(
+      "class Stub : public ::grpc::InternalStub {\n"
+      " public:\n");
   printer->Indent();
   for (int i = 0; i < service->method_count(); ++i) {
     PrintHeaderClientMethod(printer, service->method(i), vars);
@@ -219,8 +217,9 @@ void PrintHeaderService(google::protobuf::io::Printer* printer,
   printer->Print("\n");
 
   // Server side
-  printer->Print("class Service {\n"
-                " public:\n");
+  printer->Print(
+      "class Service {\n"
+      " public:\n");
   printer->Indent();
   printer->Print("Service() : service_(nullptr) {}\n");
   printer->Print("virtual ~Service();\n");
@@ -229,8 +228,9 @@ void PrintHeaderService(google::protobuf::io::Printer* printer,
   }
   printer->Print("::grpc::RpcService* service();\n");
   printer->Outdent();
-  printer->Print(" private:\n"
-                 "  ::grpc::RpcService* service_;\n");
+  printer->Print(
+      " private:\n"
+      "  ::grpc::RpcService* service_;\n");
   printer->Print("};\n");
 
   printer->Outdent();
@@ -251,8 +251,8 @@ string GetHeaderServices(const google::protobuf::FileDescriptor* file) {
 }
 
 void PrintSourceClientMethod(google::protobuf::io::Printer* printer,
-                       const google::protobuf::MethodDescriptor* method,
-                       map<string, string>* vars) {
+                             const google::protobuf::MethodDescriptor* method,
+                             map<string, string>* vars) {
   (*vars)["Method"] = method->name();
   (*vars)["Request"] =
       grpc_cpp_generator::ClassName(method->input_type(), true);
@@ -308,8 +308,8 @@ void PrintSourceClientMethod(google::protobuf::io::Printer* printer,
 }
 
 void PrintSourceServerMethod(google::protobuf::io::Printer* printer,
-                       const google::protobuf::MethodDescriptor* method,
-                       map<string, string>* vars) {
+                             const google::protobuf::MethodDescriptor* method,
+                             map<string, string>* vars) {
   (*vars)["Method"] = method->name();
   (*vars)["Request"] =
       grpc_cpp_generator::ClassName(method->input_type(), true);
@@ -362,12 +362,12 @@ void PrintSourceService(google::protobuf::io::Printer* printer,
                         map<string, string>* vars) {
   (*vars)["Service"] = service->name();
   printer->Print(*vars,
-      "$Service$::Stub* $Service$::NewStub("
-      "const std::shared_ptr<::grpc::ChannelInterface>& channel) {\n"
-      "  $Service$::Stub* stub = new $Service$::Stub();\n"
-      "  stub->set_channel(channel);\n"
-      "  return stub;\n"
-      "};\n\n");
+                 "$Service$::Stub* $Service$::NewStub("
+                 "const std::shared_ptr<::grpc::ChannelInterface>& channel) {\n"
+                 "  $Service$::Stub* stub = new $Service$::Stub();\n"
+                 "  stub->set_channel(channel);\n"
+                 "  return stub;\n"
+                 "};\n\n");
   for (int i = 0; i < service->method_count(); ++i) {
     PrintSourceClientMethod(printer, service->method(i), vars);
   }
@@ -380,11 +380,12 @@ void PrintSourceService(google::protobuf::io::Printer* printer,
     PrintSourceServerMethod(printer, service->method(i), vars);
   }
   printer->Print(*vars,
-      "::grpc::RpcService* $Service$::Service::service() {\n");
+                 "::grpc::RpcService* $Service$::Service::service() {\n");
   printer->Indent();
-  printer->Print("if (service_ != nullptr) {\n"
-                 "  return service_;\n"
-                 "}\n");
+  printer->Print(
+      "if (service_ != nullptr) {\n"
+      "  return service_;\n"
+      "}\n");
   printer->Print("service_ = new ::grpc::RpcService();\n");
   for (int i = 0; i < service->method_count(); ++i) {
     const google::protobuf::MethodDescriptor* method = service->method(i);
diff --git a/src/compiler/cpp_generator_helpers.h b/src/compiler/cpp_generator_helpers.h
index 8d8b03ea43..ba251faf29 100644
--- a/src/compiler/cpp_generator_helpers.h
+++ b/src/compiler/cpp_generator_helpers.h
@@ -85,7 +85,8 @@ inline string DotsToUnderscores(const string& name) {
   return StringReplace(name, ".", "_");
 }
 
-inline string ClassName(const google::protobuf::Descriptor* descriptor, bool qualified) {
+inline string ClassName(const google::protobuf::Descriptor* descriptor,
+                        bool qualified) {
   // Find "outer", the descriptor of the top-level message in which
   // "descriptor" is embedded.
   const google::protobuf::Descriptor* outer = descriptor;
diff --git a/src/compiler/cpp_plugin.cc b/src/compiler/cpp_plugin.cc
index 7aa745a4f1..17836b1612 100644
--- a/src/compiler/cpp_plugin.cc
+++ b/src/compiler/cpp_plugin.cc
@@ -54,9 +54,10 @@ class CppGrpcGenerator : public google::protobuf::compiler::CodeGenerator {
                         google::protobuf::compiler::GeneratorContext* context,
                         string* error) const {
     if (file->options().cc_generic_services()) {
-      *error = "cpp grpc proto compiler plugin does not work with generic "
-               "services. To generate cpp grpc APIs, please set \""
-               "cc_generic_service = false\".";
+      *error =
+          "cpp grpc proto compiler plugin does not work with generic "
+          "services. To generate cpp grpc APIs, please set \""
+          "cc_generic_service = false\".";
       return false;
     }
 
diff --git a/src/compiler/ruby_generator.cc b/src/compiler/ruby_generator.cc
index 20485b47a5..fae8858ff7 100644
--- a/src/compiler/ruby_generator.cc
+++ b/src/compiler/ruby_generator.cc
@@ -67,9 +67,8 @@ void PrintMethod(const MethodDescriptor* method, const string& package,
     output_type = "stream(" + output_type + ")";
   }
   map<string, string> method_vars = ListToDict({
-      "mth.name", method->name(),
-      "input.type", input_type,
-      "output.type", output_type,
+      "mth.name", method->name(), "input.type", input_type, "output.type",
+      output_type,
   });
   out->Print(method_vars, "rpc :$mth.name$, $input.type$, $output.type$\n");
 }
@@ -105,8 +104,7 @@ void PrintService(const ServiceDescriptor* service, const string& package,
   out->Print("self.marshal_class_method = :encode\n");
   out->Print("self.unmarshal_class_method = :decode\n");
   map<string, string> pkg_vars = ListToDict({
-      "service.name", service->name(),
-      "pkg.name", package,
+      "service.name", service->name(), "pkg.name", package,
   });
   out->Print(pkg_vars, "self.service_name = '$pkg.name$.$service.name$'\n");
   out->Print("\n");
@@ -139,9 +137,8 @@ string GetServices(const FileDescriptor* file) {
 
   // Write out a file header.
   map<string, string> header_comment_vars = ListToDict({
-        "file.name", file->name(),
-        "file.package", file->package(),
-      });
+      "file.name", file->name(), "file.package", file->package(),
+  });
   out.Print("# Generated by the protocol buffer compiler.  DO NOT EDIT!\n");
   out.Print(header_comment_vars,
             "# Source: $file.name$ for package '$file.package$'\n");
diff --git a/src/compiler/ruby_generator_helpers-inl.h b/src/compiler/ruby_generator_helpers-inl.h
index 67a5eedd09..8263e353b2 100644
--- a/src/compiler/ruby_generator_helpers-inl.h
+++ b/src/compiler/ruby_generator_helpers-inl.h
@@ -47,8 +47,9 @@ inline bool ServicesFilename(const google::protobuf::FileDescriptor* file,
   static const unsigned proto_suffix_length = 6;  // length of ".proto"
   if (file->name().size() > proto_suffix_length &&
       file->name().find_last_of(".proto") == file->name().size() - 1) {
-    *file_name_or_error = file->name().substr(
-        0, file->name().size() - proto_suffix_length) + "_services.rb";
+    *file_name_or_error =
+        file->name().substr(0, file->name().size() - proto_suffix_length) +
+        "_services.rb";
     return true;
   } else {
     *file_name_or_error = "Invalid proto file name:  must end with .proto";
@@ -56,7 +57,8 @@ inline bool ServicesFilename(const google::protobuf::FileDescriptor* file,
   }
 }
 
-inline string MessagesRequireName(const google::protobuf::FileDescriptor* file) {
+inline string MessagesRequireName(
+    const google::protobuf::FileDescriptor* file) {
   return Replace(file->name(), ".proto", "");
 }
 
diff --git a/src/compiler/ruby_generator_map-inl.h b/src/compiler/ruby_generator_map-inl.h
index ea5050652b..fa86fbb956 100644
--- a/src/compiler/ruby_generator_map-inl.h
+++ b/src/compiler/ruby_generator_map-inl.h
@@ -40,7 +40,6 @@
 #include <string>
 #include <vector>
 
-
 using std::initializer_list;
 using std::map;
 using std::vector;
@@ -51,11 +50,12 @@ namespace grpc_ruby_generator {
 // into a map of key* to value*. Is merely a readability helper for later code.
 inline map<string, string> ListToDict(const initializer_list<string>& values) {
   if (values.size() % 2 != 0) {
-    // MOE: insert     std::cerr << "Not every 'key' has a value in `values`." << std::endl;
+    // MOE: insert     std::cerr << "Not every 'key' has a value in `values`."
+    // << std::endl;
   }
   map<string, string> value_map;
   auto value_iter = values.begin();
-  for (unsigned i = 0; i < values.size()/2; ++i) {
+  for (unsigned i = 0; i < values.size() / 2; ++i) {
     string key = *value_iter;
     ++value_iter;
     string value = *value_iter;
diff --git a/src/compiler/ruby_generator_string-inl.h b/src/compiler/ruby_generator_string-inl.h
index 85a76fa421..44e17a202a 100644
--- a/src/compiler/ruby_generator_string-inl.h
+++ b/src/compiler/ruby_generator_string-inl.h
@@ -45,7 +45,7 @@ using std::transform;
 namespace grpc_ruby_generator {
 
 // Split splits a string using char into elems.
-inline vector<string> &Split(const string &s, char delim,
+inline vector<string>& Split(const string& s, char delim,
                              vector<string>* elems) {
   stringstream ss(s);
   string item;
@@ -56,7 +56,7 @@ inline vector<string> &Split(const string &s, char delim,
 }
 
 // Split splits a string using char, returning the result in a vector.
-inline vector<string> Split(const string &s, char delim) {
+inline vector<string> Split(const string& s, char delim) {
   vector<string> elems;
   Split(s, delim, &elems);
   return elems;
@@ -106,7 +106,7 @@ inline string CapitalizeFirst(string s) {
 inline string RubyTypeOf(const string& a_type, const string& package) {
   string res(a_type);
   ReplacePrefix(&res, package, "");  // remove the leading package if present
-  ReplacePrefix(&res, ".", "");  // remove the leading . (no package)
+  ReplacePrefix(&res, ".", "");      // remove the leading . (no package)
   if (res.find('.') == string::npos) {
     return res;
   } else {
diff --git a/src/core/channel/channel_args.h b/src/core/channel/channel_args.h
index cf38d5d01f..92280450a1 100644
--- a/src/core/channel/channel_args.h
+++ b/src/core/channel/channel_args.h
@@ -51,4 +51,4 @@ void grpc_channel_args_destroy(grpc_channel_args *a);
    is specified in channel args, otherwise returns 0. */
 int grpc_channel_args_is_census_enabled(const grpc_channel_args *a);
 
-#endif  /* __GRPC_INTERNAL_CHANNEL_CHANNEL_ARGS_H__ */
+#endif /* __GRPC_INTERNAL_CHANNEL_CHANNEL_ARGS_H__ */
diff --git a/src/core/channel/channel_stack.c b/src/core/channel/channel_stack.c
index 5ee412bf7d..14fc800778 100644
--- a/src/core/channel/channel_stack.c
+++ b/src/core/channel/channel_stack.c
@@ -54,7 +54,7 @@
 
 /* Given a size, round up to the next multiple of sizeof(void*) */
 #define ROUND_UP_TO_ALIGNMENT_SIZE(x) \
-  (((x)+GPR_MAX_ALIGNMENT - 1) & ~(GPR_MAX_ALIGNMENT - 1))
+  (((x) + GPR_MAX_ALIGNMENT - 1) & ~(GPR_MAX_ALIGNMENT - 1))
 
 size_t grpc_channel_stack_size(const grpc_channel_filter **filters,
                                size_t filter_count) {
@@ -190,14 +190,13 @@ void grpc_channel_next_op(grpc_channel_element *elem, grpc_channel_op *op) {
 
 grpc_channel_stack *grpc_channel_stack_from_top_element(
     grpc_channel_element *elem) {
-  return (grpc_channel_stack *)((char *)(elem) -
-                                ROUND_UP_TO_ALIGNMENT_SIZE(
-                                    sizeof(grpc_channel_stack)));
+  return (grpc_channel_stack *)((char *)(elem)-ROUND_UP_TO_ALIGNMENT_SIZE(
+      sizeof(grpc_channel_stack)));
 }
 
 grpc_call_stack *grpc_call_stack_from_top_element(grpc_call_element *elem) {
-  return (grpc_call_stack *)((char *)(elem) - ROUND_UP_TO_ALIGNMENT_SIZE(
-                                                  sizeof(grpc_call_stack)));
+  return (grpc_call_stack *)((char *)(elem)-ROUND_UP_TO_ALIGNMENT_SIZE(
+      sizeof(grpc_call_stack)));
 }
 
 static void do_nothing(void *user_data, grpc_op_error error) {}
diff --git a/src/core/channel/channel_stack.h b/src/core/channel/channel_stack.h
index 14e972f539..eb68102b43 100644
--- a/src/core/channel/channel_stack.h
+++ b/src/core/channel/channel_stack.h
@@ -302,4 +302,4 @@ void grpc_call_element_send_cancel(grpc_call_element *cur_elem);
   } while (0)
 #endif
 
-#endif  /* __GRPC_INTERNAL_CHANNEL_CHANNEL_STACK_H__ */
+#endif /* __GRPC_INTERNAL_CHANNEL_CHANNEL_STACK_H__ */
diff --git a/src/core/channel/client_channel.h b/src/core/channel/client_channel.h
index 576af64ec7..6b8a7d95a8 100644
--- a/src/core/channel/client_channel.h
+++ b/src/core/channel/client_channel.h
@@ -59,4 +59,4 @@ grpc_transport_setup_result grpc_client_channel_transport_setup_complete(
     grpc_channel_filter const **channel_filters, size_t num_channel_filters,
     grpc_mdctx *mdctx);
 
-#endif  /* __GRPC_INTERNAL_CHANNEL_CLIENT_CHANNEL_H__ */
+#endif /* __GRPC_INTERNAL_CHANNEL_CLIENT_CHANNEL_H__ */
diff --git a/src/core/channel/client_setup.h b/src/core/channel/client_setup.h
index a508785e60..155a9a5b1a 100644
--- a/src/core/channel/client_setup.h
+++ b/src/core/channel/client_setup.h
@@ -64,4 +64,4 @@ gpr_timespec grpc_client_setup_request_deadline(grpc_client_setup_request *r);
 
 grpc_mdctx *grpc_client_setup_get_mdctx(grpc_client_setup_request *r);
 
-#endif  /* __GRPC_INTERNAL_CHANNEL_CLIENT_SETUP_H__ */
+#endif /* __GRPC_INTERNAL_CHANNEL_CLIENT_SETUP_H__ */
diff --git a/src/core/channel/connected_channel.c b/src/core/channel/connected_channel.c
index e01cb81a89..30de10905c 100644
--- a/src/core/channel/connected_channel.c
+++ b/src/core/channel/connected_channel.c
@@ -69,7 +69,7 @@ typedef struct {
 /* We perform a small hack to locate transport data alongside the connected
    channel data in call allocations, to allow everything to be pulled in minimal
    cache line requests */
-#define TRANSPORT_STREAM_FROM_CALL_DATA(calld) ((grpc_stream *)((calld)+1))
+#define TRANSPORT_STREAM_FROM_CALL_DATA(calld) ((grpc_stream *)((calld) + 1))
 #define CALL_DATA_FROM_TRANSPORT_STREAM(transport_stream) \
   (((call_data *)(transport_stream)) - 1)
 
@@ -257,9 +257,9 @@ static void destroy_channel_elem(grpc_channel_element *elem) {
 }
 
 const grpc_channel_filter grpc_connected_channel_filter = {
-    call_op,              channel_op,
+    call_op, channel_op,
 
-    sizeof(call_data),    init_call_elem,    destroy_call_elem,
+    sizeof(call_data), init_call_elem, destroy_call_elem,
 
     sizeof(channel_data), init_channel_elem, destroy_channel_elem,
 
diff --git a/src/core/channel/connected_channel.h b/src/core/channel/connected_channel.h
index 660ea7ad89..9d143fc135 100644
--- a/src/core/channel/connected_channel.h
+++ b/src/core/channel/connected_channel.h
@@ -46,4 +46,4 @@ extern const grpc_channel_filter grpc_connected_channel_filter;
 grpc_transport_setup_result grpc_connected_channel_bind_transport(
     grpc_channel_stack *channel_stack, grpc_transport *transport);
 
-#endif  /* __GRPC_INTERNAL_CHANNEL_CONNECTED_CHANNEL_H__ */
+#endif /* __GRPC_INTERNAL_CHANNEL_CONNECTED_CHANNEL_H__ */
diff --git a/src/core/channel/metadata_buffer.c b/src/core/channel/metadata_buffer.c
index 75fd90b707..d4de4ba576 100644
--- a/src/core/channel/metadata_buffer.c
+++ b/src/core/channel/metadata_buffer.c
@@ -61,7 +61,7 @@ struct grpc_metadata_buffer_impl {
   size_t elem_cap;
 };
 
-#define ELEMS(buffer) ((qelem *)((buffer)+1))
+#define ELEMS(buffer) ((qelem *)((buffer) + 1))
 
 void grpc_metadata_buffer_init(grpc_metadata_buffer *buffer) {
   /* start buffer as NULL, indicating no elements */
diff --git a/src/core/channel/metadata_buffer.h b/src/core/channel/metadata_buffer.h
index 818b290ce2..011dabed1b 100644
--- a/src/core/channel/metadata_buffer.h
+++ b/src/core/channel/metadata_buffer.h
@@ -67,4 +67,4 @@ grpc_metadata *grpc_metadata_buffer_extract_elements(
     grpc_metadata_buffer *buffer);
 void grpc_metadata_buffer_cleanup_elements(void *elements, grpc_op_error error);
 
-#endif  /* __GRPC_INTERNAL_CHANNEL_METADATA_BUFFER_H__ */
+#endif /* __GRPC_INTERNAL_CHANNEL_METADATA_BUFFER_H__ */
diff --git a/src/core/channel/noop_filter.c b/src/core/channel/noop_filter.c
index b6b3f661f7..6f854a2b87 100644
--- a/src/core/channel/noop_filter.c
+++ b/src/core/channel/noop_filter.c
@@ -131,9 +131,9 @@ static void destroy_channel_elem(grpc_channel_element *elem) {
 }
 
 const grpc_channel_filter grpc_no_op_filter = {
-    call_op,              channel_op,
+    call_op, channel_op,
 
-    sizeof(call_data),    init_call_elem,    destroy_call_elem,
+    sizeof(call_data), init_call_elem, destroy_call_elem,
 
     sizeof(channel_data), init_channel_elem, destroy_channel_elem,
 
diff --git a/src/core/channel/noop_filter.h b/src/core/channel/noop_filter.h
index 4057ff7ac9..269214f893 100644
--- a/src/core/channel/noop_filter.h
+++ b/src/core/channel/noop_filter.h
@@ -41,4 +41,4 @@
    customize for their own filters */
 extern const grpc_channel_filter grpc_no_op_filter;
 
-#endif  /* __GRPC_INTERNAL_CHANNEL_NOOP_FILTER_H__ */
+#endif /* __GRPC_INTERNAL_CHANNEL_NOOP_FILTER_H__ */
diff --git a/src/core/compression/algorithm.h b/src/core/compression/algorithm.h
index 05895a889e..c5ec6d21b6 100644
--- a/src/core/compression/algorithm.h
+++ b/src/core/compression/algorithm.h
@@ -46,4 +46,4 @@ typedef enum {
 const char *grpc_compression_algorithm_name(
     grpc_compression_algorithm algorithm);
 
-#endif  /* __GRPC_INTERNAL_COMPRESSION_ALGORITHM_H__ */
+#endif /* __GRPC_INTERNAL_COMPRESSION_ALGORITHM_H__ */
diff --git a/src/core/compression/message_compress.h b/src/core/compression/message_compress.h
index af8a0a5d75..564ca69a87 100644
--- a/src/core/compression/message_compress.h
+++ b/src/core/compression/message_compress.h
@@ -49,4 +49,4 @@ int grpc_msg_compress(grpc_compression_algorithm algorithm,
 int grpc_msg_decompress(grpc_compression_algorithm algorithm,
                         gpr_slice_buffer *input, gpr_slice_buffer *output);
 
-#endif  /* __GRPC_INTERNAL_COMPRESSION_MESSAGE_COMPRESS_H__ */
+#endif /* __GRPC_INTERNAL_COMPRESSION_MESSAGE_COMPRESS_H__ */
diff --git a/src/core/httpcli/format_request.h b/src/core/httpcli/format_request.h
index 988f872563..a82130cb93 100644
--- a/src/core/httpcli/format_request.h
+++ b/src/core/httpcli/format_request.h
@@ -42,4 +42,4 @@ gpr_slice grpc_httpcli_format_post_request(const grpc_httpcli_request *request,
                                            const char *body_bytes,
                                            size_t body_size);
 
-#endif  /* __GRPC_INTERNAL_HTTPCLI_FORMAT_REQUEST_H__ */
+#endif /* __GRPC_INTERNAL_HTTPCLI_FORMAT_REQUEST_H__ */
diff --git a/src/core/httpcli/httpcli.h b/src/core/httpcli/httpcli.h
index ef8031354c..90f89a9366 100644
--- a/src/core/httpcli/httpcli.h
+++ b/src/core/httpcli/httpcli.h
@@ -115,4 +115,4 @@ typedef int (*grpc_httpcli_post_override)(const grpc_httpcli_request *request,
 void grpc_httpcli_set_override(grpc_httpcli_get_override get,
                                grpc_httpcli_post_override post);
 
-#endif  /* __GRPC_INTERNAL_HTTPCLI_HTTPCLI_H__ */
+#endif /* __GRPC_INTERNAL_HTTPCLI_HTTPCLI_H__ */
diff --git a/src/core/httpcli/httpcli_security_context.h b/src/core/httpcli/httpcli_security_context.h
index c267622e60..a73ecca0b3 100644
--- a/src/core/httpcli/httpcli_security_context.h
+++ b/src/core/httpcli/httpcli_security_context.h
@@ -40,4 +40,4 @@ grpc_security_status grpc_httpcli_ssl_channel_security_context_create(
     const unsigned char *pem_root_certs, size_t pem_root_certs_size,
     const char *secure_peer_name, grpc_channel_security_context **ctx);
 
-#endif  /* __GRPC_INTERNAL_HTTPCLI_HTTPCLI_SECURITY_CONTEXT_H__ */
+#endif /* __GRPC_INTERNAL_HTTPCLI_HTTPCLI_SECURITY_CONTEXT_H__ */
diff --git a/src/core/httpcli/parser.h b/src/core/httpcli/parser.h
index e2c24a9993..520b16fd02 100644
--- a/src/core/httpcli/parser.h
+++ b/src/core/httpcli/parser.h
@@ -61,4 +61,4 @@ void grpc_httpcli_parser_destroy(grpc_httpcli_parser *parser);
 int grpc_httpcli_parser_parse(grpc_httpcli_parser *parser, gpr_slice slice);
 int grpc_httpcli_parser_eof(grpc_httpcli_parser *parser);
 
-#endif  /* __GRPC_INTERNAL_HTTPCLI_PARSER_H__ */
+#endif /* __GRPC_INTERNAL_HTTPCLI_PARSER_H__ */
diff --git a/src/core/iomgr/pollset.h b/src/core/iomgr/pollset.h
index 7374a4ec13..36d80d5c29 100644
--- a/src/core/iomgr/pollset.h
+++ b/src/core/iomgr/pollset.h
@@ -35,6 +35,7 @@
 #define __GRPC_INTERNAL_IOMGR_POLLSET_H_
 
 #include <grpc/support/port_platform.h>
+#include <grpc/support/time.h>
 
 /* A grpc_pollset is a set of file descriptors that a higher level item is
    interested in. For example:
diff --git a/src/core/security/auth.c b/src/core/security/auth.c
index f743b25838..e36bf2382f 100644
--- a/src/core/security/auth.c
+++ b/src/core/security/auth.c
@@ -157,6 +157,5 @@ static void destroy_channel_elem(grpc_channel_element *elem) {
 }
 
 const grpc_channel_filter grpc_client_auth_filter = {
-    call_op,           channel_op,           sizeof(call_data),
-    init_call_elem,    destroy_call_elem,    sizeof(channel_data),
-    init_channel_elem, destroy_channel_elem, "auth"};
+    call_op, channel_op, sizeof(call_data), init_call_elem, destroy_call_elem,
+    sizeof(channel_data), init_channel_elem, destroy_channel_elem, "auth"};
diff --git a/src/core/security/auth.h b/src/core/security/auth.h
index 0b279f8740..94fa2aba7d 100644
--- a/src/core/security/auth.h
+++ b/src/core/security/auth.h
@@ -38,4 +38,4 @@
 
 extern const grpc_channel_filter grpc_client_auth_filter;
 
-#endif  /* __GRPC_INTERNAL_SECURITY_AUTH_H__ */
+#endif /* __GRPC_INTERNAL_SECURITY_AUTH_H__ */
diff --git a/src/core/security/credentials.h b/src/core/security/credentials.h
index 8559f239d5..4a2532d7c4 100644
--- a/src/core/security/credentials.h
+++ b/src/core/security/credentials.h
@@ -143,4 +143,4 @@ struct grpc_server_credentials {
 const grpc_ssl_config *grpc_ssl_server_credentials_get_config(
     const grpc_server_credentials *ssl_creds);
 
-#endif  /* __GRPC_INTERNAL_SECURITY_CREDENTIALS_H__ */
+#endif /* __GRPC_INTERNAL_SECURITY_CREDENTIALS_H__ */
diff --git a/src/core/security/google_root_certs.h b/src/core/security/google_root_certs.h
index 4bcfaddcdb..30ed16c03b 100644
--- a/src/core/security/google_root_certs.h
+++ b/src/core/security/google_root_certs.h
@@ -37,4 +37,4 @@
 extern unsigned char grpc_google_root_certs[];
 extern unsigned int grpc_google_root_certs_size;
 
-#endif  /* __GRPC_INTERNAL_SECURITY_GOOGLE_ROOT_CERTS_H__ */
+#endif /* __GRPC_INTERNAL_SECURITY_GOOGLE_ROOT_CERTS_H__ */
diff --git a/src/core/security/secure_endpoint.h b/src/core/security/secure_endpoint.h
index d0f0fa7d5b..20143150e0 100644
--- a/src/core/security/secure_endpoint.h
+++ b/src/core/security/secure_endpoint.h
@@ -44,4 +44,4 @@ grpc_endpoint *grpc_secure_endpoint_create(
     struct tsi_frame_protector *protector, grpc_endpoint *to_wrap,
     gpr_slice *leftover_slices, size_t leftover_nslices);
 
-#endif  /* __GRPC_INTERNAL_ENDPOINT_SECURE_ENDPOINT_H__ */
+#endif /* __GRPC_INTERNAL_ENDPOINT_SECURE_ENDPOINT_H__ */
diff --git a/src/core/security/secure_transport_setup.h b/src/core/security/secure_transport_setup.h
index 50f2b08529..b13d065fbf 100644
--- a/src/core/security/secure_transport_setup.h
+++ b/src/core/security/secure_transport_setup.h
@@ -50,4 +50,4 @@ void grpc_setup_secure_transport(grpc_security_context *ctx,
                                  grpc_secure_transport_setup_done_cb cb,
                                  void *user_data);
 
-#endif  /* __GRPC_INTERNAL_SECURITY_SECURE_TRANSPORT_SETUP_H__ */
+#endif /* __GRPC_INTERNAL_SECURITY_SECURE_TRANSPORT_SETUP_H__ */
diff --git a/src/core/security/security_context.c b/src/core/security/security_context.c
index a0c72e2d69..d519ecab87 100644
--- a/src/core/security/security_context.c
+++ b/src/core/security/security_context.c
@@ -100,8 +100,7 @@ grpc_arg grpc_security_context_to_arg(grpc_security_context *ctx) {
   return result;
 }
 
-grpc_security_context *grpc_security_context_from_arg(
-    const grpc_arg *arg) {
+grpc_security_context *grpc_security_context_from_arg(const grpc_arg *arg) {
   if (strcmp(arg->key, GRPC_SECURITY_CONTEXT_ARG)) return NULL;
   if (arg->type != GRPC_ARG_POINTER) {
     gpr_log(GPR_ERROR, "Invalid type %d for arg %s", arg->type,
@@ -140,9 +139,7 @@ static void fake_channel_destroy(grpc_security_context *ctx) {
   gpr_free(ctx);
 }
 
-static void fake_server_destroy(grpc_security_context *ctx) {
-  gpr_free(ctx);
-}
+static void fake_server_destroy(grpc_security_context *ctx) { gpr_free(ctx); }
 
 static grpc_security_status fake_channel_create_handshaker(
     grpc_security_context *ctx, tsi_handshaker **handshaker) {
@@ -234,8 +231,7 @@ static void ssl_channel_destroy(grpc_security_context *ctx) {
 }
 
 static void ssl_server_destroy(grpc_security_context *ctx) {
-  grpc_ssl_server_security_context *c =
-      (grpc_ssl_server_security_context *)ctx;
+  grpc_ssl_server_security_context *c = (grpc_ssl_server_security_context *)ctx;
   if (c->handshaker_factory != NULL) {
     tsi_ssl_handshaker_factory_destroy(c->handshaker_factory);
   }
@@ -267,8 +263,7 @@ static grpc_security_status ssl_channel_create_handshaker(
 
 static grpc_security_status ssl_server_create_handshaker(
     grpc_security_context *ctx, tsi_handshaker **handshaker) {
-  grpc_ssl_server_security_context *c =
-      (grpc_ssl_server_security_context *)ctx;
+  grpc_ssl_server_security_context *c = (grpc_ssl_server_security_context *)ctx;
   return ssl_create_handshaker(c->handshaker_factory, 0, NULL, handshaker);
 }
 
diff --git a/src/core/security/security_context.h b/src/core/security/security_context.h
index 65073abf0c..9ace7f1ccb 100644
--- a/src/core/security/security_context.h
+++ b/src/core/security/security_context.h
@@ -118,7 +118,7 @@ grpc_security_context *grpc_find_security_context_in_args(
 typedef struct grpc_channel_security_context grpc_channel_security_context;
 
 struct grpc_channel_security_context {
-  grpc_security_context base;  /* requires is_client_side to be non 0. */
+  grpc_security_context base; /* requires is_client_side to be non 0. */
   grpc_credentials *request_metadata_creds;
 };
 
diff --git a/src/core/security/server_secure_chttp2.c b/src/core/security/server_secure_chttp2.c
index 9d7c0e5e5a..931fa95651 100644
--- a/src/core/security/server_secure_chttp2.c
+++ b/src/core/security/server_secure_chttp2.c
@@ -70,8 +70,7 @@ static void on_accept(void *server, grpc_endpoint *tcp) {
   const grpc_channel_args *args = grpc_server_get_channel_args(server);
   grpc_security_context *ctx = grpc_find_security_context_in_args(args);
   GPR_ASSERT(ctx);
-  grpc_setup_secure_transport(ctx, tcp, on_secure_transport_setup_done,
-                              server);
+  grpc_setup_secure_transport(ctx, tcp, on_secure_transport_setup_done, server);
 }
 
 /* Note: the following code is the same with server_chttp2.c */
diff --git a/src/core/statistics/census_interface.h b/src/core/statistics/census_interface.h
index 7618387ee2..af9c70c4fb 100644
--- a/src/core/statistics/census_interface.h
+++ b/src/core/statistics/census_interface.h
@@ -73,4 +73,4 @@ census_op_id census_tracing_start_op();
 /* Ends tracing. Calling this function will invalidate the input op_id. */
 void census_tracing_end_op(census_op_id op_id);
 
-#endif  /* __GRPC_INTERNAL_STATISTICS_CENSUS_INTERFACE_H__ */
+#endif /* __GRPC_INTERNAL_STATISTICS_CENSUS_INTERFACE_H__ */
diff --git a/src/core/statistics/census_rpc_stats.h b/src/core/statistics/census_rpc_stats.h
index e1ff3ac31b..a9c999aa5c 100644
--- a/src/core/statistics/census_rpc_stats.h
+++ b/src/core/statistics/census_rpc_stats.h
@@ -98,4 +98,4 @@ void census_stats_store_shutdown();
 }
 #endif
 
-#endif  /* __GRPC_INTERNAL_STATISTICS_CENSUS_RPC_STATS_H__ */
+#endif /* __GRPC_INTERNAL_STATISTICS_CENSUS_RPC_STATS_H__ */
diff --git a/src/core/support/alloc.c b/src/core/support/alloc.c
index 658408f334..ddf6789773 100644
--- a/src/core/support/alloc.c
+++ b/src/core/support/alloc.c
@@ -62,6 +62,4 @@ void *gpr_malloc_aligned(size_t size, size_t alignment) {
   return (void *)ret;
 }
 
-void gpr_free_aligned(void *ptr) {
-  free(((void **)ptr)[-1]);
-}
+void gpr_free_aligned(void *ptr) { free(((void **)ptr)[-1]); }
diff --git a/src/core/support/cpu.h b/src/core/support/cpu.h
index 6ac0db35e5..2435ec0353 100644
--- a/src/core/support/cpu.h
+++ b/src/core/support/cpu.h
@@ -46,4 +46,4 @@ int gpr_cpu_num_cores();
    [0, gpr_cpu_num_cores() - 1] */
 int gpr_cpu_current_cpu();
 
-#endif  /* __GRPC_INTERNAL_SUPPORT_CPU_H__ */
+#endif /* __GRPC_INTERNAL_SUPPORT_CPU_H__ */
diff --git a/src/core/support/murmur_hash.h b/src/core/support/murmur_hash.h
index 5643717cd2..2ebf3e57b1 100644
--- a/src/core/support/murmur_hash.h
+++ b/src/core/support/murmur_hash.h
@@ -41,4 +41,4 @@
 /* compute the hash of key (length len) */
 gpr_uint32 gpr_murmur_hash3(const void *key, size_t len, gpr_uint32 seed);
 
-#endif  /* __GRPC_INTERNAL_SUPPORT_MURMUR_HASH_H__ */
+#endif /* __GRPC_INTERNAL_SUPPORT_MURMUR_HASH_H__ */
diff --git a/src/core/support/thd_internal.h b/src/core/support/thd_internal.h
index 519177a555..190d4e3668 100644
--- a/src/core/support/thd_internal.h
+++ b/src/core/support/thd_internal.h
@@ -36,4 +36,4 @@
 
 /* Internal interfaces between modules within the gpr support library.  */
 
-#endif  /* __GRPC_INTERNAL_SUPPORT_THD_INTERNAL_H__ */
+#endif /* __GRPC_INTERNAL_SUPPORT_THD_INTERNAL_H__ */
diff --git a/src/core/surface/call.c b/src/core/surface/call.c
index 9c5f5064eb..4ea8378d96 100644
--- a/src/core/surface/call.c
+++ b/src/core/surface/call.c
@@ -197,7 +197,7 @@ struct grpc_call {
   gpr_refcount internal_refcount;
 };
 
-#define CALL_STACK_FROM_CALL(call) ((grpc_call_stack *)((call)+1))
+#define CALL_STACK_FROM_CALL(call) ((grpc_call_stack *)((call) + 1))
 #define CALL_FROM_CALL_STACK(call_stack) (((grpc_call *)(call_stack)) - 1)
 #define CALL_ELEM_FROM_CALL(call, idx) \
   grpc_call_stack_element(CALL_STACK_FROM_CALL(call), idx)
diff --git a/src/core/surface/call.h b/src/core/surface/call.h
index 5c2ef3be18..01605bb38a 100644
--- a/src/core/surface/call.h
+++ b/src/core/surface/call.h
@@ -73,4 +73,4 @@ grpc_metadata_buffer *grpc_call_get_metadata_buffer(grpc_call *call);
 void grpc_call_add_mdelem(grpc_call *call, grpc_mdelem *mdelem,
                           gpr_uint32 flags);
 
-#endif  /* __GRPC_INTERNAL_SURFACE_CALL_H__ */
+#endif /* __GRPC_INTERNAL_SURFACE_CALL_H__ */
diff --git a/src/core/surface/channel.c b/src/core/surface/channel.c
index 8ef13675fe..a1bcea58dd 100644
--- a/src/core/surface/channel.c
+++ b/src/core/surface/channel.c
@@ -51,7 +51,7 @@ struct grpc_channel {
   grpc_mdstr *authority_string;
 };
 
-#define CHANNEL_STACK_FROM_CHANNEL(c) ((grpc_channel_stack *)((c)+1))
+#define CHANNEL_STACK_FROM_CHANNEL(c) ((grpc_channel_stack *)((c) + 1))
 
 grpc_channel *grpc_channel_create_from_filters(
     const grpc_channel_filter **filters, size_t num_filters,
diff --git a/src/core/surface/channel.h b/src/core/surface/channel.h
index 11d4939916..b3ea2ede40 100644
--- a/src/core/surface/channel.h
+++ b/src/core/surface/channel.h
@@ -48,4 +48,4 @@ grpc_mdstr *grpc_channel_get_message_string(grpc_channel *channel);
 void grpc_channel_internal_ref(grpc_channel *channel);
 void grpc_channel_internal_unref(grpc_channel *channel);
 
-#endif  /* __GRPC_INTERNAL_SURFACE_CHANNEL_H__ */
+#endif /* __GRPC_INTERNAL_SURFACE_CHANNEL_H__ */
diff --git a/src/core/surface/client.c b/src/core/surface/client.c
index 98cb460d63..524b0718a9 100644
--- a/src/core/surface/client.c
+++ b/src/core/surface/client.c
@@ -106,13 +106,12 @@ static void init_channel_elem(grpc_channel_element *elem,
   GPR_ASSERT(!is_last);
 }
 
-static void destroy_channel_elem(grpc_channel_element *elem) {
-}
+static void destroy_channel_elem(grpc_channel_element *elem) {}
 
 const grpc_channel_filter grpc_client_surface_filter = {
-    call_op,              channel_op,
+    call_op, channel_op,
 
-    sizeof(call_data),    init_call_elem,    destroy_call_elem,
+    sizeof(call_data), init_call_elem, destroy_call_elem,
 
     sizeof(channel_data), init_channel_elem, destroy_channel_elem,
 
diff --git a/src/core/surface/client.h b/src/core/surface/client.h
index eb567276e2..cff3d401d9 100644
--- a/src/core/surface/client.h
+++ b/src/core/surface/client.h
@@ -38,4 +38,4 @@
 
 extern const grpc_channel_filter grpc_client_surface_filter;
 
-#endif  /* __GRPC_INTERNAL_SURFACE_CLIENT_H__ */
+#endif /* __GRPC_INTERNAL_SURFACE_CLIENT_H__ */
diff --git a/src/core/surface/completion_queue.h b/src/core/surface/completion_queue.h
index 2e752a3fe0..5e45749396 100644
--- a/src/core/surface/completion_queue.h
+++ b/src/core/surface/completion_queue.h
@@ -104,4 +104,4 @@ void grpc_cq_dump_pending_ops(grpc_completion_queue *cc);
 
 grpc_pollset *grpc_cq_pollset(grpc_completion_queue *cc);
 
-#endif  /* __GRPC_INTERNAL_SURFACE_COMPLETION_QUEUE_H__ */
+#endif /* __GRPC_INTERNAL_SURFACE_COMPLETION_QUEUE_H__ */
diff --git a/src/core/surface/event_string.h b/src/core/surface/event_string.h
index 30b693e95c..b34e2d152b 100644
--- a/src/core/surface/event_string.h
+++ b/src/core/surface/event_string.h
@@ -39,4 +39,4 @@
 /* Returns a string describing an event. Must be later freed with gpr_free() */
 char *grpc_event_string(grpc_event *ev);
 
-#endif  /* __GRPC_INTERNAL_SURFACE_EVENT_STRING_H__ */
+#endif /* __GRPC_INTERNAL_SURFACE_EVENT_STRING_H__ */
diff --git a/src/core/surface/server.c b/src/core/surface/server.c
index aa544a97f2..167bfe97d1 100644
--- a/src/core/surface/server.c
+++ b/src/core/surface/server.c
@@ -405,9 +405,9 @@ static void destroy_channel_elem(grpc_channel_element *elem) {
 }
 
 static const grpc_channel_filter server_surface_filter = {
-    call_op,              channel_op,
+    call_op, channel_op,
 
-    sizeof(call_data),    init_call_elem,    destroy_call_elem,
+    sizeof(call_data), init_call_elem, destroy_call_elem,
 
     sizeof(channel_data), init_channel_elem, destroy_channel_elem,
 
diff --git a/src/core/surface/server.h b/src/core/surface/server.h
index 61292ebe4e..50574d66a4 100644
--- a/src/core/surface/server.h
+++ b/src/core/surface/server.h
@@ -60,4 +60,4 @@ grpc_transport_setup_result grpc_server_setup_transport(
 
 const grpc_channel_args *grpc_server_get_channel_args(grpc_server *server);
 
-#endif  /* __GRPC_INTERNAL_SURFACE_SERVER_H__ */
+#endif /* __GRPC_INTERNAL_SURFACE_SERVER_H__ */
diff --git a/src/core/surface/surface_trace.h b/src/core/surface/surface_trace.h
index f6f9acfd9c..df1aea9669 100644
--- a/src/core/surface/surface_trace.h
+++ b/src/core/surface/surface_trace.h
@@ -51,4 +51,4 @@
   } while (0)
 #endif
 
-#endif  /* __GRPC_INTERNAL_SURFACE_SURFACE_TRACE_H__ */
+#endif /* __GRPC_INTERNAL_SURFACE_SURFACE_TRACE_H__ */
diff --git a/src/core/transport/chttp2/frame.h b/src/core/transport/chttp2/frame.h
index a04e442ed6..6d28638309 100644
--- a/src/core/transport/chttp2/frame.h
+++ b/src/core/transport/chttp2/frame.h
@@ -77,4 +77,4 @@ typedef struct {
 #define GRPC_CHTTP2_DATA_FLAG_PADDED 8
 #define GRPC_CHTTP2_FLAG_HAS_PRIORITY 0x20
 
-#endif  /* __GRPC_INTERNAL_TRANSPORT_CHTTP2_FRAME_H__ */
+#endif /* __GRPC_INTERNAL_TRANSPORT_CHTTP2_FRAME_H__ */
diff --git a/src/core/transport/chttp2/frame_data.c b/src/core/transport/chttp2/frame_data.c
index fbd3b6cabf..c22a223737 100644
--- a/src/core/transport/chttp2/frame_data.c
+++ b/src/core/transport/chttp2/frame_data.c
@@ -161,4 +161,3 @@ grpc_chttp2_parse_error grpc_chttp2_data_parser_parse(
   abort();
   return GRPC_CHTTP2_CONNECTION_ERROR;
 }
-
diff --git a/src/core/transport/chttp2/frame_data.h b/src/core/transport/chttp2/frame_data.h
index abe26dab76..c260059e8b 100644
--- a/src/core/transport/chttp2/frame_data.h
+++ b/src/core/transport/chttp2/frame_data.h
@@ -77,4 +77,4 @@ grpc_chttp2_parse_error grpc_chttp2_data_parser_parse(
 /* create a slice with an empty data frame and is_last set */
 gpr_slice grpc_chttp2_data_frame_create_empty_close(gpr_uint32 id);
 
-#endif  /* __GRPC_INTERNAL_TRANSPORT_CHTTP2_FRAME_DATA_H__ */
+#endif /* __GRPC_INTERNAL_TRANSPORT_CHTTP2_FRAME_DATA_H__ */
diff --git a/src/core/transport/chttp2/frame_ping.h b/src/core/transport/chttp2/frame_ping.h
index a64d53644b..fa778c51b2 100644
--- a/src/core/transport/chttp2/frame_ping.h
+++ b/src/core/transport/chttp2/frame_ping.h
@@ -50,4 +50,4 @@ grpc_chttp2_parse_error grpc_chttp2_ping_parser_begin_frame(
 grpc_chttp2_parse_error grpc_chttp2_ping_parser_parse(
     void *parser, grpc_chttp2_parse_state *state, gpr_slice slice, int is_last);
 
-#endif  /* __GRPC_INTERNAL_TRANSPORT_CHTTP2_FRAME_PING_H__ */
+#endif /* __GRPC_INTERNAL_TRANSPORT_CHTTP2_FRAME_PING_H__ */
diff --git a/src/core/transport/chttp2/frame_rst_stream.h b/src/core/transport/chttp2/frame_rst_stream.h
index 78aea0f26a..dbb262971b 100644
--- a/src/core/transport/chttp2/frame_rst_stream.h
+++ b/src/core/transport/chttp2/frame_rst_stream.h
@@ -38,4 +38,4 @@
 
 gpr_slice grpc_chttp2_rst_stream_create(gpr_uint32 stream_id, gpr_uint32 code);
 
-#endif  /* __GRPC_INTERNAL_TRANSPORT_CHTTP2_FRAME_RST_STREAM_H__ */
+#endif /* __GRPC_INTERNAL_TRANSPORT_CHTTP2_FRAME_RST_STREAM_H__ */
diff --git a/src/core/transport/chttp2/frame_settings.h b/src/core/transport/chttp2/frame_settings.h
index dcb8b00ca1..855f9636bb 100644
--- a/src/core/transport/chttp2/frame_settings.h
+++ b/src/core/transport/chttp2/frame_settings.h
@@ -96,4 +96,4 @@ grpc_chttp2_parse_error grpc_chttp2_settings_parser_begin_frame(
 grpc_chttp2_parse_error grpc_chttp2_settings_parser_parse(
     void *parser, grpc_chttp2_parse_state *state, gpr_slice slice, int is_last);
 
-#endif  /* __GRPC_INTERNAL_TRANSPORT_CHTTP2_FRAME_SETTINGS_H__ */
+#endif /* __GRPC_INTERNAL_TRANSPORT_CHTTP2_FRAME_SETTINGS_H__ */
diff --git a/src/core/transport/chttp2/frame_window_update.h b/src/core/transport/chttp2/frame_window_update.h
index 4b789fcc4a..2d9e6c4dcb 100644
--- a/src/core/transport/chttp2/frame_window_update.h
+++ b/src/core/transport/chttp2/frame_window_update.h
@@ -52,4 +52,4 @@ grpc_chttp2_parse_error grpc_chttp2_window_update_parser_begin_frame(
 grpc_chttp2_parse_error grpc_chttp2_window_update_parser_parse(
     void *parser, grpc_chttp2_parse_state *state, gpr_slice slice, int is_last);
 
-#endif  /* __GRPC_INTERNAL_TRANSPORT_CHTTP2_FRAME_WINDOW_UPDATE_H__ */
+#endif /* __GRPC_INTERNAL_TRANSPORT_CHTTP2_FRAME_WINDOW_UPDATE_H__ */
diff --git a/src/core/transport/chttp2/hpack_parser.h b/src/core/transport/chttp2/hpack_parser.h
index 799513e7ff..b0a0d76713 100644
--- a/src/core/transport/chttp2/hpack_parser.h
+++ b/src/core/transport/chttp2/hpack_parser.h
@@ -108,4 +108,4 @@ grpc_chttp2_parse_error grpc_chttp2_header_parser_parse(
     void *hpack_parser, grpc_chttp2_parse_state *state, gpr_slice slice,
     int is_last);
 
-#endif  /* __GRPC_INTERNAL_TRANSPORT_CHTTP2_HPACK_PARSER_H__ */
+#endif /* __GRPC_INTERNAL_TRANSPORT_CHTTP2_HPACK_PARSER_H__ */
diff --git a/src/core/transport/chttp2/hpack_table.c b/src/core/transport/chttp2/hpack_table.c
index 8f2ebecfeb..ae8bfa8009 100644
--- a/src/core/transport/chttp2/hpack_table.c
+++ b/src/core/transport/chttp2/hpack_table.c
@@ -43,68 +43,68 @@ static struct {
   const char *key;
   const char *value;
 } static_table[] = {
-      /* 0: */ {NULL, NULL},
-      /* 1: */ {":authority", ""},
-      /* 2: */ {":method", "GET"},
-      /* 3: */ {":method", "POST"},
-      /* 4: */ {":path", "/"},
-      /* 5: */ {":path", "/index.html"},
-      /* 6: */ {":scheme", "http"},
-      /* 7: */ {":scheme", "https"},
-      /* 8: */ {":status", "200"},
-      /* 9: */ {":status", "204"},
-      /* 10: */ {":status", "206"},
-      /* 11: */ {":status", "304"},
-      /* 12: */ {":status", "400"},
-      /* 13: */ {":status", "404"},
-      /* 14: */ {":status", "500"},
-      /* 15: */ {"accept-charset", ""},
-      /* 16: */ {"accept-encoding", "gzip, deflate"},
-      /* 17: */ {"accept-language", ""},
-      /* 18: */ {"accept-ranges", ""},
-      /* 19: */ {"accept", ""},
-      /* 20: */ {"access-control-allow-origin", ""},
-      /* 21: */ {"age", ""},
-      /* 22: */ {"allow", ""},
-      /* 23: */ {"authorization", ""},
-      /* 24: */ {"cache-control", ""},
-      /* 25: */ {"content-disposition", ""},
-      /* 26: */ {"content-encoding", ""},
-      /* 27: */ {"content-language", ""},
-      /* 28: */ {"content-length", ""},
-      /* 29: */ {"content-location", ""},
-      /* 30: */ {"content-range", ""},
-      /* 31: */ {"content-type", ""},
-      /* 32: */ {"cookie", ""},
-      /* 33: */ {"date", ""},
-      /* 34: */ {"etag", ""},
-      /* 35: */ {"expect", ""},
-      /* 36: */ {"expires", ""},
-      /* 37: */ {"from", ""},
-      /* 38: */ {"host", ""},
-      /* 39: */ {"if-match", ""},
-      /* 40: */ {"if-modified-since", ""},
-      /* 41: */ {"if-none-match", ""},
-      /* 42: */ {"if-range", ""},
-      /* 43: */ {"if-unmodified-since", ""},
-      /* 44: */ {"last-modified", ""},
-      /* 45: */ {"link", ""},
-      /* 46: */ {"location", ""},
-      /* 47: */ {"max-forwards", ""},
-      /* 48: */ {"proxy-authenticate", ""},
-      /* 49: */ {"proxy-authorization", ""},
-      /* 50: */ {"range", ""},
-      /* 51: */ {"referer", ""},
-      /* 52: */ {"refresh", ""},
-      /* 53: */ {"retry-after", ""},
-      /* 54: */ {"server", ""},
-      /* 55: */ {"set-cookie", ""},
-      /* 56: */ {"strict-transport-security", ""},
-      /* 57: */ {"transfer-encoding", ""},
-      /* 58: */ {"user-agent", ""},
-      /* 59: */ {"vary", ""},
-      /* 60: */ {"via", ""},
-      /* 61: */ {"www-authenticate", ""},
+    /* 0: */ {NULL, NULL},
+    /* 1: */ {":authority", ""},
+    /* 2: */ {":method", "GET"},
+    /* 3: */ {":method", "POST"},
+    /* 4: */ {":path", "/"},
+    /* 5: */ {":path", "/index.html"},
+    /* 6: */ {":scheme", "http"},
+    /* 7: */ {":scheme", "https"},
+    /* 8: */ {":status", "200"},
+    /* 9: */ {":status", "204"},
+    /* 10: */ {":status", "206"},
+    /* 11: */ {":status", "304"},
+    /* 12: */ {":status", "400"},
+    /* 13: */ {":status", "404"},
+    /* 14: */ {":status", "500"},
+    /* 15: */ {"accept-charset", ""},
+    /* 16: */ {"accept-encoding", "gzip, deflate"},
+    /* 17: */ {"accept-language", ""},
+    /* 18: */ {"accept-ranges", ""},
+    /* 19: */ {"accept", ""},
+    /* 20: */ {"access-control-allow-origin", ""},
+    /* 21: */ {"age", ""},
+    /* 22: */ {"allow", ""},
+    /* 23: */ {"authorization", ""},
+    /* 24: */ {"cache-control", ""},
+    /* 25: */ {"content-disposition", ""},
+    /* 26: */ {"content-encoding", ""},
+    /* 27: */ {"content-language", ""},
+    /* 28: */ {"content-length", ""},
+    /* 29: */ {"content-location", ""},
+    /* 30: */ {"content-range", ""},
+    /* 31: */ {"content-type", ""},
+    /* 32: */ {"cookie", ""},
+    /* 33: */ {"date", ""},
+    /* 34: */ {"etag", ""},
+    /* 35: */ {"expect", ""},
+    /* 36: */ {"expires", ""},
+    /* 37: */ {"from", ""},
+    /* 38: */ {"host", ""},
+    /* 39: */ {"if-match", ""},
+    /* 40: */ {"if-modified-since", ""},
+    /* 41: */ {"if-none-match", ""},
+    /* 42: */ {"if-range", ""},
+    /* 43: */ {"if-unmodified-since", ""},
+    /* 44: */ {"last-modified", ""},
+    /* 45: */ {"link", ""},
+    /* 46: */ {"location", ""},
+    /* 47: */ {"max-forwards", ""},
+    /* 48: */ {"proxy-authenticate", ""},
+    /* 49: */ {"proxy-authorization", ""},
+    /* 50: */ {"range", ""},
+    /* 51: */ {"referer", ""},
+    /* 52: */ {"refresh", ""},
+    /* 53: */ {"retry-after", ""},
+    /* 54: */ {"server", ""},
+    /* 55: */ {"set-cookie", ""},
+    /* 56: */ {"strict-transport-security", ""},
+    /* 57: */ {"transfer-encoding", ""},
+    /* 58: */ {"user-agent", ""},
+    /* 59: */ {"vary", ""},
+    /* 60: */ {"via", ""},
+    /* 61: */ {"www-authenticate", ""},
 };
 
 void grpc_chttp2_hptbl_init(grpc_chttp2_hptbl *tbl, grpc_mdctx *mdctx) {
diff --git a/src/core/transport/chttp2/hpack_table.h b/src/core/transport/chttp2/hpack_table.h
index a3a07ad014..84a8e2d1e0 100644
--- a/src/core/transport/chttp2/hpack_table.h
+++ b/src/core/transport/chttp2/hpack_table.h
@@ -94,4 +94,4 @@ typedef struct {
 grpc_chttp2_hptbl_find_result grpc_chttp2_hptbl_find(
     const grpc_chttp2_hptbl *tbl, grpc_mdelem *md);
 
-#endif  /* __GRPC_INTERNAL_TRANSPORT_CHTTP2_HPACK_TABLE_H__ */
+#endif /* __GRPC_INTERNAL_TRANSPORT_CHTTP2_HPACK_TABLE_H__ */
diff --git a/src/core/transport/chttp2/http2_errors.h b/src/core/transport/chttp2/http2_errors.h
index d065422c6f..7791da6d5a 100644
--- a/src/core/transport/chttp2/http2_errors.h
+++ b/src/core/transport/chttp2/http2_errors.h
@@ -53,4 +53,4 @@ typedef enum {
   GRPC_CHTTP2__ERROR_DO_NOT_USE = -1
 } grpc_chttp2_error_code;
 
-#endif  /* __GRPC_INTERNAL_TRANSPORT_CHTTP2_HTTP2_ERRORS_H__ */
+#endif /* __GRPC_INTERNAL_TRANSPORT_CHTTP2_HTTP2_ERRORS_H__ */
diff --git a/src/core/transport/chttp2/status_conversion.h b/src/core/transport/chttp2/status_conversion.h
index ae9e7f2ca3..f78d81e0aa 100644
--- a/src/core/transport/chttp2/status_conversion.h
+++ b/src/core/transport/chttp2/status_conversion.h
@@ -47,4 +47,4 @@ grpc_status_code grpc_chttp2_http2_error_to_grpc_status(
 grpc_status_code grpc_chttp2_http2_status_to_grpc_status(int status);
 int grpc_chttp2_grpc_status_to_http2_status(grpc_status_code status);
 
-#endif  /* __GRPC_INTERNAL_TRANSPORT_CHTTP2_STATUS_CONVERSION_H__ */
+#endif /* __GRPC_INTERNAL_TRANSPORT_CHTTP2_STATUS_CONVERSION_H__ */
diff --git a/src/core/transport/chttp2/stream_encoder.h b/src/core/transport/chttp2/stream_encoder.h
index 4b093e8495..147b1d31ff 100644
--- a/src/core/transport/chttp2/stream_encoder.h
+++ b/src/core/transport/chttp2/stream_encoder.h
@@ -90,4 +90,4 @@ void grpc_chttp2_encode(grpc_stream_op *ops, size_t ops_count, int eof,
                         grpc_chttp2_hpack_compressor *compressor,
                         gpr_slice_buffer *output);
 
-#endif  /* __GRPC_INTERNAL_TRANSPORT_CHTTP2_STREAM_ENCODER_H__ */
+#endif /* __GRPC_INTERNAL_TRANSPORT_CHTTP2_STREAM_ENCODER_H__ */
diff --git a/src/core/transport/chttp2/stream_map.h b/src/core/transport/chttp2/stream_map.h
index caaee30676..03bf719f37 100644
--- a/src/core/transport/chttp2/stream_map.h
+++ b/src/core/transport/chttp2/stream_map.h
@@ -78,4 +78,4 @@ void grpc_chttp2_stream_map_for_each(grpc_chttp2_stream_map *map,
                                                void *value),
                                      void *user_data);
 
-#endif  /* __GRPC_INTERNAL_TRANSPORT_CHTTP2_STREAM_MAP_H__ */
+#endif /* __GRPC_INTERNAL_TRANSPORT_CHTTP2_STREAM_MAP_H__ */
diff --git a/src/core/transport/chttp2/varint.h b/src/core/transport/chttp2/varint.h
index 780390238f..940df00a99 100644
--- a/src/core/transport/chttp2/varint.h
+++ b/src/core/transport/chttp2/varint.h
@@ -70,4 +70,4 @@ void grpc_chttp2_hpack_write_varint_tail(gpr_uint32 tail_value,
     }                                                                         \
   } while (0)
 
-#endif  /* __GRPC_INTERNAL_TRANSPORT_CHTTP2_VARINT_H__ */
+#endif /* __GRPC_INTERNAL_TRANSPORT_CHTTP2_VARINT_H__ */
diff --git a/src/core/transport/chttp2_transport.h b/src/core/transport/chttp2_transport.h
index dd4419b98d..e12357ff5e 100644
--- a/src/core/transport/chttp2_transport.h
+++ b/src/core/transport/chttp2_transport.h
@@ -44,4 +44,4 @@ void grpc_create_chttp2_transport(grpc_transport_setup_callback setup,
                                   size_t nslices, grpc_mdctx *metadata_context,
                                   int is_client);
 
-#endif  /* __GRPC_INTERNAL_TRANSPORT_CHTTP2_TRANSPORT_H__ */
+#endif /* __GRPC_INTERNAL_TRANSPORT_CHTTP2_TRANSPORT_H__ */
diff --git a/src/core/transport/metadata.h b/src/core/transport/metadata.h
index 6c6dee5efd..943e65a981 100644
--- a/src/core/transport/metadata.h
+++ b/src/core/transport/metadata.h
@@ -136,4 +136,4 @@ const char *grpc_mdstr_as_c_string(grpc_mdstr *s);
 
 #define GRPC_MDSTR_KV_HASH(k_hash, v_hash) (GPR_ROTL((k_hash), 2) ^ (v_hash))
 
-#endif  /* __GRPC_INTERNAL_TRANSPORT_METADATA_H__ */
+#endif /* __GRPC_INTERNAL_TRANSPORT_METADATA_H__ */
diff --git a/src/core/transport/stream_op.h b/src/core/transport/stream_op.h
index be60bc2da6..20d609133f 100644
--- a/src/core/transport/stream_op.h
+++ b/src/core/transport/stream_op.h
@@ -125,4 +125,4 @@ void grpc_sopb_add_flow_ctl_cb(grpc_stream_op_buffer *sopb,
 void grpc_sopb_append(grpc_stream_op_buffer *sopb, grpc_stream_op *ops,
                       size_t nops);
 
-#endif  /* __GRPC_INTERNAL_TRANSPORT_STREAM_OP_H__ */
+#endif /* __GRPC_INTERNAL_TRANSPORT_STREAM_OP_H__ */
diff --git a/src/core/transport/transport.h b/src/core/transport/transport.h
index 00dacbf5b9..af12f4e700 100644
--- a/src/core/transport/transport.h
+++ b/src/core/transport/transport.h
@@ -254,4 +254,4 @@ void grpc_transport_setup_initiate(grpc_transport_setup *setup);
    used as a destruction call by setup). */
 void grpc_transport_setup_cancel(grpc_transport_setup *setup);
 
-#endif  /* __GRPC_INTERNAL_TRANSPORT_TRANSPORT_H__ */
+#endif /* __GRPC_INTERNAL_TRANSPORT_TRANSPORT_H__ */
diff --git a/src/core/transport/transport_impl.h b/src/core/transport/transport_impl.h
index 9f497b9cba..31e80d36ed 100644
--- a/src/core/transport/transport_impl.h
+++ b/src/core/transport/transport_impl.h
@@ -84,4 +84,4 @@ struct grpc_transport {
   const grpc_transport_vtable *vtable;
 };
 
-#endif  /* __GRPC_INTERNAL_TRANSPORT_TRANSPORT_IMPL_H__ */
+#endif /* __GRPC_INTERNAL_TRANSPORT_TRANSPORT_IMPL_H__ */
diff --git a/src/core/tsi/fake_transport_security.c b/src/core/tsi/fake_transport_security.c
index 7807e71949..63d0e1f788 100644
--- a/src/core/tsi/fake_transport_security.c
+++ b/src/core/tsi/fake_transport_security.c
@@ -83,7 +83,6 @@ typedef struct {
   uint32_t max_frame_size;
 } tsi_fake_frame_protector;
 
-
 /* --- Utils. ---*/
 
 static const char* tsi_fake_handshake_message_strings[] = {
@@ -120,7 +119,7 @@ static void store32_little_endian(uint32_t value, unsigned char* buf) {
   buf[3] = (unsigned char)(value >> 24) & 0xFF;
   buf[2] = (unsigned char)(value >> 16) & 0xFF;
   buf[1] = (unsigned char)(value >> 8) & 0xFF;
-  buf[0] = (unsigned char)(value) & 0xFF;
+  buf[0] = (unsigned char)(value)&0xFF;
 }
 
 static void tsi_fake_frame_reset(tsi_fake_frame* frame, int needs_draining) {
@@ -246,8 +245,8 @@ static tsi_result fake_protector_protect(
   /* Try to drain first. */
   if (frame->needs_draining) {
     drained_size = saved_output_size - *num_bytes_written;
-    result = drain_frame_to_bytes(protected_output_frames,
-                                  &drained_size, frame);
+    result =
+        drain_frame_to_bytes(protected_output_frames, &drained_size, frame);
     *num_bytes_written += drained_size;
     protected_output_frames += drained_size;
     if (result != TSI_OK) {
@@ -273,8 +272,8 @@ static tsi_result fake_protector_protect(
       return result;
     }
   }
-  result = fill_frame_from_bytes(unprotected_bytes, unprotected_bytes_size,
-                                 frame);
+  result =
+      fill_frame_from_bytes(unprotected_bytes, unprotected_bytes_size, frame);
   if (result != TSI_OK) {
     if (result == TSI_INCOMPLETE_DATA) result = TSI_OK;
     return result;
@@ -301,7 +300,7 @@ static tsi_result fake_protector_protect_flush(
     frame->size = frame->offset;
     frame->offset = 0;
     frame->needs_draining = 1;
-    store32_little_endian(frame->size, frame->data);  /* Overwrite header. */
+    store32_little_endian(frame->size, frame->data); /* Overwrite header. */
   }
   result = drain_frame_to_bytes(protected_output_frames,
                                 protected_output_frames_size, frame);
@@ -327,8 +326,7 @@ static tsi_result fake_protector_unprotect(
     /* Go past the header if needed. */
     if (frame->offset == 0) frame->offset = TSI_FAKE_FRAME_HEADER_SIZE;
     drained_size = saved_output_size - *num_bytes_written;
-    result = drain_frame_to_bytes(unprotected_bytes, &drained_size,
-                                  frame);
+    result = drain_frame_to_bytes(unprotected_bytes, &drained_size, frame);
     unprotected_bytes += drained_size;
     *num_bytes_written += drained_size;
     if (result != TSI_OK) {
@@ -352,7 +350,7 @@ static tsi_result fake_protector_unprotect(
   /* Try to drain again. */
   if (!frame->needs_draining) return TSI_INTERNAL_ERROR;
   if (frame->offset != 0) return TSI_INTERNAL_ERROR;
-  frame->offset = TSI_FAKE_FRAME_HEADER_SIZE;  /* Go past the header. */
+  frame->offset = TSI_FAKE_FRAME_HEADER_SIZE; /* Go past the header. */
   drained_size = saved_output_size - *num_bytes_written;
   result = drain_frame_to_bytes(unprotected_bytes, &drained_size, frame);
   *num_bytes_written += drained_size;
@@ -481,10 +479,8 @@ static void fake_handshaker_destroy(tsi_handshaker* self) {
 
 static const tsi_handshaker_vtable handshaker_vtable = {
     fake_handshaker_get_bytes_to_send_to_peer,
-    fake_handshaker_process_bytes_from_peer,
-    fake_handshaker_get_result,
-    fake_handshaker_extract_peer,
-    fake_handshaker_create_frame_protector,
+    fake_handshaker_process_bytes_from_peer, fake_handshaker_get_result,
+    fake_handshaker_extract_peer, fake_handshaker_create_frame_protector,
     fake_handshaker_destroy,
 };
 
diff --git a/src/core/tsi/fake_transport_security.h b/src/core/tsi/fake_transport_security.h
index 075d51871b..a62fe81c09 100644
--- a/src/core/tsi/fake_transport_security.h
+++ b/src/core/tsi/fake_transport_security.h
@@ -50,7 +50,6 @@ extern "C" {
    cleartext data for the protector.  */
 tsi_handshaker* tsi_create_fake_handshaker(int is_client);
 
-
 /* Creates a protector directly without going through the handshake phase. */
 tsi_frame_protector* tsi_create_fake_protector(
     uint32_t* max_protected_frame_size);
@@ -59,4 +58,4 @@ tsi_frame_protector* tsi_create_fake_protector(
 }
 #endif
 
-#endif  /* __FAKE_TRANSPORT_SECURITY_H_ */
+#endif /* __FAKE_TRANSPORT_SECURITY_H_ */
diff --git a/src/core/tsi/ssl_transport_security.c b/src/core/tsi/ssl_transport_security.c
index b9e48e7373..c98071a937 100644
--- a/src/core/tsi/ssl_transport_security.c
+++ b/src/core/tsi/ssl_transport_security.c
@@ -54,7 +54,6 @@
  * SSL structure. This is what we would ultimately want though... */
 #define TSI_SSL_MAX_PROTECTION_OVERHEAD 100
 
-
 /* --- Structure definitions. ---*/
 
 struct tsi_ssl_handshaker_factory {
@@ -100,7 +99,6 @@ typedef struct {
   uint32_t buffer_offset;
 } tsi_ssl_frame_protector;
 
-
 /* --- Library Initialization. ---*/
 
 static gpr_once init_openssl_once = GPR_ONCE_INIT;
@@ -269,7 +267,7 @@ static tsi_result peer_from_x509(X509* cert, int include_certificate_type,
                                  tsi_peer* peer) {
   /* TODO(jboeuf): Maybe add more properties. */
   uint32_t property_count = include_certificate_type ? 3 : 2;
-  tsi_result result  = tsi_construct_peer(property_count, peer);
+  tsi_result result = tsi_construct_peer(property_count, peer);
   if (result != TSI_OK) return result;
   do {
     result = peer_property_from_x509_common_name(cert, &peer->properties[0]);
@@ -299,12 +297,10 @@ static void log_ssl_error_stack(void) {
   }
 }
 
-
 /* Performs an SSL_read and handle errors. */
 static tsi_result do_ssl_read(SSL* ssl, unsigned char* unprotected_bytes,
                               uint32_t* unprotected_bytes_size) {
-  int read_from_ssl = SSL_read(ssl, unprotected_bytes,
-                               *unprotected_bytes_size);
+  int read_from_ssl = SSL_read(ssl, unprotected_bytes, *unprotected_bytes_size);
   if (read_from_ssl == 0) {
     gpr_log(GPR_ERROR, "SSL_read returned 0 unexpectedly.");
     return TSI_INTERNAL_ERROR;
@@ -378,7 +374,7 @@ static tsi_result ssl_ctx_use_certificate_chain(
       X509* certificate_authority = PEM_read_bio_X509(pem, NULL, NULL, "");
       if (certificate_authority == NULL) {
         ERR_clear_error();
-        break;  /* Done reading. */
+        break; /* Done reading. */
       }
       if (!SSL_CTX_add_extra_chain_cert(context, certificate_authority)) {
         X509_free(certificate_authority);
@@ -423,8 +419,8 @@ static tsi_result ssl_ctx_use_private_key(SSL_CTX* context,
 /* Loads in-memory PEM verification certs into the SSL context and optionally
    returns the verification cert names (root_names can be NULL). */
 static tsi_result ssl_ctx_load_verification_certs(
-    SSL_CTX* context, const unsigned char* pem_roots,
-    uint32_t pem_roots_size, STACK_OF(X509_NAME)** root_names) {
+    SSL_CTX* context, const unsigned char* pem_roots, uint32_t pem_roots_size,
+    STACK_OF(X509_NAME) * *root_names) {
   tsi_result result = TSI_OK;
   uint32_t num_roots = 0;
   X509* root = NULL;
@@ -442,7 +438,7 @@ static tsi_result ssl_ctx_load_verification_certs(
     root = PEM_read_bio_X509_AUX(pem, NULL, NULL, "");
     if (root == NULL) {
       ERR_clear_error();
-      break;  /* We're at the end of stream. */
+      break; /* We're at the end of stream. */
     }
     if (root_names != NULL) {
       root_name = X509_get_subject_name(root);
@@ -485,13 +481,11 @@ static tsi_result ssl_ctx_load_verification_certs(
   return result;
 }
 
-
 /* Populates the SSL context with a private key and a cert chain, and sets the
    cipher list and the ephemeral ECDH key. */
 static tsi_result populate_ssl_context(
     SSL_CTX* context, const unsigned char* pem_private_key,
-    uint32_t pem_private_key_size,
-    const unsigned char* pem_certificate_chain,
+    uint32_t pem_private_key_size, const unsigned char* pem_certificate_chain,
     uint32_t pem_certificate_chain_size, const char* cipher_list) {
   tsi_result result = TSI_OK;
   if (pem_certificate_chain != NULL) {
@@ -532,12 +526,12 @@ static tsi_result extract_x509_subject_names_from_pem_cert(
   tsi_result result = TSI_OK;
   X509* cert = NULL;
   BIO* pem = BIO_new_mem_buf((void*)pem_cert, pem_cert_size);
-  if (pem == NULL)  return TSI_OUT_OF_RESOURCES;
+  if (pem == NULL) return TSI_OUT_OF_RESOURCES;
 
   cert = PEM_read_bio_X509(pem, NULL, NULL, "");
   if (cert == NULL) {
-      gpr_log(GPR_ERROR, "Invalid certificate");
-      result = TSI_INVALID_ARGUMENT;
+    gpr_log(GPR_ERROR, "Invalid certificate");
+    result = TSI_INVALID_ARGUMENT;
   } else {
     result = peer_from_x509(cert, 0, peer);
   }
@@ -581,8 +575,7 @@ static tsi_result build_alpn_protocol_name_list(
 
 static tsi_result ssl_protector_protect(
     tsi_frame_protector* self, const unsigned char* unprotected_bytes,
-    uint32_t* unprotected_bytes_size,
-    unsigned char* protected_output_frames,
+    uint32_t* unprotected_bytes_size, unsigned char* protected_output_frames,
     uint32_t* protected_output_frames_size) {
   tsi_ssl_frame_protector* impl = (tsi_ssl_frame_protector*)self;
   int read_from_ssl;
@@ -634,8 +627,7 @@ static tsi_result ssl_protector_protect(
 
 static tsi_result ssl_protector_protect_flush(
     tsi_frame_protector* self, unsigned char* protected_output_frames,
-    uint32_t* protected_output_frames_size,
-    uint32_t* still_pending_size) {
+    uint32_t* protected_output_frames_size, uint32_t* still_pending_size) {
   tsi_result result = TSI_OK;
   tsi_ssl_frame_protector* impl = (tsi_ssl_frame_protector*)self;
   int read_from_ssl = 0;
@@ -662,8 +654,7 @@ static tsi_result ssl_protector_protect_flush(
 
 static tsi_result ssl_protector_unprotect(
     tsi_frame_protector* self, const unsigned char* protected_frames_bytes,
-    uint32_t* protected_frames_bytes_size,
-    unsigned char* unprotected_bytes,
+    uint32_t* protected_frames_bytes_size, unsigned char* unprotected_bytes,
     uint32_t* unprotected_bytes_size) {
   tsi_result result = TSI_OK;
   int written_into_ssl = 0;
@@ -673,7 +664,7 @@ static tsi_result ssl_protector_unprotect(
 
   /* First, try to read remaining data from ssl. */
   result = do_ssl_read(impl->ssl, unprotected_bytes, unprotected_bytes_size);
-  if (result != TSI_OK)  return result;
+  if (result != TSI_OK) return result;
   if (*unprotected_bytes_size == output_bytes_size) {
     /* We have read everything we could and cannot process any more input. */
     *protected_frames_bytes_size = 0;
@@ -684,8 +675,8 @@ static tsi_result ssl_protector_unprotect(
   *unprotected_bytes_size = output_bytes_size - output_bytes_offset;
 
   /* Then, try to write some data to ssl. */
-  written_into_ssl = BIO_write(
-      impl->into_ssl, protected_frames_bytes, *protected_frames_bytes_size);
+  written_into_ssl = BIO_write(impl->into_ssl, protected_frames_bytes,
+                               *protected_frames_bytes_size);
   if (written_into_ssl < 0) {
     gpr_log(GPR_ERROR, "Sending protected frame to ssl failed with %d",
             written_into_ssl);
@@ -710,13 +701,10 @@ static void ssl_protector_destroy(tsi_frame_protector* self) {
 }
 
 static const tsi_frame_protector_vtable frame_protector_vtable = {
-    ssl_protector_protect,
-    ssl_protector_protect_flush,
-    ssl_protector_unprotect,
+    ssl_protector_protect, ssl_protector_protect_flush, ssl_protector_unprotect,
     ssl_protector_destroy,
 };
 
-
 /* --- tsi_handshaker methods implementation. ---*/
 
 static tsi_result ssl_handshaker_get_bytes_to_send_to_peer(
@@ -751,8 +739,7 @@ static tsi_result ssl_handshaker_get_result(tsi_handshaker* self) {
 }
 
 static tsi_result ssl_handshaker_process_bytes_from_peer(
-    tsi_handshaker* self, const unsigned char* bytes,
-    uint32_t* bytes_size) {
+    tsi_handshaker* self, const unsigned char* bytes, uint32_t* bytes_size) {
   tsi_ssl_handshaker* impl = (tsi_ssl_handshaker*)self;
   int bytes_written_into_ssl_size = 0;
   if (bytes == NULL || bytes_size == 0 || *bytes_size > INT_MAX) {
@@ -884,14 +871,11 @@ static void ssl_handshaker_destroy(tsi_handshaker* self) {
 
 static const tsi_handshaker_vtable handshaker_vtable = {
     ssl_handshaker_get_bytes_to_send_to_peer,
-    ssl_handshaker_process_bytes_from_peer,
-    ssl_handshaker_get_result,
-    ssl_handshaker_extract_peer,
-    ssl_handshaker_create_frame_protector,
+    ssl_handshaker_process_bytes_from_peer, ssl_handshaker_get_result,
+    ssl_handshaker_extract_peer, ssl_handshaker_create_frame_protector,
     ssl_handshaker_destroy,
 };
 
-
 /* --- tsi_ssl_handshaker_factory common methods. --- */
 
 tsi_result tsi_ssl_handshaker_factory_create_handshaker(
@@ -971,7 +955,6 @@ static tsi_result create_tsi_ssl_handshaker(SSL_CTX* ctx, int is_client,
   return TSI_OK;
 }
 
-
 /* --- tsi_ssl__client_handshaker_factory methods implementation. --- */
 
 static tsi_result ssl_client_handshaker_factory_create_handshaker(
@@ -991,7 +974,6 @@ static void ssl_client_handshaker_factory_destroy(
   free(impl);
 }
 
-
 /* --- tsi_ssl_server_handshaker_factory methods implementation. --- */
 
 static tsi_result ssl_server_handshaker_factory_create_handshaker(
@@ -1031,19 +1013,19 @@ static int does_entry_match_name(const char* entry, uint32_t entry_length,
   const char* name_subdomain = NULL;
   if (entry_length == 0) return 0;
   if (!strncmp(name, entry, entry_length) && (strlen(name) == entry_length)) {
-    return 1;  /* Perfect match. */
+    return 1; /* Perfect match. */
   }
   if (entry[0] != '*') return 0;
 
   /* Wildchar subdomain matching. */
-  if (entry_length < 3 || entry[1] != '.') {  /* At least *.x */
+  if (entry_length < 3 || entry[1] != '.') { /* At least *.x */
     gpr_log(GPR_ERROR, "Invalid wildchar entry.");
     return 0;
   }
   name_subdomain = strchr(name, '.');
   if (name_subdomain == NULL || strlen(name_subdomain) < 2) return 0;
-  name_subdomain++;  /* Starts after the dot. */
-  entry += 2;  /* Remove *. */
+  name_subdomain++; /* Starts after the dot. */
+  entry += 2;       /* Remove *. */
   entry_length -= 2;
   return (!strncmp(entry, name_subdomain, entry_length) &&
           (strlen(name_subdomain) == entry_length));
@@ -1095,7 +1077,6 @@ static int server_handshaker_factory_alpn_callback(
   return SSL_TLSEXT_ERR_NOACK;
 }
 
-
 /* --- tsi_ssl_handshaker_factory constructors. --- */
 
 tsi_result tsi_create_ssl_client_handshaker_factory(
@@ -1277,10 +1258,8 @@ int tsi_ssl_peer_matches_name(const tsi_peer* peer, const char* name) {
   uint32_t i = 0;
   const tsi_peer_property* property = tsi_peer_get_property_by_name(
       peer, TSI_X509_SUBJECT_COMMON_NAME_PEER_PROPERTY);
-  if (property == NULL ||
-      property->type != TSI_PEER_PROPERTY_TYPE_STRING) {
-    gpr_log(GPR_ERROR,
-            "Invalid x509 subject common name property.");
+  if (property == NULL || property->type != TSI_PEER_PROPERTY_TYPE_STRING) {
+    gpr_log(GPR_ERROR, "Invalid x509 subject common name property.");
     return 0;
   }
   if (does_entry_match_name(property->value.string.data,
@@ -1291,8 +1270,7 @@ int tsi_ssl_peer_matches_name(const tsi_peer* peer, const char* name) {
   property = tsi_peer_get_property_by_name(
       peer, TSI_X509_SUBJECT_ALTERNATIVE_NAMES_PEER_PROPERTY);
   if (property == NULL || property->type != TSI_PEER_PROPERTY_TYPE_LIST) {
-    gpr_log(GPR_ERROR,
-            "Invalid x509 subject alternative names property.");
+    gpr_log(GPR_ERROR, "Invalid x509 subject alternative names property.");
     return 0;
   }
 
@@ -1308,5 +1286,5 @@ int tsi_ssl_peer_matches_name(const tsi_peer* peer, const char* name) {
       return 1;
     }
   }
-  return 0;  /* Not found. */
+  return 0; /* Not found. */
 }
diff --git a/src/core/tsi/ssl_transport_security.h b/src/core/tsi/ssl_transport_security.h
index 56f50a5dde..de2b1df7bf 100644
--- a/src/core/tsi/ssl_transport_security.h
+++ b/src/core/tsi/ssl_transport_security.h
@@ -162,9 +162,8 @@ void tsi_ssl_handshaker_factory_destroy(tsi_ssl_handshaker_factory* self);
 /* Util that checks that an ssl peer matches a specific name. */
 int tsi_ssl_peer_matches_name(const tsi_peer* peer, const char* name);
 
-
 #ifdef __cplusplus
 }
 #endif
 
-#endif  /* __SSL_TRANSPORT_SECURITY_H_ */
+#endif /* __SSL_TRANSPORT_SECURITY_H_ */
diff --git a/src/core/tsi/transport_security.c b/src/core/tsi/transport_security.c
index 94252e36d0..5a42f03f5f 100644
--- a/src/core/tsi/transport_security.c
+++ b/src/core/tsi/transport_security.c
@@ -44,7 +44,7 @@ char* tsi_strdup(const char* src) {
   if (!src) return NULL;
   len = strlen(src) + 1;
   dst = malloc(len);
-  if (!dst)  return NULL;
+  if (!dst) return NULL;
   memcpy(dst, src, len);
   return dst;
 }
@@ -84,17 +84,15 @@ const char* tsi_result_to_string(tsi_result result) {
   }
 }
 
-
 /* --- tsi_frame_protector common implementation. ---
 
    Calls specific implementation after state/input validation. */
 
-tsi_result tsi_frame_protector_protect(
-    tsi_frame_protector* self,
-    const unsigned char* unprotected_bytes,
-    uint32_t* unprotected_bytes_size,
-    unsigned char* protected_output_frames,
-    uint32_t* protected_output_frames_size) {
+tsi_result tsi_frame_protector_protect(tsi_frame_protector* self,
+                                       const unsigned char* unprotected_bytes,
+                                       uint32_t* unprotected_bytes_size,
+                                       unsigned char* protected_output_frames,
+                                       uint32_t* protected_output_frames_size) {
   if (self == NULL || unprotected_bytes == NULL ||
       unprotected_bytes_size == NULL || protected_output_frames == NULL ||
       protected_output_frames_size == NULL) {
@@ -106,10 +104,8 @@ tsi_result tsi_frame_protector_protect(
 }
 
 tsi_result tsi_frame_protector_protect_flush(
-    tsi_frame_protector* self,
-    unsigned char* protected_output_frames,
-    uint32_t* protected_output_frames_size,
-    uint32_t* still_pending_size) {
+    tsi_frame_protector* self, unsigned char* protected_output_frames,
+    uint32_t* protected_output_frames_size, uint32_t* still_pending_size) {
   if (self == NULL || protected_output_frames == NULL ||
       protected_output_frames == NULL || still_pending_size == NULL) {
     return TSI_INVALID_ARGUMENT;
@@ -120,10 +116,8 @@ tsi_result tsi_frame_protector_protect_flush(
 }
 
 tsi_result tsi_frame_protector_unprotect(
-    tsi_frame_protector* self,
-    const unsigned char* protected_frames_bytes,
-    uint32_t* protected_frames_bytes_size,
-    unsigned char* unprotected_bytes,
+    tsi_frame_protector* self, const unsigned char* protected_frames_bytes,
+    uint32_t* protected_frames_bytes_size, unsigned char* unprotected_bytes,
     uint32_t* unprotected_bytes_size) {
   if (self == NULL || protected_frames_bytes == NULL ||
       protected_frames_bytes_size == NULL || unprotected_bytes == NULL ||
@@ -140,7 +134,6 @@ void tsi_frame_protector_destroy(tsi_frame_protector* self) {
   self->vtable->destroy(self);
 }
 
-
 /* --- tsi_handshaker common implementation. ---
 
    Calls specific implementation after state/input validation. */
@@ -153,7 +146,6 @@ tsi_result tsi_handshaker_get_bytes_to_send_to_peer(tsi_handshaker* self,
   return self->vtable->get_bytes_to_send_to_peer(self, bytes, bytes_size);
 }
 
-
 tsi_result tsi_handshaker_process_bytes_from_peer(tsi_handshaker* self,
                                                   const unsigned char* bytes,
                                                   uint32_t* bytes_size) {
@@ -179,8 +171,7 @@ tsi_result tsi_handshaker_extract_peer(tsi_handshaker* self, tsi_peer* peer) {
 }
 
 tsi_result tsi_handshaker_create_frame_protector(
-    tsi_handshaker* self,
-    uint32_t* max_protected_frame_size,
+    tsi_handshaker* self, uint32_t* max_protected_frame_size,
     tsi_frame_protector** protector) {
   tsi_result result;
   if (self == NULL || protector == NULL) return TSI_INVALID_ARGUMENT;
@@ -201,7 +192,6 @@ void tsi_handshaker_destroy(tsi_handshaker* self) {
   self->vtable->destroy(self);
 }
 
-
 /* --- tsi_peer implementation. --- */
 
 const tsi_peer_property* tsi_peer_get_property_by_name(const tsi_peer* self,
@@ -227,7 +217,6 @@ tsi_peer_property tsi_init_peer_property(void) {
   return property;
 }
 
-
 static void tsi_peer_destroy_list_property(tsi_peer_property* children,
                                            uint32_t child_count) {
   uint32_t i;
@@ -254,7 +243,7 @@ void tsi_peer_property_destruct(tsi_peer_property* property) {
       /* Nothing to free. */
       break;
   }
-  *property = tsi_init_peer_property();  /* Reset everything to 0. */
+  *property = tsi_init_peer_property(); /* Reset everything to 0. */
 }
 
 void tsi_peer_destruct(tsi_peer* self) {
diff --git a/src/core/tsi/transport_security.h b/src/core/tsi/transport_security.h
index cf9a2b0195..9a20fa83a5 100644
--- a/src/core/tsi/transport_security.h
+++ b/src/core/tsi/transport_security.h
@@ -109,10 +109,10 @@ tsi_result tsi_construct_list_peer_property(const char* name,
                                             tsi_peer_property* property);
 
 /* Utils. */
-char* tsi_strdup(const char* src);  /* Sadly, no strdup in C89. */
+char* tsi_strdup(const char* src); /* Sadly, no strdup in C89. */
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif  /* __TRANSPORT_SECURITY_H_ */
+#endif /* __TRANSPORT_SECURITY_H_ */
diff --git a/src/core/tsi/transport_security_interface.h b/src/core/tsi/transport_security_interface.h
index 18545b4253..76746a4b20 100644
--- a/src/core/tsi/transport_security_interface.h
+++ b/src/core/tsi/transport_security_interface.h
@@ -60,7 +60,6 @@ typedef enum {
 
 const char* tsi_result_to_string(tsi_result result);
 
-
 /* --- tsi_frame_protector object ---
 
   This object protects and unprotects buffers once the handshake is done.
@@ -121,12 +120,11 @@ typedef struct tsi_frame_protector tsi_frame_protector;
 
    if (result != TSI_OK) HandleError(result);
    ------------------------------------------------------------------------  */
-tsi_result tsi_frame_protector_protect(
-    tsi_frame_protector* self,
-    const unsigned char* unprotected_bytes,
-    uint32_t* unprotected_bytes_size,
-    unsigned char* protected_output_frames,
-    uint32_t* protected_output_frames_size);
+tsi_result tsi_frame_protector_protect(tsi_frame_protector* self,
+                                       const unsigned char* unprotected_bytes,
+                                       uint32_t* unprotected_bytes_size,
+                                       unsigned char* protected_output_frames,
+                                       uint32_t* protected_output_frames_size);
 
 /* Indicates that we need to flush the bytes buffered in the protector and get
    the resulting frame.
@@ -137,10 +135,8 @@ tsi_result tsi_frame_protector_protect(
    - still_pending_bytes is an output parameter indicating the number of bytes
      that still need to be flushed from the protector.*/
 tsi_result tsi_frame_protector_protect_flush(
-    tsi_frame_protector* self,
-    unsigned char* protected_output_frames,
-    uint32_t* protected_output_frames_size,
-    uint32_t* still_pending_size);
+    tsi_frame_protector* self, unsigned char* protected_output_frames,
+    uint32_t* protected_output_frames_size, uint32_t* still_pending_size);
 
 /* Outputs unprotected bytes.
    - protected_frames_bytes is an input only parameter and points to the
@@ -163,16 +159,13 @@ tsi_result tsi_frame_protector_protect_flush(
      needs to be read before new protected data can be processed in which case
      protected_frames_size will be set to 0.  */
 tsi_result tsi_frame_protector_unprotect(
-    tsi_frame_protector* self,
-    const unsigned char* protected_frames_bytes,
-    uint32_t* protected_frames_bytes_size,
-    unsigned char* unprotected_bytes,
+    tsi_frame_protector* self, const unsigned char* protected_frames_bytes,
+    uint32_t* protected_frames_bytes_size, unsigned char* unprotected_bytes,
     uint32_t* unprotected_bytes_size);
 
 /* Destroys the tsi_frame_protector object.  */
 void tsi_frame_protector_destroy(tsi_frame_protector* self);
 
-
 /* --- tsi_peer objects ---
 
    tsi_peer objects are a set of properties. The peer owns the properties.  */
@@ -333,7 +326,6 @@ tsi_result tsi_handshaker_get_result(tsi_handshaker* self);
 #define tsi_handshaker_is_in_progress(h) \
   (tsi_handshaker_get_result((h)) == TSI_HANDSHAKE_IN_PROGRESS)
 
-
 /* This method may return TSI_FAILED_PRECONDITION if
    tsi_handshaker_is_in_progress returns 1, it returns TSI_OK otherwise
    assuming the handshaker is not in a fatal error state.
@@ -357,8 +349,7 @@ tsi_result tsi_handshaker_extract_peer(tsi_handshaker* self, tsi_peer* peer);
    the handshaker is not in a fatal error state.
    The caller is responsible for destroying the protector.  */
 tsi_result tsi_handshaker_create_frame_protector(
-    tsi_handshaker* self,
-    uint32_t* max_output_protected_frame_size,
+    tsi_handshaker* self, uint32_t* max_output_protected_frame_size,
     tsi_frame_protector** protector);
 
 /* This method releases the tsi_handshaker object. After this method is called,
@@ -369,4 +360,4 @@ void tsi_handshaker_destroy(tsi_handshaker* self);
 }
 #endif
 
-#endif  /* __TRANSPORT_SECURITY_INTERFACE_H_ */
+#endif /* __TRANSPORT_SECURITY_INTERFACE_H_ */
diff --git a/src/cpp/client/channel.cc b/src/cpp/client/channel.cc
index bcda4ed40c..ddda8c22d6 100644
--- a/src/cpp/client/channel.cc
+++ b/src/cpp/client/channel.cc
@@ -172,10 +172,10 @@ Status Channel::StartBlockingRpc(const RpcMethod& method,
   return status;
 }
 
-StreamContextInterface* Channel::CreateStream(const RpcMethod& method,
-                                              ClientContext* context,
-                                              const google::protobuf::Message* request,
-                                              google::protobuf::Message* result) {
+StreamContextInterface* Channel::CreateStream(
+    const RpcMethod& method, ClientContext* context,
+    const google::protobuf::Message* request,
+    google::protobuf::Message* result) {
   grpc_call* call = grpc_channel_create_call(
       c_channel_, method.name(), target_.c_str(), context->RawDeadline());
   context->set_call(call);
diff --git a/src/cpp/client/channel.h b/src/cpp/client/channel.h
index 621e58539b..8de1180ac2 100644
--- a/src/cpp/client/channel.h
+++ b/src/cpp/client/channel.h
@@ -58,10 +58,10 @@ class Channel : public ChannelInterface {
                           const google::protobuf::Message& request,
                           google::protobuf::Message* result) override;
 
-  StreamContextInterface* CreateStream(const RpcMethod& method,
-                                       ClientContext* context,
-                                       const google::protobuf::Message* request,
-                                       google::protobuf::Message* result) override;
+  StreamContextInterface* CreateStream(
+      const RpcMethod& method, ClientContext* context,
+      const google::protobuf::Message* request,
+      google::protobuf::Message* result) override;
 
  private:
   const grpc::string target_;
diff --git a/src/cpp/client/credentials.cc b/src/cpp/client/credentials.cc
index cac1d3d106..d81cf9f4d0 100644
--- a/src/cpp/client/credentials.cc
+++ b/src/cpp/client/credentials.cc
@@ -31,7 +31,6 @@
  *
  */
 
-
 #include <string>
 
 #include <grpc/grpc_security.h>
@@ -112,7 +111,6 @@ std::unique_ptr<Credentials> CredentialsFactory::IAMCredentials(
   return cpp_creds;
 }
 
-
 // Combines two credentials objects into a composite credentials.
 std::unique_ptr<Credentials> CredentialsFactory::ComposeCredentials(
     const std::unique_ptr<Credentials>& creds1,
diff --git a/src/cpp/proto/proto_utils.cc b/src/cpp/proto/proto_utils.cc
index 255d1461a9..3b94dc3c07 100644
--- a/src/cpp/proto/proto_utils.cc
+++ b/src/cpp/proto/proto_utils.cc
@@ -40,7 +40,8 @@
 
 namespace grpc {
 
-bool SerializeProto(const google::protobuf::Message& msg, grpc_byte_buffer** bp) {
+bool SerializeProto(const google::protobuf::Message& msg,
+                    grpc_byte_buffer** bp) {
   grpc::string msg_str;
   bool success = msg.SerializeToString(&msg_str);
   if (success) {
@@ -52,7 +53,8 @@ bool SerializeProto(const google::protobuf::Message& msg, grpc_byte_buffer** bp)
   return success;
 }
 
-bool DeserializeProto(grpc_byte_buffer* buffer, google::protobuf::Message* msg) {
+bool DeserializeProto(grpc_byte_buffer* buffer,
+                      google::protobuf::Message* msg) {
   grpc::string msg_string;
   grpc_byte_buffer_reader* reader = grpc_byte_buffer_reader_create(buffer);
   gpr_slice slice;
diff --git a/src/cpp/proto/proto_utils.h b/src/cpp/proto/proto_utils.h
index 11471f1acb..ea472f9c51 100644
--- a/src/cpp/proto/proto_utils.h
+++ b/src/cpp/proto/proto_utils.h
@@ -46,7 +46,8 @@ namespace grpc {
 // Serialize the msg into a buffer created inside the function. The caller
 // should destroy the returned buffer when done with it. If serialization fails,
 // false is returned and buffer is left unchanged.
-bool SerializeProto(const google::protobuf::Message& msg, grpc_byte_buffer** buffer);
+bool SerializeProto(const google::protobuf::Message& msg,
+                    grpc_byte_buffer** buffer);
 
 // The caller keeps ownership of buffer and msg.
 bool DeserializeProto(grpc_byte_buffer* buffer, google::protobuf::Message* msg);
diff --git a/src/cpp/server/async_server_context.cc b/src/cpp/server/async_server_context.cc
index f44678b569..298936dec9 100644
--- a/src/cpp/server/async_server_context.cc
+++ b/src/cpp/server/async_server_context.cc
@@ -48,8 +48,7 @@ AsyncServerContext::AsyncServerContext(
       host_(host),
       absolute_deadline_(absolute_deadline),
       request_(nullptr),
-      call_(call) {
-}
+      call_(call) {}
 
 AsyncServerContext::~AsyncServerContext() { grpc_call_destroy(call_); }
 
diff --git a/src/cpp/server/server_context_impl.cc b/src/cpp/server/server_context_impl.cc
index 13f2a3ae1a..467cc80e05 100644
--- a/src/cpp/server/server_context_impl.cc
+++ b/src/cpp/server/server_context_impl.cc
@@ -33,6 +33,4 @@
 
 #include "src/cpp/server/server_context_impl.h"
 
-namespace grpc {
-
-}  // namespace grpc
+namespace grpc {}  // namespace grpc
diff --git a/src/cpp/server/server_credentials.cc b/src/cpp/server/server_credentials.cc
index f9ca1622ba..5d899b1cd9 100644
--- a/src/cpp/server/server_credentials.cc
+++ b/src/cpp/server/server_credentials.cc
@@ -31,7 +31,6 @@
  *
  */
 
-
 #include <grpc/grpc_security.h>
 
 #include <grpc++/server_credentials.h>
diff --git a/src/cpp/server/server_rpc_handler.cc b/src/cpp/server/server_rpc_handler.cc
index b7b29c2406..42f8b755b6 100644
--- a/src/cpp/server/server_rpc_handler.cc
+++ b/src/cpp/server/server_rpc_handler.cc
@@ -60,8 +60,10 @@ void ServerRpcHandler::StartRpc() {
     async_server_context_->Accept(cq_.cq());
 
     // Allocate request and response.
-    std::unique_ptr<google::protobuf::Message> request(method_->AllocateRequestProto());
-    std::unique_ptr<google::protobuf::Message> response(method_->AllocateResponseProto());
+    std::unique_ptr<google::protobuf::Message> request(
+        method_->AllocateRequestProto());
+    std::unique_ptr<google::protobuf::Message> response(
+        method_->AllocateResponseProto());
 
     // Read request
     async_server_context_->StartRead(request.get());
@@ -86,8 +88,10 @@ void ServerRpcHandler::StartRpc() {
   } else {
     // Allocate request and response.
     // TODO(yangg) maybe not allocate both when not needed?
-    std::unique_ptr<google::protobuf::Message> request(method_->AllocateRequestProto());
-    std::unique_ptr<google::protobuf::Message> response(method_->AllocateResponseProto());
+    std::unique_ptr<google::protobuf::Message> request(
+        method_->AllocateRequestProto());
+    std::unique_ptr<google::protobuf::Message> response(
+        method_->AllocateResponseProto());
 
     StreamContext stream_context(*method_, async_server_context_->call(),
                                  cq_.cq(), request.get(), response.get());
diff --git a/src/cpp/stream/stream_context.cc b/src/cpp/stream/stream_context.cc
index 6c424b937e..7936a30dfd 100644
--- a/src/cpp/stream/stream_context.cc
+++ b/src/cpp/stream/stream_context.cc
@@ -61,7 +61,8 @@ StreamContext::StreamContext(const RpcMethod& method, ClientContext* context,
 // Server only ctor
 StreamContext::StreamContext(const RpcMethod& method, grpc_call* call,
                              grpc_completion_queue* cq,
-                             google::protobuf::Message* request, google::protobuf::Message* result)
+                             google::protobuf::Message* request,
+                             google::protobuf::Message* result)
     : is_client_(false),
       method_(&method),
       call_(call),
diff --git a/src/cpp/stream/stream_context.h b/src/cpp/stream/stream_context.h
index 6c31095042..f70fe6daa3 100644
--- a/src/cpp/stream/stream_context.h
+++ b/src/cpp/stream/stream_context.h
@@ -51,7 +51,8 @@ class RpcMethod;
 class StreamContext : public StreamContextInterface {
  public:
   StreamContext(const RpcMethod& method, ClientContext* context,
-                const google::protobuf::Message* request, google::protobuf::Message* result);
+                const google::protobuf::Message* request,
+                google::protobuf::Message* result);
   StreamContext(const RpcMethod& method, grpc_call* call,
                 grpc_completion_queue* cq, google::protobuf::Message* request,
                 google::protobuf::Message* result);
@@ -81,11 +82,11 @@ class StreamContext : public StreamContextInterface {
   grpc_completion_queue* cq() { return cq_; }
 
   bool is_client_;
-  const RpcMethod* method_;         // not owned
-  grpc_call* call_;                 // not owned
-  grpc_completion_queue* cq_;       // not owned
-  google::protobuf::Message* request_;        // first request, not owned
-  google::protobuf::Message* result_;         // last response, not owned
+  const RpcMethod* method_;             // not owned
+  grpc_call* call_;                     // not owned
+  grpc_completion_queue* cq_;           // not owned
+  google::protobuf::Message* request_;  // first request, not owned
+  google::protobuf::Message* result_;   // last response, not owned
 
   bool peer_halfclosed_;
   bool self_halfclosed_;
diff --git a/src/cpp/util/status.cc b/src/cpp/util/status.cc
index 66be26da07..e7ca41b752 100644
--- a/src/cpp/util/status.cc
+++ b/src/cpp/util/status.cc
@@ -31,7 +31,6 @@
  *
  */
 
-
 #include <grpc++/status.h>
 
 namespace grpc {
diff --git a/src/php/ext/grpc/byte_buffer.c b/src/php/ext/grpc/byte_buffer.c
index db018313a7..e2f63e3413 100755..100644
--- a/src/php/ext/grpc/byte_buffer.c
+++ b/src/php/ext/grpc/byte_buffer.c
@@ -21,16 +21,15 @@ grpc_byte_buffer *string_to_byte_buffer(char *string, size_t length) {
   return grpc_byte_buffer_create(&slice, 1);
 }
 
-void byte_buffer_to_string(grpc_byte_buffer *buffer,
-                           char **out_string,
+void byte_buffer_to_string(grpc_byte_buffer *buffer, char **out_string,
                            size_t *out_length) {
   size_t length = grpc_byte_buffer_length(buffer);
-  char *string = ecalloc(length+1, sizeof(char));
+  char *string = ecalloc(length + 1, sizeof(char));
   size_t offset = 0;
   grpc_byte_buffer_reader *reader = grpc_byte_buffer_reader_create(buffer);
   gpr_slice next;
-  while(grpc_byte_buffer_reader_next(reader, &next) != 0) {
-    memcpy(string+offset, GPR_SLICE_START_PTR(next), GPR_SLICE_LENGTH(next));
+  while (grpc_byte_buffer_reader_next(reader, &next) != 0) {
+    memcpy(string + offset, GPR_SLICE_START_PTR(next), GPR_SLICE_LENGTH(next));
     offset += GPR_SLICE_LENGTH(next);
   }
   *out_string = string;
diff --git a/src/php/ext/grpc/byte_buffer.h b/src/php/ext/grpc/byte_buffer.h
index 1dd4769de2..b83f734caf 100755..100644
--- a/src/php/ext/grpc/byte_buffer.h
+++ b/src/php/ext/grpc/byte_buffer.h
@@ -5,8 +5,7 @@
 
 grpc_byte_buffer *string_to_byte_buffer(char *string, size_t length);
 
-void byte_buffer_to_string(grpc_byte_buffer *buffer,
-                           char **out_string,
+void byte_buffer_to_string(grpc_byte_buffer *buffer, char **out_string,
                            size_t *out_length);
 
 #endif /* NET_GRPC_PHP_GRPC_BYTE_BUFFER_H_ */
diff --git a/src/php/ext/grpc/call.c b/src/php/ext/grpc/call.c
index 7f4f221caa..c01af34e95 100755..100644
--- a/src/php/ext/grpc/call.c
+++ b/src/php/ext/grpc/call.c
@@ -24,9 +24,9 @@
 #include "byte_buffer.h"
 
 /* Frees and destroys an instance of wrapped_grpc_call */
-void free_wrapped_grpc_call(void *object TSRMLS_DC){
-  wrapped_grpc_call *call = (wrapped_grpc_call*)object;
-  if(call->owned && call->wrapped != NULL){
+void free_wrapped_grpc_call(void *object TSRMLS_DC) {
+  wrapped_grpc_call *call = (wrapped_grpc_call *)object;
+  if (call->owned && call->wrapped != NULL) {
     grpc_call_destroy(call->wrapped);
   }
   efree(call);
@@ -34,38 +34,36 @@ void free_wrapped_grpc_call(void *object TSRMLS_DC){
 
 /* Initializes an instance of wrapped_grpc_call to be associated with an object
  * of a class specified by class_type */
-zend_object_value create_wrapped_grpc_call(
-    zend_class_entry *class_type TSRMLS_DC){
+zend_object_value create_wrapped_grpc_call(zend_class_entry *class_type
+                                               TSRMLS_DC) {
   zend_object_value retval;
   wrapped_grpc_call *intern;
 
-  intern = (wrapped_grpc_call*)emalloc(sizeof(wrapped_grpc_call));
+  intern = (wrapped_grpc_call *)emalloc(sizeof(wrapped_grpc_call));
   memset(intern, 0, sizeof(wrapped_grpc_call));
 
   zend_object_std_init(&intern->std, class_type TSRMLS_CC);
   object_properties_init(&intern->std, class_type);
   retval.handle = zend_objects_store_put(
-      intern,
-      (zend_objects_store_dtor_t) zend_objects_destroy_object,
-      free_wrapped_grpc_call,
-      NULL TSRMLS_CC);
+      intern, (zend_objects_store_dtor_t)zend_objects_destroy_object,
+      free_wrapped_grpc_call, NULL TSRMLS_CC);
   retval.handlers = zend_get_std_object_handlers();
   return retval;
 }
 
 /* Wraps a grpc_call struct in a PHP object. Owned indicates whether the struct
    should be destroyed at the end of the object's lifecycle */
-zval *grpc_php_wrap_call(grpc_call *wrapped, bool owned){
+zval *grpc_php_wrap_call(grpc_call *wrapped, bool owned) {
   zval *call_object;
   MAKE_STD_ZVAL(call_object);
   object_init_ex(call_object, grpc_ce_call);
-  wrapped_grpc_call *call = (wrapped_grpc_call*)zend_object_store_get_object(
-      call_object TSRMLS_CC);
+  wrapped_grpc_call *call =
+      (wrapped_grpc_call *)zend_object_store_get_object(call_object TSRMLS_CC);
   call->wrapped = wrapped;
   return call_object;
 }
 
-zval *grpc_call_create_metadata_array(int count, grpc_metadata *elements){
+zval *grpc_call_create_metadata_array(int count, grpc_metadata *elements) {
   int i;
   zval *array;
   zval **data = NULL;
@@ -78,18 +76,16 @@ zval *grpc_call_create_metadata_array(int count, grpc_metadata *elements){
   array_init(array);
   array_hash = Z_ARRVAL_P(array);
   grpc_metadata *elem;
-  for(i=0; i<count; i++){
+  for (i = 0; i < count; i++) {
     elem = &elements[i];
     key_len = strlen(elem->key);
-    str_key = ecalloc(key_len+1, sizeof(char));
+    str_key = ecalloc(key_len + 1, sizeof(char));
     memcpy(str_key, elem->key, key_len);
-    str_val = ecalloc(elem->value_length+1, sizeof(char));
+    str_val = ecalloc(elem->value_length + 1, sizeof(char));
     memcpy(str_val, elem->value, elem->value_length);
-    if(zend_hash_find(array_hash,
-                      str_key,
-                      key_len,
-                      (void**)data) == SUCCESS){
-      switch(Z_TYPE_P(*data)){
+    if (zend_hash_find(array_hash, str_key, key_len, (void **)data) ==
+        SUCCESS) {
+      switch (Z_TYPE_P(*data)) {
         case IS_STRING:
           MAKE_STD_ZVAL(inner_array);
           array_init(inner_array);
@@ -107,44 +103,36 @@ zval *grpc_call_create_metadata_array(int count, grpc_metadata *elements){
           efree(str_val);
           return NULL;
       }
-      add_next_index_stringl(inner_array,
-                             str_val,
-                             elem->value_length,
-                             false);
+      add_next_index_stringl(inner_array, str_val, elem->value_length, false);
     } else {
-      add_assoc_stringl(array,
-                        str_key,
-                        str_val,
-                        elem->value_length,
-                        false);
+      add_assoc_stringl(array, str_key, str_val, elem->value_length, false);
     }
   }
   return array;
 }
 
-int php_grpc_call_add_metadata_array_walk(void *elem TSRMLS_DC,
-                                          int num_args,
+int php_grpc_call_add_metadata_array_walk(void *elem TSRMLS_DC, int num_args,
                                           va_list args,
-                                          zend_hash_key *hash_key){
+                                          zend_hash_key *hash_key) {
   grpc_call_error error_code;
-  zval **data = (zval**)elem;
+  zval **data = (zval **)elem;
   grpc_metadata metadata;
-  grpc_call *call = va_arg(args, grpc_call*);
+  grpc_call *call = va_arg(args, grpc_call *);
   gpr_uint32 flags = va_arg(args, gpr_uint32);
   const char *key;
   HashTable *inner_hash;
   /* We assume that either two args were passed, and we are in the recursive
      case (and the second argument is the key), or one arg was passed and
      hash_key is the string key. */
-  if(num_args > 2){
-    key = va_arg(args, const char*);
+  if (num_args > 2) {
+    key = va_arg(args, const char *);
   } else {
     /* TODO(mlumish): If possible, check that hash_key is a string */
     key = hash_key->arKey;
   }
-  switch(Z_TYPE_P(*data)){
+  switch (Z_TYPE_P(*data)) {
     case IS_STRING:
-      metadata.key = (char*)key;
+      metadata.key = (char *)key;
       metadata.value = Z_STRVAL_P(*data);
       metadata.value_length = Z_STRLEN_P(*data);
       error_code = grpc_call_add_metadata(call, &metadata, 0u);
@@ -153,11 +141,8 @@ int php_grpc_call_add_metadata_array_walk(void *elem TSRMLS_DC,
     case IS_ARRAY:
       inner_hash = Z_ARRVAL_P(*data);
       zend_hash_apply_with_arguments(inner_hash TSRMLS_CC,
-                                     php_grpc_call_add_metadata_array_walk,
-                                     3,
-                                     call,
-                                     flags,
-                                     key);
+                                     php_grpc_call_add_metadata_array_walk, 3,
+                                     call, flags, key);
       break;
     default:
       zend_throw_exception(zend_exception_get_default(),
@@ -174,27 +159,26 @@ int php_grpc_call_add_metadata_array_walk(void *elem TSRMLS_DC,
  * @param string $method The method to call
  * @param Timeval $absolute_deadline The deadline for completing the call
  */
-PHP_METHOD(Call, __construct){
-  wrapped_grpc_call *call = (wrapped_grpc_call*)zend_object_store_get_object(
-      getThis() TSRMLS_CC);
+PHP_METHOD(Call, __construct) {
+  wrapped_grpc_call *call =
+      (wrapped_grpc_call *)zend_object_store_get_object(getThis() TSRMLS_CC);
   zval *channel_obj;
   char *method;
   int method_len;
   zval *deadline_obj;
   /* "OsO" == 1 Object, 1 string, 1 Object */
-  if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,
-                           "OsO",
-                           &channel_obj, grpc_ce_channel,
-                           &method, &method_len,
-                           &deadline_obj, grpc_ce_timeval) == FAILURE){
+  if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "OsO", &channel_obj,
+                            grpc_ce_channel, &method, &method_len,
+                            &deadline_obj, grpc_ce_timeval) == FAILURE) {
     zend_throw_exception(spl_ce_InvalidArgumentException,
                          "Call expects a Channel, a String, and a Timeval",
                          1 TSRMLS_CC);
     return;
   }
   wrapped_grpc_channel *channel =
-    (wrapped_grpc_channel*)zend_object_store_get_object(channel_obj TSRMLS_CC);
-  if(channel->wrapped == NULL) {
+      (wrapped_grpc_channel *)zend_object_store_get_object(
+          channel_obj TSRMLS_CC);
+  if (channel->wrapped == NULL) {
     zend_throw_exception(spl_ce_InvalidArgumentException,
                          "Call cannot be constructed from a closed Channel",
                          1 TSRMLS_CC);
@@ -202,11 +186,10 @@ PHP_METHOD(Call, __construct){
   }
   add_property_zval(getThis(), "channel", channel_obj);
   wrapped_grpc_timeval *deadline =
-    (wrapped_grpc_timeval*)zend_object_store_get_object(deadline_obj TSRMLS_CC);
-  call->wrapped = grpc_channel_create_call(channel->wrapped,
-                                           method,
-                                           channel->target,
-                                           deadline->wrapped);
+      (wrapped_grpc_timeval *)zend_object_store_get_object(
+          deadline_obj TSRMLS_CC);
+  call->wrapped = grpc_channel_create_call(channel->wrapped, method,
+                                           channel->target, deadline->wrapped);
 }
 
 /**
@@ -218,17 +201,15 @@ PHP_METHOD(Call, __construct){
  * (optional)
  * @return Void
  */
-PHP_METHOD(Call, add_metadata){
-  wrapped_grpc_call *call = (wrapped_grpc_call*)zend_object_store_get_object(
-      getThis() TSRMLS_CC);
+PHP_METHOD(Call, add_metadata) {
+  wrapped_grpc_call *call =
+      (wrapped_grpc_call *)zend_object_store_get_object(getThis() TSRMLS_CC);
   zval *array;
   HashTable *array_hash;
   long flags = 0;
   /* "a|l" == 1 array, 1 optional long */
-  if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,
-                           "a|l",
-                           &array,
-                           &flags) == FAILURE){
+  if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a|l", &array, &flags) ==
+      FAILURE) {
     zend_throw_exception(spl_ce_InvalidArgumentException,
                          "add_metadata expects an array and an optional long",
                          1 TSRMLS_CC);
@@ -236,10 +217,8 @@ PHP_METHOD(Call, add_metadata){
   }
   array_hash = Z_ARRVAL_P(array);
   zend_hash_apply_with_arguments(array_hash TSRMLS_CC,
-                                 php_grpc_call_add_metadata_array_walk,
-                                 2,
-                                 call->wrapped,
-                                 (gpr_uint32)flags);
+                                 php_grpc_call_add_metadata_array_walk, 2,
+                                 call->wrapped, (gpr_uint32)flags);
 }
 
 /**
@@ -252,7 +231,7 @@ PHP_METHOD(Call, add_metadata){
  * (optional)
  * @return Void
  */
-PHP_METHOD(Call, start_invoke){
+PHP_METHOD(Call, start_invoke) {
   grpc_call_error error_code;
   long tag1;
   long tag2;
@@ -260,31 +239,24 @@ PHP_METHOD(Call, start_invoke){
   zval *queue_obj;
   long flags = 0;
   /* "Olll|l" == 1 Object, 3 mandatory longs, 1 optional long */
-  if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,
-                           "Olll|l",
-                           &queue_obj, grpc_ce_completion_queue,
-                           &tag1,
-                           &tag2,
-                           &tag3,
-                           &flags) == FAILURE){
+  if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Olll|l", &queue_obj,
+                            grpc_ce_completion_queue, &tag1, &tag2, &tag3,
+                            &flags) == FAILURE) {
     zend_throw_exception(
         spl_ce_InvalidArgumentException,
         "start_invoke needs a CompletionQueue, 3 longs, and an optional long",
-                         1 TSRMLS_CC);
+        1 TSRMLS_CC);
     return;
   }
   add_property_zval(getThis(), "completion_queue", queue_obj);
-  wrapped_grpc_call *call = (wrapped_grpc_call*)zend_object_store_get_object(
-    getThis() TSRMLS_CC);
+  wrapped_grpc_call *call =
+      (wrapped_grpc_call *)zend_object_store_get_object(getThis() TSRMLS_CC);
   wrapped_grpc_completion_queue *queue =
-    (wrapped_grpc_completion_queue*)zend_object_store_get_object(
-        queue_obj TSRMLS_CC);
-  error_code = grpc_call_start_invoke(call->wrapped,
-                                      queue->wrapped,
-                                      (void*)tag1,
-                                      (void*)tag2,
-                                      (void*)tag3,
-                                      (gpr_uint32)flags);
+      (wrapped_grpc_completion_queue *)zend_object_store_get_object(
+          queue_obj TSRMLS_CC);
+  error_code =
+      grpc_call_start_invoke(call->wrapped, queue->wrapped, (void *)tag1,
+                             (void *)tag2, (void *)tag3, (gpr_uint32)flags);
   MAYBE_THROW_CALL_ERROR(start_invoke, error_code);
 }
 
@@ -298,15 +270,13 @@ PHP_METHOD(Call, start_invoke){
  * (optional)
  * @return Void
  */
-PHP_METHOD(Call, server_accept){
+PHP_METHOD(Call, server_accept) {
   long tag;
   zval *queue_obj;
   grpc_call_error error_code;
   /* "Ol|l" == 1 Object, 1 long */
-  if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,
-                           "Ol",
-                           &queue_obj, grpc_ce_completion_queue,
-                           &tag) == FAILURE){
+  if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Ol", &queue_obj,
+                            grpc_ce_completion_queue, &tag) == FAILURE) {
     zend_throw_exception(
         spl_ce_InvalidArgumentException,
         "server_accept expects a CompletionQueue, a long, and an optional long",
@@ -314,14 +284,13 @@ PHP_METHOD(Call, server_accept){
     return;
   }
   add_property_zval(getThis(), "completion_queue", queue_obj);
-  wrapped_grpc_call *call = (wrapped_grpc_call*)zend_object_store_get_object(
-      getThis() TSRMLS_CC);
+  wrapped_grpc_call *call =
+      (wrapped_grpc_call *)zend_object_store_get_object(getThis() TSRMLS_CC);
   wrapped_grpc_completion_queue *queue =
-    (wrapped_grpc_completion_queue*)zend_object_store_get_object(
-        queue_obj TSRMLS_CC);
-  error_code = grpc_call_server_accept(call->wrapped,
-                                       queue->wrapped,
-                                       (void*)tag);
+      (wrapped_grpc_completion_queue *)zend_object_store_get_object(
+          queue_obj TSRMLS_CC);
+  error_code =
+      grpc_call_server_accept(call->wrapped, queue->wrapped, (void *)tag);
   MAYBE_THROW_CALL_ERROR(server_accept, error_code);
 }
 
@@ -329,16 +298,14 @@ PHP_METHOD(Call, server_end_initial_metadata) {
   grpc_call_error error_code;
   long flags = 0;
   /* "|l" == 1 optional long */
-  if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,
-                           "|l",
-                           &flags) == FAILURE) {
-    zend_throw_exception(
-        spl_ce_InvalidArgumentException,
-        "server_end_initial_metadata expects an optional long",
-        1 TSRMLS_CC);
+  if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &flags) ==
+      FAILURE) {
+    zend_throw_exception(spl_ce_InvalidArgumentException,
+                         "server_end_initial_metadata expects an optional long",
+                         1 TSRMLS_CC);
   }
-  wrapped_grpc_call *call = (wrapped_grpc_call*)zend_object_store_get_object(
-      getThis() TSRMLS_CC);
+  wrapped_grpc_call *call =
+      (wrapped_grpc_call *)zend_object_store_get_object(getThis() TSRMLS_CC);
   error_code = grpc_call_server_end_initial_metadata(call->wrapped, flags);
   MAYBE_THROW_CALL_ERROR(server_end_initial_metadata, error_code);
 }
@@ -347,9 +314,9 @@ PHP_METHOD(Call, server_end_initial_metadata) {
  * Called by clients to cancel an RPC on the server.
  * @return Void
  */
-PHP_METHOD(Call, cancel){
-  wrapped_grpc_call *call = (wrapped_grpc_call*)zend_object_store_get_object(
-      getThis() TSRMLS_CC);
+PHP_METHOD(Call, cancel) {
+  wrapped_grpc_call *call =
+      (wrapped_grpc_call *)zend_object_store_get_object(getThis() TSRMLS_CC);
   grpc_call_error error_code = grpc_call_cancel(call->wrapped);
   MAYBE_THROW_CALL_ERROR(cancel, error_code);
 }
@@ -362,30 +329,25 @@ PHP_METHOD(Call, cancel){
  * (optional)
  * @return Void
  */
-PHP_METHOD(Call, start_write){
+PHP_METHOD(Call, start_write) {
   grpc_call_error error_code;
-  wrapped_grpc_call *call = (wrapped_grpc_call*)zend_object_store_get_object(
-      getThis() TSRMLS_CC);
+  wrapped_grpc_call *call =
+      (wrapped_grpc_call *)zend_object_store_get_object(getThis() TSRMLS_CC);
   char *buffer;
   int buffer_len;
   long tag;
   long flags = 0;
   /* "Ol|l" == 1 Object, 1 mandatory long, 1 optional long */
-  if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,
-                           "sl|l",
-                           &buffer, &buffer_len,
-                           &tag,
-                           &flags) == FAILURE){
-    zend_throw_exception(
-        spl_ce_InvalidArgumentException,
-        "start_write expects a string and an optional long",
-        1 TSRMLS_CC);
+  if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sl|l", &buffer,
+                            &buffer_len, &tag, &flags) == FAILURE) {
+    zend_throw_exception(spl_ce_InvalidArgumentException,
+                         "start_write expects a string and an optional long",
+                         1 TSRMLS_CC);
     return;
   }
   error_code = grpc_call_start_write(call->wrapped,
                                      string_to_byte_buffer(buffer, buffer_len),
-                                     (void*)tag,
-                                     (gpr_uint32)flags);
+                                     (void *)tag, (gpr_uint32)flags);
   MAYBE_THROW_CALL_ERROR(start_write, error_code);
 }
 
@@ -396,30 +358,26 @@ PHP_METHOD(Call, start_write){
  * @param long $tag The tag to associate with this status
  * @return Void
  */
-PHP_METHOD(Call, start_write_status){
+PHP_METHOD(Call, start_write_status) {
   grpc_call_error error_code;
-  wrapped_grpc_call *call = (wrapped_grpc_call*)zend_object_store_get_object(
-      getThis() TSRMLS_CC);
+  wrapped_grpc_call *call =
+      (wrapped_grpc_call *)zend_object_store_get_object(getThis() TSRMLS_CC);
   long status_code;
   int status_details_length;
   long tag;
   char *status_details;
   /* "lsl" == 1 long, 1 string, 1 long */
-  if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,
-                           "lsl",
-                           &status_code,
-                           &status_details, &status_details_length,
-                           &tag) == FAILURE){
+  if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lsl", &status_code,
+                            &status_details, &status_details_length,
+                            &tag) == FAILURE) {
     zend_throw_exception(
         spl_ce_InvalidArgumentException,
-        "start_write_status expects a long, a string, and a long",
-        1 TSRMLS_CC);
+        "start_write_status expects a long, a string, and a long", 1 TSRMLS_CC);
     return;
   }
-  error_code = grpc_call_start_write_status(call->wrapped,
-                                            (grpc_status_code)status_code,
-                                            status_details,
-                                            (void*)tag);
+  error_code =
+      grpc_call_start_write_status(call->wrapped, (grpc_status_code)status_code,
+                                   status_details, (void *)tag);
   MAYBE_THROW_CALL_ERROR(start_write_status, error_code);
 }
 
@@ -427,19 +385,18 @@ PHP_METHOD(Call, start_write_status){
  * Indicate that there are no more messages to send
  * @return Void
  */
-PHP_METHOD(Call, writes_done){
+PHP_METHOD(Call, writes_done) {
   grpc_call_error error_code;
-  wrapped_grpc_call *call = (wrapped_grpc_call*)zend_object_store_get_object(
-      getThis() TSRMLS_CC);
+  wrapped_grpc_call *call =
+      (wrapped_grpc_call *)zend_object_store_get_object(getThis() TSRMLS_CC);
   long tag;
   /* "l" == 1 long */
-  if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &tag) == FAILURE){
+  if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &tag) == FAILURE) {
     zend_throw_exception(spl_ce_InvalidArgumentException,
-                         "writes_done expects a long",
-                         1 TSRMLS_CC);
+                         "writes_done expects a long", 1 TSRMLS_CC);
     return;
   }
-  error_code = grpc_call_writes_done(call->wrapped, (void*)tag);
+  error_code = grpc_call_writes_done(call->wrapped, (void *)tag);
   MAYBE_THROW_CALL_ERROR(writes_done, error_code);
 }
 
@@ -449,37 +406,35 @@ PHP_METHOD(Call, writes_done){
  * @param long $tag The tag to associate with this read
  * @return Void
  */
-PHP_METHOD(Call, start_read){
+PHP_METHOD(Call, start_read) {
   grpc_call_error error_code;
-  wrapped_grpc_call *call = (wrapped_grpc_call*)zend_object_store_get_object(
-      getThis() TSRMLS_CC);
+  wrapped_grpc_call *call =
+      (wrapped_grpc_call *)zend_object_store_get_object(getThis() TSRMLS_CC);
   long tag;
   /* "l" == 1 long */
-  if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &tag) == FAILURE){
+  if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &tag) == FAILURE) {
     zend_throw_exception(spl_ce_InvalidArgumentException,
-                         "start_read expects a long",
-                         1 TSRMLS_CC);
+                         "start_read expects a long", 1 TSRMLS_CC);
     return;
   }
-  error_code = grpc_call_start_read(call->wrapped, (void*)tag);
+  error_code = grpc_call_start_read(call->wrapped, (void *)tag);
   MAYBE_THROW_CALL_ERROR(start_read, error_code);
 }
 
 static zend_function_entry call_methods[] = {
-  PHP_ME(Call, __construct, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR)
-  PHP_ME(Call, server_accept, NULL, ZEND_ACC_PUBLIC)
-  PHP_ME(Call, server_end_initial_metadata, NULL, ZEND_ACC_PUBLIC)
-  PHP_ME(Call, add_metadata, NULL, ZEND_ACC_PUBLIC)
-  PHP_ME(Call, cancel, NULL, ZEND_ACC_PUBLIC)
-  PHP_ME(Call, start_invoke, NULL, ZEND_ACC_PUBLIC)
-  PHP_ME(Call, start_read, NULL, ZEND_ACC_PUBLIC)
-  PHP_ME(Call, start_write, NULL, ZEND_ACC_PUBLIC)
-  PHP_ME(Call, start_write_status, NULL, ZEND_ACC_PUBLIC)
-  PHP_ME(Call, writes_done, NULL, ZEND_ACC_PUBLIC)
-  PHP_FE_END
-};
+    PHP_ME(Call, __construct, NULL, ZEND_ACC_PUBLIC | ZEND_ACC_CTOR)
+        PHP_ME(Call, server_accept, NULL, ZEND_ACC_PUBLIC)
+            PHP_ME(Call, server_end_initial_metadata, NULL, ZEND_ACC_PUBLIC)
+                PHP_ME(Call, add_metadata, NULL, ZEND_ACC_PUBLIC) PHP_ME(
+                    Call, cancel, NULL, ZEND_ACC_PUBLIC)
+                    PHP_ME(Call, start_invoke, NULL, ZEND_ACC_PUBLIC) PHP_ME(
+                        Call, start_read, NULL, ZEND_ACC_PUBLIC)
+                        PHP_ME(Call, start_write, NULL, ZEND_ACC_PUBLIC) PHP_ME(
+                            Call, start_write_status, NULL, ZEND_ACC_PUBLIC)
+                            PHP_ME(Call, writes_done, NULL, ZEND_ACC_PUBLIC)
+                                PHP_FE_END};
 
-void grpc_init_call(TSRMLS_D){
+void grpc_init_call(TSRMLS_D) {
   zend_class_entry ce;
   INIT_CLASS_ENTRY(ce, "Grpc\\Call", call_methods);
   ce.create_object = create_wrapped_grpc_call;
diff --git a/src/php/ext/grpc/call.h b/src/php/ext/grpc/call.h
index c3b18d66cb..232c5d7cf2 100755..100644
--- a/src/php/ext/grpc/call.h
+++ b/src/php/ext/grpc/call.h
@@ -13,15 +13,14 @@
 #include "grpc/grpc.h"
 
 // Throw an exception if error_code is not OK
-#define MAYBE_THROW_CALL_ERROR(func_name, error_code)                   \
-  do{                                                                   \
-    if(error_code != GRPC_CALL_OK) {                                    \
-      zend_throw_exception(spl_ce_LogicException,                       \
-                           #func_name " was called incorrectly",        \
-                           (long)error_code TSRMLS_CC);                 \
-    }                                                                   \
-  } while(0)
-
+#define MAYBE_THROW_CALL_ERROR(func_name, error_code)            \
+  do {                                                           \
+    if (error_code != GRPC_CALL_OK) {                            \
+      zend_throw_exception(spl_ce_LogicException,                \
+                           #func_name " was called incorrectly", \
+                           (long)error_code TSRMLS_CC);          \
+    }                                                            \
+  } while (0)
 
 /* Class entry for the Call PHP class */
 zend_class_entry *grpc_ce_call;
diff --git a/src/php/ext/grpc/channel.c b/src/php/ext/grpc/channel.c
index c2847b99f1..f0e4153b22 100755..100644
--- a/src/php/ext/grpc/channel.c
+++ b/src/php/ext/grpc/channel.c
@@ -23,9 +23,9 @@
 #include "credentials.h"
 
 /* Frees and destroys an instance of wrapped_grpc_channel */
-void free_wrapped_grpc_channel(void *object TSRMLS_DC){
-  wrapped_grpc_channel *channel = (wrapped_grpc_channel*)object;
-  if(channel->wrapped != NULL){
+void free_wrapped_grpc_channel(void *object TSRMLS_DC) {
+  wrapped_grpc_channel *channel = (wrapped_grpc_channel *)object;
+  if (channel->wrapped != NULL) {
     grpc_channel_destroy(channel->wrapped);
   }
   efree(channel);
@@ -33,24 +33,22 @@ void free_wrapped_grpc_channel(void *object TSRMLS_DC){
 
 /* Initializes an instance of wrapped_grpc_channel to be associated with an
  * object of a class specified by class_type */
-zend_object_value create_wrapped_grpc_channel(
-    zend_class_entry *class_type TSRMLS_DC){
+zend_object_value create_wrapped_grpc_channel(zend_class_entry *class_type
+                                                  TSRMLS_DC) {
   zend_object_value retval;
   wrapped_grpc_channel *intern;
-  intern = (wrapped_grpc_channel*)emalloc(sizeof(wrapped_grpc_channel));
+  intern = (wrapped_grpc_channel *)emalloc(sizeof(wrapped_grpc_channel));
   memset(intern, 0, sizeof(wrapped_grpc_channel));
   zend_object_std_init(&intern->std, class_type TSRMLS_CC);
   object_properties_init(&intern->std, class_type);
   retval.handle = zend_objects_store_put(
-      intern,
-      (zend_objects_store_dtor_t)zend_objects_destroy_object,
-      free_wrapped_grpc_channel,
-      NULL TSRMLS_CC);
+      intern, (zend_objects_store_dtor_t)zend_objects_destroy_object,
+      free_wrapped_grpc_channel, NULL TSRMLS_CC);
   retval.handlers = zend_get_std_object_handlers();
   return retval;
 }
 
-void php_grpc_read_args_array(zval *args_array, grpc_channel_args *args){
+void php_grpc_read_args_array(zval *args_array, grpc_channel_args *args) {
   HashTable *array_hash;
   HashPosition array_pointer;
   int args_index;
@@ -62,24 +60,18 @@ void php_grpc_read_args_array(zval *args_array, grpc_channel_args *args){
   args->num_args = zend_hash_num_elements(array_hash);
   args->args = ecalloc(args->num_args, sizeof(grpc_arg));
   args_index = 0;
-  for(zend_hash_internal_pointer_reset_ex(array_hash, &array_pointer);
-      zend_hash_get_current_data_ex(array_hash,
-                                    (void**)&data,
-                                    &array_pointer) == SUCCESS;
-      zend_hash_move_forward_ex(array_hash, &array_pointer)){
-    if(zend_hash_get_current_key_ex(array_hash,
-                                    &key,
-                                    &key_len,
-                                    &index,
-                                    0,
-                                    &array_pointer) != HASH_KEY_IS_STRING){
+  for (zend_hash_internal_pointer_reset_ex(array_hash, &array_pointer);
+       zend_hash_get_current_data_ex(array_hash, (void **)&data,
+                                     &array_pointer) == SUCCESS;
+       zend_hash_move_forward_ex(array_hash, &array_pointer)) {
+    if (zend_hash_get_current_key_ex(array_hash, &key, &key_len, &index, 0,
+                                     &array_pointer) != HASH_KEY_IS_STRING) {
       zend_throw_exception(spl_ce_InvalidArgumentException,
-                           "args keys must be strings",
-                           1 TSRMLS_CC);
+                           "args keys must be strings", 1 TSRMLS_CC);
       return;
     }
     args->args[args_index].key = key;
-    switch(Z_TYPE_P(*data)){
+    switch (Z_TYPE_P(*data)) {
       case IS_LONG:
         args->args[args_index].value.integer = (int)Z_LVAL_P(*data);
         break;
@@ -88,8 +80,7 @@ void php_grpc_read_args_array(zval *args_array, grpc_channel_args *args){
         break;
       default:
         zend_throw_exception(spl_ce_InvalidArgumentException,
-                             "args values must be int or string",
-                             1 TSRMLS_CC);
+                             "args values must be int or string", 1 TSRMLS_CC);
         return;
     }
     args_index++;
@@ -103,9 +94,9 @@ void php_grpc_read_args_array(zval *args_array, grpc_channel_args *args){
  * @param string $target The hostname to associate with this channel
  * @param array $args The arguments to pass to the Channel (optional)
  */
-PHP_METHOD(Channel, __construct){
+PHP_METHOD(Channel, __construct) {
   wrapped_grpc_channel *channel =
-    (wrapped_grpc_channel*)zend_object_store_get_object(getThis() TSRMLS_CC);
+      (wrapped_grpc_channel *)zend_object_store_get_object(getThis() TSRMLS_CC);
   char *target;
   int target_length;
   zval *args_array = NULL;
@@ -114,30 +105,25 @@ PHP_METHOD(Channel, __construct){
   zval **creds_obj = NULL;
   wrapped_grpc_credentials *creds = NULL;
   /* "s|a" == 1 string, 1 optional array */
-  if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,
-                           "s|a",
-                           &target, &target_length,
-                           &args_array) == FAILURE){
+  if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|a", &target,
+                            &target_length, &args_array) == FAILURE) {
     zend_throw_exception(spl_ce_InvalidArgumentException,
-                         "Channel expects a string and an array",
-                         1 TSRMLS_CC);
+                         "Channel expects a string and an array", 1 TSRMLS_CC);
     return;
   }
   if (args_array == NULL) {
     channel->wrapped = grpc_channel_create(target, NULL);
   } else {
     array_hash = Z_ARRVAL_P(args_array);
-    if(zend_hash_find(array_hash,
-                      "credentials",
-                      sizeof("credentials"),
-                      (void**)&creds_obj) == SUCCESS) {
-      if(zend_get_class_entry(*creds_obj TSRMLS_CC) != grpc_ce_credentials) {
+    if (zend_hash_find(array_hash, "credentials", sizeof("credentials"),
+                       (void **)&creds_obj) == SUCCESS) {
+      if (zend_get_class_entry(*creds_obj TSRMLS_CC) != grpc_ce_credentials) {
         zend_throw_exception(spl_ce_InvalidArgumentException,
                              "credentials must be a Credentials object",
                              1 TSRMLS_CC);
         return;
       }
-      creds = (wrapped_grpc_credentials*)zend_object_store_get_object(
+      creds = (wrapped_grpc_credentials *)zend_object_store_get_object(
           *creds_obj TSRMLS_CC);
       zend_hash_del(array_hash, "credentials", 12);
     }
@@ -146,35 +132,32 @@ PHP_METHOD(Channel, __construct){
       channel->wrapped = grpc_channel_create(target, &args);
     } else {
       gpr_log(GPR_DEBUG, "Initialized secure channel");
-      channel->wrapped = grpc_secure_channel_create(creds->wrapped,
-                                                    target,
-                                                    &args);
+      channel->wrapped =
+          grpc_secure_channel_create(creds->wrapped, target, &args);
     }
     efree(args.args);
   }
-  channel->target = ecalloc(target_length+1, sizeof(char));
+  channel->target = ecalloc(target_length + 1, sizeof(char));
   memcpy(channel->target, target, target_length);
 }
 
 /**
  * Close the channel
  */
-PHP_METHOD(Channel, close){
+PHP_METHOD(Channel, close) {
   wrapped_grpc_channel *channel =
-    (wrapped_grpc_channel*)zend_object_store_get_object(getThis() TSRMLS_CC);
-  if(channel->wrapped != NULL) {
+      (wrapped_grpc_channel *)zend_object_store_get_object(getThis() TSRMLS_CC);
+  if (channel->wrapped != NULL) {
     grpc_channel_destroy(channel->wrapped);
     channel->wrapped = NULL;
   }
 }
 
 static zend_function_entry channel_methods[] = {
-  PHP_ME(Channel, __construct, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR)
-  PHP_ME(Channel, close, NULL, ZEND_ACC_PUBLIC)
-  PHP_FE_END
-};
+    PHP_ME(Channel, __construct, NULL, ZEND_ACC_PUBLIC | ZEND_ACC_CTOR)
+        PHP_ME(Channel, close, NULL, ZEND_ACC_PUBLIC) PHP_FE_END};
 
-void grpc_init_channel(TSRMLS_D){
+void grpc_init_channel(TSRMLS_D) {
   zend_class_entry ce;
   INIT_CLASS_ENTRY(ce, "Grpc\\Channel", channel_methods);
   ce.create_object = create_wrapped_grpc_channel;
diff --git a/src/php/ext/grpc/completion_queue.c b/src/php/ext/grpc/completion_queue.c
index 0570bd5029..9785eab8cc 100755..100644
--- a/src/php/ext/grpc/completion_queue.c
+++ b/src/php/ext/grpc/completion_queue.c
@@ -20,15 +20,15 @@
 #include "timeval.h"
 
 /* Frees and destroys a wrapped instance of grpc_completion_queue */
-void free_wrapped_grpc_completion_queue(void *object TSRMLS_DC){
+void free_wrapped_grpc_completion_queue(void *object TSRMLS_DC) {
   wrapped_grpc_completion_queue *queue = NULL;
   grpc_event *event;
-  queue = (wrapped_grpc_completion_queue*)object;
-  if(queue->wrapped != NULL){
+  queue = (wrapped_grpc_completion_queue *)object;
+  if (queue->wrapped != NULL) {
     grpc_completion_queue_shutdown(queue->wrapped);
     event = grpc_completion_queue_next(queue->wrapped, gpr_inf_future);
-    while(event != NULL){
-      if(event->type == GRPC_QUEUE_SHUTDOWN){
+    while (event != NULL) {
+      if (event->type == GRPC_QUEUE_SHUTDOWN) {
         break;
       }
       event = grpc_completion_queue_next(queue->wrapped, gpr_inf_future);
@@ -41,21 +41,19 @@ void free_wrapped_grpc_completion_queue(void *object TSRMLS_DC){
 /* Initializes an instance of wrapped_grpc_channel to be associated with an
  * object of a class specified by class_type */
 zend_object_value create_wrapped_grpc_completion_queue(
-    zend_class_entry *class_type TSRMLS_DC){
+    zend_class_entry *class_type TSRMLS_DC) {
   zend_object_value retval;
   wrapped_grpc_completion_queue *intern;
 
-  intern = (wrapped_grpc_completion_queue*)emalloc(
+  intern = (wrapped_grpc_completion_queue *)emalloc(
       sizeof(wrapped_grpc_completion_queue));
   memset(intern, 0, sizeof(wrapped_grpc_completion_queue));
 
   zend_object_std_init(&intern->std, class_type TSRMLS_CC);
   object_properties_init(&intern->std, class_type);
   retval.handle = zend_objects_store_put(
-      intern,
-      (zend_objects_store_dtor_t) zend_objects_destroy_object,
-      free_wrapped_grpc_completion_queue,
-      NULL TSRMLS_CC);
+      intern, (zend_objects_store_dtor_t)zend_objects_destroy_object,
+      free_wrapped_grpc_completion_queue, NULL TSRMLS_CC);
   retval.handlers = zend_get_std_object_handlers();
   return retval;
 }
@@ -63,10 +61,10 @@ zend_object_value create_wrapped_grpc_completion_queue(
 /**
  * Construct an instance of CompletionQueue
  */
-PHP_METHOD(CompletionQueue, __construct){
+PHP_METHOD(CompletionQueue, __construct) {
   wrapped_grpc_completion_queue *queue =
-    (wrapped_grpc_completion_queue*)zend_object_store_get_object(
-        getThis() TSRMLS_CC);
+      (wrapped_grpc_completion_queue *)zend_object_store_get_object(
+          getThis() TSRMLS_CC);
   queue->wrapped = grpc_completion_queue_create();
 }
 
@@ -78,52 +76,46 @@ PHP_METHOD(CompletionQueue, __construct){
  * @param Timeval $timeout The timeout for the event
  * @return Event The event that occurred
  */
-PHP_METHOD(CompletionQueue, next){
+PHP_METHOD(CompletionQueue, next) {
   zval *timeout;
   /* "O" == 1 Object */
-  if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,
-                           "O",
-                           &timeout, grpc_ce_timeval)==FAILURE){
+  if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O", &timeout,
+                            grpc_ce_timeval) == FAILURE) {
     zend_throw_exception(spl_ce_InvalidArgumentException,
-                         "next needs a Timeval",
-                         1 TSRMLS_CC);
+                         "next needs a Timeval", 1 TSRMLS_CC);
     return;
   }
   wrapped_grpc_completion_queue *completion_queue =
-    (wrapped_grpc_completion_queue*)zend_object_store_get_object(
-        getThis() TSRMLS_CC);
+      (wrapped_grpc_completion_queue *)zend_object_store_get_object(
+          getThis() TSRMLS_CC);
   wrapped_grpc_timeval *wrapped_timeout =
-    (wrapped_grpc_timeval*)zend_object_store_get_object(timeout TSRMLS_CC);
+      (wrapped_grpc_timeval *)zend_object_store_get_object(timeout TSRMLS_CC);
   grpc_event *event = grpc_completion_queue_next(completion_queue->wrapped,
                                                  wrapped_timeout->wrapped);
-  if(event == NULL){
+  if (event == NULL) {
     RETURN_NULL();
   }
   zval *wrapped_event = grpc_php_convert_event(event);
   RETURN_DESTROY_ZVAL(wrapped_event);
 }
 
-PHP_METHOD(CompletionQueue, pluck){
+PHP_METHOD(CompletionQueue, pluck) {
   long tag;
   zval *timeout;
   /* "lO" == 1 long, 1 Object */
-  if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,
-                           "lO",
-                           &tag,
-                           &timeout, grpc_ce_timeval)==FAILURE){
+  if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lO", &tag, &timeout,
+                            grpc_ce_timeval) == FAILURE) {
     zend_throw_exception(spl_ce_InvalidArgumentException,
-                         "pluck needs a long and a Timeval",
-                         1 TSRMLS_CC);
+                         "pluck needs a long and a Timeval", 1 TSRMLS_CC);
   }
   wrapped_grpc_completion_queue *completion_queue =
-      (wrapped_grpc_completion_queue*)zend_object_store_get_object(
+      (wrapped_grpc_completion_queue *)zend_object_store_get_object(
           getThis() TSRMLS_CC);
   wrapped_grpc_timeval *wrapped_timeout =
-      (wrapped_grpc_timeval*)zend_object_store_get_object(timeout TSRMLS_CC);
-  grpc_event *event = grpc_completion_queue_pluck(completion_queue->wrapped,
-                                                    (void*)tag,
-                                                    wrapped_timeout->wrapped);
-  if(event == NULL){
+      (wrapped_grpc_timeval *)zend_object_store_get_object(timeout TSRMLS_CC);
+  grpc_event *event = grpc_completion_queue_pluck(
+      completion_queue->wrapped, (void *)tag, wrapped_timeout->wrapped);
+  if (event == NULL) {
     RETURN_NULL();
   }
   zval *wrapped_event = grpc_php_convert_event(event);
@@ -131,13 +123,11 @@ PHP_METHOD(CompletionQueue, pluck){
 }
 
 static zend_function_entry completion_queue_methods[] = {
-  PHP_ME(CompletionQueue, __construct, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR)
-  PHP_ME(CompletionQueue, next, NULL, ZEND_ACC_PUBLIC)
-  PHP_ME(CompletionQueue, pluck, NULL, ZEND_ACC_PUBLIC)
-  PHP_FE_END
-};
+    PHP_ME(CompletionQueue, __construct, NULL, ZEND_ACC_PUBLIC | ZEND_ACC_CTOR)
+        PHP_ME(CompletionQueue, next, NULL, ZEND_ACC_PUBLIC)
+            PHP_ME(CompletionQueue, pluck, NULL, ZEND_ACC_PUBLIC) PHP_FE_END};
 
-void grpc_init_completion_queue(TSRMLS_D){
+void grpc_init_completion_queue(TSRMLS_D) {
   zend_class_entry ce;
   INIT_CLASS_ENTRY(ce, "Grpc\\CompletionQueue", completion_queue_methods);
   ce.create_object = create_wrapped_grpc_completion_queue;
diff --git a/src/php/ext/grpc/credentials.c b/src/php/ext/grpc/credentials.c
index ffafddae5f..f486272531 100755..100644
--- a/src/php/ext/grpc/credentials.c
+++ b/src/php/ext/grpc/credentials.c
@@ -17,9 +17,9 @@
 #include "grpc/grpc_security.h"
 
 /* Frees and destroys an instance of wrapped_grpc_credentials */
-void free_wrapped_grpc_credentials(void *object TSRMLS_DC){
-  wrapped_grpc_credentials *creds = (wrapped_grpc_credentials*)object;
-  if(creds->wrapped != NULL) {
+void free_wrapped_grpc_credentials(void *object TSRMLS_DC) {
+  wrapped_grpc_credentials *creds = (wrapped_grpc_credentials *)object;
+  if (creds->wrapped != NULL) {
     grpc_credentials_release(creds->wrapped);
   }
   efree(creds);
@@ -27,32 +27,31 @@ void free_wrapped_grpc_credentials(void *object TSRMLS_DC){
 
 /* Initializes an instance of wrapped_grpc_credentials to be associated with an
  * object of a class specified by class_type */
-zend_object_value create_wrapped_grpc_credentials(
-    zend_class_entry *class_type TSRMLS_DC){
+zend_object_value create_wrapped_grpc_credentials(zend_class_entry *class_type
+                                                      TSRMLS_DC) {
   zend_object_value retval;
   wrapped_grpc_credentials *intern;
 
-  intern = (wrapped_grpc_credentials*)emalloc(sizeof(wrapped_grpc_credentials));
+  intern =
+      (wrapped_grpc_credentials *)emalloc(sizeof(wrapped_grpc_credentials));
   memset(intern, 0, sizeof(wrapped_grpc_credentials));
 
   zend_object_std_init(&intern->std, class_type TSRMLS_CC);
   object_properties_init(&intern->std, class_type);
   retval.handle = zend_objects_store_put(
-      intern,
-      (zend_objects_store_dtor_t) zend_objects_destroy_object,
-      free_wrapped_grpc_credentials,
-      NULL TSRMLS_CC);
+      intern, (zend_objects_store_dtor_t)zend_objects_destroy_object,
+      free_wrapped_grpc_credentials, NULL TSRMLS_CC);
   retval.handlers = zend_get_std_object_handlers();
   return retval;
 }
 
-zval *grpc_php_wrap_credentials(grpc_credentials *wrapped){
+zval *grpc_php_wrap_credentials(grpc_credentials *wrapped) {
   zval *credentials_object;
   MAKE_STD_ZVAL(credentials_object);
   object_init_ex(credentials_object, grpc_ce_credentials);
   wrapped_grpc_credentials *credentials =
-    (wrapped_grpc_credentials*)zend_object_store_get_object(
-        credentials_object TSRMLS_CC);
+      (wrapped_grpc_credentials *)zend_object_store_get_object(
+          credentials_object TSRMLS_CC);
   credentials->wrapped = wrapped;
   return credentials_object;
 }
@@ -61,7 +60,7 @@ zval *grpc_php_wrap_credentials(grpc_credentials *wrapped){
  * Create a default credentials object.
  * @return Credentials The new default credentials object
  */
-PHP_METHOD(Credentials, createDefault){
+PHP_METHOD(Credentials, createDefault) {
   grpc_credentials *creds = grpc_default_credentials_create();
   zval *creds_object = grpc_php_wrap_credentials(creds);
   RETURN_DESTROY_ZVAL(creds_object);
@@ -76,7 +75,7 @@ PHP_METHOD(Credentials, createDefault){
  *     (optional)
  * @return Credentials The new SSL credentials object
  */
-PHP_METHOD(Credentials, createSsl){
+PHP_METHOD(Credentials, createSsl) {
   char *pem_root_certs;
   char *pem_private_key = NULL;
   char *pem_cert_chain = NULL;
@@ -84,20 +83,18 @@ PHP_METHOD(Credentials, createSsl){
   int root_certs_length, private_key_length = 0, cert_chain_length = 0;
 
   /* "s|s!s! == 1 string, 2 optional nullable strings */
-  if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,
-                           "s|s!s!",
-                           &pem_root_certs, &root_certs_length,
-                           &pem_private_key, &private_key_length,
-                           &pem_cert_chain, &cert_chain_length) == FAILURE) {
+  if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|s!s!",
+                            &pem_root_certs, &root_certs_length,
+                            &pem_private_key, &private_key_length,
+                            &pem_cert_chain, &cert_chain_length) == FAILURE) {
     zend_throw_exception(spl_ce_InvalidArgumentException,
-                         "createSsl expects 1 to 3 strings",
-                         1 TSRMLS_CC);
+                         "createSsl expects 1 to 3 strings", 1 TSRMLS_CC);
     return;
   }
   grpc_credentials *creds = grpc_ssl_credentials_create(
-      (unsigned char*)pem_root_certs, (size_t)root_certs_length,
-      (unsigned char*)pem_private_key, (size_t)private_key_length,
-      (unsigned char*)pem_cert_chain, (size_t)cert_chain_length);
+      (unsigned char *)pem_root_certs, (size_t)root_certs_length,
+      (unsigned char *)pem_private_key, (size_t)private_key_length,
+      (unsigned char *)pem_cert_chain, (size_t)cert_chain_length);
   zval *creds_object = grpc_php_wrap_credentials(creds);
   RETURN_DESTROY_ZVAL(creds_object);
 }
@@ -108,28 +105,26 @@ PHP_METHOD(Credentials, createSsl){
  * @param Credentials cred2 The second credential
  * @return Credentials The new composite credentials object
  */
-PHP_METHOD(Credentials, createComposite){
+PHP_METHOD(Credentials, createComposite) {
   zval *cred1_obj;
   zval *cred2_obj;
 
   /* "OO" == 3 Objects */
-  if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,
-                           "OO",
-                           &cred1_obj, grpc_ce_credentials,
-                           &cred2_obj, grpc_ce_credentials) == FAILURE) {
+  if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "OO", &cred1_obj,
+                            grpc_ce_credentials, &cred2_obj,
+                            grpc_ce_credentials) == FAILURE) {
     zend_throw_exception(spl_ce_InvalidArgumentException,
-                         "createComposite expects 2 Credentials",
-                         1 TSRMLS_CC);
+                         "createComposite expects 2 Credentials", 1 TSRMLS_CC);
     return;
   }
   wrapped_grpc_credentials *cred1 =
-      (wrapped_grpc_credentials*)zend_object_store_get_object(
+      (wrapped_grpc_credentials *)zend_object_store_get_object(
           cred1_obj TSRMLS_CC);
   wrapped_grpc_credentials *cred2 =
-      (wrapped_grpc_credentials*)zend_object_store_get_object(
+      (wrapped_grpc_credentials *)zend_object_store_get_object(
           cred2_obj TSRMLS_CC);
-  grpc_credentials *creds = grpc_composite_credentials_create(cred1->wrapped,
-                                                              cred2->wrapped);
+  grpc_credentials *creds =
+      grpc_composite_credentials_create(cred1->wrapped, cred2->wrapped);
   zval *creds_object = grpc_php_wrap_credentials(creds);
   RETURN_DESTROY_ZVAL(creds_object);
 }
@@ -155,15 +150,16 @@ PHP_METHOD(Credentials, createFake) {
 }
 
 static zend_function_entry credentials_methods[] = {
-  PHP_ME(Credentials, createDefault, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-  PHP_ME(Credentials, createSsl, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-  PHP_ME(Credentials, createComposite, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-  PHP_ME(Credentials, createGce, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-  PHP_ME(Credentials, createFake, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-  PHP_FE_END
-};
-
-void grpc_init_credentials(TSRMLS_D){
+    PHP_ME(Credentials, createDefault, NULL, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC)
+        PHP_ME(Credentials, createSsl, NULL, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC)
+            PHP_ME(Credentials, createComposite, NULL,
+                   ZEND_ACC_PUBLIC | ZEND_ACC_STATIC)
+                PHP_ME(Credentials, createGce, NULL,
+                       ZEND_ACC_PUBLIC | ZEND_ACC_STATIC)
+                    PHP_ME(Credentials, createFake, NULL,
+                           ZEND_ACC_PUBLIC | ZEND_ACC_STATIC) PHP_FE_END};
+
+void grpc_init_credentials(TSRMLS_D) {
   zend_class_entry ce;
   INIT_CLASS_ENTRY(ce, "Grpc\\Credentials", credentials_methods);
   ce.create_object = create_wrapped_grpc_credentials;
diff --git a/src/php/ext/grpc/event.c b/src/php/ext/grpc/event.c
index c15f479448..b4069f72f0 100755..100644
--- a/src/php/ext/grpc/event.c
+++ b/src/php/ext/grpc/event.c
@@ -32,24 +32,25 @@ zval *grpc_php_convert_event(grpc_event *event) {
 
   zval *event_object;
 
-  if(event == NULL) {
+  if (event == NULL) {
     return NULL;
   }
 
   MAKE_STD_ZVAL(event_object);
   object_init(event_object);
 
-  add_property_zval(event_object,
-                    "call",
-                    grpc_php_wrap_call(event->call,
-                                       event->type==GRPC_SERVER_RPC_NEW));
+  add_property_zval(
+      event_object, "call",
+      grpc_php_wrap_call(event->call, event->type == GRPC_SERVER_RPC_NEW));
   add_property_long(event_object, "type", event->type);
   add_property_long(event_object, "tag", (long)event->tag);
 
-  switch(event->type){
-    case GRPC_QUEUE_SHUTDOWN: add_property_null(event_object, "data"); break;
+  switch (event->type) {
+    case GRPC_QUEUE_SHUTDOWN:
+      add_property_null(event_object, "data");
+      break;
     case GRPC_READ:
-      if(event->data.read == NULL){
+      if (event->data.read == NULL) {
         add_property_null(event_object, "data");
       } else {
         byte_buffer_to_string(event->data.read, &read_string, &read_len);
@@ -57,16 +58,14 @@ zval *grpc_php_convert_event(grpc_event *event) {
       }
       break;
     case GRPC_INVOKE_ACCEPTED:
-      add_property_long(event_object,
-                        "data",
+      add_property_long(event_object, "data",
                         (long)event->data.invoke_accepted);
       break;
     case GRPC_WRITE_ACCEPTED:
       add_property_long(event_object, "data", (long)event->data.write_accepted);
       break;
     case GRPC_FINISH_ACCEPTED:
-      add_property_long(event_object,
-                        "data",
+      add_property_long(event_object, "data",
                         (long)event->data.finish_accepted);
       break;
     case GRPC_CLIENT_METADATA_READ:
@@ -79,19 +78,15 @@ zval *grpc_php_convert_event(grpc_event *event) {
       MAKE_STD_ZVAL(data_object);
       object_init(data_object);
       add_property_long(data_object, "code", event->data.finished.status);
-      if(event->data.finished.details == NULL){
+      if (event->data.finished.details == NULL) {
         add_property_null(data_object, "details");
       } else {
         detail_len = strlen(event->data.finished.details);
-        detail_string = ecalloc(detail_len+1, sizeof(char));
+        detail_string = ecalloc(detail_len + 1, sizeof(char));
         memcpy(detail_string, event->data.finished.details, detail_len);
-        add_property_string(data_object,
-                            "details",
-                            detail_string,
-                            true);
+        add_property_string(data_object, "details", detail_string, true);
       }
-      add_property_zval(data_object,
-                        "metadata",
+      add_property_zval(data_object, "metadata",
                         grpc_call_create_metadata_array(
                             event->data.finished.metadata_count,
                             event->data.finished.metadata_elements));
@@ -101,31 +96,25 @@ zval *grpc_php_convert_event(grpc_event *event) {
       MAKE_STD_ZVAL(data_object);
       object_init(data_object);
       method_len = strlen(event->data.server_rpc_new.method);
-      method_string = ecalloc(method_len+1, sizeof(char));
+      method_string = ecalloc(method_len + 1, sizeof(char));
       memcpy(method_string, event->data.server_rpc_new.method, method_len);
-      add_property_string(data_object,
-                          "method",
-                          method_string,
-                          false);
+      add_property_string(data_object, "method", method_string, false);
       host_len = strlen(event->data.server_rpc_new.host);
-      host_string = ecalloc(host_len+1, sizeof(char));
+      host_string = ecalloc(host_len + 1, sizeof(char));
       memcpy(host_string, event->data.server_rpc_new.host, host_len);
-      add_property_string(data_object,
-                          "host",
-                          host_string,
-                          false);
-      add_property_zval(data_object,
-                        "absolute_timeout",
-                        grpc_php_wrap_timeval(
-                            event->data.server_rpc_new.deadline));
-      add_property_zval(data_object,
-                        "metadata",
+      add_property_string(data_object, "host", host_string, false);
+      add_property_zval(
+          data_object, "absolute_timeout",
+          grpc_php_wrap_timeval(event->data.server_rpc_new.deadline));
+      add_property_zval(data_object, "metadata",
                         grpc_call_create_metadata_array(
                             event->data.server_rpc_new.metadata_count,
                             event->data.server_rpc_new.metadata_elements));
       add_property_zval(event_object, "data", data_object);
       break;
-    default: add_property_null(event_object, "data"); break;
+    default:
+      add_property_null(event_object, "data");
+      break;
   }
   grpc_event_finish(event);
   return event_object;
diff --git a/src/php/ext/grpc/php_grpc.c b/src/php/ext/grpc/php_grpc.c
index 71449bfd06..c1042293aa 100755..100644
--- a/src/php/ext/grpc/php_grpc.c
+++ b/src/php/ext/grpc/php_grpc.c
@@ -16,14 +16,14 @@
 #include "ext/standard/info.h"
 #include "php_grpc.h"
 
-//ZEND_DECLARE_MODULE_GLOBALS(grpc)
+// ZEND_DECLARE_MODULE_GLOBALS(grpc)
 
 /* {{{ grpc_functions[]
  *
  * Every user visible function must have an entry in grpc_functions[].
  */
 const zend_function_entry grpc_functions[] = {
-    PHP_FE_END  /* Must be the last line in grpc_functions[] */
+    PHP_FE_END /* Must be the last line in grpc_functions[] */
 };
 /* }}} */
 
@@ -33,18 +33,12 @@ zend_module_entry grpc_module_entry = {
 #if ZEND_MODULE_API_NO >= 20010901
     STANDARD_MODULE_HEADER,
 #endif
-    "grpc",
-    grpc_functions,
-    PHP_MINIT(grpc),
-    PHP_MSHUTDOWN(grpc),
-    NULL,
-    NULL,
+    "grpc", grpc_functions, PHP_MINIT(grpc), PHP_MSHUTDOWN(grpc), NULL, NULL,
     PHP_MINFO(grpc),
 #if ZEND_MODULE_API_NO >= 20010901
     PHP_GRPC_VERSION,
 #endif
-    STANDARD_MODULE_PROPERTIES
-};
+    STANDARD_MODULE_PROPERTIES};
 /* }}} */
 
 #ifdef COMPILE_DL_GRPC
@@ -55,8 +49,10 @@ ZEND_GET_MODULE(grpc)
  */
 /* Remove comments and fill if you need to have entries in php.ini
 PHP_INI_BEGIN()
-    STD_PHP_INI_ENTRY("grpc.global_value",      "42", PHP_INI_ALL, OnUpdateLong, global_value, zend_grpc_globals, grpc_globals)
-    STD_PHP_INI_ENTRY("grpc.global_string", "foobar", PHP_INI_ALL, OnUpdateString, global_string, zend_grpc_globals, grpc_globals)
+    STD_PHP_INI_ENTRY("grpc.global_value",      "42", PHP_INI_ALL, OnUpdateLong,
+global_value, zend_grpc_globals, grpc_globals)
+    STD_PHP_INI_ENTRY("grpc.global_string", "foobar", PHP_INI_ALL,
+OnUpdateString, global_string, zend_grpc_globals, grpc_globals)
 PHP_INI_END()
 */
 /* }}} */
@@ -74,159 +70,118 @@ static void php_grpc_init_globals(zend_grpc_globals *grpc_globals)
 
 /* {{{ PHP_MINIT_FUNCTION
  */
-PHP_MINIT_FUNCTION(grpc)
-{
-    /* If you have INI entries, uncomment these lines
-    REGISTER_INI_ENTRIES();
-    */
-    /* Register call error constants */
-    grpc_init();
-    REGISTER_LONG_CONSTANT("Grpc\\CALL_OK", GRPC_CALL_OK, CONST_CS);
-    REGISTER_LONG_CONSTANT("Grpc\\CALL_ERROR", GRPC_CALL_ERROR, CONST_CS);
-    REGISTER_LONG_CONSTANT("Grpc\\CALL_ERROR_NOT_ON_SERVER",
-                           GRPC_CALL_ERROR_NOT_ON_SERVER,
-                           CONST_CS);
-    REGISTER_LONG_CONSTANT("Grpc\\CALL_ERROR_NOT_ON_CLIENT",
-                           GRPC_CALL_ERROR_NOT_ON_CLIENT,
-                           CONST_CS);
-    REGISTER_LONG_CONSTANT("Grpc\\CALL_ERROR_ALREADY_INVOKED",
-                           GRPC_CALL_ERROR_ALREADY_INVOKED,
-                           CONST_CS);
-    REGISTER_LONG_CONSTANT("Grpc\\CALL_ERROR_NOT_INVOKED",
-                           GRPC_CALL_ERROR_NOT_INVOKED,
-                           CONST_CS);
-    REGISTER_LONG_CONSTANT("Grpc\\CALL_ERROR_ALREADY_FINISHED",
-                           GRPC_CALL_ERROR_ALREADY_FINISHED,
-                           CONST_CS);
-    REGISTER_LONG_CONSTANT("Grpc\\CALL_ERROR_TOO_MANY_OPERATIONS",
-                           GRPC_CALL_ERROR_TOO_MANY_OPERATIONS,
-                           CONST_CS);
-    REGISTER_LONG_CONSTANT("Grpc\\CALL_ERROR_INVALID_FLAGS",
-                           GRPC_CALL_ERROR_INVALID_FLAGS,
-                           CONST_CS);
-
-    /* Register op error constants */
-    REGISTER_LONG_CONSTANT("Grpc\\OP_OK", GRPC_OP_OK, CONST_CS);
-    REGISTER_LONG_CONSTANT("Grpc\\OP_ERROR", GRPC_OP_ERROR, CONST_CS);
-
-    /* Register flag constants */
-    REGISTER_LONG_CONSTANT("Grpc\\WRITE_BUFFER_HINT",
-                           GRPC_WRITE_BUFFER_HINT,
-                           CONST_CS);
-    REGISTER_LONG_CONSTANT("Grpc\\WRITE_NO_COMPRESS",
-                           GRPC_WRITE_NO_COMPRESS,
-                           CONST_CS);
-
-    /* Register completion type constants */
-    REGISTER_LONG_CONSTANT("Grpc\\QUEUE_SHUTDOWN",
-                           GRPC_QUEUE_SHUTDOWN,
-                           CONST_CS);
-    REGISTER_LONG_CONSTANT("Grpc\\READ", GRPC_READ, CONST_CS);
-    REGISTER_LONG_CONSTANT("Grpc\\INVOKE_ACCEPTED",
-                           GRPC_INVOKE_ACCEPTED,
-                           CONST_CS);
-    REGISTER_LONG_CONSTANT("Grpc\\WRITE_ACCEPTED",
-                           GRPC_WRITE_ACCEPTED,
-                           CONST_CS);
-    REGISTER_LONG_CONSTANT("Grpc\\FINISH_ACCEPTED",
-                           GRPC_FINISH_ACCEPTED,
-                           CONST_CS);
-    REGISTER_LONG_CONSTANT("Grpc\\CLIENT_METADATA_READ",
-                           GRPC_CLIENT_METADATA_READ,
-                           CONST_CS);
-    REGISTER_LONG_CONSTANT("Grpc\\FINISHED", GRPC_FINISHED, CONST_CS);
-    REGISTER_LONG_CONSTANT("Grpc\\SERVER_RPC_NEW",
-                           GRPC_SERVER_RPC_NEW,
-                           CONST_CS);
-
-    /* Register status constants */
-    REGISTER_LONG_CONSTANT("Grpc\\STATUS_OK",
-                           GRPC_STATUS_OK,
-                           CONST_CS);
-    REGISTER_LONG_CONSTANT("Grpc\\STATUS_CANCELLED",
-                           GRPC_STATUS_CANCELLED,
-                           CONST_CS);
-    REGISTER_LONG_CONSTANT("Grpc\\STATUS_UNKNOWN",
-                           GRPC_STATUS_UNKNOWN,
-                           CONST_CS);
-    REGISTER_LONG_CONSTANT("Grpc\\STATUS_INVALID_ARGUMENT",
-                           GRPC_STATUS_INVALID_ARGUMENT,
-                           CONST_CS);
-    REGISTER_LONG_CONSTANT("Grpc\\STATUS_DEADLINE_EXCEEDED",
-                           GRPC_STATUS_DEADLINE_EXCEEDED,
-                           CONST_CS);
-    REGISTER_LONG_CONSTANT("Grpc\\STATUS_NOT_FOUND",
-                           GRPC_STATUS_NOT_FOUND,
-                           CONST_CS);
-    REGISTER_LONG_CONSTANT("Grpc\\STATUS_ALREADY_EXISTS",
-                           GRPC_STATUS_ALREADY_EXISTS,
-                           CONST_CS);
-    REGISTER_LONG_CONSTANT("Grpc\\STATUS_PERMISSION_DENIED",
-                           GRPC_STATUS_PERMISSION_DENIED,
-                           CONST_CS);
-    REGISTER_LONG_CONSTANT("Grpc\\STATUS_UNAUTHENTICATED",
-                           GRPC_STATUS_UNAUTHENTICATED,
-                           CONST_CS);
-    REGISTER_LONG_CONSTANT("Grpc\\STATUS_RESOURCE_EXHAUSTED",
-                           GRPC_STATUS_RESOURCE_EXHAUSTED,
-                           CONST_CS);
-    REGISTER_LONG_CONSTANT("Grpc\\STATUS_FAILED_PRECONDITION",
-                           GRPC_STATUS_FAILED_PRECONDITION,
-                           CONST_CS);
-    REGISTER_LONG_CONSTANT("Grpc\\STATUS_ABORTED",
-                           GRPC_STATUS_ABORTED,
-                           CONST_CS);
-    REGISTER_LONG_CONSTANT("Grpc\\STATUS_OUT_OF_RANGE",
-                           GRPC_STATUS_OUT_OF_RANGE,
-                           CONST_CS);
-    REGISTER_LONG_CONSTANT("Grpc\\STATUS_UNIMPLEMENTED",
-                           GRPC_STATUS_UNIMPLEMENTED,
-                           CONST_CS);
-    REGISTER_LONG_CONSTANT("Grpc\\STATUS_INTERNAL",
-                           GRPC_STATUS_INTERNAL,
-                           CONST_CS);
-    REGISTER_LONG_CONSTANT("Grpc\\STATUS_UNAVAILABLE",
-                           GRPC_STATUS_UNAVAILABLE,
-                           CONST_CS);
-    REGISTER_LONG_CONSTANT("Grpc\\STATUS_DATA_LOSS",
-                           GRPC_STATUS_DATA_LOSS,
-                           CONST_CS);
-
-    grpc_init_call(TSRMLS_C);
-    grpc_init_channel(TSRMLS_C);
-    grpc_init_server(TSRMLS_C);
-    grpc_init_completion_queue(TSRMLS_C);
-    grpc_init_timeval(TSRMLS_C);
-    grpc_init_credentials(TSRMLS_C);
-    grpc_init_server_credentials(TSRMLS_C);
-    return SUCCESS;
+PHP_MINIT_FUNCTION(grpc) {
+  /* If you have INI entries, uncomment these lines
+  REGISTER_INI_ENTRIES();
+  */
+  /* Register call error constants */
+  grpc_init();
+  REGISTER_LONG_CONSTANT("Grpc\\CALL_OK", GRPC_CALL_OK, CONST_CS);
+  REGISTER_LONG_CONSTANT("Grpc\\CALL_ERROR", GRPC_CALL_ERROR, CONST_CS);
+  REGISTER_LONG_CONSTANT("Grpc\\CALL_ERROR_NOT_ON_SERVER",
+                         GRPC_CALL_ERROR_NOT_ON_SERVER, CONST_CS);
+  REGISTER_LONG_CONSTANT("Grpc\\CALL_ERROR_NOT_ON_CLIENT",
+                         GRPC_CALL_ERROR_NOT_ON_CLIENT, CONST_CS);
+  REGISTER_LONG_CONSTANT("Grpc\\CALL_ERROR_ALREADY_INVOKED",
+                         GRPC_CALL_ERROR_ALREADY_INVOKED, CONST_CS);
+  REGISTER_LONG_CONSTANT("Grpc\\CALL_ERROR_NOT_INVOKED",
+                         GRPC_CALL_ERROR_NOT_INVOKED, CONST_CS);
+  REGISTER_LONG_CONSTANT("Grpc\\CALL_ERROR_ALREADY_FINISHED",
+                         GRPC_CALL_ERROR_ALREADY_FINISHED, CONST_CS);
+  REGISTER_LONG_CONSTANT("Grpc\\CALL_ERROR_TOO_MANY_OPERATIONS",
+                         GRPC_CALL_ERROR_TOO_MANY_OPERATIONS, CONST_CS);
+  REGISTER_LONG_CONSTANT("Grpc\\CALL_ERROR_INVALID_FLAGS",
+                         GRPC_CALL_ERROR_INVALID_FLAGS, CONST_CS);
+
+  /* Register op error constants */
+  REGISTER_LONG_CONSTANT("Grpc\\OP_OK", GRPC_OP_OK, CONST_CS);
+  REGISTER_LONG_CONSTANT("Grpc\\OP_ERROR", GRPC_OP_ERROR, CONST_CS);
+
+  /* Register flag constants */
+  REGISTER_LONG_CONSTANT("Grpc\\WRITE_BUFFER_HINT", GRPC_WRITE_BUFFER_HINT,
+                         CONST_CS);
+  REGISTER_LONG_CONSTANT("Grpc\\WRITE_NO_COMPRESS", GRPC_WRITE_NO_COMPRESS,
+                         CONST_CS);
+
+  /* Register completion type constants */
+  REGISTER_LONG_CONSTANT("Grpc\\QUEUE_SHUTDOWN", GRPC_QUEUE_SHUTDOWN, CONST_CS);
+  REGISTER_LONG_CONSTANT("Grpc\\READ", GRPC_READ, CONST_CS);
+  REGISTER_LONG_CONSTANT("Grpc\\INVOKE_ACCEPTED", GRPC_INVOKE_ACCEPTED,
+                         CONST_CS);
+  REGISTER_LONG_CONSTANT("Grpc\\WRITE_ACCEPTED", GRPC_WRITE_ACCEPTED, CONST_CS);
+  REGISTER_LONG_CONSTANT("Grpc\\FINISH_ACCEPTED", GRPC_FINISH_ACCEPTED,
+                         CONST_CS);
+  REGISTER_LONG_CONSTANT("Grpc\\CLIENT_METADATA_READ",
+                         GRPC_CLIENT_METADATA_READ, CONST_CS);
+  REGISTER_LONG_CONSTANT("Grpc\\FINISHED", GRPC_FINISHED, CONST_CS);
+  REGISTER_LONG_CONSTANT("Grpc\\SERVER_RPC_NEW", GRPC_SERVER_RPC_NEW, CONST_CS);
+
+  /* Register status constants */
+  REGISTER_LONG_CONSTANT("Grpc\\STATUS_OK", GRPC_STATUS_OK, CONST_CS);
+  REGISTER_LONG_CONSTANT("Grpc\\STATUS_CANCELLED", GRPC_STATUS_CANCELLED,
+                         CONST_CS);
+  REGISTER_LONG_CONSTANT("Grpc\\STATUS_UNKNOWN", GRPC_STATUS_UNKNOWN, CONST_CS);
+  REGISTER_LONG_CONSTANT("Grpc\\STATUS_INVALID_ARGUMENT",
+                         GRPC_STATUS_INVALID_ARGUMENT, CONST_CS);
+  REGISTER_LONG_CONSTANT("Grpc\\STATUS_DEADLINE_EXCEEDED",
+                         GRPC_STATUS_DEADLINE_EXCEEDED, CONST_CS);
+  REGISTER_LONG_CONSTANT("Grpc\\STATUS_NOT_FOUND", GRPC_STATUS_NOT_FOUND,
+                         CONST_CS);
+  REGISTER_LONG_CONSTANT("Grpc\\STATUS_ALREADY_EXISTS",
+                         GRPC_STATUS_ALREADY_EXISTS, CONST_CS);
+  REGISTER_LONG_CONSTANT("Grpc\\STATUS_PERMISSION_DENIED",
+                         GRPC_STATUS_PERMISSION_DENIED, CONST_CS);
+  REGISTER_LONG_CONSTANT("Grpc\\STATUS_UNAUTHENTICATED",
+                         GRPC_STATUS_UNAUTHENTICATED, CONST_CS);
+  REGISTER_LONG_CONSTANT("Grpc\\STATUS_RESOURCE_EXHAUSTED",
+                         GRPC_STATUS_RESOURCE_EXHAUSTED, CONST_CS);
+  REGISTER_LONG_CONSTANT("Grpc\\STATUS_FAILED_PRECONDITION",
+                         GRPC_STATUS_FAILED_PRECONDITION, CONST_CS);
+  REGISTER_LONG_CONSTANT("Grpc\\STATUS_ABORTED", GRPC_STATUS_ABORTED, CONST_CS);
+  REGISTER_LONG_CONSTANT("Grpc\\STATUS_OUT_OF_RANGE", GRPC_STATUS_OUT_OF_RANGE,
+                         CONST_CS);
+  REGISTER_LONG_CONSTANT("Grpc\\STATUS_UNIMPLEMENTED",
+                         GRPC_STATUS_UNIMPLEMENTED, CONST_CS);
+  REGISTER_LONG_CONSTANT("Grpc\\STATUS_INTERNAL", GRPC_STATUS_INTERNAL,
+                         CONST_CS);
+  REGISTER_LONG_CONSTANT("Grpc\\STATUS_UNAVAILABLE", GRPC_STATUS_UNAVAILABLE,
+                         CONST_CS);
+  REGISTER_LONG_CONSTANT("Grpc\\STATUS_DATA_LOSS", GRPC_STATUS_DATA_LOSS,
+                         CONST_CS);
+
+  grpc_init_call(TSRMLS_C);
+  grpc_init_channel(TSRMLS_C);
+  grpc_init_server(TSRMLS_C);
+  grpc_init_completion_queue(TSRMLS_C);
+  grpc_init_timeval(TSRMLS_C);
+  grpc_init_credentials(TSRMLS_C);
+  grpc_init_server_credentials(TSRMLS_C);
+  return SUCCESS;
 }
 /* }}} */
 
 /* {{{ PHP_MSHUTDOWN_FUNCTION
  */
-PHP_MSHUTDOWN_FUNCTION(grpc)
-{
-    /* uncomment this line if you have INI entries
-    UNREGISTER_INI_ENTRIES();
-    */
-    grpc_shutdown_timeval(TSRMLS_C);
-    grpc_shutdown();
-    return SUCCESS;
+PHP_MSHUTDOWN_FUNCTION(grpc) {
+  /* uncomment this line if you have INI entries
+  UNREGISTER_INI_ENTRIES();
+  */
+  grpc_shutdown_timeval(TSRMLS_C);
+  grpc_shutdown();
+  return SUCCESS;
 }
 /* }}} */
 
 /* {{{ PHP_MINFO_FUNCTION
  */
-PHP_MINFO_FUNCTION(grpc)
-{
-    php_info_print_table_start();
-    php_info_print_table_header(2, "grpc support", "enabled");
-    php_info_print_table_end();
-
-    /* Remove comments if you have entries in php.ini
-    DISPLAY_INI_ENTRIES();
-    */
+PHP_MINFO_FUNCTION(grpc) {
+  php_info_print_table_start();
+  php_info_print_table_header(2, "grpc support", "enabled");
+  php_info_print_table_end();
+
+  /* Remove comments if you have entries in php.ini
+  DISPLAY_INI_ENTRIES();
+  */
 }
 /* }}} */
 /* The previous line is meant for vim and emacs, so it can correctly fold and
@@ -235,7 +190,6 @@ PHP_MINFO_FUNCTION(grpc)
    follow this convention for the convenience of others editing your code.
 */
 
-
 /*
  * Local variables:
  * tab-width: 4
diff --git a/src/php/ext/grpc/php_grpc.h b/src/php/ext/grpc/php_grpc.h
index 777e0c4368..53cc5dcf6e 100755..100644
--- a/src/php/ext/grpc/php_grpc.h
+++ b/src/php/ext/grpc/php_grpc.h
@@ -7,14 +7,15 @@
 extern zend_module_entry grpc_module_entry;
 #define phpext_grpc_ptr &grpc_module_entry
 
-#define PHP_GRPC_VERSION "0.1.0" /* Replace with version number for your extension */
+#define PHP_GRPC_VERSION \
+  "0.1.0" /* Replace with version number for your extension */
 
 #ifdef PHP_WIN32
-#	define PHP_GRPC_API __declspec(dllexport)
+#define PHP_GRPC_API __declspec(dllexport)
 #elif defined(__GNUC__) && __GNUC__ >= 4
-#	define PHP_GRPC_API __attribute__ ((visibility("default")))
+#define PHP_GRPC_API __attribute__((visibility("default")))
 #else
-#	define PHP_GRPC_API
+#define PHP_GRPC_API
 #endif
 
 #ifdef ZTS
@@ -25,11 +26,9 @@ extern zend_module_entry grpc_module_entry;
 
 #include "grpc/grpc.h"
 
-#define RETURN_DESTROY_ZVAL(val)                        \
-  RETURN_ZVAL(                                          \
-      val,                                              \
-      false /* Don't execute copy constructor */,       \
-      true /* Dealloc original before returning */)
+#define RETURN_DESTROY_ZVAL(val)                               \
+  RETURN_ZVAL(val, false /* Don't execute copy constructor */, \
+              true /* Dealloc original before returning */)
 
 /* These are all function declarations */
 /* Code that runs at module initialization */
@@ -40,8 +39,8 @@ PHP_MSHUTDOWN_FUNCTION(grpc);
 PHP_MINFO_FUNCTION(grpc);
 
 /*
-  	Declare any global variables you may need between the BEGIN
-	and END macros here:
+        Declare any global variables you may need between the BEGIN
+        and END macros here:
 
 ZEND_BEGIN_MODULE_GLOBALS(grpc)
 ZEND_END_MODULE_GLOBALS(grpc)
@@ -63,4 +62,4 @@ ZEND_END_MODULE_GLOBALS(grpc)
 #define GRPC_G(v) (grpc_globals.v)
 #endif
 
-#endif	/* PHP_GRPC_H */
+#endif /* PHP_GRPC_H */
diff --git a/src/php/ext/grpc/server.c b/src/php/ext/grpc/server.c
index 5af42f76ee..f484375712 100755..100644
--- a/src/php/ext/grpc/server.c
+++ b/src/php/ext/grpc/server.c
@@ -24,9 +24,9 @@
 #include "server_credentials.h"
 
 /* Frees and destroys an instance of wrapped_grpc_server */
-void free_wrapped_grpc_server(void *object TSRMLS_DC){
-  wrapped_grpc_server *server = (wrapped_grpc_server*)object;
-  if(server->wrapped != NULL){
+void free_wrapped_grpc_server(void *object TSRMLS_DC) {
+  wrapped_grpc_server *server = (wrapped_grpc_server *)object;
+  if (server->wrapped != NULL) {
     grpc_server_shutdown(server->wrapped);
     grpc_server_destroy(server->wrapped);
   }
@@ -35,21 +35,19 @@ void free_wrapped_grpc_server(void *object TSRMLS_DC){
 
 /* Initializes an instance of wrapped_grpc_call to be associated with an object
  * of a class specified by class_type */
-zend_object_value create_wrapped_grpc_server(
-    zend_class_entry *class_type TSRMLS_DC){
+zend_object_value create_wrapped_grpc_server(zend_class_entry *class_type
+                                                 TSRMLS_DC) {
   zend_object_value retval;
   wrapped_grpc_server *intern;
 
-  intern = (wrapped_grpc_server*)emalloc(sizeof(wrapped_grpc_server));
+  intern = (wrapped_grpc_server *)emalloc(sizeof(wrapped_grpc_server));
   memset(intern, 0, sizeof(wrapped_grpc_server));
 
   zend_object_std_init(&intern->std, class_type TSRMLS_CC);
   object_properties_init(&intern->std, class_type);
   retval.handle = zend_objects_store_put(
-      intern,
-      (zend_objects_store_dtor_t) zend_objects_destroy_object,
-      free_wrapped_grpc_server,
-      NULL TSRMLS_CC);
+      intern, (zend_objects_store_dtor_t)zend_objects_destroy_object,
+      free_wrapped_grpc_server, NULL TSRMLS_CC);
   retval.handlers = zend_get_std_object_handlers();
   return retval;
 }
@@ -59,9 +57,9 @@ zend_object_value create_wrapped_grpc_server(
  * @param CompletionQueue $queue The completion queue to use with the server
  * @param array $args The arguments to pass to the server (optional)
  */
-PHP_METHOD(Server, __construct){
+PHP_METHOD(Server, __construct) {
   wrapped_grpc_server *server =
-    (wrapped_grpc_server*)zend_object_store_get_object(getThis() TSRMLS_CC);
+      (wrapped_grpc_server *)zend_object_store_get_object(getThis() TSRMLS_CC);
   zval *queue_obj;
   zval *args_array = NULL;
   grpc_channel_args args;
@@ -69,10 +67,8 @@ PHP_METHOD(Server, __construct){
   zval **creds_obj = NULL;
   wrapped_grpc_server_credentials *creds = NULL;
   /* "O|a" == 1 Object, 1 optional array */
-  if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,
-                           "O|a",
-                           &queue_obj, grpc_ce_completion_queue,
-                           &args_array) == FAILURE){
+  if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O|a", &queue_obj,
+                            grpc_ce_completion_queue, &args_array) == FAILURE) {
     zend_throw_exception(spl_ce_InvalidArgumentException,
                          "Server expects a CompletionQueue and an array",
                          1 TSRMLS_CC);
@@ -80,24 +76,22 @@ PHP_METHOD(Server, __construct){
   }
   add_property_zval(getThis(), "completion_queue", queue_obj);
   wrapped_grpc_completion_queue *queue =
-    (wrapped_grpc_completion_queue*)zend_object_store_get_object(
-        queue_obj TSRMLS_CC);
+      (wrapped_grpc_completion_queue *)zend_object_store_get_object(
+          queue_obj TSRMLS_CC);
   if (args_array == NULL) {
     server->wrapped = grpc_server_create(queue->wrapped, NULL);
   } else {
     array_hash = Z_ARRVAL_P(args_array);
-    if(zend_hash_find(array_hash,
-                      "credentials",
-                      sizeof("credentials"),
-                      (void**)&creds_obj) == SUCCESS) {
-      if(zend_get_class_entry(*creds_obj TSRMLS_CC) !=
-         grpc_ce_server_credentials) {
+    if (zend_hash_find(array_hash, "credentials", sizeof("credentials"),
+                       (void **)&creds_obj) == SUCCESS) {
+      if (zend_get_class_entry(*creds_obj TSRMLS_CC) !=
+          grpc_ce_server_credentials) {
         zend_throw_exception(spl_ce_InvalidArgumentException,
                              "credentials must be a ServerCredentials object",
                              1 TSRMLS_CC);
         return;
       }
-      creds = (wrapped_grpc_server_credentials*)zend_object_store_get_object(
+      creds = (wrapped_grpc_server_credentials *)zend_object_store_get_object(
           *creds_obj TSRMLS_CC);
       zend_hash_del(array_hash, "credentials", sizeof("credentials"));
     }
@@ -106,9 +100,8 @@ PHP_METHOD(Server, __construct){
       server->wrapped = grpc_server_create(queue->wrapped, &args);
     } else {
       gpr_log(GPR_DEBUG, "Initialized secure server");
-      server->wrapped = grpc_secure_server_create(creds->wrapped,
-                                                  queue->wrapped,
-                                                  &args);
+      server->wrapped =
+          grpc_secure_server_create(creds->wrapped, queue->wrapped, &args);
     }
     efree(args.args);
   }
@@ -120,21 +113,19 @@ PHP_METHOD(Server, __construct){
  * @param long $tag_cancel The tag to use if the call is cancelled
  * @return Void
  */
-PHP_METHOD(Server, request_call){
+PHP_METHOD(Server, request_call) {
   grpc_call_error error_code;
   wrapped_grpc_server *server =
-    (wrapped_grpc_server*)zend_object_store_get_object(getThis() TSRMLS_CC);
+      (wrapped_grpc_server *)zend_object_store_get_object(getThis() TSRMLS_CC);
   long tag_new;
   /* "l" == 1 long */
-  if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,
-                           "l",
-                           &tag_new) == FAILURE){
+  if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &tag_new) ==
+      FAILURE) {
     zend_throw_exception(spl_ce_InvalidArgumentException,
-                         "request_call expects a long",
-                         1 TSRMLS_CC);
+                         "request_call expects a long", 1 TSRMLS_CC);
     return;
   }
-  error_code = grpc_server_request_call(server->wrapped, (void*)tag_new);
+  error_code = grpc_server_request_call(server->wrapped, (void *)tag_new);
   MAYBE_THROW_CALL_ERROR(request_call, error_code);
 }
 
@@ -143,35 +134,31 @@ PHP_METHOD(Server, request_call){
  * @param string $addr The address to add
  * @return true on success, false on failure
  */
-PHP_METHOD(Server, add_http2_port){
+PHP_METHOD(Server, add_http2_port) {
   wrapped_grpc_server *server =
-    (wrapped_grpc_server*)zend_object_store_get_object(getThis() TSRMLS_CC);
+      (wrapped_grpc_server *)zend_object_store_get_object(getThis() TSRMLS_CC);
   const char *addr;
   int addr_len;
   /* "s" == 1 string */
-  if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,
-                           "s",
-                           &addr, &addr_len) == FAILURE){
+  if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &addr, &addr_len) ==
+      FAILURE) {
     zend_throw_exception(spl_ce_InvalidArgumentException,
-                         "add_http2_port expects a string",
-                         1 TSRMLS_CC);
+                         "add_http2_port expects a string", 1 TSRMLS_CC);
     return;
   }
   RETURN_BOOL(grpc_server_add_http2_port(server->wrapped, addr));
 }
 
-PHP_METHOD(Server, add_secure_http2_port){
+PHP_METHOD(Server, add_secure_http2_port) {
   wrapped_grpc_server *server =
-    (wrapped_grpc_server*)zend_object_store_get_object(getThis() TSRMLS_CC);
+      (wrapped_grpc_server *)zend_object_store_get_object(getThis() TSRMLS_CC);
   const char *addr;
   int addr_len;
   /* "s" == 1 string */
-  if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,
-                           "s",
-                           &addr, &addr_len) == FAILURE){
+  if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &addr, &addr_len) ==
+      FAILURE) {
     zend_throw_exception(spl_ce_InvalidArgumentException,
-                         "add_http2_port expects a string",
-                         1 TSRMLS_CC);
+                         "add_http2_port expects a string", 1 TSRMLS_CC);
     return;
   }
   RETURN_BOOL(grpc_server_add_secure_http2_port(server->wrapped, addr));
@@ -181,22 +168,20 @@ PHP_METHOD(Server, add_secure_http2_port){
  * Start a server - tells all listeners to start listening
  * @return Void
  */
-PHP_METHOD(Server, start){
+PHP_METHOD(Server, start) {
   wrapped_grpc_server *server =
-    (wrapped_grpc_server*)zend_object_store_get_object(getThis() TSRMLS_CC);
+      (wrapped_grpc_server *)zend_object_store_get_object(getThis() TSRMLS_CC);
   grpc_server_start(server->wrapped);
 }
 
 static zend_function_entry server_methods[] = {
-  PHP_ME(Server, __construct, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR)
-  PHP_ME(Server, request_call, NULL, ZEND_ACC_PUBLIC)
-  PHP_ME(Server, add_http2_port, NULL, ZEND_ACC_PUBLIC)
-  PHP_ME(Server, add_secure_http2_port, NULL, ZEND_ACC_PUBLIC)
-  PHP_ME(Server, start, NULL, ZEND_ACC_PUBLIC)
-  PHP_FE_END
-};
-
-void grpc_init_server(TSRMLS_D){
+    PHP_ME(Server, __construct, NULL, ZEND_ACC_PUBLIC | ZEND_ACC_CTOR)
+        PHP_ME(Server, request_call, NULL, ZEND_ACC_PUBLIC)
+            PHP_ME(Server, add_http2_port, NULL, ZEND_ACC_PUBLIC)
+                PHP_ME(Server, add_secure_http2_port, NULL, ZEND_ACC_PUBLIC)
+                    PHP_ME(Server, start, NULL, ZEND_ACC_PUBLIC) PHP_FE_END};
+
+void grpc_init_server(TSRMLS_D) {
   zend_class_entry ce;
   INIT_CLASS_ENTRY(ce, "Grpc\\Server", server_methods);
   ce.create_object = create_wrapped_grpc_server;
diff --git a/src/php/ext/grpc/server_credentials.c b/src/php/ext/grpc/server_credentials.c
index b07790b4be..5b9ab3390d 100755..100644
--- a/src/php/ext/grpc/server_credentials.c
+++ b/src/php/ext/grpc/server_credentials.c
@@ -17,10 +17,10 @@
 #include "grpc/grpc_security.h"
 
 /* Frees and destroys an instace of wrapped_grpc_server_credentials */
-void free_wrapped_grpc_server_credentials(void *object TSRMLS_DC){
+void free_wrapped_grpc_server_credentials(void *object TSRMLS_DC) {
   wrapped_grpc_server_credentials *creds =
-      (wrapped_grpc_server_credentials*)object;
-  if(creds->wrapped != NULL) {
+      (wrapped_grpc_server_credentials *)object;
+  if (creds->wrapped != NULL) {
     grpc_server_credentials_release(creds->wrapped);
   }
   efree(creds);
@@ -29,32 +29,30 @@ void free_wrapped_grpc_server_credentials(void *object TSRMLS_DC){
 /* Initializes an instace of wrapped_grpc_server_credentials to be associated
  * with an object of a class specified by class_type */
 zend_object_value create_wrapped_grpc_server_credentials(
-    zend_class_entry *class_type TSRMLS_DC){
+    zend_class_entry *class_type TSRMLS_DC) {
   zend_object_value retval;
   wrapped_grpc_server_credentials *intern;
 
-  intern = (wrapped_grpc_server_credentials*)emalloc(sizeof(
-      wrapped_grpc_server_credentials));
+  intern = (wrapped_grpc_server_credentials *)emalloc(
+      sizeof(wrapped_grpc_server_credentials));
   memset(intern, 0, sizeof(wrapped_grpc_server_credentials));
 
   zend_object_std_init(&intern->std, class_type TSRMLS_CC);
   object_properties_init(&intern->std, class_type);
   retval.handle = zend_objects_store_put(
-      intern,
-      (zend_objects_store_dtor_t) zend_objects_destroy_object,
-      free_wrapped_grpc_server_credentials,
-      NULL TSRMLS_CC);
+      intern, (zend_objects_store_dtor_t)zend_objects_destroy_object,
+      free_wrapped_grpc_server_credentials, NULL TSRMLS_CC);
   retval.handlers = zend_get_std_object_handlers();
   return retval;
 }
 
-zval *grpc_php_wrap_server_credentials(grpc_server_credentials *wrapped){
+zval *grpc_php_wrap_server_credentials(grpc_server_credentials *wrapped) {
   zval *server_credentials_object;
   MAKE_STD_ZVAL(server_credentials_object);
   object_init_ex(server_credentials_object, grpc_ce_server_credentials);
   wrapped_grpc_server_credentials *server_credentials =
-    (wrapped_grpc_server_credentials*)zend_object_store_get_object(
-        server_credentials_object TSRMLS_CC);
+      (wrapped_grpc_server_credentials *)zend_object_store_get_object(
+          server_credentials_object TSRMLS_CC);
   server_credentials->wrapped = wrapped;
   return server_credentials_object;
 }
@@ -66,7 +64,7 @@ zval *grpc_php_wrap_server_credentials(grpc_server_credentials *wrapped){
  * @param string pem_cert_chain PEM encoding of the client's certificate chain
  * @return Credentials The new SSL credentials object
  */
-PHP_METHOD(ServerCredentials, createSsl){
+PHP_METHOD(ServerCredentials, createSsl) {
   char *pem_root_certs = 0;
   char *pem_private_key;
   char *pem_cert_chain;
@@ -74,20 +72,18 @@ PHP_METHOD(ServerCredentials, createSsl){
   int root_certs_length = 0, private_key_length, cert_chain_length;
 
   /* "s!ss" == 1 nullable string, 2 strings */
-  if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,
-                           "s!ss",
-                           &pem_root_certs, &root_certs_length,
-                           &pem_private_key, &private_key_length,
-                           &pem_cert_chain, &cert_chain_length) == FAILURE) {
+  if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s!ss", &pem_root_certs,
+                            &root_certs_length, &pem_private_key,
+                            &private_key_length, &pem_cert_chain,
+                            &cert_chain_length) == FAILURE) {
     zend_throw_exception(spl_ce_InvalidArgumentException,
-                         "createSsl expects 3 strings",
-                         1 TSRMLS_CC);
+                         "createSsl expects 3 strings", 1 TSRMLS_CC);
     return;
   }
   grpc_server_credentials *creds = grpc_ssl_server_credentials_create(
-      (unsigned char*)pem_root_certs, (size_t)root_certs_length,
-      (unsigned char*)pem_private_key, (size_t)private_key_length,
-      (unsigned char*)pem_cert_chain, (size_t)cert_chain_length);
+      (unsigned char *)pem_root_certs, (size_t)root_certs_length,
+      (unsigned char *)pem_private_key, (size_t)private_key_length,
+      (unsigned char *)pem_cert_chain, (size_t)cert_chain_length);
   zval *creds_object = grpc_php_wrap_server_credentials(creds);
   RETURN_DESTROY_ZVAL(creds_object);
 }
@@ -96,7 +92,7 @@ PHP_METHOD(ServerCredentials, createSsl){
  * Create fake credentials. Only to be used for testing.
  * @return ServerCredentials The new fake credentials object
  */
-PHP_METHOD(ServerCredentials, createFake){
+PHP_METHOD(ServerCredentials, createFake) {
   grpc_server_credentials *creds =
       grpc_fake_transport_security_server_credentials_create();
   zval *creds_object = grpc_php_wrap_server_credentials(creds);
@@ -104,12 +100,12 @@ PHP_METHOD(ServerCredentials, createFake){
 }
 
 static zend_function_entry server_credentials_methods[] = {
-  PHP_ME(ServerCredentials, createSsl, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-  PHP_ME(ServerCredentials, createFake, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-  PHP_FE_END
-};
+    PHP_ME(ServerCredentials, createSsl, NULL,
+           ZEND_ACC_PUBLIC | ZEND_ACC_STATIC)
+        PHP_ME(ServerCredentials, createFake, NULL,
+               ZEND_ACC_PUBLIC | ZEND_ACC_STATIC) PHP_FE_END};
 
-void grpc_init_server_credentials(TSRMLS_D){
+void grpc_init_server_credentials(TSRMLS_D) {
   zend_class_entry ce;
   INIT_CLASS_ENTRY(ce, "Grpc\\ServerCredentials", server_credentials_methods);
   ce.create_object = create_wrapped_grpc_server_credentials;
diff --git a/src/php/ext/grpc/timeval.c b/src/php/ext/grpc/timeval.c
index 7b7e0e6443..a5508115e4 100755..100644
--- a/src/php/ext/grpc/timeval.c
+++ b/src/php/ext/grpc/timeval.c
@@ -18,36 +18,32 @@
 #include "grpc/support/time.h"
 
 /* Frees and destroys an instance of wrapped_grpc_call */
-void free_wrapped_grpc_timeval(void *object TSRMLS_DC){
-  efree(object);
-}
+void free_wrapped_grpc_timeval(void *object TSRMLS_DC) { efree(object); }
 
 /* Initializes an instance of wrapped_grpc_timeval to be associated with an
  * object of a class specified by class_type */
-zend_object_value create_wrapped_grpc_timeval(
-    zend_class_entry *class_type TSRMLS_DC){
+zend_object_value create_wrapped_grpc_timeval(zend_class_entry *class_type
+                                                  TSRMLS_DC) {
   zend_object_value retval;
   wrapped_grpc_timeval *intern;
-  intern = (wrapped_grpc_timeval*)emalloc(sizeof(wrapped_grpc_timeval));
+  intern = (wrapped_grpc_timeval *)emalloc(sizeof(wrapped_grpc_timeval));
   memset(intern, 0, sizeof(wrapped_grpc_timeval));
   zend_object_std_init(&intern->std, class_type TSRMLS_CC);
   object_properties_init(&intern->std, class_type);
   retval.handle = zend_objects_store_put(
-      intern,
-      (zend_objects_store_dtor_t)zend_objects_destroy_object,
-      free_wrapped_grpc_timeval,
-      NULL TSRMLS_CC);
+      intern, (zend_objects_store_dtor_t)zend_objects_destroy_object,
+      free_wrapped_grpc_timeval, NULL TSRMLS_CC);
   retval.handlers = zend_get_std_object_handlers();
   return retval;
 }
 
-zval *grpc_php_wrap_timeval(gpr_timespec wrapped){
+zval *grpc_php_wrap_timeval(gpr_timespec wrapped) {
   zval *timeval_object;
   MAKE_STD_ZVAL(timeval_object);
   object_init_ex(timeval_object, grpc_ce_timeval);
   wrapped_grpc_timeval *timeval =
-    (wrapped_grpc_timeval*)zend_object_store_get_object(
-        timeval_object TSRMLS_CC);
+      (wrapped_grpc_timeval *)zend_object_store_get_object(
+          timeval_object TSRMLS_CC);
   memcpy(&timeval->wrapped, &wrapped, sizeof(gpr_timespec));
   return timeval_object;
 }
@@ -56,17 +52,15 @@ zval *grpc_php_wrap_timeval(gpr_timespec wrapped){
  * Constructs a new instance of the Timeval class
  * @param long $usec The number of microseconds in the interval
  */
-PHP_METHOD(Timeval, __construct){
+PHP_METHOD(Timeval, __construct) {
   wrapped_grpc_timeval *timeval =
-    (wrapped_grpc_timeval*)zend_object_store_get_object(getThis() TSRMLS_CC);
+      (wrapped_grpc_timeval *)zend_object_store_get_object(getThis() TSRMLS_CC);
   long microseconds;
   /* "l" == 1 long */
-  if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,
-                           "l",
-                           &microseconds) == FAILURE){
+  if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &microseconds) ==
+      FAILURE) {
     zend_throw_exception(spl_ce_InvalidArgumentException,
-                         "Timeval expects a long",
-                         1 TSRMLS_CC);
+                         "Timeval expects a long", 1 TSRMLS_CC);
     return;
   }
   gpr_timespec time = gpr_time_from_micros(microseconds);
@@ -79,23 +73,21 @@ PHP_METHOD(Timeval, __construct){
  * @param Timeval $other The other Timeval object to add
  * @return Timeval A new Timeval object containing the sum
  */
-PHP_METHOD(Timeval, add){
+PHP_METHOD(Timeval, add) {
   zval *other_obj;
   /* "O" == 1 Object */
-  if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,
-                           "O",
-                           &other_obj, grpc_ce_timeval) == FAILURE){
+  if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O", &other_obj,
+                            grpc_ce_timeval) == FAILURE) {
     zend_throw_exception(spl_ce_InvalidArgumentException,
-                         "add expects a Timeval",
-                         1 TSRMLS_CC);
+                         "add expects a Timeval", 1 TSRMLS_CC);
     return;
   }
   wrapped_grpc_timeval *self =
-    (wrapped_grpc_timeval*)zend_object_store_get_object(getThis() TSRMLS_CC);
+      (wrapped_grpc_timeval *)zend_object_store_get_object(getThis() TSRMLS_CC);
   wrapped_grpc_timeval *other =
-    (wrapped_grpc_timeval*)zend_object_store_get_object(other_obj TSRMLS_CC);
-  zval *sum = grpc_php_wrap_timeval(gpr_time_add(self->wrapped,
-                                                 other->wrapped));
+      (wrapped_grpc_timeval *)zend_object_store_get_object(other_obj TSRMLS_CC);
+  zval *sum =
+      grpc_php_wrap_timeval(gpr_time_add(self->wrapped, other->wrapped));
   RETURN_DESTROY_ZVAL(sum);
 }
 
@@ -105,23 +97,21 @@ PHP_METHOD(Timeval, add){
  * @param Timeval $other The other Timeval object to subtract
  * @param Timeval A new Timeval object containing the sum
  */
-PHP_METHOD(Timeval, subtract){
+PHP_METHOD(Timeval, subtract) {
   zval *other_obj;
   /* "O" == 1 Object */
-  if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,
-                           "O",
-                           &other_obj, grpc_ce_timeval) == FAILURE){
+  if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O", &other_obj,
+                            grpc_ce_timeval) == FAILURE) {
     zend_throw_exception(spl_ce_InvalidArgumentException,
-                         "subtract expects a Timeval",
-                         1 TSRMLS_CC);
+                         "subtract expects a Timeval", 1 TSRMLS_CC);
     return;
   }
   wrapped_grpc_timeval *self =
-    (wrapped_grpc_timeval*)zend_object_store_get_object(getThis() TSRMLS_CC);
+      (wrapped_grpc_timeval *)zend_object_store_get_object(getThis() TSRMLS_CC);
   wrapped_grpc_timeval *other =
-    (wrapped_grpc_timeval*)zend_object_store_get_object(other_obj TSRMLS_CC);
-  zval *diff = grpc_php_wrap_timeval(gpr_time_sub(self->wrapped,
-                                                  other->wrapped));
+      (wrapped_grpc_timeval *)zend_object_store_get_object(other_obj TSRMLS_CC);
+  zval *diff =
+      grpc_php_wrap_timeval(gpr_time_sub(self->wrapped, other->wrapped));
   RETURN_DESTROY_ZVAL(diff);
 }
 
@@ -132,22 +122,20 @@ PHP_METHOD(Timeval, subtract){
  * @param Timeval $b The second time to compare
  * @return long
  */
-PHP_METHOD(Timeval, compare){
+PHP_METHOD(Timeval, compare) {
   zval *a_obj, *b_obj;
   /* "OO" == 2 Objects */
-  if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,
-                           "OO",
-                           &a_obj, grpc_ce_timeval,
-                           &b_obj, grpc_ce_timeval) == FAILURE){
+  if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "OO", &a_obj,
+                            grpc_ce_timeval, &b_obj,
+                            grpc_ce_timeval) == FAILURE) {
     zend_throw_exception(spl_ce_InvalidArgumentException,
-                         "compare expects two Timevals",
-                         1 TSRMLS_CC);
+                         "compare expects two Timevals", 1 TSRMLS_CC);
     return;
   }
   wrapped_grpc_timeval *a =
-    (wrapped_grpc_timeval*)zend_object_store_get_object(a_obj TSRMLS_CC);
+      (wrapped_grpc_timeval *)zend_object_store_get_object(a_obj TSRMLS_CC);
   wrapped_grpc_timeval *b =
-    (wrapped_grpc_timeval*)zend_object_store_get_object(b_obj TSRMLS_CC);
+      (wrapped_grpc_timeval *)zend_object_store_get_object(b_obj TSRMLS_CC);
   long result = gpr_time_cmp(a->wrapped, b->wrapped);
   RETURN_LONG(result);
 }
@@ -159,25 +147,23 @@ PHP_METHOD(Timeval, compare){
  * @param Timeval $threshold The threshold to check against
  * @return bool True if $a and $b are within $threshold, False otherwise
  */
-PHP_METHOD(Timeval, similar){
+PHP_METHOD(Timeval, similar) {
   zval *a_obj, *b_obj, *thresh_obj;
   /* "OOO" == 3 Objects */
-  if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,
-                           "OOO",
-                           &a_obj, grpc_ce_timeval,
-                           &b_obj, grpc_ce_timeval,
-                           &thresh_obj, grpc_ce_timeval) == FAILURE){
+  if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "OOO", &a_obj,
+                            grpc_ce_timeval, &b_obj, grpc_ce_timeval,
+                            &thresh_obj, grpc_ce_timeval) == FAILURE) {
     zend_throw_exception(spl_ce_InvalidArgumentException,
-                         "compare expects three Timevals",
-                         1 TSRMLS_CC);
+                         "compare expects three Timevals", 1 TSRMLS_CC);
     return;
   }
   wrapped_grpc_timeval *a =
-    (wrapped_grpc_timeval*)zend_object_store_get_object(a_obj TSRMLS_CC);
+      (wrapped_grpc_timeval *)zend_object_store_get_object(a_obj TSRMLS_CC);
   wrapped_grpc_timeval *b =
-    (wrapped_grpc_timeval*)zend_object_store_get_object(b_obj TSRMLS_CC);
+      (wrapped_grpc_timeval *)zend_object_store_get_object(b_obj TSRMLS_CC);
   wrapped_grpc_timeval *thresh =
-    (wrapped_grpc_timeval*)zend_object_store_get_object(thresh_obj TSRMLS_CC);
+      (wrapped_grpc_timeval *)zend_object_store_get_object(
+          thresh_obj TSRMLS_CC);
   int result = gpr_time_similar(a->wrapped, b->wrapped, thresh->wrapped);
   RETURN_BOOL(result);
 }
@@ -186,7 +172,7 @@ PHP_METHOD(Timeval, similar){
  * Returns the current time as a timeval object
  * @return Timeval The current time
  */
-PHP_METHOD(Timeval, now){
+PHP_METHOD(Timeval, now) {
   zval *now = grpc_php_wrap_timeval(gpr_now());
   RETURN_DESTROY_ZVAL(now);
 }
@@ -195,7 +181,7 @@ PHP_METHOD(Timeval, now){
  * Returns the zero time interval as a timeval object
  * @return Timeval Zero length time interval
  */
-PHP_METHOD(Timeval, zero){
+PHP_METHOD(Timeval, zero) {
   zval *grpc_php_timeval_zero = grpc_php_wrap_timeval(gpr_time_0);
   RETURN_ZVAL(grpc_php_timeval_zero,
               false, /* Copy original before returning? */
@@ -206,7 +192,7 @@ PHP_METHOD(Timeval, zero){
  * Returns the infinite future time value as a timeval object
  * @return Timeval Infinite future time value
  */
-PHP_METHOD(Timeval, inf_future){
+PHP_METHOD(Timeval, inf_future) {
   zval *grpc_php_timeval_inf_future = grpc_php_wrap_timeval(gpr_inf_future);
   RETURN_DESTROY_ZVAL(grpc_php_timeval_inf_future);
 }
@@ -215,7 +201,7 @@ PHP_METHOD(Timeval, inf_future){
  * Returns the infinite past time value as a timeval object
  * @return Timeval Infinite past time value
  */
-PHP_METHOD(Timeval, inf_past){
+PHP_METHOD(Timeval, inf_past) {
   zval *grpc_php_timeval_inf_past = grpc_php_wrap_timeval(gpr_inf_past);
   RETURN_DESTROY_ZVAL(grpc_php_timeval_inf_past);
 }
@@ -224,32 +210,33 @@ PHP_METHOD(Timeval, inf_past){
  * Sleep until this time, interpreted as an absolute timeout
  * @return void
  */
-PHP_METHOD(Timeval, sleep_until){
+PHP_METHOD(Timeval, sleep_until) {
   wrapped_grpc_timeval *this =
-    (wrapped_grpc_timeval*)zend_object_store_get_object(getThis() TSRMLS_CC);
+      (wrapped_grpc_timeval *)zend_object_store_get_object(getThis() TSRMLS_CC);
   gpr_sleep_until(this->wrapped);
 }
 
 static zend_function_entry timeval_methods[] = {
-  PHP_ME(Timeval, __construct, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR)
-  PHP_ME(Timeval, add, NULL, ZEND_ACC_PUBLIC)
-  PHP_ME(Timeval, compare, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-  PHP_ME(Timeval, inf_future, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-  PHP_ME(Timeval, inf_past, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-  PHP_ME(Timeval, now, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-  PHP_ME(Timeval, similar, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-  PHP_ME(Timeval, sleep_until, NULL, ZEND_ACC_PUBLIC)
-  PHP_ME(Timeval, subtract, NULL, ZEND_ACC_PUBLIC)
-  PHP_ME(Timeval, zero, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-  PHP_FE_END
-};
-
-void grpc_init_timeval(TSRMLS_D){
+    PHP_ME(Timeval, __construct, NULL, ZEND_ACC_PUBLIC | ZEND_ACC_CTOR) PHP_ME(
+        Timeval, add, NULL,
+        ZEND_ACC_PUBLIC) PHP_ME(Timeval, compare, NULL,
+                                ZEND_ACC_PUBLIC | ZEND_ACC_STATIC)
+        PHP_ME(Timeval, inf_future, NULL, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC)
+            PHP_ME(Timeval, inf_past, NULL, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC)
+                PHP_ME(Timeval, now, NULL, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC)
+                    PHP_ME(Timeval, similar, NULL,
+                           ZEND_ACC_PUBLIC | ZEND_ACC_STATIC)
+                        PHP_ME(Timeval, sleep_until, NULL, ZEND_ACC_PUBLIC)
+                            PHP_ME(Timeval, subtract, NULL, ZEND_ACC_PUBLIC)
+                                PHP_ME(Timeval, zero, NULL,
+                                       ZEND_ACC_PUBLIC | ZEND_ACC_STATIC)
+                                    PHP_FE_END};
+
+void grpc_init_timeval(TSRMLS_D) {
   zend_class_entry ce;
   INIT_CLASS_ENTRY(ce, "Grpc\\Timeval", timeval_methods);
   ce.create_object = create_wrapped_grpc_timeval;
   grpc_ce_timeval = zend_register_internal_class(&ce TSRMLS_CC);
 }
 
-void grpc_shutdown_timeval(TSRMLS_D){
-}
+void grpc_shutdown_timeval(TSRMLS_D) {}
diff --git a/src/ruby/bin/interop/interop_client.rb b/src/ruby/bin/interop/interop_client.rb
index d0478bb4d1..718b0fdb83 100644..100755
--- a/src/ruby/bin/interop/interop_client.rb
+++ b/src/ruby/bin/interop/interop_client.rb
@@ -1,3 +1,5 @@
+#!/usr/bin/env ruby
+
 # Copyright 2014, Google Inc.
 # All rights reserved.
 #
@@ -27,7 +29,6 @@
 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-#!/usr/bin/env ruby
 # interop_client is a testing tool that accesses a gRPC interop testing
 # server and runs a test on it.
 #
diff --git a/src/ruby/bin/interop/interop_server.rb b/src/ruby/bin/interop/interop_server.rb
index 53e271e80d..63071f3ec2 100644..100755
--- a/src/ruby/bin/interop/interop_server.rb
+++ b/src/ruby/bin/interop/interop_server.rb
@@ -1,3 +1,5 @@
+#!/usr/bin/env ruby
+
 # Copyright 2014, Google Inc.
 # All rights reserved.
 #
@@ -27,8 +29,6 @@
 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-#!/usr/bin/env ruby
-#
 # interop_server is a Testing app that runs a gRPC interop testing server.
 #
 # It helps validate interoperation b/w gRPC in different environments
diff --git a/src/ruby/bin/math_client.rb b/src/ruby/bin/math_client.rb
index 5cba9317f4..4df333d085 100644..100755
--- a/src/ruby/bin/math_client.rb
+++ b/src/ruby/bin/math_client.rb
@@ -1,3 +1,5 @@
+#!/usr/bin/env ruby
+
 # Copyright 2014, Google Inc.
 # All rights reserved.
 #
@@ -27,8 +29,7 @@
 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-#!/usr/bin/env ruby
-#
+
 # Sample app that accesses a Calc service running on a Ruby gRPC server and
 # helps validate RpcServer as a gRPC server using proto2 serialization.
 #
diff --git a/src/ruby/bin/math_server.rb b/src/ruby/bin/math_server.rb
index a0f301c3e7..0e47f71e66 100644..100755
--- a/src/ruby/bin/math_server.rb
+++ b/src/ruby/bin/math_server.rb
@@ -1,3 +1,5 @@
+#!/usr/bin/env ruby
+
 # Copyright 2014, Google Inc.
 # All rights reserved.
 #
@@ -27,8 +29,6 @@
 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-#!/usr/bin/env ruby
-#
 # Sample gRPC Ruby server that implements the Math::Calc service and helps
 # validate GRPC::RpcServer as GRPC implementation using proto2 serialization.
 #
diff --git a/src/ruby/bin/noproto_client.rb b/src/ruby/bin/noproto_client.rb
index 50ae9fb68f..34bdf545ee 100644..100755
--- a/src/ruby/bin/noproto_client.rb
+++ b/src/ruby/bin/noproto_client.rb
@@ -1,3 +1,5 @@
+#!/usr/bin/env ruby
+
 # Copyright 2014, Google Inc.
 # All rights reserved.
 #
@@ -27,7 +29,6 @@
 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-#!/usr/bin/env ruby
 # Sample app that helps validate RpcServer without protobuf serialization.
 #
 # Usage: $ ruby -S path/to/noproto_client.rb
diff --git a/src/ruby/bin/noproto_server.rb b/src/ruby/bin/noproto_server.rb
index d410827b22..1bdc192f02 100644..100755
--- a/src/ruby/bin/noproto_server.rb
+++ b/src/ruby/bin/noproto_server.rb
@@ -1,3 +1,5 @@
+#!/usr/bin/env ruby
+
 # Copyright 2014, Google Inc.
 # All rights reserved.
 #
@@ -27,7 +29,6 @@
 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-#!/usr/bin/env ruby
 # Sample app that helps validate RpcServer without protobuf serialization.
 #
 # Usage: $ path/to/noproto_server.rb
diff --git a/src/ruby/ext/grpc/rb_byte_buffer.c b/src/ruby/ext/grpc/rb_byte_buffer.c
index b75e853d6b..f73b12c417 100644
--- a/src/ruby/ext/grpc/rb_byte_buffer.c
+++ b/src/ruby/ext/grpc/rb_byte_buffer.c
@@ -49,7 +49,6 @@ typedef struct grpc_rb_byte_buffer {
   grpc_byte_buffer *wrapped;
 } grpc_rb_byte_buffer;
 
-
 /* Destroys ByteBuffer instances. */
 static void grpc_rb_byte_buffer_free(void *p) {
   grpc_rb_byte_buffer *bb = NULL;
@@ -169,7 +168,6 @@ static VALUE grpc_rb_byte_buffer_to_s(VALUE self) {
   return output_obj;
 }
 
-
 /* Initializes ByteBuffer instances. */
 static VALUE grpc_rb_byte_buffer_init(VALUE self, VALUE src) {
   gpr_slice a_slice;
@@ -205,8 +203,8 @@ static VALUE grpc_rb_byte_buffer_init(VALUE self, VALUE src) {
 VALUE rb_cByteBuffer = Qnil;
 
 void Init_google_rpc_byte_buffer() {
-  rb_cByteBuffer = rb_define_class_under(rb_mGoogleRpcCore, "ByteBuffer",
-                                         rb_cObject);
+  rb_cByteBuffer =
+      rb_define_class_under(rb_mGoogleRpcCore, "ByteBuffer", rb_cObject);
 
   /* Allocates an object managed by the ruby runtime */
   rb_define_alloc_func(rb_cByteBuffer, grpc_rb_byte_buffer_alloc);
@@ -223,7 +221,7 @@ void Init_google_rpc_byte_buffer() {
   id_empty = rb_intern("");
 }
 
-VALUE grpc_rb_byte_buffer_create_with_mark(VALUE mark, grpc_byte_buffer* bb) {
+VALUE grpc_rb_byte_buffer_create_with_mark(VALUE mark, grpc_byte_buffer *bb) {
   grpc_rb_byte_buffer *byte_buffer = NULL;
   if (bb == NULL) {
     return Qnil;
@@ -236,7 +234,7 @@ VALUE grpc_rb_byte_buffer_create_with_mark(VALUE mark, grpc_byte_buffer* bb) {
 }
 
 /* Gets the wrapped byte_buffer from the ruby wrapper */
-grpc_byte_buffer* grpc_rb_get_wrapped_byte_buffer(VALUE v) {
+grpc_byte_buffer *grpc_rb_get_wrapped_byte_buffer(VALUE v) {
   grpc_rb_byte_buffer *wrapper = NULL;
   Data_Get_Struct(v, grpc_rb_byte_buffer, wrapper);
   return wrapper->wrapped;
diff --git a/src/ruby/ext/grpc/rb_byte_buffer.h b/src/ruby/ext/grpc/rb_byte_buffer.h
index 1bdcfe4019..322c268f37 100644
--- a/src/ruby/ext/grpc/rb_byte_buffer.h
+++ b/src/ruby/ext/grpc/rb_byte_buffer.h
@@ -51,4 +51,4 @@ VALUE grpc_rb_byte_buffer_create_with_mark(VALUE mark, grpc_byte_buffer* bb);
 /* Gets the wrapped byte_buffer from its ruby object. */
 grpc_byte_buffer* grpc_rb_get_wrapped_byte_buffer(VALUE v);
 
-#endif  /* GRPC_RB_BYTE_BUFFER_H_ */
+#endif /* GRPC_RB_BYTE_BUFFER_H_ */
diff --git a/src/ruby/ext/grpc/rb_call.c b/src/ruby/ext/grpc/rb_call.c
index bf292fac75..76b80bcaa1 100644
--- a/src/ruby/ext/grpc/rb_call.c
+++ b/src/ruby/ext/grpc/rb_call.c
@@ -78,7 +78,7 @@ void grpc_rb_call_destroy(void *p) {
 
   ref_count = rb_hash_aref(hash_all_calls, OFFT2NUM((VALUE)call));
   if (ref_count == Qnil) {
-    return;  /* No longer in the hash, so already deleted */
+    return; /* No longer in the hash, so already deleted */
   } else if (NUM2UINT(ref_count) == 1) {
     rb_hash_delete(hash_all_calls, OFFT2NUM((VALUE)call));
     grpc_call_destroy(call);
@@ -92,9 +92,9 @@ void grpc_rb_call_destroy(void *p) {
 VALUE rb_error_code_details;
 
 /* Obtains the error detail string for given error code */
-const char* grpc_call_error_detail_of(grpc_call_error err) {
+const char *grpc_call_error_detail_of(grpc_call_error err) {
   VALUE detail_ref = rb_hash_aref(rb_error_code_details, UINT2NUM(err));
-  const char* detail = "unknown error code!";
+  const char *detail = "unknown error code!";
   if (detail_ref != Qnil) {
     detail = StringValueCStr(detail_ref);
   }
@@ -164,7 +164,7 @@ static VALUE grpc_rb_call_add_metadata(int argc, VALUE *argv, VALUE self) {
   /* "11" == 1 mandatory args, 1 (flags) is optional */
   rb_scan_args(argc, argv, "11", &metadata, &flags);
   if (NIL_P(flags)) {
-    flags = UINT2NUM(0);  /* Default to no flags */
+    flags = UINT2NUM(0); /* Default to no flags */
   }
   if (TYPE(metadata) != T_HASH) {
     rb_raise(rb_eTypeError, "add metadata failed: metadata should be a hash");
@@ -217,14 +217,13 @@ static VALUE grpc_rb_call_start_invoke(int argc, VALUE *argv, VALUE self) {
   rb_scan_args(argc, argv, "41", &cqueue, &invoke_accepted_tag,
                &metadata_read_tag, &finished_tag, &flags);
   if (NIL_P(flags)) {
-    flags = UINT2NUM(0);  /* Default to no flags */
+    flags = UINT2NUM(0); /* Default to no flags */
   }
   cq = grpc_rb_get_wrapped_completion_queue(cqueue);
   Data_Get_Struct(self, grpc_call, call);
   err = grpc_call_start_invoke(call, cq, ROBJECT(invoke_accepted_tag),
                                ROBJECT(metadata_read_tag),
-                               ROBJECT(finished_tag),
-                               NUM2UINT(flags));
+                               ROBJECT(finished_tag), NUM2UINT(flags));
   if (err != GRPC_CALL_OK) {
     rb_raise(rb_eCallError, "invoke failed: %s (code=%d)",
              grpc_call_error_detail_of(err), err);
@@ -329,7 +328,7 @@ static VALUE grpc_rb_call_start_write(int argc, VALUE *argv, VALUE self) {
   /* "21" == 2 mandatory args, 1 (flags) is optional */
   rb_scan_args(argc, argv, "21", &byte_buffer, &tag, &flags);
   if (NIL_P(flags)) {
-    flags = UINT2NUM(0);  /* Default to no flags */
+    flags = UINT2NUM(0); /* Default to no flags */
   }
   bfr = grpc_rb_get_wrapped_byte_buffer(byte_buffer);
   Data_Get_Struct(self, grpc_call, call);
@@ -405,7 +404,7 @@ static VALUE grpc_rb_call_server_end_initial_metadata(int argc, VALUE *argv,
   /* "01" == 1 (flags) is optional */
   rb_scan_args(argc, argv, "01", &flags);
   if (NIL_P(flags)) {
-    flags = UINT2NUM(0);  /* Default to no flags */
+    flags = UINT2NUM(0); /* Default to no flags */
   }
   Data_Get_Struct(self, grpc_call, call);
   err = grpc_call_server_end_initial_metadata(call, NUM2UINT(flags));
@@ -445,7 +444,6 @@ static VALUE grpc_rb_call_server_accept(VALUE self, VALUE cqueue,
   return Qnil;
 }
 
-
 /* rb_cCall is the ruby class that proxies grpc_call. */
 VALUE rb_cCall = Qnil;
 
@@ -477,8 +475,8 @@ void Init_google_rpc_error_codes() {
 
   /* Add the detail strings to a Hash */
   rb_error_code_details = rb_hash_new();
-  rb_hash_aset(rb_error_code_details,
-               UINT2NUM(GRPC_CALL_OK), rb_str_new2("ok"));
+  rb_hash_aset(rb_error_code_details, UINT2NUM(GRPC_CALL_OK),
+               rb_str_new2("ok"));
   rb_hash_aset(rb_error_code_details, UINT2NUM(GRPC_CALL_ERROR),
                rb_str_new2("unknown error"));
   rb_hash_aset(rb_error_code_details, UINT2NUM(GRPC_CALL_ERROR_NOT_ON_SERVER),
@@ -506,8 +504,8 @@ void Init_google_rpc_error_codes() {
 
 void Init_google_rpc_call() {
   /* CallError inherits from Exception to signal that it is non-recoverable */
-  rb_eCallError = rb_define_class_under(rb_mGoogleRpcCore, "CallError",
-                                        rb_eException);
+  rb_eCallError =
+      rb_define_class_under(rb_mGoogleRpcCore, "CallError", rb_eException);
   rb_cCall = rb_define_class_under(rb_mGoogleRpcCore, "Call", rb_cObject);
 
   /* Prevent allocation or inialization of the Call class */
@@ -519,8 +517,7 @@ void Init_google_rpc_call() {
   rb_define_method(rb_cCall, "server_accept", grpc_rb_call_server_accept, 2);
   rb_define_method(rb_cCall, "server_end_initial_metadata",
                    grpc_rb_call_server_end_initial_metadata, -1);
-  rb_define_method(rb_cCall, "add_metadata", grpc_rb_call_add_metadata,
-                   -1);
+  rb_define_method(rb_cCall, "add_metadata", grpc_rb_call_add_metadata, -1);
   rb_define_method(rb_cCall, "cancel", grpc_rb_call_cancel, 0);
   rb_define_method(rb_cCall, "start_invoke", grpc_rb_call_start_invoke, -1);
   rb_define_method(rb_cCall, "start_read", grpc_rb_call_start_read, 1);
@@ -551,25 +548,24 @@ void Init_google_rpc_call() {
 }
 
 /* Gets the call from the ruby object */
-grpc_call* grpc_rb_get_wrapped_call(VALUE v) {
+grpc_call *grpc_rb_get_wrapped_call(VALUE v) {
   grpc_call *c = NULL;
   Data_Get_Struct(v, grpc_call, c);
   return c;
 }
 
 /* Obtains the wrapped object for a given call */
-VALUE grpc_rb_wrap_call(grpc_call* c) {
+VALUE grpc_rb_wrap_call(grpc_call *c) {
   VALUE obj = Qnil;
   if (c == NULL) {
     return Qnil;
   }
   obj = rb_hash_aref(hash_all_calls, OFFT2NUM((VALUE)c));
-  if (obj == Qnil) {  /* Not in the hash add it */
+  if (obj == Qnil) { /* Not in the hash add it */
     rb_hash_aset(hash_all_calls, OFFT2NUM((VALUE)c), UINT2NUM(1));
   } else {
     rb_hash_aset(hash_all_calls, OFFT2NUM((VALUE)c),
                  UINT2NUM(NUM2UINT(obj) + 1));
   }
-  return Data_Wrap_Struct(rb_cCall, GC_NOT_MARKED, grpc_rb_call_destroy,
-                          c);
+  return Data_Wrap_Struct(rb_cCall, GC_NOT_MARKED, grpc_rb_call_destroy, c);
 }
diff --git a/src/ruby/ext/grpc/rb_call.h b/src/ruby/ext/grpc/rb_call.h
index 422e7e7a6c..965e9eef40 100644
--- a/src/ruby/ext/grpc/rb_call.h
+++ b/src/ruby/ext/grpc/rb_call.h
@@ -56,4 +56,4 @@ extern VALUE rb_eCallError;
 /* Initializes the Call class. */
 void Init_google_rpc_call();
 
-#endif  /* GRPC_RB_CALL_H_ */
+#endif /* GRPC_RB_CALL_H_ */
diff --git a/src/ruby/ext/grpc/rb_channel.c b/src/ruby/ext/grpc/rb_channel.c
index d951847662..c0187d2d11 100644
--- a/src/ruby/ext/grpc/rb_channel.c
+++ b/src/ruby/ext/grpc/rb_channel.c
@@ -137,7 +137,7 @@ static VALUE grpc_rb_channel_init(int argc, VALUE *argv, VALUE self) {
     ch = grpc_secure_channel_create(creds, target_chars, &args);
   }
   if (args.args != NULL) {
-    xfree(args.args);   /* Allocated by grpc_rb_hash_convert_to_channel_args */
+    xfree(args.args); /* Allocated by grpc_rb_hash_convert_to_channel_args */
   }
   if (ch == NULL) {
     rb_raise(rb_eRuntimeError, "could not create an rpc channel to target:%s",
@@ -256,7 +256,7 @@ void Init_google_rpc_channel() {
 }
 
 /* Gets the wrapped channel from the ruby wrapper */
-grpc_channel* grpc_rb_get_wrapped_channel(VALUE v) {
+grpc_channel *grpc_rb_get_wrapped_channel(VALUE v) {
   grpc_rb_channel *wrapper = NULL;
   Data_Get_Struct(v, grpc_rb_channel, wrapper);
   return wrapper->wrapped;
diff --git a/src/ruby/ext/grpc/rb_channel.h b/src/ruby/ext/grpc/rb_channel.h
index b0a3634474..6c1210e812 100644
--- a/src/ruby/ext/grpc/rb_channel.h
+++ b/src/ruby/ext/grpc/rb_channel.h
@@ -46,4 +46,4 @@ void Init_google_rpc_channel();
 /* Gets the wrapped channel from the ruby wrapper */
 grpc_channel* grpc_rb_get_wrapped_channel(VALUE v);
 
-#endif  /* GRPC_RB_CHANNEL_H_ */
+#endif /* GRPC_RB_CHANNEL_H_ */
diff --git a/src/ruby/ext/grpc/rb_channel_args.c b/src/ruby/ext/grpc/rb_channel_args.c
index eebced0bd8..b918e1264e 100644
--- a/src/ruby/ext/grpc/rb_channel_args.c
+++ b/src/ruby/ext/grpc/rb_channel_args.c
@@ -46,7 +46,6 @@ static int grpc_rb_channel_create_in_process_add_args_hash_cb(VALUE key,
   grpc_channel_args* args;
 
   switch (TYPE(key)) {
-
     case T_STRING:
       the_key = StringValuePtr(key);
       break;
@@ -68,13 +67,12 @@ static int grpc_rb_channel_create_in_process_add_args_hash_cb(VALUE key,
     return ST_STOP;
   }
 
-  args->args[args->num_args - 1].key = (char *)the_key;
+  args->args[args->num_args - 1].key = (char*)the_key;
   switch (TYPE(val)) {
-
     case T_SYMBOL:
       args->args[args->num_args - 1].type = GRPC_ARG_STRING;
       args->args[args->num_args - 1].value.string =
-          (char *)rb_id2name(SYM2ID(val));
+          (char*)rb_id2name(SYM2ID(val));
       --args->num_args;
       return ST_CONTINUE;
 
@@ -109,11 +107,10 @@ typedef struct channel_convert_params {
   grpc_channel_args* dst;
 } channel_convert_params;
 
-
 static VALUE grpc_rb_hash_convert_to_channel_args0(VALUE as_value) {
   ID id_size = rb_intern("size");
   VALUE rb_cChannelArgs = rb_define_class("TmpChannelArgs", rb_cObject);
-  channel_convert_params* params = (channel_convert_params *)as_value;
+  channel_convert_params* params = (channel_convert_params*)as_value;
   size_t num_args = 0;
 
   if (!NIL_P(params->src_hash) && TYPE(params->src_hash) != T_HASH) {
@@ -146,7 +143,7 @@ void grpc_rb_hash_convert_to_channel_args(VALUE src_hash,
   /* Make a protected call to grpc_rb_hash_convert_channel_args */
   params.src_hash = src_hash;
   params.dst = dst;
-  rb_protect(grpc_rb_hash_convert_to_channel_args0, (VALUE) &params, &status);
+  rb_protect(grpc_rb_hash_convert_to_channel_args0, (VALUE)&params, &status);
   if (status != 0) {
     if (dst->args != NULL) {
       /* Free any allocated memory before propagating the error */
diff --git a/src/ruby/ext/grpc/rb_channel_args.h b/src/ruby/ext/grpc/rb_channel_args.h
index bbff017c1e..07be662793 100644
--- a/src/ruby/ext/grpc/rb_channel_args.h
+++ b/src/ruby/ext/grpc/rb_channel_args.h
@@ -49,5 +49,4 @@
 void grpc_rb_hash_convert_to_channel_args(VALUE src_hash,
                                           grpc_channel_args* dst);
 
-
-#endif  /* GRPC_RB_CHANNEL_ARGS_H_ */
+#endif /* GRPC_RB_CHANNEL_ARGS_H_ */
diff --git a/src/ruby/ext/grpc/rb_completion_queue.c b/src/ruby/ext/grpc/rb_completion_queue.c
index dc95838ef5..c1b74e2606 100644
--- a/src/ruby/ext/grpc/rb_completion_queue.c
+++ b/src/ruby/ext/grpc/rb_completion_queue.c
@@ -45,33 +45,28 @@ typedef struct next_call_stack {
   grpc_completion_queue *cq;
   grpc_event *event;
   gpr_timespec timeout;
-  void* tag;
+  void *tag;
 } next_call_stack;
 
 /* Calls grpc_completion_queue_next without holding the ruby GIL */
-static void *grpc_rb_completion_queue_next_no_gil(
-    next_call_stack *next_call) {
-  next_call->event = grpc_completion_queue_next(next_call->cq,
-                                                next_call->timeout);
+static void *grpc_rb_completion_queue_next_no_gil(next_call_stack *next_call) {
+  next_call->event =
+      grpc_completion_queue_next(next_call->cq, next_call->timeout);
   return NULL;
 }
 
 /* Calls grpc_completion_queue_pluck without holding the ruby GIL */
-static void *grpc_rb_completion_queue_pluck_no_gil(
-    next_call_stack *next_call) {
-  next_call->event = grpc_completion_queue_pluck(next_call->cq,
-                                                 next_call->tag,
+static void *grpc_rb_completion_queue_pluck_no_gil(next_call_stack *next_call) {
+  next_call->event = grpc_completion_queue_pluck(next_call->cq, next_call->tag,
                                                  next_call->timeout);
   return NULL;
 }
 
-
 /* Shuts down and drains the completion queue if necessary.
  *
  * This is done when the ruby completion queue object is about to be GCed.
  */
-static void grpc_rb_completion_queue_shutdown_drain(
-    grpc_completion_queue* cq) {
+static void grpc_rb_completion_queue_shutdown_drain(grpc_completion_queue *cq) {
   next_call_stack next_call;
   grpc_completion_type type;
   int drained = 0;
@@ -120,13 +115,12 @@ static void grpc_rb_completion_queue_destroy(void *p) {
 
 /* Allocates a completion queue. */
 static VALUE grpc_rb_completion_queue_alloc(VALUE cls) {
-  grpc_completion_queue* cq = grpc_completion_queue_create();
+  grpc_completion_queue *cq = grpc_completion_queue_create();
   if (cq == NULL) {
-    rb_raise(rb_eArgError,
-             "could not create a completion queue: not sure why");
+    rb_raise(rb_eArgError, "could not create a completion queue: not sure why");
   }
-  return Data_Wrap_Struct(cls, GC_NOT_MARKED,
-                          grpc_rb_completion_queue_destroy, cq);
+  return Data_Wrap_Struct(cls, GC_NOT_MARKED, grpc_rb_completion_queue_destroy,
+                          cq);
 }
 
 /* Blocks until the next event is available, and returns the event. */
@@ -166,9 +160,8 @@ static VALUE grpc_rb_completion_queue_pluck(VALUE self, VALUE tag,
 VALUE rb_cCompletionQueue = Qnil;
 
 void Init_google_rpc_completion_queue() {
-  rb_cCompletionQueue = rb_define_class_under(rb_mGoogleRpcCore,
-                                              "CompletionQueue",
-                                              rb_cObject);
+  rb_cCompletionQueue =
+      rb_define_class_under(rb_mGoogleRpcCore, "CompletionQueue", rb_cObject);
 
   /* constructor: uses an alloc func without an initializer. Using a simple
      alloc func works here as the grpc header does not specify any args for
@@ -176,16 +169,16 @@ void Init_google_rpc_completion_queue() {
   rb_define_alloc_func(rb_cCompletionQueue, grpc_rb_completion_queue_alloc);
 
   /* Add the next method that waits for the next event. */
-  rb_define_method(rb_cCompletionQueue, "next",
-                   grpc_rb_completion_queue_next, 1);
+  rb_define_method(rb_cCompletionQueue, "next", grpc_rb_completion_queue_next,
+                   1);
 
   /* Add the pluck method that waits for the next event of given tag */
-  rb_define_method(rb_cCompletionQueue, "pluck",
-                   grpc_rb_completion_queue_pluck, 2);
+  rb_define_method(rb_cCompletionQueue, "pluck", grpc_rb_completion_queue_pluck,
+                   2);
 }
 
 /* Gets the wrapped completion queue from the ruby wrapper */
-grpc_completion_queue* grpc_rb_get_wrapped_completion_queue(VALUE v) {
+grpc_completion_queue *grpc_rb_get_wrapped_completion_queue(VALUE v) {
   grpc_completion_queue *cq = NULL;
   Data_Get_Struct(v, grpc_completion_queue, cq);
   return cq;
diff --git a/src/ruby/ext/grpc/rb_completion_queue.h b/src/ruby/ext/grpc/rb_completion_queue.h
index 1ec2718ed4..c563662c2d 100644
--- a/src/ruby/ext/grpc/rb_completion_queue.h
+++ b/src/ruby/ext/grpc/rb_completion_queue.h
@@ -47,4 +47,4 @@ extern VALUE rb_cCompletionQueue;
 /* Initializes the CompletionQueue class. */
 void Init_google_rpc_completion_queue();
 
-#endif  /* GRPC_RB_COMPLETION_QUEUE_H_ */
+#endif /* GRPC_RB_COMPLETION_QUEUE_H_ */
diff --git a/src/ruby/ext/grpc/rb_credentials.c b/src/ruby/ext/grpc/rb_credentials.c
index 658adacc06..5dec51824d 100644
--- a/src/ruby/ext/grpc/rb_credentials.c
+++ b/src/ruby/ext/grpc/rb_credentials.c
@@ -40,7 +40,6 @@
 
 #include "rb_grpc.h"
 
-
 /* grpc_rb_credentials wraps a grpc_credentials.  It provides a
  * peer ruby object, 'mark' to minimize copying when a credential is
  * created from ruby. */
@@ -92,8 +91,7 @@ static VALUE grpc_rb_credentials_alloc(VALUE cls) {
   wrapper->wrapped = NULL;
   wrapper->mark = Qnil;
   return Data_Wrap_Struct(cls, grpc_rb_credentials_mark,
-                          grpc_rb_credentials_free,
-                          wrapper);
+                          grpc_rb_credentials_free, wrapper);
 }
 
 /* Clones Credentials instances.
@@ -111,8 +109,7 @@ static VALUE grpc_rb_credentials_init_copy(VALUE copy, VALUE orig) {
   /* Raise an error if orig is not a credentials object or a subclass. */
   if (TYPE(orig) != T_DATA ||
       RDATA(orig)->dfree != (RUBY_DATA_FUNC)grpc_rb_credentials_free) {
-    rb_raise(rb_eTypeError, "not a %s",
-             rb_obj_classname(rb_cCredentials));
+    rb_raise(rb_eTypeError, "not a %s", rb_obj_classname(rb_cCredentials));
   }
 
   Data_Get_Struct(orig, grpc_rb_credentials, orig_cred);
@@ -238,14 +235,12 @@ static VALUE grpc_rb_credentials_init(int argc, VALUE *argv, VALUE self) {
         RSTRING_PTR(pem_cert_chain), RSTRING_LEN(pem_cert_chain));
   } else if (pem_private_key == Qnil) {
     creds = grpc_ssl_credentials_create(
-        RSTRING_PTR(pem_root_certs), RSTRING_LEN(pem_root_certs),
-        NULL, 0,
+        RSTRING_PTR(pem_root_certs), RSTRING_LEN(pem_root_certs), NULL, 0,
         RSTRING_PTR(pem_cert_chain), RSTRING_LEN(pem_cert_chain));
   } else {
     creds = grpc_ssl_credentials_create(
         RSTRING_PTR(pem_root_certs), RSTRING_LEN(pem_root_certs),
-        RSTRING_PTR(pem_private_key), RSTRING_LEN(pem_private_key),
-        NULL, 0);
+        RSTRING_PTR(pem_private_key), RSTRING_LEN(pem_private_key), NULL, 0);
   }
   if (creds == NULL) {
     rb_raise(rb_eRuntimeError, "could not create a credentials, not sure why");
@@ -265,15 +260,14 @@ static VALUE grpc_rb_credentials_init(int argc, VALUE *argv, VALUE self) {
 VALUE rb_cCredentials = Qnil;
 
 void Init_google_rpc_credentials() {
-  rb_cCredentials = rb_define_class_under(rb_mGoogleRpcCore, "Credentials",
-                                          rb_cObject);
+  rb_cCredentials =
+      rb_define_class_under(rb_mGoogleRpcCore, "Credentials", rb_cObject);
 
   /* Allocates an object managed by the ruby runtime */
   rb_define_alloc_func(rb_cCredentials, grpc_rb_credentials_alloc);
 
   /* Provides a ruby constructor and support for dup/clone. */
-  rb_define_method(rb_cCredentials, "initialize",
-                   grpc_rb_credentials_init, -1);
+  rb_define_method(rb_cCredentials, "initialize", grpc_rb_credentials_init, -1);
   rb_define_method(rb_cCredentials, "initialize_copy",
                    grpc_rb_credentials_init_copy, 1);
 
@@ -294,7 +288,7 @@ void Init_google_rpc_credentials() {
 }
 
 /* Gets the wrapped grpc_credentials from the ruby wrapper */
-grpc_credentials* grpc_rb_get_wrapped_credentials(VALUE v) {
+grpc_credentials *grpc_rb_get_wrapped_credentials(VALUE v) {
   grpc_rb_credentials *wrapper = NULL;
   Data_Get_Struct(v, grpc_rb_credentials, wrapper);
   return wrapper->wrapped;
diff --git a/src/ruby/ext/grpc/rb_credentials.h b/src/ruby/ext/grpc/rb_credentials.h
index d18c88ac34..fada3639d5 100644
--- a/src/ruby/ext/grpc/rb_credentials.h
+++ b/src/ruby/ext/grpc/rb_credentials.h
@@ -47,4 +47,4 @@ void Init_google_rpc_credentials();
 /* Gets the wrapped credentials from the ruby wrapper */
 grpc_credentials* grpc_rb_get_wrapped_credentials(VALUE v);
 
-#endif  /* GRPC_RB_CREDENTIALS_H_ */
+#endif /* GRPC_RB_CREDENTIALS_H_ */
diff --git a/src/ruby/ext/grpc/rb_event.c b/src/ruby/ext/grpc/rb_event.c
index 9200f923cc..0fae9502c3 100644
--- a/src/ruby/ext/grpc/rb_event.c
+++ b/src/ruby/ext/grpc/rb_event.c
@@ -50,7 +50,6 @@ typedef struct grpc_rb_event {
   grpc_event *wrapped;
 } grpc_rb_event;
 
-
 /* rb_mCompletionType is a ruby module that holds the completion type values */
 VALUE rb_mCompletionType = Qnil;
 
@@ -107,15 +106,15 @@ static VALUE grpc_rb_event_type(VALUE self) {
       return rb_const_get(rb_mCompletionType, rb_intern("READ"));
 
     case GRPC_INVOKE_ACCEPTED:
-      grpc_rb_event_result(self);  /* validates the result */
+      grpc_rb_event_result(self); /* validates the result */
       return rb_const_get(rb_mCompletionType, rb_intern("INVOKE_ACCEPTED"));
 
     case GRPC_WRITE_ACCEPTED:
-      grpc_rb_event_result(self);  /* validates the result */
+      grpc_rb_event_result(self); /* validates the result */
       return rb_const_get(rb_mCompletionType, rb_intern("WRITE_ACCEPTED"));
 
     case GRPC_FINISH_ACCEPTED:
-      grpc_rb_event_result(self);  /* validates the result */
+      grpc_rb_event_result(self); /* validates the result */
       return rb_const_get(rb_mCompletionType, rb_intern("FINISH_ACCEPTED"));
 
     case GRPC_CLIENT_METADATA_READ:
@@ -129,8 +128,8 @@ static VALUE grpc_rb_event_type(VALUE self) {
       return rb_const_get(rb_mCompletionType, rb_intern("SERVER_RPC_NEW"));
 
     default:
-      rb_raise(rb_eRuntimeError,
-               "unrecognized event code for an rpc event:%d", event->type);
+      rb_raise(rb_eRuntimeError, "unrecognized event code for an rpc event:%d",
+               event->type);
   }
   return Qnil; /* should not be reached */
 }
@@ -189,7 +188,6 @@ static VALUE grpc_rb_event_metadata(VALUE self) {
   /* Figure out which metadata to read. */
   event = wrapper->wrapped;
   switch (event->type) {
-
     case GRPC_CLIENT_METADATA_READ:
       count = event->data.client_metadata_read.count;
       metadata = event->data.client_metadata_read.elements;
@@ -218,22 +216,18 @@ static VALUE grpc_rb_event_metadata(VALUE self) {
     key = rb_str_new2(metadata[i].key);
     value = rb_hash_aref(result, key);
     if (value == Qnil) {
-      value = rb_str_new(
-          metadata[i].value,
-          metadata[i].value_length);
+      value = rb_str_new(metadata[i].value, metadata[i].value_length);
       rb_hash_aset(result, key, value);
     } else if (TYPE(value) == T_ARRAY) {
       /* Add the string to the returned array */
-      rb_ary_push(value, rb_str_new(
-          metadata[i].value,
-          metadata[i].value_length));
+      rb_ary_push(value,
+                  rb_str_new(metadata[i].value, metadata[i].value_length));
     } else {
       /* Add the current value with this key and the new one to an array */
       new_ary = rb_ary_new();
       rb_ary_push(new_ary, value);
-      rb_ary_push(new_ary, rb_str_new(
-          metadata[i].value,
-          metadata[i].value_length));
+      rb_ary_push(new_ary,
+                  rb_str_new(metadata[i].value, metadata[i].value_length));
       rb_hash_aset(result, key, new_ary);
     }
   }
@@ -252,7 +246,6 @@ static VALUE grpc_rb_event_result(VALUE self) {
   event = wrapper->wrapped;
 
   switch (event->type) {
-
     case GRPC_QUEUE_SHUTDOWN:
       return Qnil;
 
@@ -287,29 +280,24 @@ static VALUE grpc_rb_event_result(VALUE self) {
       return grpc_rb_event_metadata(self);
 
     case GRPC_FINISHED:
-      return rb_struct_new(
-          rb_sStatus,
-          UINT2NUM(event->data.finished.status),
-          (event->data.finished.details == NULL ?
-           Qnil : rb_str_new2(event->data.finished.details)),
-          grpc_rb_event_metadata(self),
-          NULL);
+      return rb_struct_new(rb_sStatus, UINT2NUM(event->data.finished.status),
+                           (event->data.finished.details == NULL
+                                ? Qnil
+                                : rb_str_new2(event->data.finished.details)),
+                           grpc_rb_event_metadata(self), NULL);
       break;
 
     case GRPC_SERVER_RPC_NEW:
       return rb_struct_new(
-          rb_sNewServerRpc,
-          rb_str_new2(event->data.server_rpc_new.method),
+          rb_sNewServerRpc, rb_str_new2(event->data.server_rpc_new.method),
           rb_str_new2(event->data.server_rpc_new.host),
-          Data_Wrap_Struct(
-              rb_cTimeVal, GC_NOT_MARKED, GC_DONT_FREE,
-              (void *)&event->data.server_rpc_new.deadline),
-          grpc_rb_event_metadata(self),
-          NULL);
+          Data_Wrap_Struct(rb_cTimeVal, GC_NOT_MARKED, GC_DONT_FREE,
+                           (void *)&event->data.server_rpc_new.deadline),
+          grpc_rb_event_metadata(self), NULL);
 
     default:
-      rb_raise(rb_eRuntimeError,
-               "unrecognized event code for an rpc event:%d", event->type);
+      rb_raise(rb_eRuntimeError, "unrecognized event code for an rpc event:%d",
+               event->type);
   }
 
   return Qfalse;
@@ -319,7 +307,7 @@ static VALUE grpc_rb_event_finish(VALUE self) {
   grpc_event *event = NULL;
   grpc_rb_event *wrapper = NULL;
   Data_Get_Struct(self, grpc_rb_event, wrapper);
-  if (wrapper->wrapped == NULL) {  /* already closed  */
+  if (wrapper->wrapped == NULL) { /* already closed  */
     return Qnil;
   }
   event = wrapper->wrapped;
@@ -337,8 +325,8 @@ VALUE rb_cEvent = Qnil;
 VALUE rb_eEventError = Qnil;
 
 void Init_google_rpc_event() {
-  rb_eEventError = rb_define_class_under(rb_mGoogleRpcCore, "EventError",
-                                         rb_eStandardError);
+  rb_eEventError =
+      rb_define_class_under(rb_mGoogleRpcCore, "EventError", rb_eStandardError);
   rb_cEvent = rb_define_class_under(rb_mGoogleRpcCore, "Event", rb_cObject);
 
   /* Prevent allocation or inialization from ruby. */
@@ -355,8 +343,8 @@ void Init_google_rpc_event() {
   rb_define_alias(rb_cEvent, "close", "finish");
 
   /* Constants representing the completion types */
-  rb_mCompletionType = rb_define_module_under(rb_mGoogleRpcCore,
-                                              "CompletionType");
+  rb_mCompletionType =
+      rb_define_module_under(rb_mGoogleRpcCore, "CompletionType");
   rb_define_const(rb_mCompletionType, "QUEUE_SHUTDOWN",
                   INT2NUM(GRPC_QUEUE_SHUTDOWN));
   rb_define_const(rb_mCompletionType, "READ", INT2NUM(GRPC_READ));
@@ -368,8 +356,7 @@ void Init_google_rpc_event() {
                   INT2NUM(GRPC_FINISH_ACCEPTED));
   rb_define_const(rb_mCompletionType, "CLIENT_METADATA_READ",
                   INT2NUM(GRPC_CLIENT_METADATA_READ));
-  rb_define_const(rb_mCompletionType, "FINISHED",
-                  INT2NUM(GRPC_FINISHED));
+  rb_define_const(rb_mCompletionType, "FINISHED", INT2NUM(GRPC_FINISHED));
   rb_define_const(rb_mCompletionType, "SERVER_RPC_NEW",
                   INT2NUM(GRPC_SERVER_RPC_NEW));
   rb_define_const(rb_mCompletionType, "RESERVED",
diff --git a/src/ruby/ext/grpc/rb_event.h b/src/ruby/ext/grpc/rb_event.h
index e4e4a796c2..a406e9e9f1 100644
--- a/src/ruby/ext/grpc/rb_event.h
+++ b/src/ruby/ext/grpc/rb_event.h
@@ -50,4 +50,4 @@ VALUE grpc_rb_new_event(grpc_event *ev);
 /* Initializes the Event and EventError classes. */
 void Init_google_rpc_event();
 
-#endif  /* GRPC_RB_EVENT_H_ */
+#endif /* GRPC_RB_EVENT_H_ */
diff --git a/src/ruby/ext/grpc/rb_grpc.c b/src/ruby/ext/grpc/rb_grpc.c
index eae011d33b..8feefb047c 100644
--- a/src/ruby/ext/grpc/rb_grpc.c
+++ b/src/ruby/ext/grpc/rb_grpc.c
@@ -98,18 +98,16 @@ gpr_timespec grpc_rb_time_timeval(VALUE time, int interval) {
   const char *want = " want <secs from epoch>|<Time>|<GRPC::TimeConst.*>";
 
   switch (TYPE(time)) {
-
     case T_DATA:
       if (CLASS_OF(time) == rb_cTimeVal) {
         Data_Get_Struct(time, gpr_timespec, time_const);
         t = *time_const;
       } else if (CLASS_OF(time) == rb_cTime) {
-        t.tv_sec =  NUM2INT(rb_funcall(time, id_tv_sec, 0));
+        t.tv_sec = NUM2INT(rb_funcall(time, id_tv_sec, 0));
         t.tv_nsec = NUM2INT(rb_funcall(time, id_tv_nsec, 0));
       } else {
-        rb_raise(rb_eTypeError,
-                 "bad input: (%s)->c_timeval, got <%s>,%s",
-                 tstr, rb_obj_classname(time), want);
+        rb_raise(rb_eTypeError, "bad input: (%s)->c_timeval, got <%s>,%s", tstr,
+                 rb_obj_classname(time), want);
       }
       break;
 
@@ -136,7 +134,7 @@ gpr_timespec grpc_rb_time_timeval(VALUE time, int interval) {
           rb_raise(rb_eRangeError, "%f out of Time range",
                    RFLOAT(time)->float_value);
         }
-        t.tv_nsec = (time_t)(d*1e9+0.5);
+        t.tv_nsec = (time_t)(d * 1e9 + 0.5);
       }
       break;
 
@@ -148,9 +146,8 @@ gpr_timespec grpc_rb_time_timeval(VALUE time, int interval) {
       break;
 
     default:
-      rb_raise(rb_eTypeError,
-               "bad input: (%s)->c_timeval, got <%s>,%s",
-               tstr, rb_obj_classname(time), want);
+      rb_raise(rb_eTypeError, "bad input: (%s)->c_timeval, got <%s>,%s", tstr,
+               rb_obj_classname(time), want);
       break;
   }
   return t;
@@ -158,8 +155,8 @@ gpr_timespec grpc_rb_time_timeval(VALUE time, int interval) {
 
 void Init_google_status_codes() {
   /* Constants representing the status codes or grpc_status_code in status.h */
-  VALUE rb_mStatusCodes = rb_define_module_under(rb_mGoogleRpcCore,
-                                                 "StatusCodes");
+  VALUE rb_mStatusCodes =
+      rb_define_module_under(rb_mGoogleRpcCore, "StatusCodes");
   rb_define_const(rb_mStatusCodes, "OK", INT2NUM(GRPC_STATUS_OK));
   rb_define_const(rb_mStatusCodes, "CANCELLED", INT2NUM(GRPC_STATUS_CANCELLED));
   rb_define_const(rb_mStatusCodes, "UNKNOWN", INT2NUM(GRPC_STATUS_UNKNOWN));
@@ -218,19 +215,19 @@ VALUE grpc_rb_time_val_to_s(VALUE self) {
 
 /* Adds a module with constants that map to gpr's static timeval structs. */
 void Init_google_time_consts() {
-  VALUE rb_mTimeConsts = rb_define_module_under(rb_mGoogleRpcCore,
-                                                "TimeConsts");
-  rb_cTimeVal = rb_define_class_under(rb_mGoogleRpcCore, "TimeSpec",
-                                      rb_cObject);
+  VALUE rb_mTimeConsts =
+      rb_define_module_under(rb_mGoogleRpcCore, "TimeConsts");
+  rb_cTimeVal =
+      rb_define_class_under(rb_mGoogleRpcCore, "TimeSpec", rb_cObject);
   rb_define_const(rb_mTimeConsts, "ZERO",
-                  Data_Wrap_Struct(rb_cTimeVal, GC_NOT_MARKED,
-                                   GC_DONT_FREE, (void *)&gpr_time_0));
+                  Data_Wrap_Struct(rb_cTimeVal, GC_NOT_MARKED, GC_DONT_FREE,
+                                   (void *)&gpr_time_0));
   rb_define_const(rb_mTimeConsts, "INFINITE_FUTURE",
-                  Data_Wrap_Struct(rb_cTimeVal, GC_NOT_MARKED,
-                                   GC_DONT_FREE, (void *)&gpr_inf_future));
+                  Data_Wrap_Struct(rb_cTimeVal, GC_NOT_MARKED, GC_DONT_FREE,
+                                   (void *)&gpr_inf_future));
   rb_define_const(rb_mTimeConsts, "INFINITE_PAST",
-                  Data_Wrap_Struct(rb_cTimeVal, GC_NOT_MARKED,
-                                   GC_DONT_FREE, (void *)&gpr_inf_past));
+                  Data_Wrap_Struct(rb_cTimeVal, GC_NOT_MARKED, GC_DONT_FREE,
+                                   (void *)&gpr_inf_past));
   rb_define_method(rb_cTimeVal, "to_time", grpc_rb_time_val_to_time, 0);
   rb_define_method(rb_cTimeVal, "inspect", grpc_rb_time_val_inspect, 0);
   rb_define_method(rb_cTimeVal, "to_s", grpc_rb_time_val_to_s, 0);
@@ -241,9 +238,7 @@ void Init_google_time_consts() {
   id_tv_nsec = rb_intern("tv_nsec");
 }
 
-void grpc_rb_shutdown(void *vm) {
-  grpc_shutdown();
-}
+void grpc_rb_shutdown(void *vm) { grpc_shutdown(); }
 
 /* Initialize the Google RPC module structs */
 
diff --git a/src/ruby/ext/grpc/rb_grpc.h b/src/ruby/ext/grpc/rb_grpc.h
index c2c894244f..d5e8930fca 100644
--- a/src/ruby/ext/grpc/rb_grpc.h
+++ b/src/ruby/ext/grpc/rb_grpc.h
@@ -74,4 +74,4 @@ VALUE grpc_rb_cannot_init_copy(VALUE copy, VALUE self);
 /* grpc_rb_time_timeval creates a gpr_timespec from a ruby time object. */
 gpr_timespec grpc_rb_time_timeval(VALUE time, int interval);
 
-#endif  /* GRPC_RB_H_ */
+#endif /* GRPC_RB_H_ */
diff --git a/src/ruby/ext/grpc/rb_metadata.c b/src/ruby/ext/grpc/rb_metadata.c
index dcacc4a976..88eb62ab73 100644
--- a/src/ruby/ext/grpc/rb_metadata.c
+++ b/src/ruby/ext/grpc/rb_metadata.c
@@ -48,7 +48,6 @@ typedef struct grpc_rb_metadata {
   grpc_metadata *wrapped;
 } grpc_rb_metadata;
 
-
 /* Destroys Metadata instances. */
 static void grpc_rb_metadata_free(void *p) {
   if (p == NULL) {
@@ -102,7 +101,7 @@ static VALUE grpc_rb_metadata_init(VALUE self, VALUE key, VALUE value) {
   wrapper->wrapped = md;
   if (TYPE(key) == T_SYMBOL) {
     md->key = (char *)rb_id2name(SYM2ID(key));
-  } else {  /* StringValueCStr does all other type exclusions for us */
+  } else { /* StringValueCStr does all other type exclusions for us */
     md->key = StringValueCStr(key);
   }
   md->value = RSTRING_PTR(value);
@@ -189,8 +188,8 @@ static VALUE grpc_rb_metadata_value(VALUE self) {
 /* rb_cMetadata is the Metadata class whose instances proxy grpc_metadata. */
 VALUE rb_cMetadata = Qnil;
 void Init_google_rpc_metadata() {
-  rb_cMetadata = rb_define_class_under(rb_mGoogleRpcCore, "Metadata",
-                                       rb_cObject);
+  rb_cMetadata =
+      rb_define_class_under(rb_mGoogleRpcCore, "Metadata", rb_cObject);
 
   /* Allocates an object managed by the ruby runtime */
   rb_define_alloc_func(rb_cMetadata, grpc_rb_metadata_alloc);
@@ -209,7 +208,7 @@ void Init_google_rpc_metadata() {
 }
 
 /* Gets the wrapped metadata from the ruby wrapper */
-grpc_metadata* grpc_rb_get_wrapped_metadata(VALUE v) {
+grpc_metadata *grpc_rb_get_wrapped_metadata(VALUE v) {
   grpc_rb_metadata *wrapper = NULL;
   Data_Get_Struct(v, grpc_rb_metadata, wrapper);
   return wrapper->wrapped;
diff --git a/src/ruby/ext/grpc/rb_metadata.h b/src/ruby/ext/grpc/rb_metadata.h
index 6b705914d6..329ef15c68 100644
--- a/src/ruby/ext/grpc/rb_metadata.h
+++ b/src/ruby/ext/grpc/rb_metadata.h
@@ -42,7 +42,7 @@ extern VALUE rb_cMetadata;
 
 /* grpc_rb_metadata_create_with_mark creates a grpc_rb_metadata with a ruby mark
  * object that will be kept alive while the metadata is alive. */
-extern VALUE grpc_rb_metadata_create_with_mark(VALUE mark, grpc_metadata *md);
+extern VALUE grpc_rb_metadata_create_with_mark(VALUE mark, grpc_metadata* md);
 
 /* Gets the wrapped metadata from the ruby wrapper */
 grpc_metadata* grpc_rb_get_wrapped_metadata(VALUE v);
@@ -50,4 +50,4 @@ grpc_metadata* grpc_rb_get_wrapped_metadata(VALUE v);
 /* Initializes the Metadata class. */
 void Init_google_rpc_metadata();
 
-#endif  /* GRPC_RB_METADATA_H_ */
+#endif /* GRPC_RB_METADATA_H_ */
diff --git a/src/ruby/ext/grpc/rb_server.c b/src/ruby/ext/grpc/rb_server.c
index 84fba5be4f..ef2a9f107b 100644
--- a/src/ruby/ext/grpc/rb_server.c
+++ b/src/ruby/ext/grpc/rb_server.c
@@ -128,7 +128,7 @@ static VALUE grpc_rb_server_init(int argc, VALUE *argv, VALUE self) {
   }
 
   if (args.args != NULL) {
-    xfree(args.args);  /* Allocated by grpc_rb_hash_convert_to_channel_args */
+    xfree(args.args); /* Allocated by grpc_rb_hash_convert_to_channel_args */
   }
   if (srv == NULL) {
     rb_raise(rb_eRuntimeError, "could not create a gRPC server, not sure why");
@@ -240,8 +240,8 @@ static VALUE grpc_rb_server_add_http2_port(int argc, VALUE *argv, VALUE self) {
                StringValueCStr(port));
     }
   } else if (TYPE(is_secure) != T_FALSE) {
-    added_ok = grpc_server_add_secure_http2_port(s->wrapped,
-                                                 StringValueCStr(port));
+    added_ok =
+        grpc_server_add_secure_http2_port(s->wrapped, StringValueCStr(port));
     if (added_ok == 0) {
       rb_raise(rb_eRuntimeError,
                "could not add secure port %s to server, not sure why",
@@ -271,7 +271,7 @@ void Init_google_rpc_server() {
 }
 
 /* Gets the wrapped server from the ruby wrapper */
-grpc_server* grpc_rb_get_wrapped_server(VALUE v) {
+grpc_server *grpc_rb_get_wrapped_server(VALUE v) {
   grpc_rb_server *wrapper = NULL;
   Data_Get_Struct(v, grpc_rb_server, wrapper);
   return wrapper->wrapped;
diff --git a/src/ruby/ext/grpc/rb_server.h b/src/ruby/ext/grpc/rb_server.h
index 7fcd32c32f..92047efd18 100644
--- a/src/ruby/ext/grpc/rb_server.h
+++ b/src/ruby/ext/grpc/rb_server.h
@@ -47,4 +47,4 @@ void Init_google_rpc_server();
 /* Gets the wrapped server from the ruby wrapper */
 grpc_server* grpc_rb_get_wrapped_server(VALUE v);
 
-#endif  /* GRPC_RB_SERVER_H_ */
+#endif /* GRPC_RB_SERVER_H_ */
diff --git a/src/ruby/ext/grpc/rb_server_credentials.c b/src/ruby/ext/grpc/rb_server_credentials.c
index fa0d6f2ce8..e534c11444 100644
--- a/src/ruby/ext/grpc/rb_server_credentials.c
+++ b/src/ruby/ext/grpc/rb_server_credentials.c
@@ -40,7 +40,6 @@
 
 #include "rb_grpc.h"
 
-
 /* grpc_rb_server_credentials wraps a grpc_server_credentials.  It provides a
    peer ruby object, 'mark' to minimize copying when a server credential is
    created from ruby. */
@@ -91,8 +90,7 @@ static VALUE grpc_rb_server_credentials_alloc(VALUE cls) {
   wrapper->wrapped = NULL;
   wrapper->mark = Qnil;
   return Data_Wrap_Struct(cls, grpc_rb_server_credentials_mark,
-                          grpc_rb_server_credentials_free,
-                          wrapper);
+                          grpc_rb_server_credentials_free, wrapper);
 }
 
 /* Clones ServerCredentials instances.
@@ -123,7 +121,6 @@ static VALUE grpc_rb_server_credentials_init_copy(VALUE copy, VALUE orig) {
   return copy;
 }
 
-
 /* The attribute used on the mark object to hold the pem_root_certs. */
 static ID id_pem_root_certs;
 
@@ -188,9 +185,8 @@ static VALUE grpc_rb_server_credentials_init(VALUE self, VALUE pem_root_certs,
 VALUE rb_cServerCredentials = Qnil;
 
 void Init_google_rpc_server_credentials() {
-  rb_cServerCredentials = rb_define_class_under(rb_mGoogleRpcCore,
-                                                "ServerCredentials",
-                                                rb_cObject);
+  rb_cServerCredentials =
+      rb_define_class_under(rb_mGoogleRpcCore, "ServerCredentials", rb_cObject);
 
   /* Allocates an object managed by the ruby runtime */
   rb_define_alloc_func(rb_cServerCredentials, grpc_rb_server_credentials_alloc);
@@ -199,8 +195,7 @@ void Init_google_rpc_server_credentials() {
   rb_define_method(rb_cServerCredentials, "initialize",
                    grpc_rb_server_credentials_init, 3);
   rb_define_method(rb_cServerCredentials, "initialize_copy",
-                   grpc_rb_server_credentials_init_copy,
-                   1);
+                   grpc_rb_server_credentials_init_copy, 1);
 
   id_pem_cert_chain = rb_intern("__pem_cert_chain");
   id_pem_private_key = rb_intern("__pem_private_key");
@@ -208,7 +203,7 @@ void Init_google_rpc_server_credentials() {
 }
 
 /* Gets the wrapped grpc_server_credentials from the ruby wrapper */
-grpc_server_credentials* grpc_rb_get_wrapped_server_credentials(VALUE v) {
+grpc_server_credentials *grpc_rb_get_wrapped_server_credentials(VALUE v) {
   grpc_rb_server_credentials *wrapper = NULL;
   Data_Get_Struct(v, grpc_rb_server_credentials, wrapper);
   return wrapper->wrapped;
diff --git a/src/ruby/ext/grpc/rb_server_credentials.h b/src/ruby/ext/grpc/rb_server_credentials.h
index 39189511ab..2a2e1fbc82 100644
--- a/src/ruby/ext/grpc/rb_server_credentials.h
+++ b/src/ruby/ext/grpc/rb_server_credentials.h
@@ -47,4 +47,4 @@ void Init_google_rpc_server_credentials();
 /* Gets the wrapped server_credentials from the ruby wrapper */
 grpc_server_credentials* grpc_rb_get_wrapped_server_credentials(VALUE v);
 
-#endif  /* GRPC_RB_SERVER_CREDENTIALS_H_ */
+#endif /* GRPC_RB_SERVER_CREDENTIALS_H_ */