#ifndef MOJO_SYSTEM_MESSAGE_PIPE_H_
#define MOJO_SYSTEM_MESSAGE_PIPE_H_
+#include <stdint.h>
+
#include <vector>
-#include "base/basictypes.h"
+#include "base/macros.h"
#include "base/memory/ref_counted.h"
#include "base/memory/scoped_ptr.h"
#include "base/synchronization/lock.h"
-#include "mojo/public/c/system/core.h"
+#include "mojo/public/c/system/message_pipe.h"
+#include "mojo/public/c/system/types.h"
#include "mojo/system/dispatcher.h"
+#include "mojo/system/handle_signals_state.h"
+#include "mojo/system/memory.h"
#include "mojo/system/message_in_transit.h"
#include "mojo/system/message_pipe_endpoint.h"
#include "mojo/system/system_impl_export.h"
namespace mojo {
namespace system {
-class Channel;
+class ChannelEndpoint;
class Waiter;
// |MessagePipe| is the secondary object implementing a message pipe (see the
-// explanatory comment in core_impl.cc). It is typically owned by the
-// dispatcher(s) corresponding to the local endpoints. This class is
-// thread-safe.
-class MOJO_SYSTEM_IMPL_EXPORT MessagePipe :
- public base::RefCountedThreadSafe<MessagePipe> {
+// explanatory comment in core.cc). It is typically owned by the dispatcher(s)
+// corresponding to the local endpoints. This class is thread-safe.
+class MOJO_SYSTEM_IMPL_EXPORT MessagePipe
+ : public base::RefCountedThreadSafe<MessagePipe> {
public:
- MessagePipe(scoped_ptr<MessagePipeEndpoint> endpoint0,
- scoped_ptr<MessagePipeEndpoint> endpoint1);
-
- // Convenience constructor that constructs a |MessagePipe| with two new
- // |LocalMessagePipeEndpoint|s.
- MessagePipe();
+ // Creates a |MessagePipe| with two new |LocalMessagePipeEndpoint|s.
+ static MessagePipe* CreateLocalLocal();
+
+ // Creates a |MessagePipe| with a |LocalMessagePipeEndpoint| on port 0 and a
+ // |ProxyMessagePipeEndpoint| on port 1. |*channel_endpoint| is set to the
+ // (newly-created) |ChannelEndpoint| for the latter.
+ static MessagePipe* CreateLocalProxy(
+ scoped_refptr<ChannelEndpoint>* channel_endpoint);
+
+ // Creates a |MessagePipe| with a |ProxyMessagePipeEndpoint| on port 0 and a
+ // |LocalMessagePipeEndpoint| on port 1. |*channel_endpoint| is set to the
+ // (newly-created) |ChannelEndpoint| for the former.
+ // Note: This is really only needed in tests (outside of tests, this
+ // configuration arises from a local message pipe having its port 0
+ // "converted" using |ConvertLocalToProxy()|).
+ static MessagePipe* CreateProxyLocal(
+ scoped_refptr<ChannelEndpoint>* channel_endpoint);
// Gets the other port number (i.e., 0 -> 1, 1 -> 0).
static unsigned GetPeerPort(unsigned port);
// Unlike |MessagePipeDispatcher::WriteMessage()|, this does not validate its
// arguments.
MojoResult WriteMessage(unsigned port,
- const void* bytes,
+ UserPointer<const void> bytes,
uint32_t num_bytes,
std::vector<DispatcherTransport>* transports,
MojoWriteMessageFlags flags);
- // Unlike |MessagePipeDispatcher::ReadMessage()|, this does not validate its
- // arguments.
MojoResult ReadMessage(unsigned port,
- void* bytes,
- uint32_t* num_bytes,
- std::vector<scoped_refptr<Dispatcher> >* dispatchers,
+ UserPointer<void> bytes,
+ UserPointer<uint32_t> num_bytes,
+ DispatcherVector* dispatchers,
uint32_t* num_dispatchers,
MojoReadMessageFlags flags);
+ HandleSignalsState GetHandleSignalsState(unsigned port) const;
MojoResult AddWaiter(unsigned port,
Waiter* waiter,
- MojoWaitFlags flags,
- MojoResult wake_result);
- void RemoveWaiter(unsigned port, Waiter* waiter);
+ MojoHandleSignals signals,
+ uint32_t context,
+ HandleSignalsState* signals_state);
+ void RemoveWaiter(unsigned port,
+ Waiter* waiter,
+ HandleSignalsState* signals_state);
// This is called by the dispatcher to convert a local endpoint to a proxy
// endpoint.
- void ConvertLocalToProxy(unsigned port);
+ scoped_refptr<ChannelEndpoint> ConvertLocalToProxy(unsigned port);
- // This is used internally by |WriteMessage()| and by |Channel| to enqueue
- // messages (typically to a |LocalMessagePipeEndpoint|). Unlike
- // |WriteMessage()|, |port| is the *destination* port. |transports| should be
- // non-null only if it's nonempty, and only if |message| has no dispatchers
- // attached.
+ // This is used by |Channel| to enqueue messages (typically to a
+ // |LocalMessagePipeEndpoint|). Unlike |WriteMessage()|, |port| is the
+ // *destination* port.
MojoResult EnqueueMessage(unsigned port,
- scoped_ptr<MessageInTransit> message,
- std::vector<DispatcherTransport>* transports);
+ scoped_ptr<MessageInTransit> message);
- // These are used by |Channel|.
- void Attach(unsigned port,
- scoped_refptr<Channel> channel,
- MessageInTransit::EndpointId local_id);
- void Run(unsigned port, MessageInTransit::EndpointId remote_id);
+ // This is used by |Channel|. TODO(vtl): Rename it (and have the
+ // |ChannelEndpoint| call it instead).
+ void OnRemove(unsigned port);
private:
+ MessagePipe();
+
friend class base::RefCountedThreadSafe<MessagePipe>;
virtual ~MessagePipe();
- // Used by |EnqueueMessage()| to handle control messages that are actually
- // meant for us.
+ // This is used internally by |WriteMessage()| and by |EnqueueMessage()|.
+ // |transports| may be non-null only if it's nonempty and |message| has no
+ // dispatchers attached.
+ MojoResult EnqueueMessageInternal(
+ unsigned port,
+ scoped_ptr<MessageInTransit> message,
+ std::vector<DispatcherTransport>* transports);
+
+ // Helper for |EnqueueMessageInternal()|. Must be called with |lock_| held.
+ MojoResult AttachTransportsNoLock(
+ unsigned port,
+ MessageInTransit* message,
+ std::vector<DispatcherTransport>* transports);
+
+ // Used by |EnqueueMessageInternal()| to handle control messages that are
+ // actually meant for us.
MojoResult HandleControlMessage(unsigned port,
scoped_ptr<MessageInTransit> message);
projects / platform / framework / web / crosswalk.git / blobdiff