Mojo: Move the header bits of MessageInTransit into a separate struct.

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 "base/macros.h"
@@ skipping 37 matching lines @@
                                   uint32_t num_bytes,
                                   uint32_t num_handles);
 
   // Destroys a |MessageInTransit| created using |Create()|.
   void Destroy();
 
   // Gets the size of the data (in number of bytes). This is the full size of
   // the data that follows the header, and may include data other than the
   // message data. (See also |num_bytes()|.)
   uint32_t data_size() const {
-    return data_size_;
+    return header()->data_size;
   }
 
   // Gets the data (of size |data_size()| bytes).
   const void* data() const {
     return reinterpret_cast<const char*>(this) + sizeof(*this);
   }
 
   // Gets the size of the message data.
   uint32_t num_bytes() const {
-    return num_bytes_;
+    return header()->num_bytes;
   }
 
   // Gets the message data (of size |num_bytes()| bytes).
   const void* bytes() const {
     return reinterpret_cast<const char*>(this) + sizeof(*this);
   }
 
   uint32_t num_handles() const {
-    return num_handles_;
+    return header()->num_handles;
   }
 
   size_t size_with_header_and_padding() const {
-    return RoundUpMessageAlignment(sizeof(*this) + data_size_);
+    return RoundUpMessageAlignment(sizeof(*this) + header()->data_size);
   }
 
-  Type type() const { return type_; }
-  Subtype subtype() const { return subtype_; }
-  EndpointId source_id() const { return source_id_; }
-  EndpointId destination_id() const { return destination_id_; }
+  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) { source_id_ = source_id; }
+  void set_source_id(EndpointId source_id) { header()->source_id = source_id; }
   void set_destination_id(EndpointId destination_id) {
-    destination_id_ = destination_id;
+    header()->destination_id = destination_id;
   }
 
   // TODO(vtl): Add whatever's necessary to transport handles.
 
   // Rounds |n| up to a multiple of |kMessageAlignment|.
   static inline size_t RoundUpMessageAlignment(size_t n) {
     return (n + kMessageAlignment - 1) & ~(kMessageAlignment - 1);
   }
 
  private:
+  // "Header" for the data. Must be a multiple of |kMessageAlignment| bytes in
+  // size.
+  struct Header {
+    Header(uint32_t data_size, Type type, Subtype subtype, EndpointId source_id,

[yzshen1, 2014/02/19 18:35:06]

I think we need to do each parameter on a separate line for the parameter list
and the initializer list if they don't fit in a single line.

+           EndpointId destination_id, uint32_t num_bytes, uint32_t num_handles)
+        : data_size(data_size), type(type), subtype(subtype),
+          source_id(source_id), destination_id(destination_id),
+          num_bytes(num_bytes), num_handles(num_handles), reserved0(0),
+          reserved1(0) {}
+
+    // Total size of data following the "header".
+    uint32_t data_size;
+    Type type;
+    Subtype subtype;
+    EndpointId source_id;
+    EndpointId destination_id;
+    // Size of actual message data.
+    uint32_t num_bytes;
+    // Number of handles "attached".
+    uint32_t num_handles;
+    // To be used soon.
+    uint32_t reserved0;
+    uint32_t reserved1;
+  };
+
   MessageInTransit(uint32_t data_size,
                    Type type,
                    Subtype subtype,
                    uint32_t num_bytes,
                    uint32_t num_handles);
 
-  // "Header" for the data. Must be a multiple of |kMessageAlignment| bytes in
-  // size.
-  // Total size of data following the "header".
-  uint32_t data_size_;
-  Type type_;
-  Subtype subtype_;
-  EndpointId source_id_;
-  EndpointId destination_id_;
-  // Size of actual message data.
-  uint32_t num_bytes_;
-  // Number of handles "attached".
-  uint32_t num_handles_;
-  // To be used soon.
-  uint32_t reserved0_;
-  uint32_t reserved1_;
+  const Header* header() const { return &header_; }
+  Header* header() { return &header_; }
+
+  Header header_;
 
   // Intentionally unimplemented (and private): Use |Destroy()| instead (which
   // simply frees the memory).
   ~MessageInTransit();
 
   DISALLOW_COPY_AND_ASSIGN(MessageInTransit);
 };
 
 // The size of |MessageInTransit| must be appropriate to maintain alignment of
 // the following data.
 COMPILE_ASSERT(sizeof(MessageInTransit) % MessageInTransit::kMessageAlignment ==
                    0, MessageInTransit_has_wrong_size);
 
 }  // namespace system
 }  // namespace mojo
 
 #endif  // MOJO_SYSTEM_MESSAGE_IN_TRANSIT_H_