Make it possible to write a message pipe endpoint's peer into it.

mojo/edk/system/dispatcher.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_DISPATCHER_H_
 #define MOJO_EDK_SYSTEM_DISPATCHER_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 17 matching lines @@
 #include "mojo/public/cpp/system/macros.h"
 
 namespace mojo {
 
 namespace platform {
 class PlatformSharedBufferMapping;
 }
 
 namespace system {
 
+class Awakable;
 class Channel;
 class Core;
 class Dispatcher;
 class DispatcherTransport;
 class HandleTable;
 class LocalMessagePipeEndpoint;
+class MessagePipe;
 class ProxyMessagePipeEndpoint;
 class TransportData;
-class Awakable;
 
 using DispatcherVector = std::vector<util::RefPtr<Dispatcher>>;
 
 namespace test {
 
 // Test helper. We need to declare it here so we can friend it.
 DispatcherTransport DispatcherTryStartTransport(Dispatcher* dispatcher);
 
 }  // namespace test
 
@@ skipping 195 matching lines @@
  protected:
   Dispatcher();
   virtual ~Dispatcher();
 
   // These are to be overridden by subclasses (if necessary). They are called
   // exactly once (first |CancelAllAwakablesNoLock()|, then |CloseImplNoLock()|)
   // when the dispatcher is being closed.
   virtual void CancelAllAwakablesNoLock() MOJO_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
   virtual void CloseImplNoLock() MOJO_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
 
-  virtual util::RefPtr<Dispatcher>
-  CreateEquivalentDispatcherAndCloseImplNoLock()
-      MOJO_EXCLUSIVE_LOCKS_REQUIRED(mutex_) = 0;
+  // This is called by |CreateEquivalentDispatcherAndCloseNoLock()|. It should
+  // produce "close" this dispatcher and return a new one equivalent to it.

[azani, 2016/05/03 19:54:27]

The meaning of "produce 'close' this dispatcher" is hard to understand. Could
you clarify?

[viettrungluu, 2016/05/03 20:28:01]

Oops, I meant to s/produce // this before landing. Will fix ASAP.

+  // Note: Probably the first thing an implementation should do is call
+  // |CancelAllAwakablesNoLock()| (or equivalent); unlike |CloseNoLock()|,
+  // |CreateEquivalentDispatcherAndCloseNoLock()| does not do this
+  // automatically.
+  virtual util::RefPtr<Dispatcher> CreateEquivalentDispatcherAndCloseImplNoLock(
+      MessagePipe* message_pipe,
+      unsigned port) MOJO_EXCLUSIVE_LOCKS_REQUIRED(mutex_) = 0;
 
   // These are to be overridden by subclasses (if necessary). They are never
   // called after the dispatcher has been closed. See the descriptions of the
   // methods without the "ImplNoLock" for more information.
   virtual MojoResult WriteMessageImplNoLock(
       UserPointer<const void> bytes,
       uint32_t num_bytes,
       std::vector<DispatcherTransport>* transports,
       MojoWriteMessageFlags flags) MOJO_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
   virtual MojoResult ReadMessageImplNoLock(UserPointer<void> bytes,
@@ skipping 97 matching lines @@
   // Closes the dispatcher. This must be done under lock, and unlike |Close()|,
   // the dispatcher must not be closed already. (This is the "equivalent" of
   // |CreateEquivalentDispatcherAndCloseNoLock()|, for situations where the
   // dispatcher must be disposed of instead of "transferred".)
   void CloseNoLock() MOJO_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
 
   // Creates an equivalent dispatcher -- representing the same resource as this
   // dispatcher -- and close (i.e., disable) this dispatcher. I.e., this
   // dispatcher will look as though it was closed, but the resource it
   // represents will be assigned to the new dispatcher. This must be called
-  // under the dispatcher's lock.
-  util::RefPtr<Dispatcher> CreateEquivalentDispatcherAndCloseNoLock()
-      MOJO_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
+  // under the dispatcher's lock. If the resulting dispatcher will be put into a
+  // message on a message pipe, then |message_pipe| will be set appropriately
+  // (otherwise, it may be null) and |port| will be set to the destination port.
+  util::RefPtr<Dispatcher> CreateEquivalentDispatcherAndCloseNoLock(
+      MessagePipe* message_pipe,
+      unsigned port) MOJO_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
 
   // API to serialize dispatchers to a |Channel|, exposed to only
   // |TransportData| (via |TransportData|). They may only be called on a
   // dispatcher attached to a |MessageInTransit| (and in particular not in
   // |CoreImpl|'s handle table).
   //
   // TODO(vtl): The serialization API (and related implementation methods,
   // including |DispatcherTransport|'s methods) is marked
   // |MOJO_NOT_THREAD_SAFE|. This is because the threading requirements are
   // somewhat complicated (e.g., |HandleTableAccess::TryStartTransport()| is
@@ skipping 38 matching lines @@
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(Dispatcher);
 };
 
 // Wrapper around a |Dispatcher| pointer, while it's being processed to be
 // passed in a message pipe. See the comment about
 // |Dispatcher::HandleTableAccess| for more details.
 //
 // Note: This class is deliberately "thin" -- no more expensive than a
 // |Dispatcher*|.
-class DispatcherTransport {
+class DispatcherTransport final {
  public:
   DispatcherTransport() : dispatcher_(nullptr) {}
 
   void End() MOJO_NOT_THREAD_SAFE;
 
   Dispatcher::Type GetType() const { return dispatcher_->GetType(); }
   bool IsBusy() const MOJO_NOT_THREAD_SAFE {
     return dispatcher_->IsBusyNoLock();
   }
   void Close() MOJO_NOT_THREAD_SAFE { dispatcher_->CloseNoLock(); }
-  util::RefPtr<Dispatcher> CreateEquivalentDispatcherAndClose()
-      MOJO_NOT_THREAD_SAFE {
-    return dispatcher_->CreateEquivalentDispatcherAndCloseNoLock();
+  util::RefPtr<Dispatcher> CreateEquivalentDispatcherAndClose(
+      MessagePipe* message_pipe,
+      unsigned port) MOJO_NOT_THREAD_SAFE {
+    return dispatcher_->CreateEquivalentDispatcherAndCloseNoLock(message_pipe,
+                                                                 port);
   }
 
   bool is_valid() const { return !!dispatcher_; }
 
- protected:
-  Dispatcher* dispatcher() { return dispatcher_; }
-
  private:
   friend class Dispatcher::HandleTableAccess;
 
   explicit DispatcherTransport(Dispatcher* dispatcher)
       : dispatcher_(dispatcher) {}
 
   Dispatcher* dispatcher_;
 
   // Copy and assign allowed.
 };
 
 // So logging macros and |DCHECK_EQ()|, etc. work.
 inline std::ostream& operator<<(std::ostream& out, Dispatcher::Type type) {
   return out << static_cast<int>(type);
 }
 
 }  // namespace system
 }  // namespace mojo
 
 #endif  // MOJO_EDK_SYSTEM_DISPATCHER_H_