clang-format c++ code

8 files changed, 25 insertions, 23 deletions

diff --git a/src/cpp/server/async_generic_service.cc b/src/cpp/server/async_generic_service.cc
index 2009af7cbd..07cb933715 100644
--- a/src/cpp/server/async_generic_service.cc
+++ b/src/cpp/server/async_generic_service.cc
@@ -47,5 +47,4 @@ CompletionQueue* AsyncGenericService::completion_queue() {
   return &server_->cq_;
 }
 
-} // namespace grpc
-
+}  // namespace grpc
diff --git a/src/cpp/server/async_server_context.cc b/src/cpp/server/async_server_context.cc
index f21efcfb19..628822a338 100644
--- a/src/cpp/server/async_server_context.cc
+++ b/src/cpp/server/async_server_context.cc
@@ -42,7 +42,7 @@
 namespace grpc {
 
 AsyncServerContext::AsyncServerContext(
-    grpc_call *call, const grpc::string &method, const grpc::string &host,
+    grpc_call* call, const grpc::string& method, const grpc::string& host,
     system_clock::time_point absolute_deadline)
     : method_(method),
       host_(host),
@@ -52,22 +52,22 @@ AsyncServerContext::AsyncServerContext(
 
 AsyncServerContext::~AsyncServerContext() { grpc_call_destroy(call_); }
 
-void AsyncServerContext::Accept(grpc_completion_queue *cq) {
+void AsyncServerContext::Accept(grpc_completion_queue* cq) {
   GPR_ASSERT(grpc_call_server_accept_old(call_, cq, this) == GRPC_CALL_OK);
   GPR_ASSERT(grpc_call_server_end_initial_metadata_old(
                  call_, GRPC_WRITE_BUFFER_HINT) == GRPC_CALL_OK);
 }
 
-bool AsyncServerContext::StartRead(grpc::protobuf::Message *request) {
+bool AsyncServerContext::StartRead(grpc::protobuf::Message* request) {
   GPR_ASSERT(request);
   request_ = request;
   grpc_call_error err = grpc_call_start_read_old(call_, this);
   return err == GRPC_CALL_OK;
 }
 
-bool AsyncServerContext::StartWrite(const grpc::protobuf::Message &response,
+bool AsyncServerContext::StartWrite(const grpc::protobuf::Message& response,
                                     int flags) {
-  grpc_byte_buffer *buffer = nullptr;
+  grpc_byte_buffer* buffer = nullptr;
   if (!SerializeProto(response, &buffer)) {
     return false;
   }
@@ -76,16 +76,16 @@ bool AsyncServerContext::StartWrite(const grpc::protobuf::Message &response,
   return err == GRPC_CALL_OK;
 }
 
-bool AsyncServerContext::StartWriteStatus(const Status &status) {
+bool AsyncServerContext::StartWriteStatus(const Status& status) {
   grpc_call_error err = grpc_call_start_write_status_old(
       call_, static_cast<grpc_status_code>(status.code()),
       status.details().empty() ? nullptr
-                               : const_cast<char *>(status.details().c_str()),
+                               : const_cast<char*>(status.details().c_str()),
       this);
   return err == GRPC_CALL_OK;
 }
 
-bool AsyncServerContext::ParseRead(grpc_byte_buffer *read_buffer) {
+bool AsyncServerContext::ParseRead(grpc_byte_buffer* read_buffer) {
   GPR_ASSERT(request_);
   bool success = DeserializeProto(read_buffer, request_);
   request_ = nullptr;
diff --git a/src/cpp/server/insecure_server_credentials.cc b/src/cpp/server/insecure_server_credentials.cc
index f5e4732f73..55dd90d7a7 100644
--- a/src/cpp/server/insecure_server_credentials.cc
+++ b/src/cpp/server/insecure_server_credentials.cc
@@ -46,7 +46,8 @@ class InsecureServerCredentialsImpl GRPC_FINAL : public ServerCredentials {
 }  // namespace
 
 std::shared_ptr<ServerCredentials> InsecureServerCredentials() {
-  return std::shared_ptr<ServerCredentials>(new InsecureServerCredentialsImpl());
+  return std::shared_ptr<ServerCredentials>(
+      new InsecureServerCredentialsImpl());
 }
 
 }  // namespace grpc
diff --git a/src/cpp/server/secure_server_credentials.cc b/src/cpp/server/secure_server_credentials.cc
index ff35638503..88f7a9b1a9 100644
--- a/src/cpp/server/secure_server_credentials.cc
+++ b/src/cpp/server/secure_server_credentials.cc
@@ -40,7 +40,8 @@ namespace grpc {
 namespace {
 class SecureServerCredentials GRPC_FINAL : public ServerCredentials {
  public:
-  explicit SecureServerCredentials(grpc_server_credentials* creds) : creds_(creds) {}
+  explicit SecureServerCredentials(grpc_server_credentials* creds)
+      : creds_(creds) {}
   ~SecureServerCredentials() GRPC_OVERRIDE {
     grpc_server_credentials_release(creds_);
   }
@@ -56,16 +57,17 @@ class SecureServerCredentials GRPC_FINAL : public ServerCredentials {
 }  // namespace
 
 std::shared_ptr<ServerCredentials> SslServerCredentials(
-    const SslServerCredentialsOptions &options) {
+    const SslServerCredentialsOptions& options) {
   std::vector<grpc_ssl_pem_key_cert_pair> pem_key_cert_pairs;
-  for (const auto &key_cert_pair : options.pem_key_cert_pairs) {
+  for (const auto& key_cert_pair : options.pem_key_cert_pairs) {
     pem_key_cert_pairs.push_back(
         {key_cert_pair.private_key.c_str(), key_cert_pair.cert_chain.c_str()});
   }
-  grpc_server_credentials *c_creds = grpc_ssl_server_credentials_create(
+  grpc_server_credentials* c_creds = grpc_ssl_server_credentials_create(
       options.pem_root_certs.empty() ? nullptr : options.pem_root_certs.c_str(),
       &pem_key_cert_pairs[0], pem_key_cert_pairs.size());
-  return std::shared_ptr<ServerCredentials>(new SecureServerCredentials(c_creds));
+  return std::shared_ptr<ServerCredentials>(
+      new SecureServerCredentials(c_creds));
 }
 
 }  // namespace grpc
diff --git a/src/cpp/server/server.cc b/src/cpp/server/server.cc
index 4d5e77e633..4ed4c45507 100644
--- a/src/cpp/server/server.cc
+++ b/src/cpp/server/server.cc
@@ -322,11 +322,10 @@ class Server::AsyncRequest GRPC_FINAL : public CompletionQueueTag {
         payload_(nullptr) {
     memset(&array_, 0, sizeof(array_));
     grpc_call_details_init(&call_details_);
-    grpc_server_request_call(
-        server->server_, &call_, &call_details_, &array_, cq->cq(), this);
+    grpc_server_request_call(server->server_, &call_, &call_details_, &array_,
+                             cq->cq(), this);
   }
 
-
   ~AsyncRequest() {
     if (payload_) {
       grpc_byte_buffer_destroy(payload_);
diff --git a/src/cpp/server/server_builder.cc b/src/cpp/server/server_builder.cc
index 835596d393..2f5a0dc6c8 100644
--- a/src/cpp/server/server_builder.cc
+++ b/src/cpp/server/server_builder.cc
@@ -56,7 +56,8 @@ void ServerBuilder::RegisterAsyncGenericService(AsyncGenericService* service) {
   if (generic_service_) {
     gpr_log(GPR_ERROR,
             "Adding multiple AsyncGenericService is unsupported for now. "
-            "Dropping the service %p", service);
+            "Dropping the service %p",
+            service);
     return;
   }
   generic_service_ = service;
diff --git a/src/cpp/server/thread_pool.cc b/src/cpp/server/thread_pool.cc
index 5dc9bcf916..d3013b806c 100644
--- a/src/cpp/server/thread_pool.cc
+++ b/src/cpp/server/thread_pool.cc
@@ -66,12 +66,12 @@ ThreadPool::~ThreadPool() {
     shutdown_ = true;
     cv_.notify_all();
   }
-  for (auto &t : threads_) {
+  for (auto& t : threads_) {
     t.join();
   }
 }
 
-void ThreadPool::ScheduleCallback(const std::function<void()> &callback) {
+void ThreadPool::ScheduleCallback(const std::function<void()>& callback) {
   std::lock_guard<std::mutex> lock(mu_);
   callbacks_.push(callback);
   cv_.notify_one();
diff --git a/src/cpp/server/thread_pool.h b/src/cpp/server/thread_pool.h
index 6157e403e9..6225d82a0b 100644
--- a/src/cpp/server/thread_pool.h
+++ b/src/cpp/server/thread_pool.h
@@ -50,7 +50,7 @@ class ThreadPool GRPC_FINAL : public ThreadPoolInterface {
   explicit ThreadPool(int num_threads);
   ~ThreadPool();
 
-  void ScheduleCallback(const std::function<void()> &callback) GRPC_OVERRIDE;
+  void ScheduleCallback(const std::function<void()>& callback) GRPC_OVERRIDE;
 
  private:
   std::mutex mu_;