[Tracing] Disable registration of regular dump providers during tests

base/trace_event/memory_dump_manager.h

 // 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.
 
 #ifndef BASE_TRACE_EVENT_MEMORY_DUMP_MANAGER_H_
 #define BASE_TRACE_EVENT_MEMORY_DUMP_MANAGER_H_
 
 #include <set>
 
 #include "base/atomicops.h"
 #include "base/containers/hash_tables.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/singleton.h"
 #include "base/synchronization/lock.h"
 #include "base/timer/timer.h"
 #include "base/trace_event/memory_dump_request_args.h"
 #include "base/trace_event/process_memory_dump.h"
 #include "base/trace_event/trace_event.h"
 
+namespace content {
+class MemoryTracingTest;

[Primiano Tucci (use gerrit), 2015/08/24 17:23:34]

Hmm no, base should never know anything about content, we have to find another
way to achieve this.

[Ruud van Asseldonk, 2015/08/25 09:51:17]

I made |ignore_dumper_registrations_for_testing()| public. The for_testing
suffix should prevent people from using this outside of tests anyway.

+}
+
 namespace base {
 
 class SingleThreadTaskRunner;
 
 namespace trace_event {
 
 class MemoryDumpManagerDelegate;
 class MemoryDumpProvider;
 class MemoryDumpSessionState;
 
@@ skipping 70 matching lines @@
   // Tells the initialization phase to skip scheduling periodic memory dumps.
   void DisablePeriodicDumpsForTesting() {
     disable_periodic_dumps_for_testing_ = true;
   }
 
  private:
   friend struct DefaultDeleter<MemoryDumpManager>;  // For the testing instance.
   friend struct DefaultSingletonTraits<MemoryDumpManager>;
   friend class MemoryDumpManagerDelegate;
   friend class MemoryDumpManagerTest;
+  friend class content::MemoryTracingTest;
   FRIEND_TEST_ALL_PREFIXES(MemoryDumpManagerTest, DisableFailingDumpers);
   FRIEND_TEST_ALL_PREFIXES(MemoryDumpManagerTest,
                            UnregisterDumperFromThreadWhileDumping);
 
   // Descriptor struct used to hold information about registered MDPs. It is
   // deliberately copyable, in order to allow it to be used as std::set value.
   struct MemoryDumpProviderInfo {
     MemoryDumpProviderInfo(
         MemoryDumpProvider* dump_provider,
         const scoped_refptr<SingleThreadTaskRunner>& task_runner);
@@ skipping 81 matching lines @@
   // affinity (MDPs belonging to the same thread are adjacent).
   MemoryDumpProviderInfoSet dump_providers_;
 
   // Shared among all the PMDs to keep state scoped to the tracing session.
   scoped_refptr<MemoryDumpSessionState> session_state_;
 
   MemoryDumpManagerDelegate* delegate_;  // Not owned.
 
   // Protects from concurrent accesses to the |dump_providers_*| and |delegate_|
   // to guard against disabling logging while dumping on another thread.
-  Lock lock_;
+  mutable Lock lock_;

[Primiano Tucci (use gerrit), 2015/08/24 17:23:34]

See comment below, you don't need to use the lock at all.

 
   // Optimization to avoid attempting any memory dump (i.e. to not walk an empty
   // dump_providers_enabled_ list) when tracing is not enabled.
   subtle::AtomicWord memory_tracing_enabled_;
 
   // For time-triggered periodic dumps.
   RepeatingTimer<MemoryDumpManager> periodic_dump_timer_;
 
   // The unique id of the child process. This is created only for tracing and is
   // expected to be valid only when tracing is enabled.
   uint64 tracing_process_id_;
 
   // Name of the allocated_objects dump.
   const char* system_allocator_pool_name_;
 
-  // Skips the auto-registration of the core dumpers during Initialize().
-  bool skip_core_dumpers_auto_registration_for_testing_;
+  // When true, calling RegisterMemoryDumpProvider is a no-op.
+  bool ignore_registrations_for_testing_;

[Primiano Tucci (use gerrit), 2015/08/24 17:23:34]

I'd name this (and the setter) ignore_dumper_registrations_for_testing_

[Ruud van Asseldonk, 2015/08/25 09:51:17]

Done.

+
+  bool ignore_registrations_for_testing() const {
+    AutoLock lock(lock_);

[Primiano Tucci (use gerrit), 2015/08/24 17:23:34]

If this was production code would have been fine.
But for testing code we can just safely assume that the setter is called early
enough and does not race.
Also, I think you just want a setter here. Are you ever going to use the getter?

[Ruud van Asseldonk, 2015/08/25 09:51:17]

It is used in |MemoryDumpManagerTest::EnableTracing| to enable tracing without
registering any extra dump provider, and without changing the state of whether
registrations are ignored (because the tests do register providers, and it would
be tedious to wrap every registration into a set ignore/unset ignore pair).

I think you are right about the lock, setting is only done from one thread so
even if a test starts up new threads this is not a problem.

+    return ignore_registrations_for_testing_;
+  }
+
+  void set_ignore_registrations_for_testing(bool ignore) {
+    AutoLock lock(lock_);
+    ignore_registrations_for_testing_ = ignore;
+  }
 
   // When true, the initialization phase does not start the periodic memory
   // dumps.
   // TODO(primiano): This should go into TraceConfig. https://goo.gl/5Hj3o0.
   bool disable_periodic_dumps_for_testing_;
 
   DISALLOW_COPY_AND_ASSIGN(MemoryDumpManager);
 };
 
 // The delegate is supposed to be long lived (read: a Singleton) and thread
@@ skipping 21 matching lines @@
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MemoryDumpManagerDelegate);
 };
 
 }  // namespace trace_event
 }  // namespace base
 
 #endif  // BASE_TRACE_EVENT_MEMORY_DUMP_MANAGER_H_