src/mojo/system/message_pipe.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_H_
   6 #define MOJO_SYSTEM_MESSAGE_PIPE_H_
   7
   8 #include <stdint.h>
   9
  10 #include <vector>
  11
  12 #include "base/macros.h"
  13 #include "base/memory/ref_counted.h"
  14 #include "base/memory/scoped_ptr.h"
  15 #include "base/synchronization/lock.h"
  16 #include "mojo/public/c/system/message_pipe.h"
  17 #include "mojo/public/c/system/types.h"
  18 #include "mojo/system/dispatcher.h"
  19 #include "mojo/system/handle_signals_state.h"
  20 #include "mojo/system/memory.h"
  21 #include "mojo/system/message_in_transit.h"
  22 #include "mojo/system/message_pipe_endpoint.h"
  23 #include "mojo/system/system_impl_export.h"
  24
  25 namespace mojo {
  26 namespace system {
  27
  28 class ChannelEndpoint;
  29 class Waiter;
  30
  31 // |MessagePipe| is the secondary object implementing a message pipe (see the
  32 // explanatory comment in core.cc). It is typically owned by the dispatcher(s)
  33 // corresponding to the local endpoints. This class is thread-safe.
  34 class MOJO_SYSTEM_IMPL_EXPORT MessagePipe
  35     : public base::RefCountedThreadSafe<MessagePipe> {
  36  public:
  37   // Creates a |MessagePipe| with two new |LocalMessagePipeEndpoint|s.
  38   static MessagePipe* CreateLocalLocal();
  39
  40   // Creates a |MessagePipe| with a |LocalMessagePipeEndpoint| on port 0 and a
  41   // |ProxyMessagePipeEndpoint| on port 1. |*channel_endpoint| is set to the
  42   // (newly-created) |ChannelEndpoint| for the latter.
  43   static MessagePipe* CreateLocalProxy(
  44       scoped_refptr<ChannelEndpoint>* channel_endpoint);
  45
  46   // Creates a |MessagePipe| with a |ProxyMessagePipeEndpoint| on port 0 and a
  47   // |LocalMessagePipeEndpoint| on port 1. |*channel_endpoint| is set to the
  48   // (newly-created) |ChannelEndpoint| for the former.
  49   // Note: This is really only needed in tests (outside of tests, this
  50   // configuration arises from a local message pipe having its port 0
  51   // "converted" using |ConvertLocalToProxy()|).
  52   static MessagePipe* CreateProxyLocal(
  53       scoped_refptr<ChannelEndpoint>* channel_endpoint);
  54
  55   // Gets the other port number (i.e., 0 -> 1, 1 -> 0).
  56   static unsigned GetPeerPort(unsigned port);
  57
  58   // Gets the type of the endpoint (used for assertions, etc.).
  59   MessagePipeEndpoint::Type GetType(unsigned port);
  60
  61   // These are called by the dispatcher to implement its methods of
  62   // corresponding names. In all cases, the port |port| must be open.
  63   void CancelAllWaiters(unsigned port);
  64   void Close(unsigned port);
  65   // Unlike |MessagePipeDispatcher::WriteMessage()|, this does not validate its
  66   // arguments.
  67   MojoResult WriteMessage(unsigned port,
  68                           UserPointer<const void> bytes,
  69                           uint32_t num_bytes,
  70                           std::vector<DispatcherTransport>* transports,
  71                           MojoWriteMessageFlags flags);
  72   MojoResult ReadMessage(unsigned port,
  73                          UserPointer<void> bytes,
  74                          UserPointer<uint32_t> num_bytes,
  75                          DispatcherVector* dispatchers,
  76                          uint32_t* num_dispatchers,
  77                          MojoReadMessageFlags flags);
  78   HandleSignalsState GetHandleSignalsState(unsigned port) const;
  79   MojoResult AddWaiter(unsigned port,
  80                        Waiter* waiter,
  81                        MojoHandleSignals signals,
  82                        uint32_t context,
  83                        HandleSignalsState* signals_state);
  84   void RemoveWaiter(unsigned port,
  85                     Waiter* waiter,
  86                     HandleSignalsState* signals_state);
  87
  88   // This is called by the dispatcher to convert a local endpoint to a proxy
  89   // endpoint.
  90   scoped_refptr<ChannelEndpoint> ConvertLocalToProxy(unsigned port);
  91
  92   // This is used by |Channel| to enqueue messages (typically to a
  93   // |LocalMessagePipeEndpoint|). Unlike |WriteMessage()|, |port| is the
  94   // *destination* port.
  95   MojoResult EnqueueMessage(unsigned port,
  96                             scoped_ptr<MessageInTransit> message);
  97
  98   // This is used by |Channel|. TODO(vtl): Rename it (and have the
  99   // |ChannelEndpoint| call it instead).
 100   void OnRemove(unsigned port);
 101
 102  private:
 103   MessagePipe();
 104
 105   friend class base::RefCountedThreadSafe<MessagePipe>;
 106   virtual ~MessagePipe();
 107
 108   // This is used internally by |WriteMessage()| and by |EnqueueMessage()|.
 109   // |transports| may be non-null only if it's nonempty and |message| has no
 110   // dispatchers attached.
 111   MojoResult EnqueueMessageInternal(
 112       unsigned port,
 113       scoped_ptr<MessageInTransit> message,
 114       std::vector<DispatcherTransport>* transports);
 115
 116   // Helper for |EnqueueMessageInternal()|. Must be called with |lock_| held.
 117   MojoResult AttachTransportsNoLock(
 118       unsigned port,
 119       MessageInTransit* message,
 120       std::vector<DispatcherTransport>* transports);
 121
 122   // Used by |EnqueueMessageInternal()| to handle control messages that are
 123   // actually meant for us.
 124   MojoResult HandleControlMessage(unsigned port,
 125                                   scoped_ptr<MessageInTransit> message);
 126
 127   base::Lock lock_;  // Protects the following members.
 128   scoped_ptr<MessagePipeEndpoint> endpoints_[2];
 129
 130   DISALLOW_COPY_AND_ASSIGN(MessagePipe);
 131 };
 132
 133 }  // namespace system
 134 }  // namespace mojo
 135
 136 #endif  // MOJO_SYSTEM_MESSAGE_PIPE_H_