src/mojo/public/java/src/org/chromium/mojo/system/SharedBufferHandle.java

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 package org.chromium.mojo.system;
   6
   7 import java.nio.ByteBuffer;
   8
   9 /**
  10  * A buffer that can be shared between applications.
  11  */
  12 public interface SharedBufferHandle extends Handle {
  13
  14     /**
  15      * Flags for the shared buffer creation operation.
  16      */
  17     public static class CreateFlags extends Flags<CreateFlags> {
  18         private static final int FLAG_NONE = 0;
  19
  20         /**
  21          * Immutable flag with not bit set.
  22          */
  23         public static final CreateFlags NONE = CreateFlags.none().immutable();
  24
  25         /**
  26          * Dedicated constructor.
  27          *
  28          * @param flags initial value of the flags.
  29          */
  30         protected CreateFlags(int flags) {
  31             super(flags);
  32         }
  33
  34         /**
  35          * @return flags with no bit set.
  36          */
  37         public static CreateFlags none() {
  38             return new CreateFlags(FLAG_NONE);
  39         }
  40
  41     }
  42
  43     /**
  44      * Used to specify creation parameters for a shared buffer to |Core#createSharedBuffer()|.
  45      */
  46     public static class CreateOptions {
  47         private CreateFlags mFlags = CreateFlags.none();
  48
  49         /**
  50          * @return the flags
  51          */
  52         public CreateFlags getFlags() {
  53             return mFlags;
  54         }
  55
  56     }
  57
  58     /**
  59      * Flags for the shared buffer duplication operation.
  60      */
  61     public static class DuplicateFlags extends Flags<DuplicateFlags> {
  62         private static final int FLAG_NONE = 0;
  63
  64         /**
  65          * Immutable flag with not bit set.
  66          */
  67         public static final DuplicateFlags NONE = DuplicateFlags.none().immutable();
  68
  69         /**
  70          * Dedicated constructor.
  71          *
  72          * @param flags initial value of the flags.
  73          */
  74         protected DuplicateFlags(int flags) {
  75             super(flags);
  76         }
  77
  78         /**
  79          * @return flags with no bit set.
  80          */
  81         public static DuplicateFlags none() {
  82             return new DuplicateFlags(FLAG_NONE);
  83         }
  84
  85     }
  86
  87     /**
  88      * Used to specify parameters in duplicating access to a shared buffer to
  89      * |SharedBufferHandle#duplicate|
  90      */
  91     public static class DuplicateOptions {
  92         private DuplicateFlags mFlags = DuplicateFlags.none();
  93
  94         /**
  95          * @return the flags
  96          */
  97         public DuplicateFlags getFlags() {
  98             return mFlags;
  99         }
 100
 101     }
 102
 103     /**
 104      * Flags for the shared buffer map operation.
 105      */
 106     public static class MapFlags extends Flags<MapFlags> {
 107         private static final int FLAG_NONE = 0;
 108
 109         /**
 110          * Immutable flag with not bit set.
 111          */
 112         public static final MapFlags NONE = MapFlags.none().immutable();
 113
 114         /**
 115          * Dedicated constructor.
 116          *
 117          * @param flags initial value of the flags.
 118          */
 119         protected MapFlags(int flags) {
 120             super(flags);
 121         }
 122
 123         /**
 124          * @return flags with no bit set.
 125          */
 126         public static MapFlags none() {
 127             return new MapFlags(FLAG_NONE);
 128         }
 129
 130     }
 131
 132     /**
 133      * Duplicates the handle. This creates another handle (returned on success), which can then be
 134      * sent to another application over a message pipe, while retaining access to this handle (and
 135      * any mappings that it may have).
 136      */
 137     public SharedBufferHandle duplicate(DuplicateOptions options);
 138
 139     /**
 140      * Map the part (at offset |offset| of length |numBytes|) of the buffer given by this handle
 141      * into memory. |offset + numBytes| must be less than or equal to the size of the buffer. On
 142      * success, the returned buffer points to memory with the requested part of the buffer. A single
 143      * buffer handle may have multiple active mappings (possibly depending on the buffer type). The
 144      * permissions (e.g., writable or executable) of the returned memory may depend on the
 145      * properties of the buffer and properties attached to the buffer handle as well as |flags|.
 146      */
 147     public ByteBuffer map(long offset, long numBytes, MapFlags flags);
 148
 149     /**
 150      * Unmap a buffer pointer that was mapped by |map()|.
 151      */
 152     public void unmap(ByteBuffer buffer);
 153
 154 }