Mojo: Small fixes/cleanup to MessageInTransit, before I factor out the secondary buffer.

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 <stdint.h>
 
 #include <vector>
 
 #include "base/macros.h"
+#include "base/memory/aligned_memory.h"
 #include "base/memory/scoped_ptr.h"
 #include "mojo/embedder/platform_handle.h"
 #include "mojo/system/dispatcher.h"
 #include "mojo/system/system_impl_export.h"
 
 namespace mojo {
 namespace system {
 
 class Channel;
 
@@ skipping 148 matching lines @@
   // stays alive through the call.
   void SerializeAndCloseDispatchers(Channel* channel);
 
   // Deserializes any dispatchers from the secondary buffer. This message must
   // not have any dispatchers attached.
   // TODO(vtl): Having to copy the secondary buffer (in the constructor from a
   // |View|) is suboptimal. Maybe this should just be done in the constructor?
   void DeserializeDispatchers(Channel* channel);
 
   // Gets the main buffer and its size (in number of bytes), respectively.
-  const void* main_buffer() const { return main_buffer_; }
+  const void* main_buffer() const { return main_buffer_.get(); }
   size_t main_buffer_size() const { return main_buffer_size_; }
 
   // Gets the secondary buffer and its size (in number of bytes), respectively.
-  const void* secondary_buffer() const { return secondary_buffer_; }
+  const void* secondary_buffer() const { return secondary_buffer_.get(); }
   size_t secondary_buffer_size() const { return secondary_buffer_size_; }
 
   // Gets the total size of the message (see comment in |Header|, below).
   size_t total_size() const { return header()->total_size; }
 
   // Gets the size of the message data.
   uint32_t num_bytes() const { return header()->num_bytes; }
 
   // Gets the message data (of size |num_bytes()| bytes).
-  const void* bytes() const {
-    return static_cast<const char*>(main_buffer_) + sizeof(Header);
-  }
-  void* bytes() { return static_cast<char*>(main_buffer_) + sizeof(Header); }
+  const void* bytes() const { return main_buffer_.get() + sizeof(Header); }
+  void* bytes() { return main_buffer_.get() + sizeof(Header); }
 
   uint32_t num_handles() const { return header()->num_handles; }
 
   Type type() const { return header()->type; }
   Subtype subtype() const { return header()->subtype; }
   EndpointId source_id() const { return header()->source_id; }
   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) {
@@ skipping 65 matching lines @@
   // The maximum total number of platform handles that may be attached.
   static const size_t kMaxPlatformHandles;
 
   // Validates the secondary buffer. Returns null on success, or a
   // human-readable error message (meant for logging/debugging) on error.
   static const char* ValidateSecondaryBuffer(size_t num_handles,
                                              const void* secondary_buffer,
                                              size_t secondary_buffer_size);
 
   const Header* header() const {
-    return static_cast<const Header*>(main_buffer_);
+    return reinterpret_cast<const Header*>(main_buffer_.get());
   }
-  Header* header() { return static_cast<Header*>(main_buffer_); }
+  Header* header() { return reinterpret_cast<Header*>(main_buffer_.get()); }
 
   void UpdateTotalSize();
 
-  size_t main_buffer_size_;
-  void* main_buffer_;
+  const size_t main_buffer_size_;
+  const scoped_ptr<char, base::AlignedFreeDeleter> main_buffer_;  // Never null.
 
   size_t secondary_buffer_size_;
-  void* secondary_buffer_;  // May be null.
+  scoped_ptr<char, base::AlignedFreeDeleter> secondary_buffer_;  // 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_;
 
   // Any platform-specific handles attached to this message (for inter-process
   // transport). The vector (if any) owns the handles that it contains (and is
   // responsible for closing them).
   // TODO(vtl): With C++11, change it to a vector of |ScopedPlatformHandles|.
   scoped_ptr<std::vector<embedder::PlatformHandle> > platform_handles_;
 
   DISALLOW_COPY_AND_ASSIGN(MessageInTransit);
 };
 
 }  // namespace system
 }  // namespace mojo
 
 #endif  // MOJO_SYSTEM_MESSAGE_IN_TRANSIT_H_