Align base::Pickle allocations to 4k boundaries

base/trace_event/trace_event_memory_overhead.cc

 // Copyright 2015 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 "base/trace_event/trace_event_memory_overhead.h"
 
 #include <algorithm>
 
+#include "base/bits.h"
 #include "base/memory/ref_counted_memory.h"
 #include "base/strings/stringprintf.h"
 #include "base/trace_event/memory_allocator_dump.h"
 #include "base/trace_event/process_memory_dump.h"
 #include "base/values.h"
 
-namespace {
-size_t RoundUp(size_t size, size_t alignment) {
-  return (size + alignment - 1) & ~(alignment - 1);
-}
-}  // namespace
-
 namespace base {
 namespace trace_event {
 
 TraceEventMemoryOverhead::TraceEventMemoryOverhead() {
 }
 
 TraceEventMemoryOverhead::~TraceEventMemoryOverhead() {
 }
 
 void TraceEventMemoryOverhead::AddOrCreateInternal(
@@ skipping 23 matching lines @@
                                    size_t allocated_size_in_bytes,
                                    size_t resident_size_in_bytes) {
   AddOrCreateInternal(object_type, 1, allocated_size_in_bytes,
                       resident_size_in_bytes);
 }
 
 void TraceEventMemoryOverhead::AddString(const std::string& str) {
   // The number below are empirical and mainly based on profiling of real-world
   // std::string implementations:
   //  - even short string end up malloc()-inc at least 32 bytes.
-  //  - longer stings seem to malloc() multiples of 16 bytes.
-  Add("std::string",
-      sizeof(std::string) + std::max<size_t>(RoundUp(str.capacity(), 16), 32u));
+  //  - longer strings seem to malloc() multiples of 16 bytes.
+  const size_t capacity = bits::Align(str.capacity(), 16);
+  Add("std::string", sizeof(std::string) + std::max<size_t>(capacity, 32u));
 }
 
 void TraceEventMemoryOverhead::AddRefCountedString(
     const RefCountedString& str) {
   Add("RefCountedString", sizeof(RefCountedString));
   AddString(str.data());
 }
 
 void TraceEventMemoryOverhead::AddValue(const Value& value) {
   switch (value.GetType()) {
@@ skipping 75 matching lines @@
                    it.second.allocated_size_in_bytes);
     mad->AddScalar("resident_size", MemoryAllocatorDump::kUnitsBytes,
                    it.second.resident_size_in_bytes);
     mad->AddScalar(MemoryAllocatorDump::kNameObjectsCount,
                    MemoryAllocatorDump::kUnitsObjects, it.second.count);
   }
 }
 
 }  // namespace trace_event
 }  // namespace base