[Tracing] Disable registration of regular dump providers during tests

base/trace_event/memory_dump_manager.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/memory_dump_manager.h"
 
 #include <algorithm>
 
 #include "base/atomic_sequence_num.h"
 #include "base/command_line.h"
@@ skipping 69 matching lines @@
 MemoryDumpManager* MemoryDumpManager::GetInstance() {
   if (g_instance_for_testing)
     return g_instance_for_testing;
 
   return Singleton<MemoryDumpManager,
                    LeakySingletonTraits<MemoryDumpManager>>::get();
 }
 
 // static
 void MemoryDumpManager::SetInstanceForTesting(MemoryDumpManager* instance) {
-  if (instance)
-    instance->skip_core_dumpers_auto_registration_for_testing_ = true;
   g_instance_for_testing = instance;
 }
 
 MemoryDumpManager::MemoryDumpManager()
     : delegate_(nullptr),
       memory_tracing_enabled_(0),
       tracing_process_id_(kInvalidTracingProcessId),
       system_allocator_pool_name_(nullptr),
-      skip_core_dumpers_auto_registration_for_testing_(false),
+      ignore_registrations_for_testing_(false),
       disable_periodic_dumps_for_testing_(false) {
   g_next_guid.GetNext();  // Make sure that first guid is not zero.
 }
 
 MemoryDumpManager::~MemoryDumpManager() {
   base::trace_event::TraceLog::GetInstance()->RemoveEnabledStateObserver(this);
 }
 
 void MemoryDumpManager::Initialize() {
   TRACE_EVENT0(kTraceCategory, "init");  // Add to trace-viewer category list.
   trace_event::TraceLog::GetInstance()->AddEnabledStateObserver(this);
 
-  if (skip_core_dumpers_auto_registration_for_testing_)
-    return;
-
   // Enable the core dump providers.
 #if !defined(OS_NACL)
   RegisterDumpProvider(ProcessMemoryTotalsDumpProvider::GetInstance());
 #endif
 
 #if defined(OS_LINUX) || defined(OS_ANDROID)
   // The memory maps dump provider is currently disabled for security reasons
   // and will be enabled once tracing is more secure (crbug.com/517906).
   // It is still enabled for running benchmarks.
   if (CommandLine::ForCurrentProcess()->HasSwitch(
@@ skipping 17 matching lines @@
 
 void MemoryDumpManager::SetDelegate(MemoryDumpManagerDelegate* delegate) {
   AutoLock lock(lock_);
   DCHECK_EQ(static_cast<MemoryDumpManagerDelegate*>(nullptr), delegate_);
   delegate_ = delegate;
 }
 
 void MemoryDumpManager::RegisterDumpProvider(
     MemoryDumpProvider* mdp,
     const scoped_refptr<SingleThreadTaskRunner>& task_runner) {
+  AutoLock lock(lock_);
+
+  if (ignore_registrations_for_testing_)
+    return;
+
   MemoryDumpProviderInfo mdp_info(mdp, task_runner);
-  AutoLock lock(lock_);
   auto iter_new = dump_providers_.insert(mdp_info);
 
   // If there was a previous entry, replace it with the new one. This is to deal
   // with the case where a dump provider unregisters itself and then re-
   // registers before a memory dump happens, so its entry was still in the
   // collection but flagged |unregistered|.
   if (!iter_new.second) {
     dump_providers_.erase(iter_new.first);
     dump_providers_.insert(mdp_info);
   }
@@ skipping 311 matching lines @@
       next_dump_provider(next_dump_provider),
       callback(callback),
       task_runner(MessageLoop::current()->task_runner()) {
 }
 
 MemoryDumpManager::ProcessMemoryDumpAsyncState::~ProcessMemoryDumpAsyncState() {
 }
 
 }  // namespace trace_event
 }  // namespace base