Create MemoryPressureStatsCollector.

components/memory_pressure/memory_pressure_stats_collector_unittest.cc

Index: components/memory_pressure/memory_pressure_stats_collector_unittest.cc
diff --git a/components/memory_pressure/memory_pressure_stats_collector_unittest.cc b/components/memory_pressure/memory_pressure_stats_collector_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..161798833287578d40df87d8eee86e6af1a1e4c5
--- /dev/null
+++ b/components/memory_pressure/memory_pressure_stats_collector_unittest.cc
@@ -0,0 +1,144 @@
+// 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.
+
+#include "components/memory_pressure/memory_pressure_stats_collector.h"
+
+#include "base/test/histogram_tester.h"
+#include "base/test/simple_test_tick_clock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace memory_pressure {
+
+// This is outside of the anonymous namespace as it is a friend to the class
+// under test.
+class TestMemoryPressureStatsCollector : public MemoryPressureStatsCollector {
+ public:
+  TestMemoryPressureStatsCollector(base::TickClock* tick_clock)
+      : MemoryPressureStatsCollector(tick_clock) {}
+
+  // Accessors.
+  base::TimeDelta unreported_cumulative_time(int i) const {
+    return unreported_cumulative_time_[i];
+  }
+  MemoryPressureLevel last_pressure_level() const {
+    return last_pressure_level_;
+  }
+  base::TimeTicks last_update_time() const { return last_update_time_; }
+};
+
+namespace {
+
+// Histogram names.
+static const char kPressureLevel[] = "Memory.PressureLevel";

[grt (UTC plus 2), 2015/09/08 17:22:46]

nit: no "static" for constants in the unnamed namespace

[chrisha, 2015/09/08 18:48:43]

Done.

+static const char kPressureLevelChange[] = "Memory.PressureLevelChange";
+
+// Test fixture.
+class MemoryPressureStatsCollectorTest : public testing::Test {

[grt (UTC plus 2), 2015/09/08 17:22:47]

i don't see an advantage to having this in an unnamed namespace. it makes it
harder to set breakpoints in the fixture in windbg, and makes it impossible to
friend the fixture as mentioned in the recent thread here:
https://groups.google.com/a/chromium.org/d/msg/chromium-dev/pKY2G4GHcu0/wzmsu....
although it isn't mandated, i have a strong preference for Kent's style
(https://groups.google.com/a/chromium.org/d/msg/chromium-dev/pKY2G4GHcu0/dY_73...)
in which the test fixture and individual tests are not in an unnamed namespace.
so, unless you have a compelling reason to leave it here, please take it out.
thanks.

[chrisha, 2015/09/08 18:48:43]

No compelling reason, just habit. Done.

+ public:
+  MemoryPressureStatsCollectorTest() : collector_(&tick_clock_) {}
+
+  void Tick(int ms) {
+    tick_clock_.Advance(base::TimeDelta::FromMilliseconds(ms));
+  }
+
+  // Validates expectations on the amount of accumulated (and unreported)
+  // time (milliseconds) per pressure level.
+  void ExpectAccumulated(int none_ms, int moderate_ms, int critical_ms) {
+    EXPECT_EQ(base::TimeDelta::FromMilliseconds(none_ms),
+            collector_.unreported_cumulative_time(0));  // None.
+    EXPECT_EQ(base::TimeDelta::FromMilliseconds(moderate_ms),
+              collector_.unreported_cumulative_time(1));  // Moderate.
+    EXPECT_EQ(base::TimeDelta::FromMilliseconds(critical_ms),
+              collector_.unreported_cumulative_time(2));  // Critical.
+  }
+
+  // Validates expectations on the amount of reported time (seconds) per
+  // pressure level.
+  void ExpectReported(int none_s, int moderate_s, int critical_s) {
+    int total_s = none_s + moderate_s + critical_s;
+
+    // If the histogram should be empty then simply confirm that it doesn't
+    // yet exist.
+    if (total_s == 0) {
+      EXPECT_TRUE(histograms_.GetTotalCountsForPrefix(kPressureLevel).empty());
+      return;
+    }
+
+    histograms_.ExpectBucketCount(kPressureLevel, 0, none_s);  // None.
+    histograms_.ExpectBucketCount(kPressureLevel, 1, moderate_s);  // Moderate.
+    histograms_.ExpectBucketCount(kPressureLevel, 2, critical_s);  // Critical.
+    histograms_.ExpectTotalCount(kPressureLevel, total_s);
+  }
+
+  TestMemoryPressureStatsCollector collector_;
+  base::SimpleTestTickClock tick_clock_;

[grt (UTC plus 2), 2015/09/08 17:22:46]

since |tick_clock_| is passed to |collector_|'s ctor, swap the order here so the
tick clock is valid when handed to the collector.

[chrisha, 2015/09/08 18:48:43]

Done.

+  base::HistogramTester histograms_;
+};
+
+}  // namespace
+
+TEST_F(MemoryPressureStatsCollectorTest, EndToEnd) {
+  // Upon construction the last pressure level should be invalid.

[grt (UTC plus 2), 2015/09/08 17:22:46]

this seems to be testing an implementation detail. why is it important for the
last level to be invalid in this case? what's important is that the right thing
is logged the first time the statistics are updated, no?

[chrisha, 2015/09/08 18:48:43]

Good point.

+  EXPECT_NE(MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE,
+            collector_.last_pressure_level());
+  EXPECT_NE(MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE,
+            collector_.last_pressure_level());
+  EXPECT_NE(MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL,
+            collector_.last_pressure_level());
+  ExpectAccumulated(0, 0, 0);
+  ExpectReported(0, 0, 0);
+
+  // A first call should not invoke any reporting functions, but it should
+  // modify member variables.
+  Tick(500);
+  collector_.UpdateStatistics(
+      MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE);
+  EXPECT_EQ(MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE,
+            collector_.last_pressure_level());
+  EXPECT_EQ(tick_clock_.NowTicks(), collector_.last_update_time());
+  ExpectAccumulated(0, 0, 0);
+  ExpectReported(0, 0, 0);
+  histograms_.ExpectTotalCount(kPressureLevelChange, 0);
+
+  // A subsequent call with the same pressure level should increment the
+  // cumulative time but not make a report, as less than one second of time
+  // has been accumulated.
+  Tick(500);
+  collector_.UpdateStatistics(
+      MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE);
+  EXPECT_EQ(MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE,
+            collector_.last_pressure_level());
+  EXPECT_EQ(tick_clock_.NowTicks(), collector_.last_update_time());
+  ExpectAccumulated(500, 0, 0);
+  ExpectReported(0, 0, 0);
+  histograms_.ExpectTotalCount(kPressureLevelChange, 0);
+
+  // Yet another call and this time a report should be made, as one second
+  // of time has been accumulated. 500ms should remain unreported.
+  Tick(1000);
+  collector_.UpdateStatistics(
+      MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE);
+  EXPECT_EQ(MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE,
+            collector_.last_pressure_level());
+  EXPECT_EQ(tick_clock_.NowTicks(), collector_.last_update_time());
+  ExpectAccumulated(500, 0, 0);
+  ExpectReported(1, 0, 0);
+  histograms_.ExpectTotalCount(kPressureLevelChange, 0);
+
+  // A subsequent call with a different pressure level should increment the
+  // cumulative time and make several reports.
+  Tick(2250);
+  collector_.UpdateStatistics(
+      MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE);
+  EXPECT_EQ(MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE,
+            collector_.last_pressure_level());
+  EXPECT_EQ(tick_clock_.NowTicks(), collector_.last_update_time());
+  ExpectAccumulated(500, 250, 0);
+  ExpectReported(1, 2, 0);
+  histograms_.ExpectBucketCount(kPressureLevelChange,
+      UMA_MEMORY_PRESSURE_LEVEL_CHANGE_NONE_TO_MODERATE, 1);
+  histograms_.ExpectTotalCount(kPressureLevelChange, 1);
+}
+
+}  // namespace memory_pressure