Mojo: Change the way message pipes are passed over channels.

mojo/edk/system/channel.h

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef MOJO_EDK_SYSTEM_CHANNEL_H_
 #define MOJO_EDK_SYSTEM_CHANNEL_H_
 
 #include <stdint.h>
 
 #include "base/containers/hash_tables.h"
@@ skipping 62 matching lines @@
 
   // TODO(vtl): Remove these once |AttachAndRunEndpoint()| is fully implemented
   // and everything is converted to use it.
   ChannelEndpointId AttachEndpoint(scoped_refptr<ChannelEndpoint> endpoint);
   void RunEndpoint(scoped_refptr<ChannelEndpoint> endpoint,
                    ChannelEndpointId remote_id);
 
   // Attaches the given endpoint to this channel and runs it. |is_bootstrap|
   // should be set if and only if it is the first endpoint on the channel. This
   // assigns the endpoint both local and remote IDs. If |is_bootstrap| is set,
-  // both are the bootstrap ID (given by |ChannelEndpointId::GetBootstrap()|).
+  // both are the bootstrap ID (given by |ChannelEndpointId::GetBootstrap()|);
+  // if not, it will also send a |kSubtypeChannelAttachAndRunEndpoint| message
+  // to the remote side to tell it to create an endpoint as well.
   //
   // (Bootstrapping is symmetric: Both sides attach and run endpoints with
   // |is_bootstrap| set, which establishes the first message pipe across a
   // channel.)
   //
+  // This returns the *remote* ID (which will be the bootstrap ID in the
+  // bootstrap case, and a "remote ID", i.e., one for which |is_remote()|
+  // returns true, otherwise).
+  //
   // TODO(vtl): Maybe limit the number of attached message pipes.
-  void AttachAndRunEndpoint(scoped_refptr<ChannelEndpoint> endpoint,
-                            bool is_bootstrap);
-
-  // Tells the other side of the channel to run a message pipe endpoint (which
-  // must already be attached); |local_id| and |remote_id| are relative to this
-  // channel (i.e., |local_id| is the other side's remote ID and |remote_id| is
-  // its local ID).
-  // TODO(vtl): Maybe we should just have a flag argument to
-  // |RunMessagePipeEndpoint()| that tells it to do this.
-  void RunRemoteMessagePipeEndpoint(ChannelEndpointId local_id,
-                                    ChannelEndpointId remote_id);
+  ChannelEndpointId AttachAndRunEndpoint(
+      scoped_refptr<ChannelEndpoint> endpoint,
+      bool is_bootstrap);
 
   // This forwards |message| verbatim to |raw_channel_|.
   bool WriteMessage(scoped_ptr<MessageInTransit> message);
 
   // See |RawChannel::IsWriteBufferEmpty()|.
   // TODO(vtl): Maybe we shouldn't expose this, and instead have a
   // |FlushWriteBufferAndShutdown()| or something like that.
   bool IsWriteBufferEmpty();
 
-  // This removes the given endpoint from this channel (|local_id| and
-  // |remote_id| are specified as an optimization; the latter should be an
-  // invalid |ChannelEndpointId| if the endpoint is not yet running). Note: If
-  // this is called, the |Channel| will *not* call
+  // Removes the given endpoint from this channel (|local_id| and |remote_id|
+  // are specified as an optimization; the latter should be an invalid
+  // |ChannelEndpointId| if the endpoint is not yet running). Note: If this is
+  // called, the |Channel| will *not* call
   // |ChannelEndpoint::DetachFromChannel()|.
   void DetachEndpoint(ChannelEndpoint* endpoint,
                       ChannelEndpointId local_id,
                       ChannelEndpointId remote_id);
 
+  // Takes ownership of an incoming message pipe (i.e., one that was created via
+  // a |kSubtypeChannelAttachAndRunEndpoint| message).
+  scoped_refptr<MessagePipe> PassIncomingMessagePipe(
+      ChannelEndpointId local_id);
+
   // See |RawChannel::GetSerializedPlatformHandleSize()|.
   size_t GetSerializedPlatformHandleSize() const;
 
   embedder::PlatformSupport* platform_support() const {
     return platform_support_;
   }
 
  private:
   friend class base::RefCountedThreadSafe<Channel>;
   virtual ~Channel();
 
   // |RawChannel::Delegate| implementation (only called on the creation thread):
   virtual void OnReadMessage(
       const MessageInTransit::View& message_view,
       embedder::ScopedPlatformHandleVectorPtr platform_handles) override;
   virtual void OnError(Error error) override;
 
   // Helpers for |OnReadMessage| (only called on the creation thread):
   void OnReadMessageForDownstream(
       const MessageInTransit::View& message_view,
       embedder::ScopedPlatformHandleVectorPtr platform_handles);
   void OnReadMessageForChannel(
       const MessageInTransit::View& message_view,
       embedder::ScopedPlatformHandleVectorPtr platform_handles);
 
-  // Handles "run message pipe endpoint" messages.
-  bool OnRunMessagePipeEndpoint(ChannelEndpointId local_id,
-                                ChannelEndpointId remote_id);
+  // Handles "attach and run endpoint" messages.
+  bool OnAttachAndRunEndpoint(ChannelEndpointId local_id,
+                              ChannelEndpointId remote_id);
   // Handles "remove message pipe endpoint" messages.
   bool OnRemoveMessagePipeEndpoint(ChannelEndpointId local_id,
                                    ChannelEndpointId remote_id);
   // Handles "remove message pipe endpoint ack" messages.
   bool OnRemoveMessagePipeEndpointAck(ChannelEndpointId local_id);
 
   // Handles errors (e.g., invalid messages) from the remote side. Callable from
   // any thread.
   void HandleRemoteError(const base::StringPiece& error_message);
   // Handles internal errors/failures from the local side. Callable from any
@@ skipping 22 matching lines @@
   bool is_shutting_down_;
 
   typedef base::hash_map<ChannelEndpointId, scoped_refptr<ChannelEndpoint>>
       IdToEndpointMap;
   // Map from local IDs to endpoints. If the endpoint is null, this means that
   // we're just waiting for the remove ack before removing the entry.
   IdToEndpointMap local_id_to_endpoint_map_;
   // Note: The IDs generated by this should be checked for existence before use.
   LocalChannelEndpointIdGenerator local_id_generator_;
 
+  typedef base::hash_map<ChannelEndpointId, scoped_refptr<MessagePipe>>
+      IdToMessagePipeMap;
+  // Map from local IDs to pending/incoming endpoints (i.e., those which do not
+  // yet have a dispatcher attached).
+  IdToMessagePipeMap incoming_message_pipes_;
   // TODO(vtl): We need to keep track of remote IDs (so that we don't collide
   // if/when we wrap).
   RemoteChannelEndpointIdGenerator remote_id_generator_;
 
   DISALLOW_COPY_AND_ASSIGN(Channel);
 };
 
 }  // namespace system
 }  // namespace mojo
 
 #endif  // MOJO_EDK_SYSTEM_CHANNEL_H_