src/mojo/system/message_pipe_dispatcher.h

   1 // Copyright 2013 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 #ifndef MOJO_SYSTEM_MESSAGE_PIPE_DISPATCHER_H_
   6 #define MOJO_SYSTEM_MESSAGE_PIPE_DISPATCHER_H_
   7
   8 #include "base/macros.h"
   9 #include "base/memory/ref_counted.h"
  10 #include "mojo/system/dispatcher.h"
  11 #include "mojo/system/memory.h"
  12 #include "mojo/system/system_impl_export.h"
  13
  14 namespace mojo {
  15 namespace system {
  16
  17 class ChannelEndpoint;
  18 class MessagePipe;
  19 class MessagePipeDispatcherTransport;
  20
  21 // This is the |Dispatcher| implementation for message pipes (created by the
  22 // Mojo primitive |MojoCreateMessagePipe()|). This class is thread-safe.
  23 class MOJO_SYSTEM_IMPL_EXPORT MessagePipeDispatcher : public Dispatcher {
  24  public:
  25   // The default options to use for |MojoCreateMessagePipe()|. (Real uses
  26   // should obtain this via |ValidateCreateOptions()| with a null |in_options|;
  27   // this is exposed directly for testing convenience.)
  28   static const MojoCreateMessagePipeOptions kDefaultCreateOptions;
  29
  30   MessagePipeDispatcher(
  31       const MojoCreateMessagePipeOptions& /*validated_options*/);
  32
  33   // Validates and/or sets default options for |MojoCreateMessagePipeOptions|.
  34   // If non-null, |in_options| must point to a struct of at least
  35   // |in_options->struct_size| bytes. |out_options| must point to a (current)
  36   // |MojoCreateMessagePipeOptions| and will be entirely overwritten on success
  37   // (it may be partly overwritten on failure).
  38   static MojoResult ValidateCreateOptions(
  39       UserPointer<const MojoCreateMessagePipeOptions> in_options,
  40       MojoCreateMessagePipeOptions* out_options);
  41
  42   // Must be called before any other methods. (This method is not thread-safe.)
  43   void Init(scoped_refptr<MessagePipe> message_pipe, unsigned port);
  44
  45   // |Dispatcher| public methods:
  46   virtual Type GetType() const OVERRIDE;
  47
  48   // Creates a |MessagePipe| with a local endpoint (at port 0) and a proxy
  49   // endpoint, and creates/initializes a |MessagePipeDispatcher| (attached to
  50   // the message pipe, port 0).
  51   // TODO(vtl): This currently uses |kDefaultCreateOptions|, which is okay since
  52   // there aren't any options, but eventually options should be plumbed through.
  53   static scoped_refptr<MessagePipeDispatcher> CreateRemoteMessagePipe(
  54       scoped_refptr<ChannelEndpoint>* channel_endpoint);
  55
  56   // The "opposite" of |SerializeAndClose()|. (Typically this is called by
  57   // |Dispatcher::Deserialize()|.)
  58   static scoped_refptr<MessagePipeDispatcher> Deserialize(Channel* channel,
  59                                                           const void* source,
  60                                                           size_t size);
  61
  62  private:
  63   friend class MessagePipeDispatcherTransport;
  64
  65   virtual ~MessagePipeDispatcher();
  66
  67   // Gets a dumb pointer to |message_pipe_|. This must be called under the
  68   // |Dispatcher| lock (that it's a dumb pointer is okay since it's under lock).
  69   // This is needed when sending handles across processes, where nontrivial,
  70   // invasive work needs to be done.
  71   MessagePipe* GetMessagePipeNoLock() const;
  72   // Similarly for the port.
  73   unsigned GetPortNoLock() const;
  74
  75   // |Dispatcher| protected methods:
  76   virtual void CancelAllWaitersNoLock() OVERRIDE;
  77   virtual void CloseImplNoLock() OVERRIDE;
  78   virtual scoped_refptr<Dispatcher>
  79       CreateEquivalentDispatcherAndCloseImplNoLock() OVERRIDE;
  80   virtual MojoResult WriteMessageImplNoLock(
  81       UserPointer<const void> bytes,
  82       uint32_t num_bytes,
  83       std::vector<DispatcherTransport>* transports,
  84       MojoWriteMessageFlags flags) OVERRIDE;
  85   virtual MojoResult ReadMessageImplNoLock(UserPointer<void> bytes,
  86                                            UserPointer<uint32_t> num_bytes,
  87                                            DispatcherVector* dispatchers,
  88                                            uint32_t* num_dispatchers,
  89                                            MojoReadMessageFlags flags) OVERRIDE;
  90   virtual HandleSignalsState GetHandleSignalsStateImplNoLock() const OVERRIDE;
  91   virtual MojoResult AddWaiterImplNoLock(
  92       Waiter* waiter,
  93       MojoHandleSignals signals,
  94       uint32_t context,
  95       HandleSignalsState* signals_state) OVERRIDE;
  96   virtual void RemoveWaiterImplNoLock(
  97       Waiter* waiter,
  98       HandleSignalsState* signals_state) OVERRIDE;
  99   virtual void StartSerializeImplNoLock(Channel* channel,
 100                                         size_t* max_size,
 101                                         size_t* max_platform_handles) OVERRIDE;
 102   virtual bool EndSerializeAndCloseImplNoLock(
 103       Channel* channel,
 104       void* destination,
 105       size_t* actual_size,
 106       embedder::PlatformHandleVector* platform_handles) OVERRIDE;
 107
 108   // Protected by |lock()|:
 109   scoped_refptr<MessagePipe> message_pipe_;  // This will be null if closed.
 110   unsigned port_;
 111
 112   DISALLOW_COPY_AND_ASSIGN(MessagePipeDispatcher);
 113 };
 114
 115 class MessagePipeDispatcherTransport : public DispatcherTransport {
 116  public:
 117   explicit MessagePipeDispatcherTransport(DispatcherTransport transport);
 118
 119   MessagePipe* GetMessagePipe() {
 120     return message_pipe_dispatcher()->GetMessagePipeNoLock();
 121   }
 122   unsigned GetPort() { return message_pipe_dispatcher()->GetPortNoLock(); }
 123
 124  private:
 125   MessagePipeDispatcher* message_pipe_dispatcher() {
 126     return static_cast<MessagePipeDispatcher*>(dispatcher());
 127   }
 128
 129   // Copy and assign allowed.
 130 };
 131
 132 }  // namespace system
 133 }  // namespace mojo
 134
 135 #endif  // MOJO_SYSTEM_MESSAGE_PIPE_DISPATCHER_H_