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_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_
    136