Adding discardable memory dump provider.

content/common/discardable_shared_memory_heap.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 "content/common/discardable_shared_memory_heap.h"
 
 #include <algorithm>
 
 #include "base/memory/discardable_shared_memory.h"
+#include "base/strings/stringprintf.h"
 
 namespace content {
 namespace {
 
 bool IsPowerOfTwo(size_t x) {
   return (x & (x - 1)) == 0;
 }
 
 bool IsInFreeList(DiscardableSharedMemoryHeap::Span* span) {
   return span->previous() || span->next();
@@ skipping 185 matching lines @@
 }
 
 size_t DiscardableSharedMemoryHeap::GetSize() const {
   return num_blocks_ * block_size_;
 }
 
 size_t DiscardableSharedMemoryHeap::GetSizeOfFreeLists() const {
   return num_free_blocks_ * block_size_;
 }
 
+bool DiscardableSharedMemoryHeap::DumpMemoryStatisticsInto(
+    base::trace_event::ProcessMemoryDump* pmd) {
+  for (size_t segment = 0; segment < memory_segments_.size(); segment++) {

[reveman, 2015/04/24 14:19:36]

Would be nice to do something c++-ish like ReleaseFreeMemory here. e.g.

std::for_each(memory_segments_.begin(), memory_segments_.end(),
              [pmd](const ScopedMemorySegment* segment) {
                segment->DumpInto(pmd);
              }), memory_segments_.end());

[ssid, 2015/04/27 11:19:20]

Thanks done.

+    std::string segment_id = base::StringPrintf("segment_%zu", segment);

[reveman, 2015/04/24 14:19:36]

nit: maybe move "segment" string to a kMemoryAllocatorHeapNamePrefix constant

[ssid, 2015/04/27 11:19:20]

Done.

+    base::trace_event::MemoryAllocatorDump* segment_dump =
+        pmd->CreateAllocatorDump("discardable", segment_id.c_str());

[reveman, 2015/04/24 14:19:36]

nit: and maybe move this string to a kMemoryAllocatorName constant

[ssid, 2015/04/27 11:19:20]

Done.

+
+    size_t num_of_objects = 0;

[reveman, 2015/04/24 14:19:36]

nit: allocated_objects_count

Might as well keep this consistent with setters instead of using some other
names here...

[ssid, 2015/04/27 11:19:20]

Done.

+    size_t used_size = 0;

[reveman, 2015/04/24 14:19:36]

nit: allocated_objects_size_in_bytes

[ssid, 2015/04/27 11:19:20]

Done.

+    size_t offset = reinterpret_cast<size_t>(
+                        memory_segments_[segment]->shared_memory_->memory()) /
+                    block_size_;
+    size_t end = offset + memory_segments_[segment]->size_ / block_size_;
+    while (offset < end) {
+      Span* span = spans_[offset];
+      if (!IsInFreeList(span)) {
+        num_of_objects++;
+        used_size += span->length_;
+      }
+      offset += span->length_;
+    }
+
+    segment_dump->set_physical_size_in_bytes(
+        static_cast<int>(memory_segments_[segment]->size_));
+    segment_dump->set_allocated_objects_count(static_cast<int>(num_of_objects));
+    segment_dump->set_allocated_objects_size_in_bytes(
+        static_cast<int>(used_size));
+  }
+  return true;
+}
+
 void DiscardableSharedMemoryHeap::InsertIntoFreeList(
     scoped_ptr<DiscardableSharedMemoryHeap::Span> span) {
   DCHECK(!IsInFreeList(span.get()));
   size_t index = std::min(span->length_, arraysize(free_spans_)) - 1;
   free_spans_[index].Append(span.release());
 }
 
 scoped_ptr<DiscardableSharedMemoryHeap::Span>
 DiscardableSharedMemoryHeap::RemoveFromFreeList(Span* span) {
   DCHECK(IsInFreeList(span));
@@ skipping 85 matching lines @@
     // If |span| is in the free list, remove it and update |num_free_blocks_|.
     if (IsInFreeList(span)) {
       DCHECK_GE(num_free_blocks_, span->length_);
       num_free_blocks_ -= span->length_;
       RemoveFromFreeList(span);
     }
   }
 }
 
 }  // namespace content