Fix crash in InvokeOnMemoryDump when tracing

components/tracing/common/process_metrics_memory_dump_provider_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 "components/tracing/common/process_metrics_memory_dump_provider.h"
 
 #include <stdint.h>
 
 #include <memory>
+#include <unordered_set>
 
 #include "base/files/file_util.h"
 #include "base/memory/ptr_util.h"
 #include "base/process/process_metrics.h"
+#include "base/trace_event/memory_dump_manager.h"
 #include "base/trace_event/process_memory_dump.h"
 #include "base/trace_event/process_memory_maps.h"
 #include "base/trace_event/process_memory_totals.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if defined(OS_MACOSX)
 #include <libgen.h>
 #include <mach-o/dyld.h>
 #endif
@@ skipping 102 matching lines @@
   file->reset(temp_file);
   ASSERT_TRUE(temp_file);
 
   ASSERT_TRUE(
       base::WriteFileDescriptor(fileno(temp_file), contents, strlen(contents)));
 }
 
 }  // namespace
 #endif  // defined(OS_LINUX) || defined(OS_ANDROID)
 
+class MockMemoryDumpProvider : public ProcessMetricsMemoryDumpProvider {
+ public:
+  MockMemoryDumpProvider(base::ProcessId process);
+  ~MockMemoryDumpProvider() override;
+};
+
+std::unordered_set<MockMemoryDumpProvider*> g_live_mocks;
+std::unordered_set<MockMemoryDumpProvider*> g_dead_mocks;
+
+MockMemoryDumpProvider::MockMemoryDumpProvider(base::ProcessId process)
+    : ProcessMetricsMemoryDumpProvider(process) {
+  g_live_mocks.insert(this);
+}
+
+MockMemoryDumpProvider::~MockMemoryDumpProvider() {
+  g_live_mocks.erase(this);
+  g_dead_mocks.insert(this);
+}
+
 TEST(ProcessMetricsMemoryDumpProviderTest, DumpRSS) {
   const base::trace_event::MemoryDumpArgs high_detail_args = {
       base::trace_event::MemoryDumpLevelOfDetail::DETAILED};
   std::unique_ptr<ProcessMetricsMemoryDumpProvider> pmtdp(
       new ProcessMetricsMemoryDumpProvider(base::kNullProcessId));
   std::unique_ptr<base::trace_event::ProcessMemoryDump> pmd_before(
       new base::trace_event::ProcessMemoryDump(nullptr, high_detail_args));
   std::unique_ptr<base::trace_event::ProcessMemoryDump> pmd_after(
       new base::trace_event::ProcessMemoryDump(nullptr, high_detail_args));
 
@@ skipping 91 matching lines @@
   EXPECT_EQ(0x7fe7ce7a8000UL - 0x7fe7ce79c000UL, regions_2[0].size_in_bytes);
   EXPECT_EQ(0U, regions_2[0].protection_flags);
   EXPECT_EQ("", regions_2[0].mapped_file);
   EXPECT_EQ(32 * 1024UL, regions_2[0].byte_stats_proportional_resident);
   EXPECT_EQ(16 * 1024UL, regions_2[0].byte_stats_shared_clean_resident);
   EXPECT_EQ(12 * 1024UL, regions_2[0].byte_stats_shared_dirty_resident);
   EXPECT_EQ(8 * 1024UL, regions_2[0].byte_stats_private_clean_resident);
   EXPECT_EQ(4 * 1024UL, regions_2[0].byte_stats_private_dirty_resident);
   EXPECT_EQ(0 * 1024UL, regions_2[0].byte_stats_swapped);
 }
+
+TEST(ProcessMetricsMemoryDumpProviderTest, DoubleRegister) {
+  auto factory = [](base::ProcessId process) {
+    return std::unique_ptr<ProcessMetricsMemoryDumpProvider>(
+        new MockMemoryDumpProvider(process));
+  };
+  ProcessMetricsMemoryDumpProvider::factory_for_testing = factory;
+  ProcessMetricsMemoryDumpProvider::RegisterForProcess(1);
+  ProcessMetricsMemoryDumpProvider::RegisterForProcess(1);
+  ASSERT_EQ(1u, g_live_mocks.size());
+  ASSERT_EQ(1u, g_dead_mocks.size());
+  auto* manager = base::trace_event::MemoryDumpManager::GetInstance();
+  MockMemoryDumpProvider* live_mock = *g_live_mocks.begin();
+  EXPECT_TRUE(manager->IsDumpProviderRegisteredForTesting(live_mock));
+  auto* dead_mock = *g_dead_mocks.begin();
+  EXPECT_FALSE(manager->IsDumpProviderRegisteredForTesting(dead_mock));
+  ProcessMetricsMemoryDumpProvider::UnregisterForProcess(1);
+  g_live_mocks.clear();
+  g_dead_mocks.clear();
+}
+
 #endif  // defined(OS_LINUX) || defined(OS_ANDROID)
 
 TEST(ProcessMetricsMemoryDumpProviderTest, TestPollFastMemoryTotal) {
   ProcessMetricsMemoryDumpProvider mdp(base::kNullProcessId);
 
   uint64_t total1, total2;
   mdp.PollFastMemoryTotal(&total1);
   ASSERT_GT(total1, 0u);
   size_t kBufSize = 16 * 1024 * 1024;
   auto buf = base::MakeUnique<char[]>(kBufSize);
@@ skipping 128 matching lines @@
               return a.start_address < b.start_address;
             });
   uint64_t last_address = 0;
   for (const VMRegion& region : regions) {
     EXPECT_GE(region.start_address, last_address);
     last_address = region.start_address + region.size_in_bytes;
   }
 }
 
 #endif  // defined(OS_MACOSX)
-
 }  // namespace tracing