[tracing] Introduce "allowed_dump_modes" for memory dump config

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>
@@ skipping 97 matching lines @@
                          const MemoryDumpCallback& callback);
 
   // Same as above (still asynchronous), but without callback.
   void RequestGlobalDump(MemoryDumpType dump_type,
                          MemoryDumpLevelOfDetail level_of_detail);
 
   // TraceLog::EnabledStateObserver implementation.
   void OnTraceLogEnabled() override;
   void OnTraceLogDisabled() override;
 
+  // Returns true if the dump mode is allowed for current tracing session.
+  bool IsDumpModeAllowed(MemoryDumpLevelOfDetail dump_mode) const;
+
   // Returns the MemoryDumpSessionState object, which is shared by all the
   // ProcessMemoryDump and MemoryAllocatorDump instances through all the tracing
   // session lifetime.
   const scoped_refptr<MemoryDumpSessionState>& session_state() const {
     return session_state_;
   }
 
   // Returns a unique id for identifying the processes. The id can be
   // retrieved by child processes only when tracing is enabled. This is
   // intended to express cross-process sharing of memory dumps on the
@@ skipping 137 matching lines @@
     const scoped_refptr<SingleThreadTaskRunner> dump_thread_task_runner;
 
    private:
     DISALLOW_COPY_AND_ASSIGN(ProcessMemoryDumpAsyncState);
   };
 
   // Sets up periodic memory dump timers to start global dump requests based on
   // the dump triggers from trace config.
   class BASE_EXPORT PeriodicGlobalDumpTimer {
    public:
-    PeriodicGlobalDumpTimer();
+    explicit PeriodicGlobalDumpTimer(MemoryDumpManager* mdm);
     ~PeriodicGlobalDumpTimer();
 
     void Start(const std::vector<TraceConfig::MemoryDumpConfig::Trigger>&
                    triggers_list);
     void Stop();
 
     bool IsRunning();
 
    private:
     // Periodically called by the timer.
     void RequestPeriodicGlobalDump();
 
+    MemoryDumpManager* mdm_;
+
     RepeatingTimer timer_;
     uint32_t periodic_dumps_count_;
     uint32_t light_dump_rate_;
     uint32_t heavy_dump_rate_;
 
     DISALLOW_COPY_AND_ASSIGN(PeriodicGlobalDumpTimer);
   };
 
   static const int kMaxConsecutiveFailuresCount;
   static const char* const kSystemAllocatorPoolName;
@@ skipping 98 matching lines @@
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MemoryDumpManagerDelegate);
 };
 
 }  // namespace trace_event
 }  // namespace base
 
 #endif  // BASE_TRACE_EVENT_MEMORY_DUMP_MANAGER_H_