Merge github.com:grpc/grpc into shutdown-c++

14 files changed, 54 insertions, 60 deletions

diff --git a/include/grpc++/async_unary_call.h b/include/grpc++/async_unary_call.h
index d631ccd134..3d22df4b33 100644
--- a/include/grpc++/async_unary_call.h
+++ b/include/grpc++/async_unary_call.h
@@ -121,8 +121,8 @@ class ServerAsyncResponseWriter GRPC_FINAL
     }
     // The response is dropped if the status is not OK.
     if (status.ok()) {
-      finish_buf_.ServerSendStatus(
-          ctx_->trailing_metadata_, finish_buf_.SendMessage(msg));
+      finish_buf_.ServerSendStatus(ctx_->trailing_metadata_,
+                                   finish_buf_.SendMessage(msg));
     } else {
       finish_buf_.ServerSendStatus(ctx_->trailing_metadata_, status);
     }
diff --git a/include/grpc++/auth_context.h b/include/grpc++/auth_context.h
index f8ea8ad6f4..7dced90ce5 100644
--- a/include/grpc++/auth_context.h
+++ b/include/grpc++/auth_context.h
@@ -62,6 +62,7 @@ class AuthPropertyIterator
   AuthPropertyIterator();
   AuthPropertyIterator(const grpc_auth_property* property,
                        const grpc_auth_property_iterator* iter);
+
  private:
   friend class SecureAuthContext;
   const grpc_auth_property* property_;
@@ -92,4 +93,3 @@ class AuthContext {
 }  // namespace grpc
 
 #endif  // GRPCXX_AUTH_CONTEXT_H
-
diff --git a/include/grpc++/byte_buffer.h b/include/grpc++/byte_buffer.h
index cb3c6a1159..6467776398 100644
--- a/include/grpc++/byte_buffer.h
+++ b/include/grpc++/byte_buffer.h
@@ -91,8 +91,8 @@ class SerializationTraits<ByteBuffer, void> {
     dest->set_buffer(byte_buffer);
     return Status::OK;
   }
-  static Status Serialize(const ByteBuffer& source, grpc_byte_buffer** buffer, 
-                        bool* own_buffer) {
+  static Status Serialize(const ByteBuffer& source, grpc_byte_buffer** buffer,
+                          bool* own_buffer) {
     *buffer = source.buffer();
     *own_buffer = false;
     return Status::OK;
diff --git a/include/grpc++/client_context.h b/include/grpc++/client_context.h
index 915a80ddb0..8de2ba4877 100644
--- a/include/grpc++/client_context.h
+++ b/include/grpc++/client_context.h
@@ -185,7 +185,9 @@ class ClientContext {
 
   // Get and set census context
   void set_census_context(struct census_context* ccp) { census_context_ = ccp; }
-  struct census_context* census_context() const { return census_context_; }
+  struct census_context* census_context() const {
+    return census_context_;
+  }
 
   void TryCancel();
 
diff --git a/include/grpc++/dynamic_thread_pool.h b/include/grpc++/dynamic_thread_pool.h
index f0cd35940f..a4d4885b51 100644
--- a/include/grpc++/dynamic_thread_pool.h
+++ b/include/grpc++/dynamic_thread_pool.h
@@ -55,11 +55,12 @@ class DynamicThreadPool GRPC_FINAL : public ThreadPoolInterface {
 
  private:
   class DynamicThread {
-  public:
-    DynamicThread(DynamicThreadPool *pool);
+   public:
+    DynamicThread(DynamicThreadPool* pool);
     ~DynamicThread();
-  private:
-    DynamicThreadPool *pool_;
+
+   private:
+    DynamicThreadPool* pool_;
     std::unique_ptr<grpc::thread> thd_;
     void ThreadFunc();
   };
diff --git a/include/grpc++/generic_stub.h b/include/grpc++/generic_stub.h
index c34e1fcf55..172f10e45a 100644
--- a/include/grpc++/generic_stub.h
+++ b/include/grpc++/generic_stub.h
@@ -52,8 +52,8 @@ class GenericStub GRPC_FINAL {
 
   // begin a call to a named method
   std::unique_ptr<GenericClientAsyncReaderWriter> Call(
-      ClientContext* context, const grpc::string& method,
-      CompletionQueue* cq, void* tag);
+      ClientContext* context, const grpc::string& method, CompletionQueue* cq,
+      void* tag);
 
  private:
   std::shared_ptr<ChannelInterface> channel_;
diff --git a/include/grpc++/impl/call.h b/include/grpc++/impl/call.h
index d49102fa3e..bc1db4c12c 100644
--- a/include/grpc++/impl/call.h
+++ b/include/grpc++/impl/call.h
@@ -67,14 +67,10 @@ class WriteOptions {
   WriteOptions(const WriteOptions& other) : flags_(other.flags_) {}
 
   /// Clear all flags.
-  inline void Clear() {
-    flags_ = 0;
-  }
+  inline void Clear() { flags_ = 0; }
 
   /// Returns raw flags bitset.
-  inline gpr_uint32 flags() const {
-    return flags_;
-  }
+  inline gpr_uint32 flags() const { return flags_; }
 
   /// Sets flag for the disabling of compression for the next message write.
   ///
@@ -122,9 +118,7 @@ class WriteOptions {
   /// not go out on the wire immediately.
   ///
   /// \sa GRPC_WRITE_BUFFER_HINT
-  inline bool get_buffer_hint() const {
-    return GetBit(GRPC_WRITE_BUFFER_HINT);
-  }
+  inline bool get_buffer_hint() const { return GetBit(GRPC_WRITE_BUFFER_HINT); }
 
   WriteOptions& operator=(const WriteOptions& rhs) {
     flags_ = rhs.flags_;
@@ -132,17 +126,11 @@ class WriteOptions {
   }
 
  private:
-  void SetBit(const gpr_int32 mask) {
-    flags_ |= mask;
-  }
+  void SetBit(const gpr_int32 mask) { flags_ |= mask; }
 
-  void ClearBit(const gpr_int32 mask) {
-    flags_ &= ~mask;
-  }
+  void ClearBit(const gpr_int32 mask) { flags_ &= ~mask; }
 
-  bool GetBit(const gpr_int32 mask) const {
-    return flags_ & mask;
-  }
+  bool GetBit(const gpr_int32 mask) const { return flags_ & mask; }
 
   gpr_uint32 flags_;
 };
diff --git a/include/grpc++/impl/grpc_library.h b/include/grpc++/impl/grpc_library.h
index f9fa677901..ce4211418d 100644
--- a/include/grpc++/impl/grpc_library.h
+++ b/include/grpc++/impl/grpc_library.h
@@ -46,5 +46,4 @@ class GrpcLibrary {
 
 }  // namespace grpc
 
-
 #endif  // GRPCXX_IMPL_GRPC_LIBRARY_H
diff --git a/include/grpc++/impl/serialization_traits.h b/include/grpc++/impl/serialization_traits.h
index 1f5c674e4c..3ea66a3405 100644
--- a/include/grpc++/impl/serialization_traits.h
+++ b/include/grpc++/impl/serialization_traits.h
@@ -37,12 +37,12 @@
 namespace grpc {
 
 /// Defines how to serialize and deserialize some type.
-/// 
+///
 /// Used for hooking different message serialization API's into GRPC.
 /// Each SerializationTraits implementation must provide the following
 /// functions:
 ///   static Status Serialize(const Message& msg,
-///                           grpc_byte_buffer** buffer, 
+///                           grpc_byte_buffer** buffer,
 //                            bool* own_buffer);
 ///   static Status Deserialize(grpc_byte_buffer* buffer,
 ///                             Message* msg,
@@ -57,7 +57,7 @@ namespace grpc {
 /// msg. max_message_size is passed in as a bound on the maximum number of
 /// message bytes Deserialize should accept.
 ///
-/// Both functions return a Status, allowing them to explain what went 
+/// Both functions return a Status, allowing them to explain what went
 /// wrong if required.
 template <class Message,
           class UnusedButHereForPartialTemplateSpecialization = void>
diff --git a/include/grpc++/impl/sync_no_cxx11.h b/include/grpc++/impl/sync_no_cxx11.h
index 5869b04c76..120a031045 100644
--- a/include/grpc++/impl/sync_no_cxx11.h
+++ b/include/grpc++/impl/sync_no_cxx11.h
@@ -38,7 +38,7 @@
 
 namespace grpc {
 
-template<class mutex>
+template <class mutex>
 class lock_guard;
 class condition_variable;
 
@@ -46,6 +46,7 @@ class mutex {
  public:
   mutex() { gpr_mu_init(&mu_); }
   ~mutex() { gpr_mu_destroy(&mu_); }
+
  private:
   ::gpr_mu mu_;
   template <class mutex>
@@ -58,6 +59,7 @@ class lock_guard {
  public:
   lock_guard(mutex &mu) : mu_(mu), locked(true) { gpr_mu_lock(&mu.mu_); }
   ~lock_guard() { unlock_internal(); }
+
  protected:
   void lock_internal() {
     if (!locked) gpr_mu_lock(&mu_.mu_);
@@ -67,6 +69,7 @@ class lock_guard {
     if (locked) gpr_mu_unlock(&mu_.mu_);
     locked = false;
   }
+
  private:
   mutex &mu_;
   bool locked;
@@ -76,7 +79,7 @@ class lock_guard {
 template <class mutex>
 class unique_lock : public lock_guard<mutex> {
  public:
-  unique_lock(mutex &mu) : lock_guard<mutex>(mu) { }
+  unique_lock(mutex &mu) : lock_guard<mutex>(mu) {}
   void lock() { this->lock_internal(); }
   void unlock() { this->unlock_internal(); }
 };
@@ -92,6 +95,7 @@ class condition_variable {
   }
   void notify_one() { gpr_cv_signal(&cv_); }
   void notify_all() { gpr_cv_broadcast(&cv_); }
+
  private:
   gpr_cv cv_;
 };
diff --git a/include/grpc++/impl/thd_no_cxx11.h b/include/grpc++/impl/thd_no_cxx11.h
index a6bdd7dfe9..84d03ce184 100644
--- a/include/grpc++/impl/thd_no_cxx11.h
+++ b/include/grpc++/impl/thd_no_cxx11.h
@@ -40,7 +40,8 @@ namespace grpc {
 
 class thread {
  public:
-  template<class T> thread(void (T::*fptr)(), T *obj) {
+  template <class T>
+  thread(void (T::*fptr)(), T *obj) {
     func_ = new thread_function<T>(fptr, obj);
     joined_ = false;
     start();
@@ -53,28 +54,28 @@ class thread {
     gpr_thd_join(thd_);
     joined_ = true;
   }
+
  private:
   void start() {
     gpr_thd_options options = gpr_thd_options_default();
     gpr_thd_options_set_joinable(&options);
-    gpr_thd_new(&thd_, thread_func, (void *) func_, &options);
+    gpr_thd_new(&thd_, thread_func, (void *)func_, &options);
   }
   static void thread_func(void *arg) {
-    thread_function_base *func = (thread_function_base *) arg;
+    thread_function_base *func = (thread_function_base *)arg;
     func->call();
   }
   class thread_function_base {
    public:
-    virtual ~thread_function_base() { }
+    virtual ~thread_function_base() {}
     virtual void call() = 0;
   };
-  template<class T>
+  template <class T>
   class thread_function : public thread_function_base {
    public:
-    thread_function(void (T::*fptr)(), T *obj)
-      : fptr_(fptr)
-      , obj_(obj) { }
+    thread_function(void (T::*fptr)(), T *obj) : fptr_(fptr), obj_(obj) {}
     virtual void call() { (obj_->*fptr_)(); }
+
    private:
     void (T::*fptr_)();
     T *obj_;
@@ -84,8 +85,8 @@ class thread {
   bool joined_;
 
   // Disallow copy and assign.
-  thread(const thread&);
-  void operator=(const thread&);
+  thread(const thread &);
+  void operator=(const thread &);
 };
 
 }  // namespace grpc
diff --git a/include/grpc++/server.h b/include/grpc++/server.h
index 084c9936d5..6a15dcb371 100644
--- a/include/grpc++/server.h
+++ b/include/grpc++/server.h
@@ -90,8 +90,9 @@ class Server GRPC_FINAL : public GrpcLibrary, private CallHook {
          int max_message_size);
   // 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, RpcService* service);
-  bool RegisterAsyncService(const grpc::string *host, AsynchronousService* service);
+  bool RegisterService(const grpc::string* host, RpcService* service);
+  bool RegisterAsyncService(const grpc::string* host,
+                            AsynchronousService* service);
   void RegisterAsyncGenericService(AsyncGenericService* service);
   // Add a listening port. Can be called multiple times.
   int AddListeningPort(const grpc::string& addr, ServerCredentials* creds);
diff --git a/include/grpc++/server_builder.h b/include/grpc++/server_builder.h
index 44ee00eec9..906daf1370 100644
--- a/include/grpc++/server_builder.h
+++ b/include/grpc++/server_builder.h
@@ -76,15 +76,14 @@ class ServerBuilder {
   // The service must exist for the lifetime of the Server instance returned by
   // BuildAndStart().
   // Only matches requests with :authority \a host
-  void RegisterService(const grpc::string& host, 
-                       SynchronousService* service);
+  void RegisterService(const grpc::string& host, SynchronousService* service);
 
   // Register an asynchronous service.
   // This call does not take ownership of the service or completion queue.
   // The service and completion queuemust exist for the lifetime of the Server
   // instance returned by BuildAndStart().
   // Only matches requests with :authority \a host
-  void RegisterAsyncService(const grpc::string& host, 
+  void RegisterAsyncService(const grpc::string& host,
                             AsynchronousService* service);
 
   // Set max message size in bytes.
@@ -117,9 +116,10 @@ class ServerBuilder {
   };
 
   typedef std::unique_ptr<grpc::string> HostString;
-  template <class T> struct NamedService {
+  template <class T>
+  struct NamedService {
     explicit NamedService(T* s) : service(s) {}
-    NamedService(const grpc::string& h, T *s)
+    NamedService(const grpc::string& h, T* s)
         : host(new grpc::string(h)), service(s) {}
     HostString host;
     T* service;
@@ -127,7 +127,8 @@ class ServerBuilder {
 
   int max_message_size_;
   std::vector<std::unique_ptr<NamedService<RpcService>>> services_;
-  std::vector<std::unique_ptr<NamedService<AsynchronousService>>> async_services_;
+  std::vector<std::unique_ptr<NamedService<AsynchronousService>>>
+      async_services_;
   std::vector<Port> ports_;
   std::vector<ServerCompletionQueue*> cqs_;
   std::shared_ptr<ServerCredentials> creds_;
diff --git a/include/grpc++/stream.h b/include/grpc++/stream.h
index bc0c3c0f3b..45dafcd282 100644
--- a/include/grpc++/stream.h
+++ b/include/grpc++/stream.h
@@ -85,9 +85,7 @@ class WriterInterface {
   // Returns false when the stream has been closed.
   virtual bool Write(const W& msg, const WriteOptions& options) = 0;
 
-  inline bool Write(const W& msg) {
-    return Write(msg, WriteOptions());
-  }
+  inline bool Write(const W& msg) { return Write(msg, WriteOptions()); }
 };
 
 template <class R>
@@ -640,9 +638,8 @@ class ServerAsyncReader GRPC_FINAL : public ServerAsyncStreamingInterface,
     }
     // The response is dropped if the status is not OK.
     if (status.ok()) {
-      finish_ops_.ServerSendStatus(
-          ctx_->trailing_metadata_,
-          finish_ops_.SendMessage(msg));
+      finish_ops_.ServerSendStatus(ctx_->trailing_metadata_,
+                                   finish_ops_.SendMessage(msg));
     } else {
       finish_ops_.ServerSendStatus(ctx_->trailing_metadata_, status);
     }