base: Change auto to not deduce raw pointers.

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"
@@ skipping 50 matching lines @@
   ASSERT_FALSE(pmd1->has_process_mmaps());
   ASSERT_TRUE(pmd1->process_mmaps()->vm_regions().empty());
   ASSERT_EQ(nullptr, pmd1->GetSharedGlobalAllocatorDump(shared_mad_guid1));
   ASSERT_EQ(nullptr, pmd1->GetSharedGlobalAllocatorDump(shared_mad_guid2));
 
   // Check that calling AsValueInto() doesn't cause a crash.
   std::unique_ptr<TracedValue> traced_value(new TracedValue);
   pmd1->AsValueInto(traced_value.get());
 
   // Check that the pmd can be reused and behaves as expected.
-  auto mad1 = pmd1->CreateAllocatorDump("mad1");
-  auto mad3 = pmd1->CreateAllocatorDump("mad3");
-  auto shared_mad1 = pmd1->CreateSharedGlobalAllocatorDump(shared_mad_guid1);
-  auto shared_mad2 =
+  auto* mad1 = pmd1->CreateAllocatorDump("mad1");
+  auto* mad3 = pmd1->CreateAllocatorDump("mad3");
+  auto* shared_mad1 = pmd1->CreateSharedGlobalAllocatorDump(shared_mad_guid1);
+  auto* shared_mad2 =
       pmd1->CreateWeakSharedGlobalAllocatorDump(shared_mad_guid2);
   ASSERT_EQ(4u, pmd1->allocator_dumps().size());
   ASSERT_EQ(mad1, pmd1->GetAllocatorDump("mad1"));
   ASSERT_EQ(nullptr, pmd1->GetAllocatorDump("mad2"));
   ASSERT_EQ(mad3, pmd1->GetAllocatorDump("mad3"));
   ASSERT_EQ(shared_mad1, pmd1->GetSharedGlobalAllocatorDump(shared_mad_guid1));
   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());
 
@@ skipping 10 matching lines @@
   TraceEventMemoryOverhead overhead;
 
   scoped_refptr<MemoryDumpSessionState> session_state =
       new MemoryDumpSessionState;
   session_state->SetStackFrameDeduplicator(
       WrapUnique(new StackFrameDeduplicator));
   session_state->SetTypeNameDeduplicator(
       WrapUnique(new TypeNameDeduplicator));
   std::unique_ptr<ProcessMemoryDump> pmd1(
       new ProcessMemoryDump(session_state.get(), kDetailedDumpArgs));
-  auto mad1_1 = pmd1->CreateAllocatorDump("pmd1/mad1");
-  auto mad1_2 = pmd1->CreateAllocatorDump("pmd1/mad2");
+  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(session_state.get(), kDetailedDumpArgs));
-  auto mad2_1 = pmd2->CreateAllocatorDump("pmd2/mad1");
-  auto mad2_2 = pmd2->CreateAllocatorDump("pmd2/mad2");
+  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 =
+  auto* shared_mad1 = pmd2->CreateSharedGlobalAllocatorDump(shared_mad_guid1);
+  auto* shared_mad2 =
       pmd2->CreateWeakSharedGlobalAllocatorDump(shared_mad_guid2);
 
   pmd1->TakeAllDumpsFrom(pmd2.get());
 
   // Make sure that pmd2 is empty but still usable after it has been emptied.
   ASSERT_TRUE(pmd2->allocator_dumps().empty());
   ASSERT_TRUE(pmd2->allocator_dumps_edges().empty());
   ASSERT_TRUE(pmd2->heap_dumps().empty());
   pmd2->CreateAllocatorDump("pmd2/this_mad_stays_with_pmd2");
   ASSERT_EQ(1u, pmd2->allocator_dumps().size());
@@ skipping 32 matching lines @@
 }
 
 TEST(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");
+  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",
+  auto* pic2_dump = pmd->CreateAllocatorDump("picturemanager/picture2",
                                             MemoryAllocatorDumpGuid(0x42));
   pmd->AddSuballocation(pic2_dump->guid(), allocator_dump_name);
 
   // Now check that AddSuballocation() has created anonymous child dumps under
   // "fakealloc/allocated_objects".
   auto anon_node_1_it = pmd->allocator_dumps().find(
       allocator_dump_name + "/__" + pic1_dump->guid().ToString());
   ASSERT_NE(pmd->allocator_dumps().end(), anon_node_1_it);
 
   auto anon_node_2_it =
@@ skipping 16 matching lines @@
   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, kDetailedDumpArgs));
   MemoryAllocatorDumpGuid shared_mad_guid(1);
-  auto shared_mad1 = pmd->CreateWeakSharedGlobalAllocatorDump(shared_mad_guid);
+  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);
+  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);
+  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);
+  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);
+  auto* shared_mad5 = pmd->CreateWeakSharedGlobalAllocatorDump(shared_mad_guid);
   ASSERT_EQ(shared_mad1, shared_mad5);
   ASSERT_EQ(MemoryAllocatorDump::Flags::DEFAULT, shared_mad1->flags());
 }
 
 TEST(ProcessMemoryDumpTest, BackgroundModeTest) {
   MemoryDumpArgs background_args = {MemoryDumpLevelOfDetail::BACKGROUND};
   std::unique_ptr<ProcessMemoryDump> pmd(
       new ProcessMemoryDump(nullptr, background_args));
   ProcessMemoryDump::is_black_hole_non_fatal_for_testing_ = true;
   SetAllocatorDumpNameWhitelistForTesting(kTestDumpNameWhitelist);
@@ skipping 54 matching lines @@
       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