Make FilteredMemoryPressureCalculator injected dependencies externally owned.

This makes final integration with the MemoryPressureMonitor easier, as it will own a single TickClock which can be injected down the entire stack of dependencies.

BUG=520962

Review URL: https://codereview.chromium.org/1317353006

Cr-Commit-Position: refs/heads/master@{#347850}

components/memory_pressure/filtered_memory_pressure_calculator.cc

@@ -4,7 +4,7 @@
 
 #include "components/memory_pressure/filtered_memory_pressure_calculator.h"
 
-#include "base/time/default_tick_clock.h"
+#include "base/time/tick_clock.h"
 
 namespace memory_pressure {
 
@@ -24,13 +24,17 @@ const int FilteredMemoryPressureCalculator::kModeratePressureCooldownPeriodMs =
     5000;
 
 FilteredMemoryPressureCalculator::FilteredMemoryPressureCalculator(
-    scoped_ptr<MemoryPressureCalculator> pressure_calculator)
-    : tick_clock_(new base::DefaultTickClock()),
-      pressure_calculator_(pressure_calculator.Pass()),
+    MemoryPressureCalculator* pressure_calculator,
+    base::TickClock* tick_clock)
+    : pressure_calculator_(pressure_calculator),
+      tick_clock_(tick_clock),
       current_pressure_level_(
           MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE),
       samples_taken_(false),
-      cooldown_in_progress_(false) {}
+      cooldown_in_progress_(false) {
+  DCHECK(pressure_calculator);
+  DCHECK(tick_clock);
+}
 
 FilteredMemoryPressureCalculator::~FilteredMemoryPressureCalculator() {
 }

components/memory_pressure/filtered_memory_pressure_calculator.h

@@ -5,9 +5,14 @@
 #ifndef COMPONENTS_MEMORY_PRESSURE_FILTERED_MEMORY_PRESSURE_CALCULATOR_H_
 #define COMPONENTS_MEMORY_PRESSURE_FILTERED_MEMORY_PRESSURE_CALCULATOR_H_
 
-#include "base/time/tick_clock.h"
 #include "components/memory_pressure/memory_pressure_calculator.h"
 
+#include "base/time/time.h"
+
+namespace base {
+class TickClock;
+}  // namespace base
+
 namespace memory_pressure {
 
 #if defined(MEMORY_PRESSURE_IS_POLLING)
@@ -26,18 +31,16 @@ class FilteredMemoryPressureCalculator : public MemoryPressureCalculator {
   static const int kCriticalPressureCooldownPeriodMs;
   static const int kModeratePressureCooldownPeriodMs;
 
-  explicit FilteredMemoryPressureCalculator(
-      scoped_ptr<MemoryPressureCalculator> pressure_calculator);
+  // The provided |pressure_calculator| and |tick_clock| must outlive this
+  // object.
+  FilteredMemoryPressureCalculator(
+      MemoryPressureCalculator* pressure_calculator,
+      base::TickClock* tick_clock);
   ~FilteredMemoryPressureCalculator() override;
 
   // Calculates the current pressure level.
   MemoryPressureLevel CalculateCurrentPressureLevel() override;
 
-  // Testing seam for configuring the tick clock in use.
-  void set_tick_clock(scoped_ptr<base::TickClock> tick_clock) {
-    tick_clock_ = tick_clock.Pass();
-  }
-
   // Accessors for unittesting.
   bool cooldown_in_progress() const { return cooldown_in_progress_; }
   base::TimeTicks cooldown_start_time() const { return cooldown_start_time_; }
@@ -46,11 +49,11 @@ class FilteredMemoryPressureCalculator : public MemoryPressureCalculator {
  private:
   friend class TestFilteredMemoryPressureCalculator;
 
-  // The delegate tick clock. This is settable as a testing seam.
-  scoped_ptr<base::TickClock> tick_clock_;
-
   // The delegate pressure calculator. Provided by the constructor.
-  scoped_ptr<MemoryPressureCalculator> pressure_calculator_;
+  MemoryPressureCalculator* pressure_calculator_;
+
+  // The delegate tick clock. Provided by the constructor.
+  base::TickClock* tick_clock_;
 
   // The memory pressure currently being reported.
   MemoryPressureLevel current_pressure_level_;