Add rights for mapping buffer. Update (shared) buffer APIs.

mojo/public/c/system/handle.h

 // Copyright 2016 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 Mojo system handle-related declarations/definitions.
 //
 // Note: This header should be compilable as C.
 
 #ifndef MOJO_PUBLIC_C_SYSTEM_HANDLE_H_
 #define MOJO_PUBLIC_C_SYSTEM_HANDLE_H_
@@ skipping 17 matching lines @@
 //   |MOJO_HANDLE_RIGHT_NONE| - No rights.
 //   |MOJO_HANDLE_RIGHT_DUPLICATE| - Right to duplicate a handle.
 //   |MOJO_HANDLE_RIGHT_TRANSFER| - Right to transfer a handle (e.g., include in
 //       a message).
 //   |MOJO_HANDLE_RIGHT_READ| - Right to "read" from the handle (e.g., read a
 //       message).
 //   |MOJO_HANDLE_RIGHT_WRITE| - Right to "write" to the handle (e.g., write a
 //       message).
 //   |MOJO_HANDLE_RIGHT_GET_OPTIONS| - Right to get a handle's options.
 //   |MOJO_HANDLE_RIGHT_SET_OPTIONS| - Right to set a handle's options.
+//   |MOJO_HANDLE_RIGHT_MAP_READABLE| - Right to "map" a (e.g., buffer) handle
+//       as readable memory.
+//   |MOJO_HANDLE_RIGHT_MAP_WRITABLE| - Right to "map" a (e.g., buffer) handle
+//       as writable memory.
+//   |MOJO_HANDLE_RIGHT_MAP_EXECUTABLE| - Right to "map" a (e.g., buffer) handle
+//       as executable memory.
 //
 // TODO(vtl): Add rights support/checking to existing handle types.
 
 typedef uint32_t MojoHandleRights;
 
 #define MOJO_HANDLE_RIGHT_NONE ((MojoHandleRights)0)
 #define MOJO_HANDLE_RIGHT_DUPLICATE ((MojoHandleRights)1 << 0)
 #define MOJO_HANDLE_RIGHT_TRANSFER ((MojoHandleRights)1 << 1)
 #define MOJO_HANDLE_RIGHT_READ ((MojoHandleRights)1 << 2)
 #define MOJO_HANDLE_RIGHT_WRITE ((MojoHandleRights)1 << 3)
 #define MOJO_HANDLE_RIGHT_GET_OPTIONS ((MojoHandleRights)1 << 4)
 #define MOJO_HANDLE_RIGHT_SET_OPTIONS ((MojoHandleRights)1 << 5)
+#define MOJO_HANDLE_RIGHT_MAP_READABLE ((MojoHandleRights)1 << 6)
+#define MOJO_HANDLE_RIGHT_MAP_WRITABLE ((MojoHandleRights)1 << 7)
+#define MOJO_HANDLE_RIGHT_MAP_EXECUTABLE ((MojoHandleRights)1 << 8)
 
 // |MojoHandleSignals|: Used to specify signals that can be waited on for a
 // handle (and which can be triggered), e.g., the ability to read or write to
 // the handle.
 //   |MOJO_HANDLE_SIGNAL_NONE| - No flags. |MojoWait()|, etc. will return
 //       |MOJO_RESULT_FAILED_PRECONDITION| if you attempt to wait on this.
 //   |MOJO_HANDLE_SIGNAL_READABLE| - Can read (e.g., a message) from the handle.
 //   |MOJO_HANDLE_SIGNAL_WRITABLE| - Can write (e.g., a message) to the handle.
 //   |MOJO_HANDLE_SIGNAL_PEER_CLOSED| - The peer handle is closed.
 //   |MOJO_HANDLE_SIGNAL_READ_THRESHOLD| - Can read a certain amount of data
@@ skipping 12 matching lines @@
 // |MojoHandleSignalsState|: Returned by wait functions to indicate the
 // signaling state of handles. Members are as follows:
 //   - |satisfied signals|: Bitmask of signals that were satisfied at some time
 //         before the call returned.
 //   - |satisfiable signals|: These are the signals that are possible to
 //         satisfy. For example, if the return value was
 //         |MOJO_RESULT_FAILED_PRECONDITION|, you can use this field to
 //         determine which, if any, of the signals can still be satisfied.
 // Note: This struct is not extensible (and only has 32-bit quantities), so it's
 // 32-bit-aligned.
+

[azani, 2016/05/10 18:44:50]

Nit: did you mean to add that extra blank line?

 MOJO_STATIC_ASSERT(MOJO_ALIGNOF(uint32_t) == 4, "uint32_t has weird alignment");
 struct MOJO_ALIGNAS(4) MojoHandleSignalsState {
   MojoHandleSignals satisfied_signals;
   MojoHandleSignals satisfiable_signals;
 };
 MOJO_STATIC_ASSERT(sizeof(MojoHandleSignalsState) == 8,
                    "MojoHandleSignalsState has wrong size");
 
 MOJO_BEGIN_EXTERN_C
 
@@ skipping 82 matching lines @@
 //       been reached.
 //   |MOJO_RESULT_BUSY| if |handle| is currently in use in some transaction
 //       (that, e.g., may result in it being invalidated, such as being sent in
 //       a message).
 MojoResult MojoDuplicateHandle(MojoHandle handle,
                                MojoHandle* new_handle);  // Out.
 
 MOJO_END_EXTERN_C
 
 #endif  // MOJO_PUBLIC_C_SYSTEM_HANDLE_H_