[tracing] Introduce BACKGROUND mode in MemoryInfra

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 <stdint.h>
 
 #include <map>
 #include <memory>
 #include <set>
 #include <vector>
 
 #include "base/atomicops.h"
 #include "base/containers/hash_tables.h"
 #include "base/macros.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 base {
 
 class SingleThreadTaskRunner;
 class Thread;
 
 namespace trace_event {
@@ skipping 107 matching lines @@
   // When set to true, calling |RegisterMemoryDumpProvider| is a no-op.
   void set_dumper_registrations_ignored_for_testing(bool ignored) {
     dumper_registrations_ignored_for_testing_ = ignored;
   }
 
  private:
   friend std::default_delete<MemoryDumpManager>;  // For the testing instance.
   friend struct DefaultSingletonTraits<MemoryDumpManager>;
   friend class MemoryDumpManagerDelegate;
   friend class MemoryDumpManagerTest;
+  class PeriodicGlobalDumpInvokeHelper;

[Primiano Tucci (use gerrit), 2016/05/26 17:20:53]

I think just PeriodicDumpHelper is enough (which also matches the name of the
variable below)

[ssid, 2016/05/26 22:12:54]

I think after including start and stop it is more like PeriodicGlobalDumpTimer.
Global because it says it is a global timer not per process.

Also declared it here since test needs isRunning function.

 
   // Descriptor used to hold information about registered MDPs.
   // Some important considerations about lifetime of this object:
   // - In nominal conditions, all the MemoryDumpProviderInfo instances live in
   //   the |dump_providers_| collection (% unregistration while dumping).
   // - Upon each dump they (actually their scoped_refptr-s) are copied into
   //   the ProcessMemoryDumpAsyncState. This is to allow removal (see below).
   // - When the MDP.OnMemoryDump() is invoked, the corresponding MDPInfo copy
   //   inside ProcessMemoryDumpAsyncState is removed.
   // - In most cases, the MDPInfo is destroyed within UnregisterDumpProvider().
@@ skipping 34 matching lines @@
 
     // The |options| arg passed to RegisterDumpProvider().
     const MemoryDumpProvider::Options options;
 
     // For fail-safe logic (auto-disable failing MDPs).
     int consecutive_failures;
 
     // Flagged either by the auto-disable logic or during unregistration.
     bool disabled;
 
+    // True if the dump provider is not whitelited for background mode.

[Primiano Tucci (use gerrit), 2016/05/26 17:20:53]

nit: whitelisted

[ssid, 2016/05/26 22:12:54]

Done.

+    const bool disabled_for_background_mode;

[Primiano Tucci (use gerrit), 2016/05/26 17:20:53]

in order to make this less confusing (initially I thought "why we have disabled
and disabled_for_background"?) I think this should really be named:
whitelisted_for_background_mode;

[ssid, 2016/05/26 22:12:54]

Done thanks

+
    private:
     friend class base::RefCountedThreadSafe<MemoryDumpProviderInfo>;
     ~MemoryDumpProviderInfo();
 
     DISALLOW_COPY_AND_ASSIGN(MemoryDumpProviderInfo);
   };
 
   // Holds the state of a process memory dump that needs to be carried over
   // across task runners in order to fulfil an asynchronous CreateProcessDump()
   // request. At any time exactly one task runner owns a
@@ skipping 105 matching lines @@
 
   // Protects from concurrent accesses to the |dump_providers_*| and |delegate_|
   // to guard against disabling logging while dumping on another thread.
   Lock lock_;
 
   // 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 periodic_dump_timer_;
+  std::unique_ptr<PeriodicGlobalDumpInvokeHelper> periodic_dump_helper_;
 
   // Thread used for MemoryDumpProviders which don't specify a task runner
   // affinity.
   std::unique_ptr<Thread> dump_thread_;
 
   // 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_t tracing_process_id_;
 
   // When true, calling |RegisterMemoryDumpProvider| is a no-op.
@@ skipping 26 matching lines @@
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MemoryDumpManagerDelegate);
 };
 
 }  // namespace trace_event
 }  // namespace base
 
 #endif  // BASE_TRACE_EVENT_MEMORY_DUMP_MANAGER_H_