memory-infra: Add peak-detector skeleton.

base/trace_event/memory_peak_detector.h

Index: base/trace_event/memory_peak_detector.h
diff --git a/base/trace_event/memory_peak_detector.h b/base/trace_event/memory_peak_detector.h
new file mode 100644
index 0000000000000000000000000000000000000000..b91429583322549619e7f91da7eb45af953696aa
--- /dev/null
+++ b/base/trace_event/memory_peak_detector.h
@@ -0,0 +1,139 @@
+// Copyright 2017 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_PEAK_DETECTOR_H_
+#define BASE_TRACE_EVENT_MEMORY_PEAK_DETECTOR_H_
+
+#include <stdint.h>
+
+#include <memory>
+#include <vector>
+
+#include "base/base_export.h"
+#include "base/callback.h"
+#include "base/macros.h"
+#include "base/memory/ref_counted.h"
+
+namespace base {
+
+class SequencedTaskRunner;
+
+namespace trace_event {
+
+struct MemoryDumpProviderInfo;
+
+// This class is NOT thread-safe, the caller has to ensure linearization of
+// the calls to the public methods. In any case, the public methods do NOT have
+// to be called from the |task_runner| on which the polling tasks run.
+class BASE_EXPORT MemoryPeakDetector {
+ public:
+  using OnPeakDetectedCallback = RepeatingClosure;
+  using DumpProvidersList = std::vector<scoped_refptr<MemoryDumpProviderInfo>>;
+  using GetDumpProvidersFunction = RepeatingCallback<void(DumpProvidersList*)>;
+
+  enum State {
+    NOT_INITIALIZED = 0,  // Before Setup()
+    DISABLED,             // Before Start() or after Stop().
+    ENABLED,              // After Start() but no dump_providers_ are available.
+    RUNNING  // After Start(). The PollMemoryAndDetectPeak() task is scheduled.
+  };
+
+  static MemoryPeakDetector* GetInstance();
+
+  // Configures the peak detector, binding the polling tasks on the given
+  // thread. Setup() can be called several times, provided that: (1) Stop()
+  // is called; (2a) the previous task_runner is flushed or (2b) the task_runner
+  // remains the same.
+  // GetDumpProvidersFunction: is the function that will be invoked to get
+  //   an updated list of polling-capable dump providers. This is really just
+  //   MemoryDumpManager::GetDumpProvidersForPolling, but this extra level of
+  //   indirection allows easier testing.
+  // SequencedTaskRunner: the task runner where PollMemoryAndDetectPeak() will
+  //  be periodically called.
+  // OnPeakDetectedCallback: a callback that will be invoked on the
+  //   given task runner when a memory peak is detected.
+  void Setup(const GetDumpProvidersFunction&,
+             const scoped_refptr<SequencedTaskRunner>&,
+             const OnPeakDetectedCallback&);
+
+  // Releases the |task_runner_| and the bound callbacks.
+  void TearDown();
+
+  // This posts a task onto the passed task runner which refreshes the list of
+  // dump providers via the GetDumpProvidersFunction. If at least one dump
+  // provider is available, this starts immediately polling on the task runner.
+  // If not, the detector remains in the ENABLED state and will start polling
+  // automatically (i.e. without requiring another call to Start()) on the
+  // next call to NotifyMemoryDumpProvidersChanged().
+  void Start();
+
+  // Stops the polling on the task runner (if was active at all). This doesn't
+  // wait for the task runner to drain pending tasks, so it is possible that
+  // a polling will happen concurrently (or in the immediate future) with the
+  // Stop() call. It is responsibility of the caller to drain or synchronize
+  // with the task runner.
+  void Stop();
+
+  // Used by MemoryDumpManager to notify that the list of polling-capable dump
+  // providers has changed. The peak detector will reload the list on the next
+  // polling task. This function can be called before Setup(), in which
+  // case will be just a no-op.
+  void NotifyMemoryDumpProvidersChanged();
+
+ private:
+  friend class MemoryPeakDetectorTest;
+
+  MemoryPeakDetector();
+  ~MemoryPeakDetector();
+
+  // All these methods are always called on the |task_runner_|.
+  void StartInternal();
+  void StopInternal();
+  void TearDownInternal();
+  void ReloadDumpProvidersAndStartPollingIfNeeded();
+  void PollMemoryAndDetectPeak(uint32_t expected_generation);
+
+  // It is safe to call these testing methods only on the |task_runner_|.
+  State state_for_testing() const { return state_; }
+  uint32_t poll_tasks_count_for_testing() const {
+    return poll_tasks_count_for_testing_;
+  }
+
+  // The task runner where all the internal calls are posted onto. This field
+  // must be NOT be accessed by the tasks posted on the |task_runner_| because
+  // there might still be outstanding tasks on the |task_runner_| while this
+  // refptr is reset. This can only be safely accessed by the public methods
+  // above, which the client of this class is supposed to call sequentially.
+  scoped_refptr<SequencedTaskRunner> task_runner_;
+
+  // After the Setup() call, the fields below, must be accessed only from
+  // the |task_runner_|.
+
+  // Bound function to get an updated list of polling-capable dump providers.
+  GetDumpProvidersFunction get_dump_providers_function_;
+
+  // The callback to invoke when peaks are detected.
+  OnPeakDetectedCallback on_peak_detected_callback_;
+
+  // List of polling-aware dump providers to invoke upon each poll.
+  DumpProvidersList dump_providers_;
+
+  // The generation is incremented every time the |state_| is changed and causes
+  // PollMemoryAndDetectPeak() to early out if the posted task doesn't match the
+  // most recent |generation_|. This allows to drop on the floor outstanding
+  // PostDelayedTask that refer to an old sequence that was later Stop()-ed or
+  // disabled because of NotifyMemoryDumpProvidersChanged().
+  uint32_t generation_;
+
+  State state_;
+  uint32_t polling_interval_ms_;
+  uint32_t poll_tasks_count_for_testing_;
+
+  DISALLOW_COPY_AND_ASSIGN(MemoryPeakDetector);
+};
+
+}  // namespace trace_event
+}  // namespace base
+
+#endif  // BASE_TRACE_EVENT_MEMORY_PEAK_DETECTOR_H_