Revert format changes of unrelated files

src/objective-c/GRPCClient/GRPCCall+ChannelArg.h

@@ -40,18 +40,15 @@
 @interface GRPCCall (ChannelArg)
 
 /**
- * Use the provided @c userAgentPrefix at the beginning of the HTTP User Agent
- * string for all calls to the specified @c host.
+ * Use the provided @c userAgentPrefix at the beginning of the HTTP User Agent string for all calls
+ * to the specified @c host.
  */
-+ (void)setUserAgentPrefix:(nonnull NSString *)userAgentPrefix
-                   forHost:(nonnull NSString *)host;
++ (void)setUserAgentPrefix:(nonnull NSString *)userAgentPrefix forHost:(nonnull NSString *)host;
 
-/** The default response size limit is 4MB. Set this to override that default.
- */
+/** The default response size limit is 4MB. Set this to override that default. */
 + (void)setResponseSizeLimit:(NSUInteger)limit forHost:(nonnull NSString *)host;
 
-+ (void)closeOpenConnections DEPRECATED_MSG_ATTRIBUTE(
-    "The API for this feature is experimental, "
++ (void)closeOpenConnections DEPRECATED_MSG_ATTRIBUTE("The API for this feature is experimental, "
                                                       "and might be removed or modified at any "
                                                       "time.");
 @end

src/objective-c/GRPCClient/GRPCCall+ChannelCredentials.h

@@ -33,21 +33,19 @@
 
 #import "GRPCCall.h"
 
-/** Helpers for setting TLS Trusted Roots, Client Certificates, and Private Key
- */
+/** Helpers for setting TLS Trusted Roots, Client Certificates, and Private Key */
 @interface GRPCCall (ChannelCredentials)
 
 /**
- * Use the provided @c pemRootCert as the set of trusted root Certificate
- * Authorities for @c host.
+ * Use the provided @c pemRootCert as the set of trusted root Certificate Authorities for @c host.
  */
 + (BOOL)setTLSPEMRootCerts:(nullable NSString *)pemRootCert
                    forHost:(nonnull NSString *)host
                      error:(NSError * _Nullable * _Nullable)errorPtr;
 /**
- * Configures @c host with TLS/SSL Client Credentials and optionally trusted
- * root Certificate Authorities. If @c pemRootCerts is nil, the default CA
- * Certificates bundled with gRPC will be used.
+ * Configures @c host with TLS/SSL Client Credentials and optionally trusted root Certificate
+ * Authorities. If @c pemRootCerts is nil, the default CA Certificates bundled with gRPC will be
+ * used.
  */
 + (BOOL)setTLSPEMRootCerts:(nullable NSString *)pemRootCerts
             withPrivateKey:(nullable NSString *)pemPrivateKey

src/objective-c/GRPCClient/GRPCCall+OAuth2.h

@@ -37,17 +37,15 @@
 @interface GRPCCall (OAuth2)
 
 /**
- * Setting this property is equivalent to setting "Bearer <passed token>" as the
- * value of the request header with key "authorization" (the authorization
- * header). Setting it to nil removes the authorization header from the request.
- * The value obtained by getting the property is the OAuth2 bearer token if the
- * authorization header of the request has the form "Bearer <token>", or nil
- * otherwise.
+ * Setting this property is equivalent to setting "Bearer <passed token>" as the value of the
+ * request header with key "authorization" (the authorization header). Setting it to nil removes the
+ * authorization header from the request.
+ * The value obtained by getting the property is the OAuth2 bearer token if the authorization header
+ * of the request has the form "Bearer <token>", or nil otherwise.
  */
 @property(atomic, copy) NSString *oauth2AccessToken;
 
-/** Returns the value (if any) of the "www-authenticate" response header (the
- * challenge header). */
+/** Returns the value (if any) of the "www-authenticate" response header (the challenge header). */
 @property(atomic, readonly) NSString *oauth2ChallengeHeader;
 
 @end

src/objective-c/GRPCClient/GRPCCall+Tests.h

@@ -34,36 +34,33 @@
 #import "GRPCCall.h"
 
 /**
- * Methods to let tune down the security of gRPC connections for specific hosts.
- * These shouldn't be used in releases, but are sometimes needed for testing.
+ * Methods to let tune down the security of gRPC connections for specific hosts. These shouldn't be
+ * used in releases, but are sometimes needed for testing.
  */
 @interface GRPCCall (Tests)
 
 /**
- * Establish all SSL connections to the provided host using the passed SSL
- * target name and the root certificates found in the file at |certsPath|.
+ * Establish all SSL connections to the provided host using the passed SSL target name and the root
+ * certificates found in the file at |certsPath|.
  *
- * Must be called before any gRPC call to that host is made. It's illegal to
- * pass the same host to more than one invocation of the methods of this
- * category.
+ * Must be called before any gRPC call to that host is made. It's illegal to pass the same host to
+ * more than one invocation of the methods of this category.
  */
 + (void)useTestCertsPath:(NSString *)certsPath
                 testName:(NSString *)testName
                  forHost:(NSString *)host;
 
 /**
- * Establish all connections to the provided host using cleartext instead of
- * SSL.
+ * Establish all connections to the provided host using cleartext instead of SSL.
  *
- * Must be called before any gRPC call to that host is made. It's illegal to
- * pass the same host to more than one invocation of the methods of this
- * category.
+ * Must be called before any gRPC call to that host is made. It's illegal to pass the same host to
+ * more than one invocation of the methods of this category.
  */
 + (void)useInsecureConnectionsForHost:(NSString *)host;
 
 /**
- * Resets all host configurations to their default values, and flushes all
- * connections from the cache.
+ * Resets all host configurations to their default values, and flushes all connections from the
+ * cache.
  */
 + (void)resetHostSettings;
 @end

src/objective-c/GRPCClient/GRPCCall.h

@@ -34,18 +34,17 @@
 /**
  * The gRPC protocol is an RPC protocol on top of HTTP2.
  *
- * While the most common type of RPC receives only one request message and
- * returns only one response message, the protocol also supports RPCs that
- * return multiple individual messages in a streaming fashion, RPCs that accept
- * a stream of request messages, or RPCs with both streaming requests and
+ * While the most common type of RPC receives only one request message and returns only one response
+ * message, the protocol also supports RPCs that return multiple individual messages in a streaming
+ * fashion, RPCs that accept a stream of request messages, or RPCs with both streaming requests and
  * responses.
  *
- * Conceptually, each gRPC call consists of a bidirectional stream of binary
- * messages, with RPCs of the "non-streaming type" sending only one message in
- * the corresponding direction (the protocol doesn't make any distinction).
+ * Conceptually, each gRPC call consists of a bidirectional stream of binary messages, with RPCs of
+ * the "non-streaming type" sending only one message in the corresponding direction (the protocol
+ * doesn't make any distinction).
  *
- * Each RPC uses a different HTTP2 stream, and thus multiple simultaneous RPCs
- * can be multiplexed transparently on the same TCP connection.
+ * Each RPC uses a different HTTP2 stream, and thus multiple simultaneous RPCs can be multiplexed
+ * transparently on the same TCP connection.
  */
 
 #import <Foundation/Foundation.h>
@@ -60,56 +59,51 @@ extern NSString *const kGRPCErrorDomain;
 
 /**
  * gRPC error codes.
- * Note that a few of these are never produced by the gRPC libraries, but are of
- * general utility for server applications to produce.
+ * Note that a few of these are never produced by the gRPC libraries, but are of general utility for
+ * server applications to produce.
  */
 typedef NS_ENUM(NSUInteger, GRPCErrorCode) {
   /** The operation was cancelled (typically by the caller). */
   GRPCErrorCodeCancelled = 1,
 
   /**
-   * Unknown error. Errors raised by APIs that do not return enough error
-   * information may be
+   * Unknown error. Errors raised by APIs that do not return enough error information may be
    * converted to this error.
    */
   GRPCErrorCodeUnknown = 2,
 
   /**
-   * The client specified an invalid argument. Note that this differs from
-   * FAILED_PRECONDITION.
-   * INVALID_ARGUMENT indicates arguments that are problematic regardless of the
-   * state of the server (e.g., a malformed file name).
+   * The client specified an invalid argument. Note that this differs from FAILED_PRECONDITION.
+   * INVALID_ARGUMENT indicates arguments that are problematic regardless of the state of the
+   * server (e.g., a malformed file name).
    */
   GRPCErrorCodeInvalidArgument = 3,
 
   /**
-   * Deadline expired before operation could complete. For operations that
-   * change the state of the server, this error may be returned even if the
-   * operation has completed successfully. For example, a successful response
-   * from the server could have been delayed long enough for the deadline to
-   * expire.
+   * Deadline expired before operation could complete. For operations that change the state of the
+   * server, this error may be returned even if the operation has completed successfully. For
+   * example, a successful response from the server could have been delayed long enough for the
+   * deadline to expire.
    */
   GRPCErrorCodeDeadlineExceeded = 4,
 
   /** Some requested entity (e.g., file or directory) was not found. */
   GRPCErrorCodeNotFound = 5,
 
-  /** Some entity that we attempted to create (e.g., file or directory) already
-     exists. */
+  /** Some entity that we attempted to create (e.g., file or directory) already exists. */
   GRPCErrorCodeAlreadyExists = 6,
 
   /**
-   * The caller does not have permission to execute the specified operation.
-   * PERMISSION_DENIED isn't used for rejections caused by exhausting some
-   * resource (RESOURCE_EXHAUSTED is used instead for those errors).
-   * PERMISSION_DENIED doesn't indicate a failure to identify the caller
+   * The caller does not have permission to execute the specified operation. PERMISSION_DENIED isn't
+   * used for rejections caused by exhausting some resource (RESOURCE_EXHAUSTED is used instead for
+   * those errors). PERMISSION_DENIED doesn't indicate a failure to identify the caller
    * (UNAUTHENTICATED is used instead for those errors).
    */
   GRPCErrorCodePermissionDenied = 7,
 
   /**
-   * The request does not have valid authentication credentials for the
-   * operation (e.g. the caller's identity can't be verified).
+   * The request does not have valid authentication credentials for the operation (e.g. the caller's
+   * identity can't be verified).
    */
   GRPCErrorCodeUnauthenticated = 16,
 
@@ -117,47 +111,42 @@ typedef NS_ENUM(NSUInteger, GRPCErrorCode) {
   GRPCErrorCodeResourceExhausted = 8,
 
   /**
-   * The RPC was rejected because the server is not in a state required for the
-   * procedure's
+   * The RPC was rejected because the server is not in a state required for the procedure's
    * execution. For example, a directory to be deleted may be non-empty, etc.
-   * The client should not retry until the server state has been explicitly
-   * fixed (e.g. by
-   * performing another RPC). The details depend on the service being called,
-   * and should be found in the NSError's userInfo.
+   * The client should not retry until the server state has been explicitly fixed (e.g. by
+   * performing another RPC). The details depend on the service being called, and should be found in
+   * the NSError's userInfo.
    */
   GRPCErrorCodeFailedPrecondition = 9,
 
   /**
-   * The RPC was aborted, typically due to a concurrency issue like sequencer
-   * check failures, transaction aborts, etc. The client should retry at a
-   * higher-level (e.g., restarting a read-modify-write sequence).
+   * The RPC was aborted, typically due to a concurrency issue like sequencer check failures,
+   * transaction aborts, etc. The client should retry at a higher-level (e.g., restarting a read-
+   * modify-write sequence).
    */
   GRPCErrorCodeAborted = 10,
 
   /**
-   * The RPC was attempted past the valid range. E.g., enumerating past the end
-   * of a list.
-   * Unlike INVALID_ARGUMENT, this error indicates a problem that may be fixed
-   * if the system state changes. For example, an RPC to get elements of a list
-   * will generate INVALID_ARGUMENT if asked to return the element at a negative
-   * index, but it will generate OUT_OF_RANGE if asked to return the element at
-   * an index past the current size of the list.
+   * The RPC was attempted past the valid range. E.g., enumerating past the end of a list.
+   * Unlike INVALID_ARGUMENT, this error indicates a problem that may be fixed if the system state
+   * changes. For example, an RPC to get elements of a list will generate INVALID_ARGUMENT if asked
+   * to return the element at a negative index, but it will generate OUT_OF_RANGE if asked to return
+   * the element at an index past the current size of the list.
    */
   GRPCErrorCodeOutOfRange = 11,
 
-  /** The procedure is not implemented or not supported/enabled in this server.
-     */
+  /** The procedure is not implemented or not supported/enabled in this server. */
   GRPCErrorCodeUnimplemented = 12,
 
   /**
-   * Internal error. Means some invariant expected by the server application or
-   * the gRPC library has been broken.
+   * Internal error. Means some invariant expected by the server application or the gRPC library has
+   * been broken.
    */
   GRPCErrorCodeInternal = 13,
 
   /**
-   * The server is currently unavailable. This is most likely a transient
-   * condition and may be corrected by retrying with a backoff.
+   * The server is currently unavailable. This is most likely a transient condition and may be
+   * corrected by retrying with a backoff.
    */
   GRPCErrorCodeUnavailable = 14,
 
@@ -169,19 +158,17 @@ typedef NS_ENUM(NSUInteger, GRPCErrorCode) {
  * Safety remark of a gRPC method as defined in RFC 2616 Section 9.1
  */
 typedef NS_ENUM(NSUInteger, GRPCCallSafety) {
-  /** Signal that there is no guarantees on how the call affects the server
-     state. */
+  /** Signal that there is no guarantees on how the call affects the server state. */
   GRPCCallSafetyDefault = 0,
   /** Signal that the call is idempotent. gRPC is free to use PUT verb. */
   GRPCCallSafetyIdempotentRequest = 1,
-  /** Signal that the call is cacheable and will not affect server state. gRPC
-     is free to use GET verb. */
+  /** Signal that the call is cacheable and will not affect server state. gRPC is free to use GET verb. */
   GRPCCallSafetyCacheableRequest = 2,
 };
 
 /**
- * Keys used in |NSError|'s |userInfo| dictionary to store the response headers
- * and trailers sent by the server.
+ * Keys used in |NSError|'s |userInfo| dictionary to store the response headers and trailers sent by
+ * the server.
  */
 extern id const kGRPCHeadersKey;
 extern id const kGRPCTrailersKey;
@@ -192,24 +179,20 @@ extern id const kGRPCTrailersKey;
 @interface GRPCCall : GRXWriter
 
 /**
- * The container of the request headers of an RPC conforms to this protocol,
- * which is a subset of NSMutableDictionary's interface. It will become a
- * NSMutableDictionary later on. The keys of this container are the header
- * names, which per the HTTP standard are case-insensitive. They are stored in
- * lowercase (which is how HTTP/2 mandates them on the wire), and can only
- * consist of ASCII characters.
- * A header value is a NSString object (with only ASCII characters), unless the
- * header name has the suffix "-bin", in which case the value has to be a NSData
- * object.
+ * The container of the request headers of an RPC conforms to this protocol, which is a subset of
+ * NSMutableDictionary's interface. It will become a NSMutableDictionary later on.
+ * The keys of this container are the header names, which per the HTTP standard are case-
+ * insensitive. They are stored in lowercase (which is how HTTP/2 mandates them on the wire), and
+ * can only consist of ASCII characters.
+ * A header value is a NSString object (with only ASCII characters), unless the header name has the
+ * suffix "-bin", in which case the value has to be a NSData object.
  */
 /**
- * These HTTP headers will be passed to the server as part of this call. Each
- * HTTP header is a name-value pair with string names and either string or
- * binary values.
+ * These HTTP headers will be passed to the server as part of this call. Each HTTP header is a
+ * name-value pair with string names and either string or binary values.
  *
- * The passed dictionary has to use NSString keys, corresponding to the header
- * names. The value associated to each can be a NSString object or a NSData
- * object. E.g.:
+ * The passed dictionary has to use NSString keys, corresponding to the header names. The value
+ * associated to each can be a NSString object or a NSData object. E.g.:
  *
  * call.requestHeaders = @{@"authorization": @"Bearer ..."};
  *
@@ -222,61 +205,53 @@ extern id const kGRPCTrailersKey;
 @property(atomic, readonly) NSMutableDictionary *requestHeaders;
 
 /**
- * This dictionary is populated with the HTTP headers received from the server.
- * This happens before any response message is received from the server. It has
- * the same structure as the request headers dictionary: Keys are NSString
- * header names; names ending with the suffix "-bin" have a NSData value; the
- * others have a NSString value.
+ * This dictionary is populated with the HTTP headers received from the server. This happens before
+ * any response message is received from the server. It has the same structure as the request
+ * headers dictionary: Keys are NSString header names; names ending with the suffix "-bin" have a
+ * NSData value; the others have a NSString value.
  *
- * The value of this property is nil until all response headers are received,
- * and will change before any of -writeValue: or -writesFinishedWithError: are
- * sent to the writeable.
+ * The value of this property is nil until all response headers are received, and will change before
+ * any of -writeValue: or -writesFinishedWithError: are sent to the writeable.
  */
 @property(atomic, readonly) NSDictionary *responseHeaders;
 
 /**
- * Same as responseHeaders, but populated with the HTTP trailers received from
- * the server before the call finishes.
+ * Same as responseHeaders, but populated with the HTTP trailers received from the server before the
+ * call finishes.
  *
- * The value of this property is nil until all response trailers are received,
- * and will change before -writesFinishedWithError: is sent to the writeable.
+ * The value of this property is nil until all response trailers are received, and will change
+ * before -writesFinishedWithError: is sent to the writeable.
  */
 @property(atomic, readonly) NSDictionary *responseTrailers;
 
 /**
- * The request writer has to write NSData objects into the provided Writeable.
- * The server will receive each of those separately and in order as distinct
- * messages.
- * A gRPC call might not complete until the request writer finishes. On the
- * other hand, the request finishing doesn't necessarily make the call to
- * finish, as the server might continue sending messages to the response side of
- * the call indefinitely (depending on the semantics of the specific remote
- * method called).
+ * The request writer has to write NSData objects into the provided Writeable. The server will
+ * receive each of those separately and in order as distinct messages.
+ * A gRPC call might not complete until the request writer finishes. On the other hand, the request
+ * finishing doesn't necessarily make the call to finish, as the server might continue sending
+ * messages to the response side of the call indefinitely (depending on the semantics of the
+ * specific remote method called).
  * To finish a call right away, invoke cancel.
- * host parameter should not contain the scheme (http:// or https://), only the
- * name or IP addr and the port number, for example @"localhost:5050".
+ * host parameter should not contain the scheme (http:// or https://), only the name or IP addr
+ * and the port number, for example @"localhost:5050".
  */
 - (instancetype)initWithHost:(NSString *)host
                         path:(NSString *)path
-              requestsWriter:(GRXWriter *)requestsWriter
-    NS_DESIGNATED_INITIALIZER;
+              requestsWriter:(GRXWriter *)requestsWriter NS_DESIGNATED_INITIALIZER;
 
 /**
- * Finishes the request side of this call, notifies the server that the RPC
- * should be cancelled, and finishes the response side of the call with an error
- * of code CANCELED.
+ * Finishes the request side of this call, notifies the server that the RPC should be cancelled, and
+ * finishes the response side of the call with an error of code CANCELED.
  */
 - (void)cancel;
 
 /**
  * Set the call flag for a specific host path.
  *
- * Host parameter should not contain the scheme (http:// or https://), only the
- * name or IP addr and the port number, for example @"localhost:5050".
+ * Host parameter should not contain the scheme (http:// or https://), only the name or IP addr
+ * and the port number, for example @"localhost:5050".
  */
-+ (void)setCallSafety:(GRPCCallSafety)callSafety
-                 host:(NSString *)host
-                 path:(NSString *)path;
++ (void)setCallSafety:(GRPCCallSafety)callSafety host:(NSString *)host path:(NSString *)path;
 
 // TODO(jcanizales): Let specify a deadline. As a category of GRXWriter?
 @end

src/objective-c/GRPCClient/private/GRPCCompletionQueue.h

@@ -37,16 +37,15 @@
 typedef void(^GRPCQueueCompletionHandler)(bool success);
 
 /**
- * This class lets one more easily use |grpc_completion_queue|. To use it, pass
- * the value of the |unmanagedQueue| property of an instance of this class to
- * |grpc_channel_create_call|. Then for every |grpc_call_*| method that accepts
- * a tag, you can pass a block of type |GRPCQueueCompletionHandler| (remembering
- * to cast it using |__bridge_retained|). The block is guaranteed to eventually
- * be called, by a concurrent queue, and then released. Each such block is
+ * This class lets one more easily use |grpc_completion_queue|. To use it, pass the value of the
+ * |unmanagedQueue| property of an instance of this class to |grpc_channel_create_call|. Then for
+ * every |grpc_call_*| method that accepts a tag, you can pass a block of type
+ * |GRPCQueueCompletionHandler| (remembering to cast it using |__bridge_retained|). The block is
+ * guaranteed to eventually be called, by a concurrent queue, and then released. Each such block is
  * passed a |bool| that tells if the operation was successful.
  *
- * Release the GRPCCompletionQueue object only after you are not going to pass
- * any more blocks to the |grpc_call| that's using it.
+ * Release the GRPCCompletionQueue object only after you are not going to pass any more blocks to
+ * the |grpc_call| that's using it.
  */
 @interface GRPCCompletionQueue : NSObject
 @property(nonatomic, readonly) grpc_completion_queue *unmanagedQueue;

src/objective-c/GRPCClient/private/GRPCRequestHeaders.m

@@ -40,8 +40,7 @@
 // Used by the setter.
 static void CheckIsNonNilASCII(NSString *name, NSString* value) {
   if (!value) {
-    [NSException raise:NSInvalidArgumentException
-                format:@"%@ cannot be nil", name];
+    [NSException raise:NSInvalidArgumentException format:@"%@ cannot be nil", name];
   }
   if (![value canBeConvertedToEncoding:NSASCIIStringEncoding]) {
     [NSException raise:NSInvalidArgumentException
@@ -53,20 +52,15 @@ static void CheckIsNonNilASCII(NSString *name, NSString *value) {
 static void CheckKeyValuePairIsValid(NSString *key, id value) {
   if ([key hasSuffix:@"-bin"]) {
     if (![value isKindOfClass:NSData.class]) {
-      [NSException
-           raise:NSInvalidArgumentException
+      [NSException raise:NSInvalidArgumentException
                   format:@"Expected NSData value for header %@ ending in \"-bin\", "
-                 @"instead got %@",
-                 key, value];
+       @"instead got %@", key, value];
     }
   } else {
     if (![value isKindOfClass:NSString.class]) {
-      [NSException
-           raise:NSInvalidArgumentException
-          format:
-              @"Expected NSString value for header %@ not ending in \"-bin\", "
-              @"instead got %@",
-              key, value];
+      [NSException raise:NSInvalidArgumentException
+                  format:@"Expected NSString value for header %@ not ending in \"-bin\", "
+       @"instead got %@", key, value];
     }
     CheckIsNonNilASCII(@"Text header value", (NSString *)value);
   }
@@ -74,10 +68,9 @@ static void CheckKeyValuePairIsValid(NSString *key, id value) {
 
 @implementation GRPCRequestHeaders {
   __weak GRPCCall *_call;
-  // The NSMutableDictionary superclass doesn't hold any storage (so that people
-  // can implement their own in subclasses). As that's not the reason we're
-  // subclassing, we just delegate storage to the default NSMutableDictionary
-  // subclass returned by the cluster (e.g. __NSDictionaryM on iOS 9).
+  // The NSMutableDictionary superclass doesn't hold any storage (so that people can implement their
+  // own in subclasses). As that's not the reason we're subclassing, we just delegate storage to the
+  // default NSMutableDictionary subclass returned by the cluster (e.g. __NSDictionaryM on iOS 9).
   NSMutableDictionary *_delegate;
 }
 
@@ -98,8 +91,7 @@ static void CheckKeyValuePairIsValid(NSString *key, id value) {
 }
 
 // Designated initializer
-- (instancetype)initWithCall:(GRPCCall *)call
-                     storage:(NSMutableDictionary *)storage {
+- (instancetype)initWithCall:(GRPCCall *)call storage:(NSMutableDictionary *)storage {
   // TODO(jcanizales): Throw if call or storage are nil.
   if ((self = [super init])) {
     _call = call;
@@ -108,8 +100,7 @@ static void CheckKeyValuePairIsValid(NSString *key, id value) {
   return self;
 }
 
-- (instancetype)
-initWithObjects:(const id _Nonnull __unsafe_unretained *)objects
+- (instancetype)initWithObjects:(const id  _Nonnull __unsafe_unretained *)objects
                         forKeys:(const id<NSCopying>  _Nonnull __unsafe_unretained *)keys
                           count:(NSUInteger)cnt {
   return [self init];

src/objective-c/GRPCClient/private/GRPCWrappedCall.m

@@ -34,20 +34,20 @@
 #import "GRPCWrappedCall.h"
 
 #import <Foundation/Foundation.h>
-#include <grpc/byte_buffer.h>
 #include <grpc/grpc.h>
+#include <grpc/byte_buffer.h>
 #include <grpc/support/alloc.h>
 
 #import "GRPCCompletionQueue.h"
 #import "GRPCHost.h"
-#import "NSData+GRPC.h"
 #import "NSDictionary+GRPC.h"
+#import "NSData+GRPC.h"
 #import "NSError+GRPC.h"
 
 @implementation GRPCOperation {
 @protected
-  // Most operation subclasses don't set any flags in the grpc_op, and rely on
-  // the flag member being initialized to zero.
+  // Most operation subclasses don't set any flags in the grpc_op, and rely on the flag member being
+  // initialized to zero.
   grpc_op _op;
   void(^_handler)();
 }
@@ -101,8 +101,7 @@
 
 - (instancetype)initWithMessage:(NSData *)message handler:(void (^)())handler {
   if (!message) {
-    [NSException raise:NSInvalidArgumentException
-                format:@"message cannot be nil"];
+    [NSException raise:NSInvalidArgumentException format:@"message cannot be nil"];
   }
   if (self = [super init]) {
     _op.op = GRPC_OP_SEND_MESSAGE;
@@ -217,8 +216,7 @@
       __weak typeof(self) weakSelf = self;
       _handler = ^{
         __strong typeof(self) strongSelf = weakSelf;
-        NSError *error =
-            [NSError grpc_errorFromStatusCode:strongSelf->_statusCode
+        NSError *error = [NSError grpc_errorFromStatusCode:strongSelf->_statusCode
                                                    details:strongSelf->_details];
         NSDictionary *trailers = [NSDictionary
                                   grpc_dictionaryFromMetadataArray:strongSelf->_trailers];
@@ -247,21 +245,20 @@
   return [self initWithHost:nil path:nil];
 }
 
-- (instancetype)initWithHost:(NSString *)host path:(NSString *)path {
+- (instancetype)initWithHost:(NSString *)host
+                        path:(NSString *)path {
   if (!path || !host) {
     [NSException raise:NSInvalidArgumentException
                 format:@"path and host cannot be nil."];
   }
 
   if (self = [super init]) {
-    // Each completion queue consumes one thread. There's a trade to be made
-    // between creating and consuming too many threads and having contention of
-    // multiple calls in a single completion queue. Currently we use a singleton
-    // queue.
+    // Each completion queue consumes one thread. There's a trade to be made between creating and
+    // consuming too many threads and having contention of multiple calls in a single completion
+    // queue. Currently we use a singleton queue.
     _queue = [GRPCCompletionQueue completionQueue];
 
-    _call = [[GRPCHost hostWithAddress:host] unmanagedCallWithPath:path
-                                                   completionQueue:_queue];
+    _call = [[GRPCHost hostWithAddress:host] unmanagedCallWithPath:path completionQueue:_queue];
     if (_call == NULL) {
       return nil;
     }
@@ -273,16 +270,15 @@
   [self startBatchWithOperations:operations errorHandler:nil];
 }
 
-- (void)startBatchWithOperations:(NSArray *)operations
-                    errorHandler:(void (^)())errorHandler {
+- (void)startBatchWithOperations:(NSArray *)operations errorHandler:(void (^)())errorHandler {
   size_t nops = operations.count;
   grpc_op *ops_array = gpr_malloc(nops * sizeof(grpc_op));
   size_t i = 0;
   for (GRPCOperation *operation in operations) {
     ops_array[i++] = operation.op;
   }
-  grpc_call_error error = grpc_call_start_batch(
-      _call, ops_array, nops, (__bridge_retained void *)(^(bool success) {
+  grpc_call_error error = grpc_call_start_batch(_call, ops_array, nops,
+                                                (__bridge_retained void *)(^(bool success){
     if (!success) {
       if (errorHandler) {
         errorHandler();
@@ -293,14 +289,12 @@
     for (GRPCOperation *operation in operations) {
       [operation finish];
     }
-      }),
-      NULL);
+  }), NULL);
   gpr_free(ops_array);
 
   if (error != GRPC_CALL_OK) {
     [NSException raise:NSInternalInconsistencyException
-                format:@"A precondition for calling grpc_call_start_batch "
-                       @"wasn't met. Error %i",
+                format:@"A precondition for calling grpc_call_start_batch wasn't met. Error %i",
      error];
   }
 }

src/objective-c/GRPCClient/private/NSError+GRPC.h

@@ -36,9 +36,8 @@
 
 @interface NSError (GRPC)
 /**
- * Returns nil if the status code is OK. Otherwise, a NSError whose code is one
- * of |GRPCErrorCode| and whose domain is |kGRPCErrorDomain|.
+ * Returns nil if the status code is OK. Otherwise, a NSError whose code is one of |GRPCErrorCode|
+ * and whose domain is |kGRPCErrorDomain|.
  */
-+ (instancetype)grpc_errorFromStatusCode:(grpc_status_code)statusCode
-                                 details:(char *)details;
++ (instancetype)grpc_errorFromStatusCode:(grpc_status_code)statusCode details:(char *)details;
 @end