[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 80 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),
       is_coordinator_(false),
       memory_tracing_enabled_(0),
       tracing_process_id_(kInvalidTracingProcessId),
-      skip_core_dumpers_auto_registration_for_testing_(false) {
+      dumper_registrations_ignored_for_testing_(false) {
   g_next_guid.GetNext();  // Make sure that first guid is not zero.
 }
 
 MemoryDumpManager::~MemoryDumpManager() {
   TraceLog::GetInstance()->RemoveEnabledStateObserver(this);
 }
 
 void MemoryDumpManager::Initialize(MemoryDumpManagerDelegate* delegate,
                                    bool is_coordinator) {
   {
     AutoLock lock(lock_);
     DCHECK(delegate);
     DCHECK(!delegate_);
     delegate_ = delegate;
     is_coordinator_ = is_coordinator;
   }
 
   // Enable the core dump providers.
-  if (!skip_core_dumpers_auto_registration_for_testing_) {
 #if !defined(OS_NACL)
     RegisterDumpProvider(ProcessMemoryTotalsDumpProvider::GetInstance());
 #endif
 
 #if defined(OS_LINUX) || defined(OS_ANDROID)
     RegisterDumpProvider(ProcessMemoryMapsDumpProvider::GetInstance());
     RegisterDumpProvider(MallocDumpProvider::GetInstance());
 #endif
 
 #if defined(OS_ANDROID)
     RegisterDumpProvider(JavaHeapDumpProvider::GetInstance());
 #endif
 
 #if defined(OS_WIN)
     RegisterDumpProvider(WinHeapDumpProvider::GetInstance());
 #endif
-  }  // !skip_core_dumpers_auto_registration_for_testing_
 
   // If tracing was enabled before initializing MemoryDumpManager, we missed the
   // OnTraceLogEnabled() event. Synthetize it so we can late-join the party.
   bool is_tracing_already_enabled = TraceLog::GetInstance()->IsEnabled();
   TRACE_EVENT0(kTraceCategory, "init");  // Add to trace-viewer category list.
   TraceLog::GetInstance()->AddEnabledStateObserver(this);
   if (is_tracing_already_enabled)
     OnTraceLogEnabled();
 }
 
 void MemoryDumpManager::RegisterDumpProvider(
     MemoryDumpProvider* mdp,
     const scoped_refptr<SingleThreadTaskRunner>& task_runner) {
+  if (dumper_registrations_ignored_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);
@@ skipping 335 matching lines @@
       next_dump_provider(next_dump_provider),
       callback(callback),
       task_runner(MessageLoop::current()->task_runner()) {
 }
 
 MemoryDumpManager::ProcessMemoryDumpAsyncState::~ProcessMemoryDumpAsyncState() {
 }
 
 }  // namespace trace_event
 }  // namespace base