Move base to DEPS

base/trace_event/memory_dump_manager.h

Index: base/trace_event/memory_dump_manager.h
diff --git a/base/trace_event/memory_dump_manager.h b/base/trace_event/memory_dump_manager.h
deleted file mode 100644
index f9ece6e14f22a5ab4ebd206ca538166caff84b65..0000000000000000000000000000000000000000
--- a/base/trace_event/memory_dump_manager.h
+++ /dev/null
@@ -1,257 +0,0 @@
-// 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 base {
-
-class SingleThreadTaskRunner;
-
-namespace trace_event {
-
-class MemoryDumpManagerDelegate;
-class MemoryDumpProvider;
-class MemoryDumpSessionState;
-
-// 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 uint64 kInvalidTracingProcessId;
-  static const char* const kTraceCategoryForTesting;
-
-  static MemoryDumpManager* GetInstance();
-
-  // Invoked once per process to register the TraceLog observer.
-  void Initialize();
-
-  // See the lifetime and thread-safety requirements on the delegate below in
-  // the |MemoryDumpManagerDelegate| docstring.
-  void SetDelegate(MemoryDumpManagerDelegate* delegate);
-
-  // MemoryDumpManager does NOT take memory ownership of |mdp|, which is
-  // expected to either be a singleton or unregister itself.
-  // If the optional |task_runner| argument is non-null, all the calls to the
-  // |mdp| will be issues on the given thread. Otherwise, the |mdp| should be
-  // able to handle calls on arbitrary threads.
-  void RegisterDumpProvider(
-      MemoryDumpProvider* mdp,
-      const scoped_refptr<SingleThreadTaskRunner>& task_runner);
-  void RegisterDumpProvider(MemoryDumpProvider* mdp);
-  void UnregisterDumpProvider(MemoryDumpProvider* mdp);
-
-  // Requests a memory dump. The dump might happen or not depending on the
-  // filters and categories specified when enabling tracing.
-  // 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,
-                         const MemoryDumpCallback& callback);
-
-  // Same as above (still asynchronous), but without callback.
-  void RequestGlobalDump(MemoryDumpType dump_type);
-
-  // TraceLog::EnabledStateObserver implementation.
-  void OnTraceLogEnabled() override;
-  void OnTraceLogDisabled() override;
-
-  // 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_;
-  }
-
-  // Derives a tracing process id from a child process id. Child process ids
-  // cannot be used directly in tracing for security reasons (see: discussion in
-  // crrev.com/1173263004). This method is meant to be used when dumping
-  // cross-process shared memory from a process which knows the child process id
-  // of its endpoints. The value returned by this method is guaranteed to be
-  // equal to the value returned by tracing_process_id() in the corresponding
-  // child process.
-  // This will never return kInvalidTracingProcessId.
-  static uint64 ChildProcessIdToTracingProcessId(int child_id);
-
-  // Returns a unique id for the current process. The id can be retrieved only
-  // by child processes and 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 tracing_process_id() const { return tracing_process_id_; }
-
- private:
-  friend struct DefaultDeleter<MemoryDumpManager>;  // For the testing instance.
-  friend struct DefaultSingletonTraits<MemoryDumpManager>;
-  friend class MemoryDumpManagerDelegate;
-  friend class MemoryDumpManagerTest;
-  FRIEND_TEST_ALL_PREFIXES(MemoryDumpManagerTest, DisableFailingDumpers);
-
-  // 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);
-    ~MemoryDumpProviderInfo();
-
-    // Define a total order based on the thread (i.e. |task_runner|) affinity,
-    // so that all MDP belonging to the same thread are adjacent in the set.
-    bool operator<(const MemoryDumpProviderInfo& other) const;
-
-    MemoryDumpProvider* const dump_provider;
-    scoped_refptr<SingleThreadTaskRunner> task_runner;  // Optional.
-
-    // For fail-safe logic (auto-disable failing MDPs). These fields are mutable
-    // as can be safely changed without impacting the order within the set.
-    mutable int consecutive_failures;
-    mutable bool disabled;
-  };
-
-  using MemoryDumpProviderInfoSet = std::set<MemoryDumpProviderInfo>;
-
-  // Holds the state of a process memory dump that needs to be carried over
-  // across threads in order to fulfil an asynchronous CreateProcessDump()
-  // request. At any time exactly one thread owns a ProcessMemoryDumpAsyncState.
-  struct ProcessMemoryDumpAsyncState {
-    ProcessMemoryDumpAsyncState(
-        MemoryDumpRequestArgs req_args,
-        MemoryDumpProviderInfoSet::iterator next_dump_provider,
-        const scoped_refptr<MemoryDumpSessionState>& session_state,
-        MemoryDumpCallback callback);
-    ~ProcessMemoryDumpAsyncState();
-
-    // The ProcessMemoryDump container, where each dump provider will dump its
-    // own MemoryAllocatorDump(s) upon the OnMemoryDump() call.
-    ProcessMemoryDump process_memory_dump;
-
-    // The arguments passed to the initial CreateProcessDump() request.
-    const MemoryDumpRequestArgs req_args;
-
-    // The |dump_providers_| iterator to the next dump provider that should be
-    // invoked (or dump_providers_.end() if at the end of the sequence).
-    MemoryDumpProviderInfoSet::iterator next_dump_provider;
-
-    // Callback passed to the initial call to CreateProcessDump().
-    MemoryDumpCallback callback;
-
-    // The thread on which FinalizeDumpAndAddToTrace() (and hence |callback|)
-    // should be invoked. This is the thread on which the initial
-    // CreateProcessDump() request was called.
-    const scoped_refptr<SingleThreadTaskRunner> task_runner;
-
-   private:
-    DISALLOW_COPY_AND_ASSIGN(ProcessMemoryDumpAsyncState);
-  };
-
-  static const int kMaxConsecutiveFailuresCount;
-
-  MemoryDumpManager();
-  ~MemoryDumpManager() override;
-
-  static void SetInstanceForTesting(MemoryDumpManager* instance);
-  static void FinalizeDumpAndAddToTrace(
-      scoped_ptr<ProcessMemoryDumpAsyncState> pmd_async_state);
-  static void AbortDumpLocked(MemoryDumpCallback callback,
-                              scoped_refptr<SingleThreadTaskRunner> task_runner,
-                              uint64 dump_guid);
-
-  // Internal, used only by MemoryDumpManagerDelegate.
-  // Creates a memory dump for the current process and appends it to the trace.
-  // |callback| will be invoked asynchronously upon completion on the same
-  // thread on which CreateProcessDump() was called.
-  void CreateProcessDump(const MemoryDumpRequestArgs& args,
-                         const MemoryDumpCallback& callback);
-
-  // Continues the ProcessMemoryDump started by CreateProcessDump(), hopping
-  // across threads as needed as specified by MDPs in RegisterDumpProvider().
-  void ContinueAsyncProcessDump(
-      scoped_ptr<ProcessMemoryDumpAsyncState> pmd_async_state);
-
-  // Pass kInvalidTracingProcessId to invalidate the id.
-  void set_tracing_process_id(uint64 id) {
-    DCHECK(tracing_process_id_ == kInvalidTracingProcessId ||
-           id == kInvalidTracingProcessId || tracing_process_id_ == id);
-    tracing_process_id_ = id;
-  }
-
-  // An ordererd set of registered MemoryDumpProviderInfo(s), sorted by thread
-  // affinity (MDPs belonging to the same thread are adjacent).
-  MemoryDumpProviderInfoSet dump_providers_;
-
-  // Flag used to signal that some provider was removed from |dump_providers_|
-  // and therefore the current memory dump (if any) should be aborted.
-  bool did_unregister_dump_provider_;
-
-  // 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_;
-
-  // 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_;
-
-  // Skips the auto-registration of the core dumpers during Initialize().
-  bool skip_core_dumpers_auto_registration_for_testing_;
-
-  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;
-
-  // Determines whether the MemoryDumpManager instance should be the master
-  // (the ones which initiates and coordinates the multiprocess dumps) or not.
-  virtual bool IsCoordinatorProcess() const = 0;
-
- protected:
-  MemoryDumpManagerDelegate() {}
-  virtual ~MemoryDumpManagerDelegate() {}
-
-  void CreateProcessDump(const MemoryDumpRequestArgs& args,
-                         const MemoryDumpCallback& callback) {
-    MemoryDumpManager::GetInstance()->CreateProcessDump(args, callback);
-  }
-
-  void set_tracing_process_id(uint64 id) {
-    MemoryDumpManager::GetInstance()->set_tracing_process_id(id);
-  }
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(MemoryDumpManagerDelegate);
-};
-
-}  // namespace trace_event
-}  // namespace base
-
-#endif  // BASE_TRACE_EVENT_MEMORY_DUMP_MANAGER_H_