[tracing] Display the resident size of the discardable memory segments

base/trace_event/process_memory_dump_unittest.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/process_memory_dump.h"
 
 #include "base/memory/scoped_ptr.h"
+#include "base/process/process_metrics.h"
 #include "base/trace_event/memory_allocator_dump_guid.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
 namespace trace_event {
 
 TEST(ProcessMemoryDumpTest, Clear) {
   scoped_ptr<ProcessMemoryDump> pmd1(new ProcessMemoryDump(nullptr));
   pmd1->CreateAllocatorDump("mad1");
@@ skipping 129 matching lines @@
   ASSERT_TRUE(found_edge[0]);
   ASSERT_TRUE(found_edge[1]);
 
   // Check that calling AsValueInto() doesn't cause a crash.
   scoped_refptr<TracedValue> traced_value(new TracedValue());
   pmd->AsValueInto(traced_value.get());
 
   pmd.reset();
 }
 
+#if defined(OS_POSIX) && !defined(OS_NACL)
+TEST(ProcessMemoryDumpTest, CountResidentBytes) {
+  const size_t page_size = base::GetPageSize();
+  // Allocate a segment on stack and check if the page is resident.
+  char memory1[100] = {0};
+  void* page_start1 = reinterpret_cast<void*>(
+      reinterpret_cast<uintptr_t>(memory1) / page_size * page_size);
+  ssize_t res1 = ProcessMemoryDump::CountResidentBytes(page_start1, page_size);
+  ASSERT_GE(static_cast<size_t>(res1), page_size);
+
+  // Allocate few page of dirty memory and check if it is resident.
+  scoped_ptr<char[]> memory2(new char[5 * page_size]());
+  void* page_start2 = reinterpret_cast<void*>(
+      reinterpret_cast<uintptr_t>(memory2.get()) / page_size * page_size);
+  ssize_t res2 =
+      ProcessMemoryDump::CountResidentBytes(page_start2, 5 * page_size);
+  ASSERT_NE(-1, res2);
+  ASSERT_GE(static_cast<size_t>(res2), 5 * page_size);
+
+  // Allocate a large memory segment (>32Mib).
+  const size_t kVeryLargeMemorySize = 34 * 1024 * 1024;
+  scoped_ptr<char[]> memory3(new char[kVeryLargeMemorySize]());
+  void* page_start3 = reinterpret_cast<void*>(
+      reinterpret_cast<uintptr_t>(memory3.get()) / page_size * page_size);
+  ssize_t res3 =
+      ProcessMemoryDump::CountResidentBytes(page_start3, kVeryLargeMemorySize);
+  ASSERT_NE(-1, res3);
+  ASSERT_GE(static_cast<size_t>(res3), kVeryLargeMemorySize);
+}
+#endif  // defined(OS_POSIX) && !defined(OS_NACL)
+
 }  // namespace trace_event
 }  // namespace base