Mojo: Factor MessageInTransit secondary buffer stuff out into a separate class.

mojo/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_SYSTEM_DISPATCHER_H_
 #define MOJO_SYSTEM_DISPATCHER_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <vector>
 
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/synchronization/lock.h"
 #include "mojo/embedder/platform_handle.h"
 #include "mojo/public/c/system/core.h"
 #include "mojo/system/system_impl_export.h"
 
 namespace mojo {
 namespace system {
 
 class Channel;
 class Core;
 class Dispatcher;
 class DispatcherTransport;
 class HandleTable;
 class LocalMessagePipeEndpoint;
-class MessageInTransit;
 class ProxyMessagePipeEndpoint;
 class RawSharedBufferMapping;
+class TransportData;
 class Waiter;
 
 namespace test {
 
 // Test helper. We need to declare it here so we can friend it.
 MOJO_SYSTEM_IMPL_EXPORT DispatcherTransport DispatcherTryStartTransport(
     Dispatcher* dispatcher);
 
 }  // namespace test
 
@@ skipping 96 matching lines @@
     friend class HandleTable;
     // Tests also need this, to avoid needing |Core|.
     friend DispatcherTransport test::DispatcherTryStartTransport(Dispatcher*);
 
     // This must be called under the handle table lock and only if the handle
     // table entry is not marked busy. The caller must maintain a reference to
     // |dispatcher| until |DispatcherTransport::End()| is called.
     static DispatcherTransport TryStartTransport(Dispatcher* dispatcher);
   };
 
-  // A |MessageInTransit| may serialize dispatchers that are attached to it to a
-  // given |Channel| and then (probably in a different process) deserialize.
+  // A |TransportData| may serialize dispatchers that are given to it (and which
+  // were previously attached to the |MessageInTransit| that is creating it) to
+  // a given |Channel| and then (probably in a different process) deserialize.
   // Note that the |MessageInTransit| "owns" (i.e., has the only ref to) these
   // dispatchers, so there are no locking issues. (There's no lock ordering
   // issue, and in fact no need to take dispatcher locks at all.)
   // TODO(vtl): Consider making another wrapper similar to |DispatcherTransport|
   // (but with an owning, unique reference), and having
   // |CreateEquivalentDispatcherAndCloseImplNoLock()| return that wrapper (and
-  // |MessageInTransit| only holding on to such wrappers).
-  class MessageInTransitAccess {
+  // |MessageInTransit|, etc. only holding on to such wrappers).
+  class TransportDataAccess {
    private:
-    friend class MessageInTransit;
+    friend class TransportData;
 
     // Serialization API. These functions may only be called on such
     // dispatchers. (|channel| is the |Channel| to which the dispatcher is to be
     // serialized.) See the |Dispatcher| methods of the same names for more
     // details.
     static void StartSerialize(Dispatcher* dispatcher,
                                Channel* channel,
                                size_t* max_size,
                                size_t* max_platform_handles);
     static bool EndSerializeAndClose(
@@ skipping 108 matching lines @@
   void CloseNoLock();
 
   // 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.
   scoped_refptr<Dispatcher> CreateEquivalentDispatcherAndCloseNoLock();
 
   // API to serialize dispatchers to a |Channel|, exposed to only
-  // |MessageInTransit| (via |MessageInTransitAccess|). They may only be called
-  // on a dispatcher attached to a |MessageInTransit| (and in particular not in
+  // |TransportData| (via |TransportData|). They may only be called on a
+  // dispatcher attached to a |MessageInTransit| (and in particular not in
   // |CoreImpl|'s handle table).
   //
   // Starts the serialization. Returns (via the two "out" parameters) the
   // maximum amount of space that may be needed to serialize this dispatcher to
   // the given |Channel| (no more than
-  // |MessageInTransit::kMaxSerializedDispatcherSize|) and the maximum number of
+  // |TransportData::kMaxSerializedDispatcherSize|) and the maximum number of
   // |PlatformHandle|s that may need to be attached (no more than
-  // |MessageInTransit::kMaxSerializedDispatcherPlatformHandles|). If this
+  // |TransportData::kMaxSerializedDispatcherPlatformHandles|). If this
   // dispatcher cannot be serialized to the given |Channel|, |*max_size| and
   // |*max_platform_handles| should be set to zero. A call to this method will
   // ALWAYS be followed by a call to |EndSerializeAndClose()| (even if this
   // dispatcher cannot be serialized to the given |Channel|).
   void StartSerialize(Channel* channel,
                       size_t* max_size,
                       size_t* max_platform_handles);
   // Completes the serialization of this dispatcher to the given |Channel| and
   // closes it. (This call will always follow an earlier call to
   // |StartSerialize()|, with the same |Channel|.) This does so by writing to
@@ skipping 51 matching lines @@
 
   Dispatcher* dispatcher_;
 
   // Copy and assign allowed.
 };
 
 }  // namespace system
 }  // namespace mojo
 
 #endif  // MOJO_SYSTEM_DISPATCHER_H_