Make sure that ScratchBuffer::Allocate() always return 8-byte aligned address.

mojo/public/cpp/bindings/lib/scratch_buffer.cc

 // Copyright 2014 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.
 
 #include "mojo/public/cpp/bindings/lib/scratch_buffer.h"
 
 #include <assert.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include <algorithm>
 
 #include "mojo/public/cpp/bindings/lib/bindings_serialization.h"
 
 // Scrub memory in debug builds to help catch use-after-free bugs.
 #ifdef NDEBUG
 #define DEBUG_SCRUB(address, size) (void) (address), (void) (size)
 #else
 #define DEBUG_SCRUB(address, size) memset(address, 0xCD, size)
 #endif
 
 namespace mojo {
 namespace internal {
 
 ScratchBuffer::ScratchBuffer()
     : overflow_(NULL) {
   fixed_.next = NULL;
-  fixed_.cursor = fixed_data_;
+  fixed_.cursor = internal::AlignPointer(fixed_data_);

[darin (slow to review), 2014/05/06 07:32:55]

maybe we should align fixed_.end too?

doesn't this mean that we waste a few bytes of fixed_data_ on 32-bit systems?
maybe if we moved the overflow_ pointer to be listed before fixed_data_ that
would avoid that minor issue?

[darin (slow to review), 2014/05/06 07:35:29]

nevermind. that would increase fixed_.end in some cases, which would be bad.

[yzshen1, 2014/05/06 08:06:43]

On 32-bit systems, it is possible that pointers are 4-byte aligned, therefore,
this whole object may be 4-byte aligned, right? In that case, no matter how we
reorder the fields, we cannot guarantee that |fixed_data_| is 8-byte aligned. (I
probably need to double-check the differences between platforms/compilers.)

   fixed_.end = fixed_data_ + kMinSegmentSize;
 }
 
 ScratchBuffer::~ScratchBuffer() {
   // Invoke destructors in reverse order to mirror allocation order.
   std::deque<PendingDestructor>::reverse_iterator it;
   for (it = pending_dtors_.rbegin(); it != pending_dtors_.rend(); ++it)
     it->func(it->address);
 
   while (overflow_) {
@@ skipping 34 matching lines @@
 }
 
 bool ScratchBuffer::AddOverflowSegment(size_t delta) {
   if (delta < kMinSegmentSize)
     delta = kMinSegmentSize;
 
   if (delta > kMaxSegmentSize)
     return false;
 
   // Ensure segment buffer is aligned.
-  size_t segment_size = internal::Align(sizeof(Segment)) + delta;
-  Segment* segment = static_cast<Segment*>(malloc(segment_size));
+  size_t padded_segment_size = internal::Align(sizeof(Segment));
+  Segment* segment = static_cast<Segment*>(
+      malloc(padded_segment_size + delta));
   if (segment) {
     segment->next = overflow_;
-    segment->cursor = reinterpret_cast<char*>(segment + 1);
+    segment->cursor = reinterpret_cast<char*>(segment) + padded_segment_size;
     segment->end = segment->cursor + delta;
     overflow_ = segment;
     return true;
   }
 
   return false;
 }
 
 }  // namespace internal
 }  // namespace mojo