Mojo: Add/use |typedef std::vector<scoped_refptr<Dispatcher> > DispatcherVector.

mojo/system/message_in_transit.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_MESSAGE_IN_TRANSIT_H_
 #define MOJO_SYSTEM_MESSAGE_IN_TRANSIT_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 131 matching lines @@
   // TODO(vtl): In |RawChannelPosix|, the alignment requirements are currently
   // satisified on a faith-based basis.
   static bool GetNextMessageSize(const void* buffer,
                                  size_t buffer_size,
                                  size_t* next_message_size);
 
   // Makes this message "own" the given set of dispatchers. The dispatchers must
   // not be referenced from anywhere else (in particular, not from the handle
   // table), i.e., each dispatcher must have a reference count of 1. This
   // message must not already have dispatchers.
-  void SetDispatchers(
-      scoped_ptr<std::vector<scoped_refptr<Dispatcher> > > dispatchers);
+  void SetDispatchers(scoped_ptr<DispatcherVector> dispatchers);
 
   // Serializes any dispatchers to the secondary buffer. This message must not
   // already have a secondary buffer (so this must only be called once). The
   // caller must ensure (e.g., by holding on to a reference) that |channel|
   // stays alive through the call.
   void SerializeAndCloseDispatchers(Channel* channel);
 
   // Gets the main buffer and its size (in number of bytes), respectively.
   const void* main_buffer() const { return main_buffer_.get(); }
   size_t main_buffer_size() const { return main_buffer_size_; }
@@ skipping 17 matching lines @@
   EndpointId destination_id() const { return header()->destination_id; }
 
   void set_source_id(EndpointId source_id) { header()->source_id = source_id; }
   void set_destination_id(EndpointId destination_id) {
     header()->destination_id = destination_id;
   }
 
   // Gets the dispatchers attached to this message; this may return null if
   // there are none. Note that the caller may mutate the set of dispatchers
   // (e.g., take ownership of all the dispatchers, leaving the vector empty).
-  std::vector<scoped_refptr<Dispatcher> >* dispatchers() {
-    return dispatchers_.get();
-  }
+  DispatcherVector* dispatchers() { return dispatchers_.get(); }
 
   // Returns true if this message has dispatchers attached.
   bool has_dispatchers() const {
     return dispatchers_ && !dispatchers_->empty();
   }
 
   // Rounds |n| up to a multiple of |kMessageAlignment|.
   static inline size_t RoundUpMessageAlignment(size_t n) {
     return (n + kMessageAlignment - 1) & ~(kMessageAlignment - 1);
   }
@@ skipping 29 matching lines @@
 
   const size_t main_buffer_size_;
   const scoped_ptr<char, base::AlignedFreeDeleter> main_buffer_;  // Never null.
 
   scoped_ptr<TransportData> transport_data_;  // May be null.
 
   // Any dispatchers that may be attached to this message. These dispatchers
   // should be "owned" by this message, i.e., have a ref count of exactly 1. (We
   // allow a dispatcher entry to be null, in case it couldn't be duplicated for
   // some reason.)
-  scoped_ptr<std::vector<scoped_refptr<Dispatcher> > > dispatchers_;
+  scoped_ptr<DispatcherVector> dispatchers_;
 
   DISALLOW_COPY_AND_ASSIGN(MessageInTransit);
 };
 
 }  // namespace system
 }  // namespace mojo
 
 #endif  // MOJO_SYSTEM_MESSAGE_IN_TRANSIT_H_