sanity fixes

include/grpc++/impl/codegen/async_unary_call.h

@@ -92,12 +92,10 @@ class ClientAsyncResponseReader GRPC_FINAL
   ClientContext* context_;
   Call call_;
   SneakyCallOpSet<CallOpSendInitialMetadata, CallOpSendMessage,
-                  CallOpClientSendClose>
-      init_buf_;
+                  CallOpClientSendClose> init_buf_;
   CallOpSet<CallOpRecvInitialMetadata> meta_buf_;
   CallOpSet<CallOpRecvInitialMetadata, CallOpRecvMessage<R>,
-            CallOpClientRecvStatus>
-      finish_buf_;
+            CallOpClientRecvStatus> finish_buf_;
 };
 
 template <class W>
@@ -150,8 +148,7 @@ class ServerAsyncResponseWriter GRPC_FINAL
   ServerContext* ctx_;
   CallOpSet<CallOpSendInitialMetadata> meta_buf_;
   CallOpSet<CallOpSendInitialMetadata, CallOpSendMessage,
-            CallOpServerSendStatus>
-      finish_buf_;
+            CallOpServerSendStatus> finish_buf_;
 };
 
 }  // namespace grpc

include/grpc++/impl/codegen/client_unary_call.h

@@ -55,8 +55,7 @@ Status BlockingUnaryCall(ChannelInterface* channel, const RpcMethod& method,
   Call call(channel->CreateCall(method, context, &cq));
   CallOpSet<CallOpSendInitialMetadata, CallOpSendMessage,
             CallOpRecvInitialMetadata, CallOpRecvMessage<OutputMessage>,
-            CallOpClientSendClose, CallOpClientRecvStatus>
-      ops;
+            CallOpClientSendClose, CallOpClientRecvStatus> ops;
   Status status = ops.SendMessage(request);
   if (!status.ok()) {
     return status;

include/grpc++/impl/codegen/method_handler_impl.h

@@ -43,10 +43,10 @@ namespace grpc {
 template <class ServiceType, class RequestType, class ResponseType>
 class RpcMethodHandler : public MethodHandler {
  public:
-  RpcMethodHandler(std::function<Status(ServiceType*, ServerContext*,
-                                        const RequestType*, ResponseType*)>
-                       func,
-                   ServiceType* service)
+  RpcMethodHandler(
+      std::function<Status(ServiceType*, ServerContext*, const RequestType*,
+                           ResponseType*)> func,
+      ServiceType* service)
       : func_(func), service_(service) {}
 
   void RunHandler(const HandlerParameter& param) GRPC_FINAL {
@@ -60,8 +60,7 @@ class RpcMethodHandler : public MethodHandler {
 
     GPR_ASSERT(!param.server_context->sent_initial_metadata_);
     CallOpSet<CallOpSendInitialMetadata, CallOpSendMessage,
-              CallOpServerSendStatus>
-        ops;
+              CallOpServerSendStatus> ops;
     ops.SendInitialMetadata(param.server_context->initial_metadata_);
     if (status.ok()) {
       status = ops.SendMessage(rsp);
@@ -74,8 +73,7 @@ class RpcMethodHandler : public MethodHandler {
  private:
   // Application provided rpc handler function.
   std::function<Status(ServiceType*, ServerContext*, const RequestType*,
-                       ResponseType*)>
-      func_;
+                       ResponseType*)> func_;
   // The class the above handler function lives in.
   ServiceType* service_;
 };
@@ -86,8 +84,7 @@ class ClientStreamingHandler : public MethodHandler {
  public:
   ClientStreamingHandler(
       std::function<Status(ServiceType*, ServerContext*,
-                           ServerReader<RequestType>*, ResponseType*)>
-          func,
+                           ServerReader<RequestType>*, ResponseType*)> func,
       ServiceType* service)
       : func_(func), service_(service) {}
 
@@ -98,8 +95,7 @@ class ClientStreamingHandler : public MethodHandler {
 
     GPR_ASSERT(!param.server_context->sent_initial_metadata_);
     CallOpSet<CallOpSendInitialMetadata, CallOpSendMessage,
-              CallOpServerSendStatus>
-        ops;
+              CallOpServerSendStatus> ops;
     ops.SendInitialMetadata(param.server_context->initial_metadata_);
     if (status.ok()) {
       status = ops.SendMessage(rsp);
@@ -111,8 +107,7 @@ class ClientStreamingHandler : public MethodHandler {
 
  private:
   std::function<Status(ServiceType*, ServerContext*, ServerReader<RequestType>*,
-                       ResponseType*)>
-      func_;
+                       ResponseType*)> func_;
   ServiceType* service_;
 };
 
@@ -122,8 +117,7 @@ class ServerStreamingHandler : public MethodHandler {
  public:
   ServerStreamingHandler(
       std::function<Status(ServiceType*, ServerContext*, const RequestType*,
-                           ServerWriter<ResponseType>*)>
-          func,
+                           ServerWriter<ResponseType>*)> func,
       ServiceType* service)
       : func_(func), service_(service) {}
 
@@ -148,8 +142,7 @@ class ServerStreamingHandler : public MethodHandler {
 
  private:
   std::function<Status(ServiceType*, ServerContext*, const RequestType*,
-                       ServerWriter<ResponseType>*)>
-      func_;
+                       ServerWriter<ResponseType>*)> func_;
   ServiceType* service_;
 };
 
@@ -180,8 +173,7 @@ class BidiStreamingHandler : public MethodHandler {
 
  private:
   std::function<Status(ServiceType*, ServerContext*,
-                       ServerReaderWriter<ResponseType, RequestType>*)>
-      func_;
+                       ServerReaderWriter<ResponseType, RequestType>*)> func_;
   ServiceType* service_;
 };
 

include/grpc++/impl/codegen/service_type.h

@@ -34,10 +34,10 @@
 #ifndef GRPCXX_IMPL_CODEGEN_SERVICE_TYPE_H
 #define GRPCXX_IMPL_CODEGEN_SERVICE_TYPE_H
 
-#include <grpc++/impl/rpc_service_method.h>
-#include <grpc++/impl/serialization_traits.h>
-#include <grpc++/impl/codegen/server_interface.h>
 #include <grpc++/impl/codegen/config.h>
+#include <grpc++/impl/codegen/rpc_service_method.h>
+#include <grpc++/impl/codegen/serialization_traits.h>
+#include <grpc++/impl/codegen/server_interface.h>
 #include <grpc++/impl/codegen/status.h>
 
 namespace grpc {

include/grpc++/impl/codegen/sync_stream.h

@@ -122,8 +122,7 @@ class ClientReader GRPC_FINAL : public ClientReaderInterface<R> {
                ClientContext* context, const W& request)
       : context_(context), call_(channel->CreateCall(method, context, &cq_)) {
     CallOpSet<CallOpSendInitialMetadata, CallOpSendMessage,
-              CallOpClientSendClose>
-        ops;
+              CallOpClientSendClose> ops;
     ops.SendInitialMetadata(context->send_initial_metadata_);
     // TODO(ctiller): don't assert
     GPR_ASSERT(ops.SendMessage(request).ok());

include/grpc/impl/codegen/propagation_bits.h

@@ -64,5 +64,4 @@ extern "C" {
 }
 #endif
 
-
 #endif /* GRPC_IMPL_CODEGEN_H */

test/cpp/qps/client_async.cc

@@ -161,12 +161,11 @@ class AsyncClient : public ClientImpl<StubType, RequestType> {
   using Client::closed_loop_;
   using ClientImpl<StubType, RequestType>::channels_;
   using ClientImpl<StubType, RequestType>::request_;
-  AsyncClient(
-      const ClientConfig& config,
-      std::function<ClientRpcContext*(int, StubType*, const RequestType&)>
-          setup_ctx,
-      std::function<std::unique_ptr<StubType>(std::shared_ptr<Channel>)>
-          create_stub)
+  AsyncClient(const ClientConfig& config,
+              std::function<ClientRpcContext*(int, StubType*,
+                                              const RequestType&)> setup_ctx,
+              std::function<std::unique_ptr<StubType>(std::shared_ptr<Channel>)>
+                  create_stub)
       : ClientImpl<StubType, RequestType>(config, create_stub),
         num_async_threads_(NumThreads(config)),
         channel_lock_(new std::mutex[config.client_channels()]),

tools/jenkins/run_portability.sh

@@ -54,4 +54,4 @@ then
   USE_DOCKER_MAYBE="--use_docker"
 fi
 
-python tools/run_tests/run_tests.py $USE_DOCKER_MAYBE -t -l $language -c $config --arch ${curr_arch} --compiler ${curr_compiler} -x report.xml -j 3 $@
+python tools/run_tests/run_tests.py $USE_DOCKER_MAYBE -t -l $language -c $config --arch ${curr_arch} --compiler ${curr_compiler} -x report.xml -j 3 $@
\ No newline at end of file