clang-format

include/grpc++/channel.h

@@ -47,9 +47,9 @@ struct grpc_channel;
 namespace grpc {
 /// Channels represent a connection to an endpoint. Created by \a CreateChannel.
 class Channel final : public ChannelInterface,
-                           public CallHook,
+                      public CallHook,
-                           public std::enable_shared_from_this<Channel>,
+                      public std::enable_shared_from_this<Channel>,
-                           private GrpcLibraryCodegen {
+                      private GrpcLibraryCodegen {
  public:
   ~Channel();
 

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

@@ -113,8 +113,7 @@ class ClientAsyncResponseReader final
 };
 
 template <class W>
-class ServerAsyncResponseWriter final
+class ServerAsyncResponseWriter final : public ServerAsyncStreamingInterface {
-    : public ServerAsyncStreamingInterface {
  public:
   explicit ServerAsyncResponseWriter(ServerContext* ctx)
       : call_(nullptr, nullptr, nullptr), ctx_(ctx) {}

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

@@ -45,8 +45,7 @@ namespace grpc {
 /// Implementation of the core codegen interface.
 class CoreCodegen : public CoreCodegenInterface {
  private:
-  grpc_completion_queue* grpc_completion_queue_create(void* reserved)
+  grpc_completion_queue* grpc_completion_queue_create(void* reserved) override;
-      override;
   void grpc_completion_queue_destroy(grpc_completion_queue* cq) override;
   grpc_event grpc_completion_queue_pluck(grpc_completion_queue* cq, void* tag,
                                          gpr_timespec deadline,
@@ -61,8 +60,7 @@ class CoreCodegen : public CoreCodegenInterface {
   void gpr_mu_unlock(gpr_mu* mu) override;
   void gpr_cv_init(gpr_cv* cv) override;
   void gpr_cv_destroy(gpr_cv* cv) override;
-  int gpr_cv_wait(gpr_cv* cv, gpr_mu* mu,
+  int gpr_cv_wait(gpr_cv* cv, gpr_mu* mu, gpr_timespec abs_deadline) override;
-                  gpr_timespec abs_deadline) override;
   void gpr_cv_signal(gpr_cv* cv) override;
   void gpr_cv_broadcast(gpr_cv* cv) override;
 
@@ -70,8 +68,8 @@ class CoreCodegen : public CoreCodegenInterface {
 
   int grpc_byte_buffer_reader_init(grpc_byte_buffer_reader* reader,
                                    grpc_byte_buffer* buffer) override;
-  void grpc_byte_buffer_reader_destroy(grpc_byte_buffer_reader* reader)
+  void grpc_byte_buffer_reader_destroy(
-      override;
+      grpc_byte_buffer_reader* reader) override;
   int grpc_byte_buffer_reader_next(grpc_byte_buffer_reader* reader,
                                    gpr_slice* slice) override;
 
@@ -81,8 +79,7 @@ class CoreCodegen : public CoreCodegenInterface {
   gpr_slice gpr_slice_malloc(size_t length) override;
   void gpr_slice_unref(gpr_slice slice) override;
   gpr_slice gpr_slice_split_tail(gpr_slice* s, size_t split) override;
-  void gpr_slice_buffer_add(gpr_slice_buffer* sb,
+  void gpr_slice_buffer_add(gpr_slice_buffer* sb, gpr_slice slice) override;
-                            gpr_slice slice) override;
   void gpr_slice_buffer_pop(gpr_slice_buffer* sb) override;
 
   void grpc_metadata_array_init(grpc_metadata_array* array) override;

include/grpc++/server.h

@@ -143,8 +143,7 @@ class Server final : public ServerInterface, private GrpcLibraryCodegen {
 
   /// Register a service. This call does not take ownership of the service.
   /// The service must exist for the lifetime of the Server instance.
-  bool RegisterService(const grpc::string* host,
+  bool RegisterService(const grpc::string* host, Service* service) override;
-                       Service* service) override;
 
   /// Register a generic service. This call does not take ownership of the
   /// service. The service must exist for the lifetime of the Server instance.

src/compiler/cpp_generator.cc

@@ -423,11 +423,10 @@ void PrintHeaderClientMethod(Printer *printer, const Method *method,
                      "::grpc::ClientWriter< $Request$>* $Method$Raw("
                      "::grpc::ClientContext* context, $Response$* response) "
                      "override;\n");
-      printer->Print(
+      printer->Print(*vars,
-          *vars,
+                     "::grpc::ClientAsyncWriter< $Request$>* Async$Method$Raw("
-          "::grpc::ClientAsyncWriter< $Request$>* Async$Method$Raw("
+                     "::grpc::ClientContext* context, $Response$* response, "
-          "::grpc::ClientContext* context, $Response$* response, "
+                     "::grpc::CompletionQueue* cq, void* tag) override;\n");
-          "::grpc::CompletionQueue* cq, void* tag) override;\n");
     } else if (method->ServerOnlyStreaming()) {
       printer->Print(*vars,
                      "::grpc::ClientReader< $Response$>* $Method$Raw("
@@ -439,15 +438,13 @@ void PrintHeaderClientMethod(Printer *printer, const Method *method,
           "::grpc::ClientContext* context, const $Request$& request, "
           "::grpc::CompletionQueue* cq, void* tag) override;\n");
     } else if (method->BidiStreaming()) {
-      printer->Print(
+      printer->Print(*vars,
-          *vars,
+                     "::grpc::ClientReaderWriter< $Request$, $Response$>* "
-          "::grpc::ClientReaderWriter< $Request$, $Response$>* "
+                     "$Method$Raw(::grpc::ClientContext* context) override;\n");
-          "$Method$Raw(::grpc::ClientContext* context) override;\n");
+      printer->Print(*vars,
-      printer->Print(
+                     "::grpc::ClientAsyncReaderWriter< $Request$, $Response$>* "
-          *vars,
+                     "Async$Method$Raw(::grpc::ClientContext* context, "
-          "::grpc::ClientAsyncReaderWriter< $Request$, $Response$>* "
+                     "::grpc::CompletionQueue* cq, void* tag) override;\n");
-          "Async$Method$Raw(::grpc::ClientContext* context, "
-          "::grpc::CompletionQueue* cq, void* tag) override;\n");
     }
   }
 }

src/cpp/client/cronet_credentials.cc

@@ -53,9 +53,7 @@ class CronetChannelCredentialsImpl final : public ChannelCredentials {
                                               &channel_args, nullptr));
   }
 
-  SecureChannelCredentials* AsSecureCredentials() override {
+  SecureChannelCredentials* AsSecureCredentials() override { return nullptr; }
-    return nullptr;
-  }
 
  private:
   void* engine_;

src/cpp/client/insecure_credentials.cc

@@ -54,9 +54,7 @@ class InsecureChannelCredentialsImpl final : public ChannelCredentials {
         grpc_insecure_channel_create(target.c_str(), &channel_args, nullptr));
   }
 
-  SecureChannelCredentials* AsSecureCredentials() override {
+  SecureChannelCredentials* AsSecureCredentials() override { return nullptr; }
-    return nullptr;
-  }
 };
 }  // namespace
 

src/cpp/common/secure_auth_context.h

@@ -62,8 +62,7 @@ class SecureAuthContext final : public AuthContext {
   void AddProperty(const grpc::string& key,
                    const grpc::string_ref& value) override;
 
-  virtual bool SetPeerIdentityPropertyName(const grpc::string& name)
+  virtual bool SetPeerIdentityPropertyName(const grpc::string& name) override;
-      override;
 
  private:
   grpc_auth_context* ctx_;

src/cpp/server/insecure_server_credentials.cc

@@ -40,8 +40,7 @@ namespace grpc {
 namespace {
 class InsecureServerCredentialsImpl final : public ServerCredentials {
  public:
-  int AddPortToServer(const grpc::string& addr,
+  int AddPortToServer(const grpc::string& addr, grpc_server* server) override {
-                      grpc_server* server) override {
     return grpc_server_add_insecure_http2_port(server, addr.c_str());
   }
   void SetAuthMetadataProcessor(

src/cpp/server/secure_server_credentials.h

@@ -72,8 +72,7 @@ class SecureServerCredentials final : public ServerCredentials {
     grpc_server_credentials_release(creds_);
   }
 
-  int AddPortToServer(const grpc::string& addr,
+  int AddPortToServer(const grpc::string& addr, grpc_server* server) override;
-                      grpc_server* server) override;
 
   void SetAuthMetadataProcessor(
       const std::shared_ptr<AuthMetadataProcessor>& processor) override;

test/cpp/end2end/async_end2end_test.cc

@@ -213,8 +213,8 @@ class ServerBuilderSyncPluginDisabler : public ::grpc::ServerBuilderOption {
  public:
   void UpdateArguments(ChannelArguments* arg) override {}
 
-  void UpdatePlugins(std::vector<std::unique_ptr<ServerBuilderPlugin>>* plugins)
+  void UpdatePlugins(
-      override {
+      std::vector<std::unique_ptr<ServerBuilderPlugin>>* plugins) override {
     plugins->erase(std::remove_if(plugins->begin(), plugins->end(),
                                   plugin_has_sync_methods),
                    plugins->end());

test/cpp/end2end/client_crash_test_server.cc

@@ -58,11 +58,10 @@ using namespace gflags;
 namespace grpc {
 namespace testing {
 
-class ServiceImpl final
+class ServiceImpl final : public ::grpc::testing::EchoTestService::Service {
-    : public ::grpc::testing::EchoTestService::Service {
+  Status BidiStream(
-  Status BidiStream(ServerContext* context,
+      ServerContext* context,
-                    ServerReaderWriter<EchoResponse, EchoRequest>* stream)
+      ServerReaderWriter<EchoResponse, EchoRequest>* stream) override {
-      override {
     EchoRequest request;
     EchoResponse response;
     while (stream->Read(&request)) {

test/cpp/end2end/end2end_test.cc

@@ -94,10 +94,10 @@ class TestMetadataCredentialsPlugin : public MetadataCredentialsPlugin {
 
   bool IsBlocking() const override { return is_blocking_; }
 
-  Status GetMetadata(grpc::string_ref service_url, grpc::string_ref method_name,
+  Status GetMetadata(
-                     const grpc::AuthContext& channel_auth_context,
+      grpc::string_ref service_url, grpc::string_ref method_name,
-                     std::multimap<grpc::string, grpc::string>* metadata)
+      const grpc::AuthContext& channel_auth_context,
-      override {
+      std::multimap<grpc::string, grpc::string>* metadata) override {
     EXPECT_GT(service_url.length(), 0UL);
     EXPECT_GT(method_name.length(), 0UL);
     EXPECT_TRUE(channel_auth_context.IsPeerAuthenticated());

test/cpp/end2end/hybrid_end2end_test.cc

@@ -449,9 +449,9 @@ class StreamedUnaryDupPkg
     : public duplicate::EchoTestService::WithStreamedUnaryMethod_Echo<
           TestServiceImplDupPkg> {
  public:
-  Status StreamedEcho(ServerContext* context,
+  Status StreamedEcho(
-                      ServerUnaryStreamer<EchoRequest, EchoResponse>* stream)
+      ServerContext* context,
-      override {
+      ServerUnaryStreamer<EchoRequest, EchoResponse>* stream) override {
     EchoRequest req;
     EchoResponse resp;
     uint32_t next_msg_sz;
@@ -487,9 +487,9 @@ TEST_F(HybridEnd2endTest,
 class FullyStreamedUnaryDupPkg
     : public duplicate::EchoTestService::StreamedUnaryService {
  public:
-  Status StreamedEcho(ServerContext* context,
+  Status StreamedEcho(
-                      ServerUnaryStreamer<EchoRequest, EchoResponse>* stream)
+      ServerContext* context,
-      override {
+      ServerUnaryStreamer<EchoRequest, EchoResponse>* stream) override {
     EchoRequest req;
     EchoResponse resp;
     uint32_t next_msg_sz;
@@ -605,9 +605,9 @@ TEST_F(HybridEnd2endTest,
 // Add a second service that is fully server streamed
 class FullyStreamedDupPkg : public duplicate::EchoTestService::StreamedService {
  public:
-  Status StreamedEcho(ServerContext* context,
+  Status StreamedEcho(
-                      ServerUnaryStreamer<EchoRequest, EchoResponse>* stream)
+      ServerContext* context,
-      override {
+      ServerUnaryStreamer<EchoRequest, EchoResponse>* stream) override {
     EchoRequest req;
     EchoResponse resp;
     uint32_t next_msg_sz;

test/cpp/end2end/mock_test.cc

@@ -61,8 +61,7 @@ namespace testing {
 
 namespace {
 template <class W, class R>
-class MockClientReaderWriter final
+class MockClientReaderWriter final : public ClientReaderWriterInterface<W, R> {
-    : public ClientReaderWriterInterface<W, R> {
  public:
   void WaitForInitialMetadata() override {}
   bool NextMessageSize(uint32_t* sz) override {
@@ -90,8 +89,7 @@ class MockClientReaderWriter<EchoRequest, EchoResponse> final
     return true;
   }
 
-  bool Write(const EchoRequest& msg,
+  bool Write(const EchoRequest& msg, const WriteOptions& options) override {
-             const WriteOptions& options) override {
     gpr_log(GPR_INFO, "mock recv msg %s", msg.message().c_str());
     last_message_ = msg.message();
     return true;
@@ -221,9 +219,9 @@ class TestServiceImpl : public EchoTestService::Service {
     return Status::OK;
   }
 
-  Status BidiStream(ServerContext* context,
+  Status BidiStream(
-                    ServerReaderWriter<EchoResponse, EchoRequest>* stream)
+      ServerContext* context,
-      override {
+      ServerReaderWriter<EchoResponse, EchoRequest>* stream) override {
     EchoRequest request;
     EchoResponse response;
     while (stream->Read(&request)) {

test/cpp/end2end/server_builder_plugin_test.cc

@@ -114,8 +114,8 @@ class InsertPluginServerBuilderOption : public ServerBuilderOption {
 
   void UpdateArguments(ChannelArguments* arg) override {}
 
-  void UpdatePlugins(std::vector<std::unique_ptr<ServerBuilderPlugin>>* plugins)
+  void UpdatePlugins(
-      override {
+      std::vector<std::unique_ptr<ServerBuilderPlugin>>* plugins) override {
     plugins->clear();
 
     std::unique_ptr<TestServerBuilderPlugin> plugin(

test/cpp/end2end/server_crash_test.cc

@@ -60,14 +60,13 @@ namespace testing {
 
 namespace {
 
-class ServiceImpl final
+class ServiceImpl final : public ::grpc::testing::EchoTestService::Service {
-    : public ::grpc::testing::EchoTestService::Service {
  public:
   ServiceImpl() : bidi_stream_count_(0), response_stream_count_(0) {}
 
-  Status BidiStream(ServerContext* context,
+  Status BidiStream(
-                    ServerReaderWriter<EchoResponse, EchoRequest>* stream)
+      ServerContext* context,
-      override {
+      ServerReaderWriter<EchoResponse, EchoRequest>* stream) override {
     bidi_stream_count_++;
     EchoRequest request;
     EchoResponse response;

test/cpp/end2end/streaming_throughput_test.cc

@@ -121,9 +121,9 @@ class TestServiceImpl : public ::grpc::testing::EchoTestService::Service {
   }
 
   // Only implement the one method we will be calling for brevity.
-  Status BidiStream(ServerContext* context,
+  Status BidiStream(
-                    ServerReaderWriter<EchoResponse, EchoRequest>* stream)
+      ServerContext* context,
-      override {
+      ServerReaderWriter<EchoResponse, EchoRequest>* stream) override {
     EchoRequest request;
     gpr_atm should_exit;
     gpr_atm_rel_store(&should_exit, static_cast<gpr_atm>(0));

test/cpp/end2end/test_service_impl.h

@@ -74,9 +74,9 @@ class TestServiceImpl : public ::grpc::testing::EchoTestService::Service {
   Status ResponseStream(ServerContext* context, const EchoRequest* request,
                         ServerWriter<EchoResponse>* writer) override;
 
-  Status BidiStream(ServerContext* context,
+  Status BidiStream(
-                    ServerReaderWriter<EchoResponse, EchoRequest>* stream)
+      ServerContext* context,
-      override;
+      ServerReaderWriter<EchoResponse, EchoRequest>* stream) override;
 
   bool signal_client() {
     std::unique_lock<std::mutex> lock(mu_);

test/cpp/end2end/thread_stress_test.cc

@@ -142,9 +142,9 @@ class TestServiceImpl : public ::grpc::testing::EchoTestService::Service {
     return Status::OK;
   }
 
-  Status BidiStream(ServerContext* context,
+  Status BidiStream(
-                    ServerReaderWriter<EchoResponse, EchoRequest>* stream)
+      ServerContext* context,
-      override {
+      ServerReaderWriter<EchoResponse, EchoRequest>* stream) override {
     EchoRequest request;
     EchoResponse response;
     while (stream->Read(&request)) {

test/cpp/qps/client_async.cc

@@ -228,8 +228,7 @@ class AsyncClient : public ClientImpl<StubType, RequestType> {
     this->EndThreads();  // this needed for resolution
   }
 
-  bool ThreadFunc(HistogramEntry* entry,
+  bool ThreadFunc(HistogramEntry* entry, size_t thread_idx) override final {
-                  size_t thread_idx) override final {
     void* got_tag;
     bool ok;
 

test/cpp/qps/qps_worker.cc

@@ -118,9 +118,9 @@ class WorkerServiceImpl final : public WorkerService::Service {
   WorkerServiceImpl(int server_port, QpsWorker* worker)
       : acquired_(false), server_port_(server_port), worker_(worker) {}
 
-  Status RunClient(ServerContext* ctx,
+  Status RunClient(
-                   ServerReaderWriter<ClientStatus, ClientArgs>* stream)
+      ServerContext* ctx,
-      override {
+      ServerReaderWriter<ClientStatus, ClientArgs>* stream) override {
     InstanceGuard g(this);
     if (!g.Acquired()) {
       return Status(StatusCode::RESOURCE_EXHAUSTED, "Client worker busy");
@@ -132,9 +132,9 @@ class WorkerServiceImpl final : public WorkerService::Service {
     return ret;
   }
 
-  Status RunServer(ServerContext* ctx,
+  Status RunServer(
-                   ServerReaderWriter<ServerStatus, ServerArgs>* stream)
+      ServerContext* ctx,
-      override {
+      ServerReaderWriter<ServerStatus, ServerArgs>* stream) override {
     InstanceGuard g(this);
     if (!g.Acquired()) {
       return Status(StatusCode::RESOURCE_EXHAUSTED, "Server worker busy");

test/cpp/qps/server_async.cc

@@ -214,9 +214,7 @@ class AsyncQpsServerTest final : public grpc::testing::Server {
                       AsyncQpsServerTest::tag(this));
     }
     ~ServerRpcContextUnaryImpl() override {}
-    bool RunNextState(bool ok) override {
+    bool RunNextState(bool ok) override { return (this->*next_state_)(ok); }
-      return (this->*next_state_)(ok);
-    }
     void Reset() override {
       srv_ctx_.reset(new ServerContextType);
       req_ = RequestType();
@@ -274,9 +272,7 @@ class AsyncQpsServerTest final : public grpc::testing::Server {
       request_method_(srv_ctx_.get(), &stream_, AsyncQpsServerTest::tag(this));
     }
     ~ServerRpcContextStreamingImpl() override {}
-    bool RunNextState(bool ok) override {
+    bool RunNextState(bool ok) override { return (this->*next_state_)(ok); }
-      return (this->*next_state_)(ok);
-    }
     void Reset() override {
       srv_ctx_.reset(new ServerContextType);
       req_ = RequestType();

test/cpp/thread_manager/thread_manager_test.cc

@@ -51,8 +51,7 @@ class ThreadManagerTest final : public grpc::ThreadManager {
         num_poll_for_work_(0),
         num_work_found_(0) {}
 
-  grpc::ThreadManager::WorkStatus PollForWork(void **tag,
+  grpc::ThreadManager::WorkStatus PollForWork(void **tag, bool *ok) override;
-                                              bool *ok) override;
   void DoWork(void *tag, bool ok) override;
   void PerformTest();
 

test/cpp/util/grpc_tool_test.cc

@@ -95,8 +95,7 @@ namespace {
 
 class TestCliCredentials final : public grpc::testing::CliCredentials {
  public:
-  std::shared_ptr<grpc::ChannelCredentials> GetCredentials() const
+  std::shared_ptr<grpc::ChannelCredentials> GetCredentials() const override {
-      override {
     return InsecureChannelCredentials();
   }
   const grpc::string GetCredentialUsage() const override { return ""; }

test/cpp/util/proto_reflection_descriptor_database.h

@@ -68,8 +68,7 @@ class ProtoReflectionDescriptorDatabase : public protobuf::DescriptorDatabase {
   // If found, fills in *output and returns true, otherwise returns false
   // and leaves *output undefined.
   bool FindFileContainingSymbol(const string& symbol_name,
-                                protobuf::FileDescriptorProto* output)
+                                protobuf::FileDescriptorProto* output) override;
-      override;
 
   // Find the file which defines an extension extending the given message type
   // with the given field number.  If found, fills in *output and returns true,

test/cpp/util/test_credentials_provider.cc

@@ -66,9 +66,9 @@ class DefaultCredentialsProvider : public CredentialsProvider {
  public:
   ~DefaultCredentialsProvider() override {}
 
-  void AddSecureType(const grpc::string& type,
+  void AddSecureType(
-                     std::unique_ptr<CredentialTypeProvider> type_provider)
+      const grpc::string& type,
-      override {
+      std::unique_ptr<CredentialTypeProvider> type_provider) override {
     // This clobbers any existing entry for type, except the defaults, which
     // can't be clobbered.
     grpc::unique_lock<grpc::mutex> lock(mu_);