Reland of Linux: Disable DBus auto-launch

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 28 matching lines @@
 // This is the interface exposed to the rest of the codebase to deal with
 // memory tracing. The main entry point for clients is represented by
 // RequestDumpPoint(). The extension by Un(RegisterDumpProvider).
 class BASE_EXPORT MemoryDumpManager {
  public:
   using RequestGlobalDumpFunction =
       RepeatingCallback<void(const MemoryDumpRequestArgs& args,
                              const GlobalMemoryDumpCallback& callback)>;
 
   static const char* const kTraceCategory;
-  static const char* const kLogPrefix;
 
   // This value is returned as the tracing id of the child processes by
   // GetTracingProcessId() when tracing is not enabled.
   static const uint64_t kInvalidTracingProcessId;
 
   static MemoryDumpManager* GetInstance();
   static std::unique_ptr<MemoryDumpManager> CreateInstanceForTesting();
 
   // Invoked once per process to listen to trace begin / end events.
   // Initialization can happen after (Un)RegisterMemoryDumpProvider() calls
@@ skipping 46 matching lines @@
       std::unique_ptr<MemoryDumpProvider> mdp);
 
   // Requests a memory dump. The dump might happen or not depending on the
   // filters and categories specified when enabling tracing.
   // A SUMMARY_ONLY dump can be requested at any time after initialization and
   // other type of dumps can be requested only when MDM is enabled.
   // The optional |callback| is executed asynchronously, on an arbitrary thread,
   // to notify about the completion of the global dump (i.e. after all the
   // processes have dumped) and its success (true iff all the dumps were
   // successful).
-  void RequestGlobalDump(MemoryDumpType dump_type,
-                         MemoryDumpLevelOfDetail level_of_detail,
-                         const GlobalMemoryDumpCallback& callback);
+  void RequestGlobalDump(MemoryDumpType,
+                         MemoryDumpLevelOfDetail,
+                         const GlobalMemoryDumpCallback&);
 
   // Same as above (still asynchronous), but without callback.
-  void RequestGlobalDump(MemoryDumpType dump_type,
-                         MemoryDumpLevelOfDetail level_of_detail);
+  void RequestGlobalDump(MemoryDumpType, MemoryDumpLevelOfDetail);
 
   // Prepare MemoryDumpManager for RequestGlobalMemoryDump calls for tracing
   // related modes (non-SUMMARY_ONLY).
   // Initializes the peak detector, scheduler and heap profiler with the given
   // config.
   void SetupForTracing(const TraceConfig::MemoryDumpConfig&);
 
   // Tear-down tracing related state.
   // Non-tracing modes (e.g. SUMMARY_ONLY) will continue to work.
   void TeardownForTracing();
@@ skipping 140 matching lines @@
 
   // Helper for the public UnregisterDumpProvider* functions.
   void UnregisterDumpProviderInternal(MemoryDumpProvider* mdp,
                                       bool take_mdp_ownership_and_delete_async);
 
   // Fills the passed vector with the subset of dump providers which were
   // registered with is_fast_polling_supported == true.
   void GetDumpProvidersForPolling(
       std::vector<scoped_refptr<MemoryDumpProviderInfo>>*);
 
+  // Returns true if Initialize() has been called, false otherwise.
+  bool is_initialized() const { return !request_dump_function_.is_null(); }
+
   // An ordererd set of registered MemoryDumpProviderInfo(s), sorted by task
   // runner affinity (MDPs belonging to the same task runners are adjacent).
   MemoryDumpProviderInfo::OrderedSet dump_providers_;
 
   // Shared among all the PMDs to keep state scoped to the tracing session.
   scoped_refptr<HeapProfilerSerializationState>
       heap_profiler_serialization_state_;
 
   std::unique_ptr<MemoryTracingObserver> tracing_observer_;
 
@@ skipping 21 matching lines @@
   // Whether new memory dump providers should be told to enable heap profiling.
   bool heap_profiling_enabled_;
 
   DISALLOW_COPY_AND_ASSIGN(MemoryDumpManager);
 };
 
 }  // namespace trace_event
 }  // namespace base
 
 #endif  // BASE_TRACE_EVENT_MEMORY_DUMP_MANAGER_H_