Home | History | Annotate | Download | only in system 
      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_
    137