Record the fraction of the time without user input - Aura only

ui/events/fraction_of_time_without_user_input_recorder_unittest.cc

Index: ui/events/fraction_of_time_without_user_input_recorder_unittest.cc
diff --git a/ui/events/fraction_of_time_without_user_input_recorder_unittest.cc b/ui/events/fraction_of_time_without_user_input_recorder_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..65cbd090988d9ce0d2f0ab89d25b831b3cb8e816
--- /dev/null
+++ b/ui/events/fraction_of_time_without_user_input_recorder_unittest.cc
@@ -0,0 +1,169 @@
+// 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.
+
+#include "ui/events/fraction_of_time_without_user_input_recorder.h"
+
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/events/base_event_utils.h"
+
+namespace ui {
+
+namespace {
+
+using testing::ElementsAre;
+using testing::Pair;
+
+class TestFractionOfTimeWithoutUserInputRecorder
+    : public FractionOfTimeWithoutUserInputRecorder {
+ public:
+  void RecordActiveInterval(base::TimeTicks start_time,
+                            base::TimeTicks end_time) override {
+    active_intervals_.push_back(std::make_pair(start_time, end_time));
+    FractionOfTimeWithoutUserInputRecorder::RecordActiveInterval(start_time,
+                                                                 end_time);
+  }
+
+  void RecordToUma(float idle_fraction) override {

[sadrul, 2017/03/19 00:38:51]

Instead of making this virtual (and override from here), can you use
HistogramTester (and HistogramTester::GetAllSamples()) instead?

[tdresser, 2017/03/24 14:56:31]

Done.

+    idle_fractions_.push_back(idle_fraction);
+    FractionOfTimeWithoutUserInputRecorder::RecordToUma(idle_fraction);
+  }
+
+  void SetWindowSize(base::TimeDelta window_size) {

[sadrul, 2017/03/19 00:38:52]

set_window_size

[tdresser, 2017/03/24 14:56:31]

Done.

+    window_size_ = window_size;
+  }
+
+  void SetIdleTimeout(base::TimeDelta idle_timeout) {

[sadrul, 2017/03/19 00:38:52]

set_idle_timeout

[tdresser, 2017/03/24 14:56:31]

Done.

+    idle_timeout_ = idle_timeout;
+  }
+
+  std::vector<std::pair<base::TimeTicks, base::TimeTicks>> active_intervals() {

[sadrul, 2017/03/19 00:38:52]

const&

[tdresser, 2017/03/24 14:56:31]

Done.

+    return active_intervals_;
+  }
+
+  std::vector<float> idle_fractions() { return idle_fractions_; }

[sadrul, 2017/03/19 00:38:52]

ditto

[tdresser, 2017/03/24 14:56:31]

Removed.

+
+ private:
+  std::vector<std::pair<base::TimeTicks, base::TimeTicks>> active_intervals_;
+  std::vector<float> idle_fractions_;
+};
+
+TEST(FractionOfTimeWithoutUserInputRecorderTest, IntervalIncludesIdleTimeout) {
+  TestFractionOfTimeWithoutUserInputRecorder idle_fraction_recorder;
+  idle_fraction_recorder.SetIdleTimeout(base::TimeDelta::FromSecondsD(0.1));
+
+  idle_fraction_recorder.RecordEventAtTime(EventTimeStampFromSeconds(0.5));
+
+  // Flush the previous event.
+  idle_fraction_recorder.RecordEventAtTime(EventTimeStampFromSeconds(100));
+
+  // We observed a single event, so the we consider it to have lasted a duration
+  // of one idle timeout.
+  EXPECT_THAT(idle_fraction_recorder.active_intervals(),
+              ElementsAre(Pair(EventTimeStampFromSeconds(0.5),
+                               EventTimeStampFromSeconds(0.6))));
+}
+
+TEST(FractionOfTimeWithoutUserInputRecorderTest, TwoLongIntervals) {
+  TestFractionOfTimeWithoutUserInputRecorder idle_fraction_recorder;
+  idle_fraction_recorder.SetIdleTimeout(base::TimeDelta::FromSecondsD(0.1));
+
+  // Send events regularly between 0.1 seconds and 0.1 + 20 * 0.05 = 1.10
+  // seconds.
+  base::TimeTicks time = base::TimeTicks() + base::TimeDelta::FromSecondsD(0.1);
+  idle_fraction_recorder.RecordEventAtTime(time);
+
+  for (int i = 0; i < 20; ++i) {
+    time += base::TimeDelta::FromSecondsD(0.05);
+    idle_fraction_recorder.RecordEventAtTime(time);
+  }
+
+  // Send events regularly between 2.2 seconds and 2.2 + 20 * 0.05 = 3.20
+  // seconds.
+  time = base::TimeTicks() + base::TimeDelta::FromSecondsD(2.2);
+  idle_fraction_recorder.RecordEventAtTime(time);
+
+  for (int i = 0; i < 20; ++i) {
+    time += base::TimeDelta::FromSecondsD(0.05);
+    idle_fraction_recorder.RecordEventAtTime(time);
+  }
+
+  // Flush the previous event.
+  idle_fraction_recorder.RecordEventAtTime(EventTimeStampFromSeconds(100));
+
+  // Interval end times include idle timeout.
+  EXPECT_THAT(idle_fraction_recorder.active_intervals(),
+              ElementsAre(Pair(EventTimeStampFromSeconds(0.1),
+                               EventTimeStampFromSeconds(1.2)),
+                          Pair(EventTimeStampFromSeconds(2.2),
+                               EventTimeStampFromSeconds(3.3))));
+}
+
+TEST(FractionOfTimeWithoutUserInputRecorderTest, SingleShortRange) {
+  TestFractionOfTimeWithoutUserInputRecorder idle_fraction_recorder;
+  idle_fraction_recorder.SetWindowSize(base::TimeDelta::FromSecondsD(1));
+
+  // Start window at 1 second.
+  idle_fraction_recorder.RecordActiveInterval(EventTimeStampFromSeconds(1),
+                                              EventTimeStampFromSeconds(1));
+
+  idle_fraction_recorder.RecordActiveInterval(EventTimeStampFromSeconds(1.1),
+                                              EventTimeStampFromSeconds(1.6));
+
+  // Flush the previous interval.
+  idle_fraction_recorder.RecordActiveInterval(EventTimeStampFromSeconds(2),
+                                              EventTimeStampFromSeconds(2));
+
+  EXPECT_THAT(idle_fraction_recorder.idle_fractions(), ElementsAre(0.5));
+}
+
+TEST(FractionOfTimeWithoutUserInputRecorderTest, SingleLongRange) {
+  TestFractionOfTimeWithoutUserInputRecorder idle_fraction_recorder;
+  idle_fraction_recorder.SetWindowSize(base::TimeDelta::FromSecondsD(1));
+
+  // Start window at 1 second.
+  idle_fraction_recorder.RecordActiveInterval(EventTimeStampFromSeconds(1),
+                                              EventTimeStampFromSeconds(1));
+
+  idle_fraction_recorder.RecordActiveInterval(EventTimeStampFromSeconds(1.1),
+                                              EventTimeStampFromSeconds(4.2));
+
+  // Flush the previous interval.
+  idle_fraction_recorder.RecordActiveInterval(EventTimeStampFromSeconds(5),
+                                              EventTimeStampFromSeconds(5));
+
+  // The windows contain: [1.1, 2], [2, 3], [3, 4], [4, 4.2].
+  EXPECT_THAT(idle_fraction_recorder.idle_fractions(),
+              ElementsAre(0.9, 1, 1, 0.2));
+}
+
+TEST(FractionOfTimeWithoutUserInputRecorderTest, TwoLongRanges) {
+  TestFractionOfTimeWithoutUserInputRecorder idle_fraction_recorder;
+  idle_fraction_recorder.SetWindowSize(base::TimeDelta::FromSecondsD(1));
+
+  // Start window at 1 second.
+  idle_fraction_recorder.RecordActiveInterval(EventTimeStampFromSeconds(1),
+                                              EventTimeStampFromSeconds(1));
+
+  idle_fraction_recorder.RecordActiveInterval(EventTimeStampFromSeconds(1.1),
+                                              EventTimeStampFromSeconds(2.2));
+
+  idle_fraction_recorder.RecordActiveInterval(EventTimeStampFromSeconds(2.6),
+                                              EventTimeStampFromSeconds(3.2));
+
+  // Flush the previous interval.
+  idle_fraction_recorder.RecordActiveInterval(EventTimeStampFromSeconds(4),
+                                              EventTimeStampFromSeconds(4));
+
+  // The windows contain:
+  // 1: 1.1 - 2.0
+  // 2: 2.0 - 2.2, 2.6 - 3.0
+  // 3: 3.0 - 3.2
+  EXPECT_THAT(idle_fraction_recorder.idle_fractions(),
+              ElementsAre(0.9, 0.6, 0.2));
+}
+
+}  // namespace
+
+}  // namespace ui