memory-infra: Finish moving memory_infra from TracingController

base/trace_event/memory_dump_manager.h

 // Copyright 2015 The Chromium Authors. All rights reserved.

[Primiano Tucci (use gerrit), 2017/02/17 19:08:44]

note this cl will very likely need to be rebased on top of ssid's
https://codereview.chromium.org/2582453002/

[chiniforooshan, 2017/02/22 05:16:34]

Acknowledged.

 // 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>
@@ skipping 24 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 TraceLog::EnabledStateObserver {
  public:
   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.
+  // tracing_process_id() when tracing is not enabled.
   static const uint64_t kInvalidTracingProcessId;
 
   static MemoryDumpManager* GetInstance();
 
   // Invoked once per process to listen to trace begin / end events.
   // Initialization can happen after (Un)RegisterMemoryDumpProvider() calls
   // and the MemoryDumpManager guarantees to support this.
   // On the other side, the MemoryDumpManager will not be fully operational
   // (i.e. will NACK any RequestGlobalMemoryDump()) until initialized.
   // Arguments:
-  //  is_coordinator: if true this MemoryDumpManager instance will act as a
-  //      coordinator and schedule periodic dumps (if enabled via TraceConfig);
-  //      false when the MemoryDumpManager is initialized in a slave process.
   //  delegate: inversion-of-control interface for embedder-specific behaviors
   //      (multiprocess handshaking). See the lifetime and thread-safety
   //      requirements in the |MemoryDumpManagerDelegate| docstring.
-  void Initialize(MemoryDumpManagerDelegate* delegate, bool is_coordinator);
+  void Initialize(std::unique_ptr<MemoryDumpManagerDelegate> delegate);

[Primiano Tucci (use gerrit), 2017/02/17 19:08:44]

the MDM is a leaky singleton, passing ownership of an object to a leaky
singleton is IMHO a bit an obscure way to make the original object singleton in
the first place. can you just make the delegate leaky singleton?

[chiniforooshan, 2017/02/22 05:16:34]

Done.

 
   // (Un)Registers a MemoryDumpProvider instance.
   // Args:
   //  - mdp: the MemoryDumpProvider instance to be registered. MemoryDumpManager
   //      does NOT take memory ownership of |mdp|, which is expected to either
   //      be a singleton or unregister itself.
   //  - name: a friendly name (duplicates allowed). Used for debugging and
   //      run-time profiling of memory-infra internals. Must be a long-lived
   //      C string.
   //  - task_runner: either a SingleThreadTaskRunner or SequencedTaskRunner. All
@@ skipping 54 matching lines @@
   // session lifetime.
   const scoped_refptr<MemoryDumpSessionState>& session_state_for_testing()
       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
   // child-process side, without having to know its own child process id.
-  uint64_t GetTracingProcessId() const;
+  uint64_t tracing_process_id() const { return tracing_process_id_; }

[Primiano Tucci (use gerrit), 2017/02/17 19:08:44]

Renaming this getter will require you a lot more owner dances and increase the
likeliness of merge conflicts along the road.
I'd honestly keep this called GetProcessId(), even if becomes an inliner getter,
and eventually renaming in a separate CL.

[chiniforooshan, 2017/02/22 05:16:34]

Done.

+  void set_tracing_process_id(uint64_t tracing_process_id) {
+    tracing_process_id_ = tracing_process_id;
+  }
 
   // Returns the name for a the allocated_objects dump. Use this to declare
   // suballocator dumps from other dump providers.
   // It will return nullptr if there is no dump provider for the system
   // allocator registered (which is currently the case for Mac OS).
   const char* system_allocator_pool_name() const {
     return kSystemAllocatorPoolName;
   };
 
   // When set to true, calling |RegisterMemoryDumpProvider| is a no-op.
@@ skipping 215 matching lines @@
   MemoryDumpProviderInfo::OrderedSet dump_providers_for_polling_;
 
   // Shared among all the PMDs to keep state scoped to the tracing session.
   scoped_refptr<MemoryDumpSessionState> session_state_;
 
   // The list of names of dump providers that are blacklisted from strict thread
   // affinity check on unregistration.
   std::unordered_set<StringPiece, StringPieceHash>
       strict_thread_check_blacklist_;
 
-  MemoryDumpManagerDelegate* delegate_;  // Not owned.
-
-  // When true, this instance is in charge of coordinating periodic dumps.
-  bool is_coordinator_;
+  std::unique_ptr<MemoryDumpManagerDelegate> delegate_;
 
   // 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.
@@ skipping 16 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(MemoryDumpManager);
 };
 
 // The delegate is supposed to be long lived (read: a Singleton) and thread
 // safe (i.e. should expect calls from any thread and handle thread hopping).
 class BASE_EXPORT MemoryDumpManagerDelegate {
  public:
   virtual void RequestGlobalMemoryDump(const MemoryDumpRequestArgs& args,
                                        const MemoryDumpCallback& callback) = 0;
 
-  // Returns tracing process id of the current process. This is used by
-  // MemoryDumpManager::GetTracingProcessId.
-  virtual uint64_t GetTracingProcessId() const = 0;
+  virtual bool IsCoordinator() const = 0;
 
  protected:
+  friend std::default_delete<MemoryDumpManagerDelegate>;
+
   MemoryDumpManagerDelegate() {}
   virtual ~MemoryDumpManagerDelegate() {}
 
   void CreateProcessDump(const MemoryDumpRequestArgs& args,
                          const MemoryDumpCallback& callback) {
     MemoryDumpManager::GetInstance()->CreateProcessDump(args, callback);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MemoryDumpManagerDelegate);
 };
 
 }  // namespace trace_event
 }  // namespace base
 
 #endif  // BASE_TRACE_EVENT_MEMORY_DUMP_MANAGER_H_