[tracing] Sanitize process memory dumps for background mode

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 <stddef.h>
 
 #include "base/memory/aligned_memory.h"
+#include "base/memory/ptr_util.h"
 #include "base/process/process_metrics.h"
 #include "base/trace_event/memory_allocator_dump_guid.h"
+#include "base/trace_event/memory_infra_background_whitelist.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
 namespace trace_event {
 
 namespace {
+
+const MemoryDumpArgs kDetailedDumpArgs = {MemoryDumpLevelOfDetail::DETAILED};
+const char* const kTestDumpNameWhitelist[] = {"WhitelistedTestName", nullptr};

[Primiano Tucci (use gerrit), 2016/06/02 20:24:04]

I think you should move this below, because you reference this only in one
TEST_F right?

[ssid, 2016/06/03 01:59:46]

Hm it is bad i will be setting a global g_whitelist (in whitelist.h) using a
stack vaiable which vanishes later. It might cause unexpected behaviour in other
tests in future.

+
 TracedValue* GetHeapDump(const ProcessMemoryDump& pmd, const char* name) {
   auto it = pmd.heap_dumps().find(name);
   return it == pmd.heap_dumps().end() ? nullptr : it->second.get();
 }
+
 }  // namespace
 
-TEST(ProcessMemoryDumpTest, Clear) {
-  std::unique_ptr<ProcessMemoryDump> pmd1(new ProcessMemoryDump(nullptr));
+class ProcessMemoryDumpTest : public testing::Test {
+ protected:
+  MemoryAllocatorDump* CreateAllocatorDumpInPMD(ProcessMemoryDump* pmd,
+                                                const char* name) {
+    return pmd->AddAllocatorDumpInternal(WrapUnique(
+        new MemoryAllocatorDump(name, pmd, MemoryAllocatorDumpGuid())));
+  }
+};
+
+TEST_F(ProcessMemoryDumpTest, Clear) {
+  std::unique_ptr<ProcessMemoryDump> pmd1(
+      new ProcessMemoryDump(nullptr, kDetailedDumpArgs));
   pmd1->CreateAllocatorDump("mad1");
   pmd1->CreateAllocatorDump("mad2");
   ASSERT_FALSE(pmd1->allocator_dumps().empty());
 
   pmd1->process_totals()->set_resident_set_bytes(42);
   pmd1->set_has_process_totals();
 
   pmd1->process_mmaps()->AddVMRegion(ProcessMemoryMaps::VMRegion());
   pmd1->set_has_process_mmaps();
 
@@ skipping 34 matching lines @@
   ASSERT_EQ(MemoryAllocatorDump::Flags::DEFAULT, shared_mad1->flags());
   ASSERT_EQ(shared_mad2, pmd1->GetSharedGlobalAllocatorDump(shared_mad_guid2));
   ASSERT_EQ(MemoryAllocatorDump::Flags::WEAK, shared_mad2->flags());
 
   traced_value.reset(new TracedValue);
   pmd1->AsValueInto(traced_value.get());
 
   pmd1.reset();
 }
 
-TEST(ProcessMemoryDumpTest, TakeAllDumpsFrom) {
+TEST_F(ProcessMemoryDumpTest, TakeAllDumpsFrom) {
   std::unique_ptr<TracedValue> traced_value(new TracedValue);
   hash_map<AllocationContext, AllocationMetrics> metrics_by_context;
   metrics_by_context[AllocationContext()] = { 1, 1 };
   TraceEventMemoryOverhead overhead;
 
   std::unique_ptr<ProcessMemoryDump> pmd1(
-      new ProcessMemoryDump(new MemoryDumpSessionState()));
+      new ProcessMemoryDump(new MemoryDumpSessionState(), kDetailedDumpArgs));
   auto mad1_1 = pmd1->CreateAllocatorDump("pmd1/mad1");
   auto mad1_2 = pmd1->CreateAllocatorDump("pmd1/mad2");
   pmd1->AddOwnershipEdge(mad1_1->guid(), mad1_2->guid());
   pmd1->DumpHeapUsage(metrics_by_context, overhead, "pmd1/heap_dump1");
   pmd1->DumpHeapUsage(metrics_by_context, overhead, "pmd1/heap_dump2");
 
   std::unique_ptr<ProcessMemoryDump> pmd2(
-      new ProcessMemoryDump(new MemoryDumpSessionState()));
+      new ProcessMemoryDump(new MemoryDumpSessionState(), kDetailedDumpArgs));
   auto mad2_1 = pmd2->CreateAllocatorDump("pmd2/mad1");
   auto mad2_2 = pmd2->CreateAllocatorDump("pmd2/mad2");
   pmd2->AddOwnershipEdge(mad2_1->guid(), mad2_2->guid());
   pmd2->DumpHeapUsage(metrics_by_context, overhead, "pmd2/heap_dump1");
   pmd2->DumpHeapUsage(metrics_by_context, overhead, "pmd2/heap_dump2");
 
   MemoryAllocatorDumpGuid shared_mad_guid1(1);
   MemoryAllocatorDumpGuid shared_mad_guid2(2);
   auto shared_mad1 = pmd2->CreateSharedGlobalAllocatorDump(shared_mad_guid1);
   auto shared_mad2 =
@@ skipping 34 matching lines @@
   ASSERT_TRUE(GetHeapDump(*pmd1, "pmd2/heap_dump1") != nullptr);
   ASSERT_TRUE(GetHeapDump(*pmd1, "pmd2/heap_dump2") != nullptr);
 
   // Check that calling AsValueInto() doesn't cause a crash.
   traced_value.reset(new TracedValue);
   pmd1->AsValueInto(traced_value.get());
 
   pmd1.reset();
 }
 
-TEST(ProcessMemoryDumpTest, Suballocations) {
-  std::unique_ptr<ProcessMemoryDump> pmd(new ProcessMemoryDump(nullptr));
+TEST_F(ProcessMemoryDumpTest, Suballocations) {
+  std::unique_ptr<ProcessMemoryDump> pmd(
+      new ProcessMemoryDump(nullptr, kDetailedDumpArgs));
   const std::string allocator_dump_name = "fakealloc/allocated_objects";
   pmd->CreateAllocatorDump(allocator_dump_name);
 
   // Create one allocation with an auto-assigned guid and mark it as a
   // suballocation of "fakealloc/allocated_objects".
   auto pic1_dump = pmd->CreateAllocatorDump("picturemanager/picture1");
   pmd->AddSuballocation(pic1_dump->guid(), allocator_dump_name);
 
   // Same here, but this time create an allocation with an explicit guid.
   auto pic2_dump = pmd->CreateAllocatorDump("picturemanager/picture2",
@@ skipping 22 matching lines @@
   ASSERT_TRUE(found_edge[0]);
   ASSERT_TRUE(found_edge[1]);
 
   // Check that calling AsValueInto() doesn't cause a crash.
   std::unique_ptr<TracedValue> traced_value(new TracedValue);
   pmd->AsValueInto(traced_value.get());
 
   pmd.reset();
 }
 
-TEST(ProcessMemoryDumpTest, GlobalAllocatorDumpTest) {
-  std::unique_ptr<ProcessMemoryDump> pmd(new ProcessMemoryDump(nullptr));
+TEST_F(ProcessMemoryDumpTest, GlobalAllocatorDumpTest) {
+  std::unique_ptr<ProcessMemoryDump> pmd(
+      new ProcessMemoryDump(nullptr, kDetailedDumpArgs));
   MemoryAllocatorDumpGuid shared_mad_guid(1);
   auto shared_mad1 = pmd->CreateWeakSharedGlobalAllocatorDump(shared_mad_guid);
   ASSERT_EQ(shared_mad_guid, shared_mad1->guid());
   ASSERT_EQ(MemoryAllocatorDump::Flags::WEAK, shared_mad1->flags());
 
   auto shared_mad2 = pmd->GetSharedGlobalAllocatorDump(shared_mad_guid);
   ASSERT_EQ(shared_mad1, shared_mad2);
   ASSERT_EQ(MemoryAllocatorDump::Flags::WEAK, shared_mad1->flags());
 
   auto shared_mad3 = pmd->CreateWeakSharedGlobalAllocatorDump(shared_mad_guid);
   ASSERT_EQ(shared_mad1, shared_mad3);
   ASSERT_EQ(MemoryAllocatorDump::Flags::WEAK, shared_mad1->flags());
 
   auto shared_mad4 = pmd->CreateSharedGlobalAllocatorDump(shared_mad_guid);
   ASSERT_EQ(shared_mad1, shared_mad4);
   ASSERT_EQ(MemoryAllocatorDump::Flags::DEFAULT, shared_mad1->flags());
 
   auto shared_mad5 = pmd->CreateWeakSharedGlobalAllocatorDump(shared_mad_guid);
   ASSERT_EQ(shared_mad1, shared_mad5);
   ASSERT_EQ(MemoryAllocatorDump::Flags::DEFAULT, shared_mad1->flags());
 }
 
+TEST_F(ProcessMemoryDumpTest, BackgroundModeTest) {
+  MemoryDumpArgs background_args = {MemoryDumpLevelOfDetail::BACKGROUND};
+  std::unique_ptr<ProcessMemoryDump> pmd(
+      new ProcessMemoryDump(nullptr, background_args));
+  SetAllocatorDumpNameWhitelistForTesting(kTestDumpNameWhitelist);
+  MemoryAllocatorDump* black_hole_mad = pmd->black_hole_mad_.get();
+
+  // Invalid dump names.
+  EXPECT_EQ(black_hole_mad,
+            CreateAllocatorDumpInPMD(pmd.get(), "NotWhitelistedTestName"));

[Primiano Tucci (use gerrit), 2016/06/02 20:24:04]

Isn't this going to hit all those DCHECKs? I guess you just tested this in
release :)
If you do the GetBlackHole helper, you can add a static bool
black_hole_non_fatal_for_testing to PMD.

[ssid, 2016/06/03 01:59:46]

No, I had to make the test class and call AddInternal just to not hit this
dcheck. That is the reason I made the ProcessMemoryDumpTest class to call the
AddInternal method.
black_hole_non_fatal_for_testing sounds like a exact thing in need! :D

+  EXPECT_EQ(black_hole_mad,
+            CreateAllocatorDumpInPMD(pmd.get(), "NotWhitelistedTestName"));

[Primiano Tucci (use gerrit), 2016/06/02 20:24:04]

I think this is identical to the above?

[ssid, 2016/06/03 01:59:46]

fixed.

+  EXPECT_EQ(black_hole_mad, CreateAllocatorDumpInPMD(pmd.get(), "TestName"));
+  EXPECT_EQ(black_hole_mad,
+            CreateAllocatorDumpInPMD(pmd.get(), "Whitelisted/Test"));
+  EXPECT_EQ(black_hole_mad,
+            CreateAllocatorDumpInPMD(pmd.get(), "Not/Whitelisted/TestName"));
+  EXPECT_EQ(black_hole_mad,
+            CreateAllocatorDumpInPMD(pmd.get(), "Whitelisted/TestName/Google"));
+  EXPECT_EQ(black_hole_mad, CreateAllocatorDumpInPMD(
+                                pmd.get(), "Whitelisted/TestName/0x1a2Google"));
+  EXPECT_EQ(black_hole_mad, CreateAllocatorDumpInPMD(
+                                pmd.get(), "Whitelisted/TestName/__12/Google"));
+
+  // Global dumps.
+  MemoryAllocatorDumpGuid guid(1);
+  EXPECT_EQ(black_hole_mad, pmd->CreateSharedGlobalAllocatorDump(guid));
+  EXPECT_EQ(black_hole_mad, pmd->CreateWeakSharedGlobalAllocatorDump(guid));
+  EXPECT_EQ(black_hole_mad, pmd->GetSharedGlobalAllocatorDump(guid));
+
+  // Suballocations.
+  pmd->AddSuballocation(guid, "malloc/allocated_objects");
+  EXPECT_EQ(0u, pmd->allocator_dumps_edges_.size());
+  EXPECT_EQ(0u, pmd->allocator_dumps_.size());
+
+  // Valid dump names.
+  EXPECT_NE(black_hole_mad,
+            CreateAllocatorDumpInPMD(pmd.get(), "WhitelistedTestName"));
+  EXPECT_NE(black_hole_mad,
+            CreateAllocatorDumpInPMD(pmd.get(), "Whitelisted/TestName/0xA1b2"));
+  EXPECT_NE(black_hole_mad, CreateAllocatorDumpInPMD(
+                                pmd.get(), "Whitelisted/TestName_123/0xab"));
+  EXPECT_NE(black_hole_mad, CreateAllocatorDumpInPMD(
+                                pmd.get(), "Whitelisted_12/0xaB/TestName"));
+
+  // GetAllocatorDump is consistent.
+  EXPECT_EQ(black_hole_mad, pmd->GetAllocatorDump("NotWhitelistedTestName"));
+  auto mad = pmd->GetAllocatorDump("WhitelistedTestName");
+  EXPECT_NE(black_hole_mad, mad);
+}
+
 #if defined(COUNT_RESIDENT_BYTES_SUPPORTED)
-TEST(ProcessMemoryDumpTest, CountResidentBytes) {
+TEST_F(ProcessMemoryDumpTest, CountResidentBytes) {
   const size_t page_size = ProcessMemoryDump::GetSystemPageSize();
 
   // Allocate few page of dirty memory and check if it is resident.
   const size_t size1 = 5 * page_size;
   std::unique_ptr<char, base::AlignedFreeDeleter> memory1(
       static_cast<char*>(base::AlignedAlloc(size1, page_size)));
   memset(memory1.get(), 0, size1);
   size_t res1 = ProcessMemoryDump::CountResidentBytes(memory1.get(), size1);
   ASSERT_EQ(res1, size1);
 
   // Allocate a large memory segment (> 8Mib).
   const size_t kVeryLargeMemorySize = 15 * 1024 * 1024;
   std::unique_ptr<char, base::AlignedFreeDeleter> memory2(
       static_cast<char*>(base::AlignedAlloc(kVeryLargeMemorySize, page_size)));
   memset(memory2.get(), 0, kVeryLargeMemorySize);
   size_t res2 = ProcessMemoryDump::CountResidentBytes(memory2.get(),
                                                       kVeryLargeMemorySize);
   ASSERT_EQ(res2, kVeryLargeMemorySize);
 }
 #endif  // defined(COUNT_RESIDENT_BYTES_SUPPORTED)
 
 }  // namespace trace_event
 }  // namespace base