Mojo: Dispatcher::MessageInTransitAccess functions don't need to take the lock.

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>
 
@@ skipping 129 matching lines @@
     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.
+  // 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 {
    private:
     friend class MessageInTransit;
 
     // 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.
     // TODO(vtl): Consider replacing this API below with a proper two-phase one
     // ("StartSerialize()" and "EndSerializeAndClose()", with the lock possibly
     // being held across their invocations).
     static size_t GetMaximumSerializedSize(const Dispatcher* dispatcher,
                                            const Channel* channel);
     static bool SerializeAndClose(Dispatcher* dispatcher,
                                   Channel* channel,
                                   void* destination,
                                   size_t* actual_size);
 
     // Deserialization API.
-    // TODO(vtl): Implement this.
     static scoped_refptr<Dispatcher> Deserialize(Channel* channel,
                                                  int32_t type,
                                                  const void* source,
                                                  size_t size);
   };
 
  protected:
   friend class base::RefCountedThreadSafe<Dispatcher>;
 
   Dispatcher();
@@ skipping 147 matching lines @@
 
   Dispatcher* dispatcher_;
 
   // Copy and assign allowed.
 };
 
 }  // namespace system
 }  // namespace mojo
 
 #endif  // MOJO_SYSTEM_DISPATCHER_H_