EDK: Add Dispatcher::SupportsEntrypointClass().

mojo/edk/system/dispatcher.h

 // Copyright 2013 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.
 
 #ifndef MOJO_EDK_SYSTEM_DISPATCHER_H_
 #define MOJO_EDK_SYSTEM_DISPATCHER_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 42 matching lines @@
 
 }  // namespace test
 
 // A |Dispatcher| implements Mojo primitives that are "attached" to a particular
 // handle. This includes most (all?) primitives except for |MojoWait...()|. This
 // object is thread-safe, with its state being protected by a single mutex
 // |mutex_|, which is also made available to implementation subclasses (via the
 // |mutex()| method).
 class Dispatcher : public util::RefCountedThreadSafe<Dispatcher> {
  public:
+  // Types of dispatchers. Note that these are not necessarily a one-to-one with
+  // implementations of |Dispatcher|: multiple implementations may share the
+  // same type.
   enum class Type {
     UNKNOWN = 0,
     MESSAGE_PIPE,
     DATA_PIPE_PRODUCER,
     DATA_PIPE_CONSUMER,
     SHARED_BUFFER,
 
     // "Private" types (not exposed via the public interface):
     PLATFORM_HANDLE = -1
   };
+
+  // Classes of "entrypoints"/"syscalls": Each dispatcher should support entire
+  // classes of methods (and if they don't support a given class, they should
+  // return |MOJO_RESULT_INVALID_ARGUMENT| for all the methods in that class).
+  // Warning: A method may be called even if |SupportsEntrypointClass()|
+  // indicates that the method's class is not supported (see below).
+  enum class EntrypointClass {
+    // |ReadMessage()|, |WriteMessage()|:
+    MESSAGE_PIPE,
+
+    // |SetDataPipeProducerOptions()|, |GetDataPipeProducerOptions()|,
+    // |WriteData()|, |BeginWriteData()|, |EndWriteData()|:
+    DATA_PIPE_PRODUCER,
+
+    // |SetDataPipeConsumerOptions()|, |GetDataPipeConsumerOptions()|,
+    // |ReadData()|, |BeginReadData()|, |EndReadData()|:
+    DATA_PIPE_CONSUMER,
+
+    // |DuplicateBufferHandle()|, |GetBufferInformation()|, |MapBuffer()|:
+    BUFFER,
+  };
+
+  // Gets the type of the dispatcher; see |Type| above.
   virtual Type GetType() const = 0;
 
+  // Gets whether the given entrypoint class is supported; see |EntrypointClass|
+  // above. This is ONLY called when a rights check has failed, to determine
+  // whether |MOJO_RESULT_PERMISSION_DENIED| (if the entrypoint class is
+  // supported) or |MOJO_RESULT_INVALID_ARGUMENT| (if not) should be returned.
+  // In the case that the rights check passes, |Core| will proceed immediately
+  // to call the method (so if the method is not supported, it must still return
+  // |MOJO_RESULT_INVALID_ARGUMENT|).
+  virtual bool SupportsEntrypointClass(
+      EntrypointClass entrypoint_class) const = 0;
+
   // These methods implement the various primitives named |Mojo...()|. These
   // take |mutex_| and handle races with |Close()|. Then they call out to
   // subclasses' |...ImplNoLock()| methods (still under |mutex_|), which
   // actually implement the primitives.
   // NOTE(vtl): This puts a big lock around each dispatcher (i.e., handle), and
   // prevents the various |...ImplNoLock()|s from releasing the lock as soon as
   // possible. If this becomes an issue, we can rethink this.
   MojoResult Close();
 
+  // |EntrypointClass::MESSAGE_PIPE|:
   // |transports| may be non-null if and only if there are handles to be
   // written; not that |this| must not be in |transports|. On success, all the
   // dispatchers in |transports| must have been moved to a closed state; on
   // failure, they should remain in their original state.
   MojoResult WriteMessage(UserPointer<const void> bytes,
                           uint32_t num_bytes,
                           std::vector<DispatcherTransport>* transports,
                           MojoWriteMessageFlags flags);
   // |dispatchers| must be non-null but empty, if |num_dispatchers| is non-null
   // and nonzero. On success, it will be set to the dispatchers to be received
   // (and assigned handles) as part of the message.
   MojoResult ReadMessage(UserPointer<void> bytes,
                          UserPointer<uint32_t> num_bytes,
                          DispatcherVector* dispatchers,
                          uint32_t* num_dispatchers,
                          MojoReadMessageFlags flags);
 
+  // |EntrypointClass::DATA_PIPE_PRODUCER|:
   MojoResult SetDataPipeProducerOptions(
       UserPointer<const MojoDataPipeProducerOptions> options);
   MojoResult GetDataPipeProducerOptions(
       UserPointer<MojoDataPipeProducerOptions> options,
       uint32_t options_num_bytes);
   MojoResult WriteData(UserPointer<const void> elements,
                        UserPointer<uint32_t> elements_num_bytes,
                        MojoWriteDataFlags flags);
   MojoResult BeginWriteData(UserPointer<void*> buffer,
                             UserPointer<uint32_t> buffer_num_bytes,
                             MojoWriteDataFlags flags);
   MojoResult EndWriteData(uint32_t num_bytes_written);
+
+  // |EntrypointClass::DATA_PIPE_CONSUMER|:
   MojoResult SetDataPipeConsumerOptions(
       UserPointer<const MojoDataPipeConsumerOptions> options);
   MojoResult GetDataPipeConsumerOptions(
       UserPointer<MojoDataPipeConsumerOptions> options,
       uint32_t options_num_bytes);
   MojoResult ReadData(UserPointer<void> elements,
                       UserPointer<uint32_t> num_bytes,
                       MojoReadDataFlags flags);
   MojoResult BeginReadData(UserPointer<const void*> buffer,
                            UserPointer<uint32_t> buffer_num_bytes,
                            MojoReadDataFlags flags);
   MojoResult EndReadData(uint32_t num_bytes_read);
 
+  // |EntrypointClass::BUFFER|:
   // |options| may be null. |new_dispatcher| must not be null, but
   // |*new_dispatcher| should be null (and will contain the dispatcher for the
   // new handle on success).
   MojoResult DuplicateBufferHandle(
       UserPointer<const MojoDuplicateBufferHandleOptions> options,
       util::RefPtr<Dispatcher>* new_dispatcher);
   MojoResult GetBufferInformation(UserPointer<MojoBufferInformation> info,
                                   uint32_t info_num_bytes);
   MojoResult MapBuffer(
       uint64_t offset,
@@ skipping 317 matching lines @@
 
 // So logging macros and |DCHECK_EQ()|, etc. work.
 inline std::ostream& operator<<(std::ostream& out, Dispatcher::Type type) {
   return out << static_cast<int>(type);
 }
 
 }  // namespace system
 }  // namespace mojo
 
 #endif  // MOJO_EDK_SYSTEM_DISPATCHER_H_