Mojo: clang-format mojo/public/c/... and add a presubmit check.

mojo/public/c/system/message_pipe.h

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // This file contains types/constants and functions specific to message pipes.
 //
 // Note: This header should be compilable as C.
 
 #ifndef MOJO_PUBLIC_C_SYSTEM_MESSAGE_PIPE_H_
 #define MOJO_PUBLIC_C_SYSTEM_MESSAGE_PIPE_H_
@@ skipping 10 matching lines @@
 //   |MojoCreateMessagePipeOptionsFlags flags|: Reserved for future use.
 //       |MOJO_CREATE_MESSAGE_PIPE_OPTIONS_FLAG_NONE|: No flags; default mode.
 
 typedef uint32_t MojoCreateMessagePipeOptionsFlags;
 
 #ifdef __cplusplus
 const MojoCreateMessagePipeOptionsFlags
     MOJO_CREATE_MESSAGE_PIPE_OPTIONS_FLAG_NONE = 0;
 #else
 #define MOJO_CREATE_MESSAGE_PIPE_OPTIONS_FLAG_NONE \
-    ((MojoCreateMessagePipeOptionsFlags) 0)
+  ((MojoCreateMessagePipeOptionsFlags)0)
 #endif
 
 MOJO_COMPILE_ASSERT(MOJO_ALIGNOF(int64_t) == 8, int64_t_has_weird_alignment);
 struct MOJO_ALIGNAS(8) MojoCreateMessagePipeOptions {
   uint32_t struct_size;
   MojoCreateMessagePipeOptionsFlags flags;
 };
 MOJO_COMPILE_ASSERT(sizeof(MojoCreateMessagePipeOptions) == 8,
                     MojoCreateMessagePipeOptions_has_wrong_size);
 
 // |MojoWriteMessageFlags|: Used to specify different modes to
 // |MojoWriteMessage()|.
 //   |MOJO_WRITE_MESSAGE_FLAG_NONE| - No flags; default mode.
 
 typedef uint32_t MojoWriteMessageFlags;
 
 #ifdef __cplusplus
 const MojoWriteMessageFlags MOJO_WRITE_MESSAGE_FLAG_NONE = 0;
 #else
-#define MOJO_WRITE_MESSAGE_FLAG_NONE ((MojoWriteMessageFlags) 0)
+#define MOJO_WRITE_MESSAGE_FLAG_NONE ((MojoWriteMessageFlags)0)
 #endif
 
 // |MojoReadMessageFlags|: Used to specify different modes to
 // |MojoReadMessage()|.
 //   |MOJO_READ_MESSAGE_FLAG_NONE| - No flags; default mode.
 //   |MOJO_READ_MESSAGE_FLAG_MAY_DISCARD| - If the message is unable to be read
 //       for whatever reason (e.g., the caller-supplied buffer is too small),
 //       discard the message (i.e., simply dequeue it).
 
 typedef uint32_t MojoReadMessageFlags;
 
 #ifdef __cplusplus
 const MojoReadMessageFlags MOJO_READ_MESSAGE_FLAG_NONE = 0;
 const MojoReadMessageFlags MOJO_READ_MESSAGE_FLAG_MAY_DISCARD = 1 << 0;
 #else
-#define MOJO_READ_MESSAGE_FLAG_NONE ((MojoReadMessageFlags) 0)
-#define MOJO_READ_MESSAGE_FLAG_MAY_DISCARD ((MojoReadMessageFlags) 1 << 0)
+#define MOJO_READ_MESSAGE_FLAG_NONE ((MojoReadMessageFlags)0)
+#define MOJO_READ_MESSAGE_FLAG_MAY_DISCARD ((MojoReadMessageFlags)1 << 0)
 #endif
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 // Note: See the comment in functions.h about the meaning of the "optional"
 // label for pointer parameters.
 
 // Creates a message pipe, which is a bidirectional communication channel for
 // framed data (i.e., messages). Messages can contain plain data and/or Mojo
 // handles.
 //
 // |options| may be set to null for a message pipe with the default options.
 //
 // On success, |*message_pipe_handle0| and |*message_pipe_handle1| are set to
 // handles for the two endpoints (ports) for the message pipe.
 //
 // Returns:
 //   |MOJO_RESULT_OK| on success.
 //   |MOJO_RESULT_INVALID_ARGUMENT| if some argument was invalid (e.g.,
 //       |*options| is invalid).
 //   |MOJO_RESULT_RESOURCE_EXHAUSTED| if a process/system/quota/etc. limit has
 //       been reached.
 //
 // TODO(vtl): Add an options struct pointer argument.
 MOJO_SYSTEM_EXPORT MojoResult MojoCreateMessagePipe(
     const struct MojoCreateMessagePipeOptions* options,  // Optional.
-    MojoHandle* message_pipe_handle0,  // Out.
-    MojoHandle* message_pipe_handle1);  // Out.
+    MojoHandle* message_pipe_handle0,                    // Out.
+    MojoHandle* message_pipe_handle1);                   // Out.
 
 // Writes a message to the message pipe endpoint given by |message_pipe_handle|,
 // with message data specified by |bytes| of size |num_bytes| and attached
 // handles specified by |handles| of count |num_handles|, and options specified
 // by |flags|. If there is no message data, |bytes| may be null, in which case
 // |num_bytes| must be zero. If there are no attached handles, |handles| may be
 // null, in which case |num_handles| must be zero.
 //
 // If handles are attached, on success the handles will no longer be valid (the
 // receiver will receive equivalent, but logically different, handles). Handles
 // to be sent should not be in simultaneous use (e.g., on another thread).
 //
 // Returns:
 //   |MOJO_RESULT_OK| on success (i.e., the message was enqueued).
 //   |MOJO_RESULT_INVALID_ARGUMENT| if some argument was invalid (e.g., if
 //       |message_pipe_handle| is not a valid handle, or some of the
 //       requirements above are not satisfied).
 //   |MOJO_RESULT_RESOURCE_EXHAUSTED| if some system limit has been reached, or
 //       the number of handles to send is too large (TODO(vtl): reconsider the
 //       latter case).
 //   |MOJO_RESULT_FAILED_PRECONDITION| if the other endpoint has been closed.
 //       Note that closing an endpoint is not necessarily synchronous (e.g.,
 //       across processes), so this function may be succeed even if the other
 //       endpoint has been closed (in which case the message would be dropped).
 //   |MOJO_RESULT_UNIMPLEMENTED| if an unsupported flag was set in |*options|.
 //   |MOJO_RESULT_BUSY| if some handle to be sent is currently in use.
 //
 // TODO(vtl): Add a notion of capacity for message pipes, and return
 // |MOJO_RESULT_SHOULD_WAIT| if the message pipe is full.
-MOJO_SYSTEM_EXPORT MojoResult MojoWriteMessage(
-    MojoHandle message_pipe_handle,
-    const void* bytes,  // Optional.
-    uint32_t num_bytes,
-    const MojoHandle* handles,  // Optional.
-    uint32_t num_handles,
-    MojoWriteMessageFlags flags);
+MOJO_SYSTEM_EXPORT MojoResult
+    MojoWriteMessage(MojoHandle message_pipe_handle,
+                     const void* bytes,  // Optional.
+                     uint32_t num_bytes,
+                     const MojoHandle* handles,  // Optional.
+                     uint32_t num_handles,
+                     MojoWriteMessageFlags flags);
 
 // Reads a message from the message pipe endpoint given by
 // |message_pipe_handle|; also usable to query the size of the next message or
 // discard the next message. |bytes|/|*num_bytes| indicate the buffer/buffer
 // size to receive the message data (if any) and |handles|/|*num_handles|
 // indicate the buffer/maximum handle count to receive the attached handles (if
 // any).
 //
 // |num_bytes| and |num_handles| are optional "in-out" parameters. If non-null,
 // on return |*num_bytes| and |*num_handles| will usually indicate the number
@@ skipping 12 matching lines @@
 // Returns:
 //   |MOJO_RESULT_OK| on success (i.e., a message was actually read).
 //   |MOJO_RESULT_INVALID_ARGUMENT| if some argument was invalid.
 //   |MOJO_RESULT_FAILED_PRECONDITION| if the other endpoint has been closed.
 //   |MOJO_RESULT_RESOURCE_EXHAUSTED| if one of the buffers to receive the
 //       message/attached handles (|bytes|/|*num_bytes| or
 //       |handles|/|*num_handles|) was too small. (TODO(vtl): Reconsider this
 //       error code; should distinguish this from the hitting-system-limits
 //       case.)
 //   |MOJO_RESULT_SHOULD_WAIT| if no message was available to be read.
-MOJO_SYSTEM_EXPORT MojoResult MojoReadMessage(
-    MojoHandle message_pipe_handle,
-    void* bytes,  // Optional out.
-    uint32_t* num_bytes,  // Optional in/out.
-    MojoHandle* handles,  // Optional out.
-    uint32_t* num_handles,  // Optional in/out.
-    MojoReadMessageFlags flags);
+MOJO_SYSTEM_EXPORT MojoResult
+    MojoReadMessage(MojoHandle message_pipe_handle,
+                    void* bytes,            // Optional out.
+                    uint32_t* num_bytes,    // Optional in/out.
+                    MojoHandle* handles,    // Optional out.
+                    uint32_t* num_handles,  // Optional in/out.
+                    MojoReadMessageFlags flags);
 
 #ifdef __cplusplus
 }  // extern "C"
 #endif
 
 #endif  // MOJO_PUBLIC_C_SYSTEM_MESSAGE_PIPE_H_