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
25namespace mojo {
26namespace system {
27
28class ChannelEndpoint;
29class 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.
34class 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