[scheduler] Change ThreadLoadTracker to use only recent data.

third_party/WebKit/Source/platform/scheduler/base/thread_load_tracker_unittest.cc

Index: third_party/WebKit/Source/platform/scheduler/base/thread_load_tracker_unittest.cc
diff --git a/third_party/WebKit/Source/platform/scheduler/base/thread_load_tracker_unittest.cc b/third_party/WebKit/Source/platform/scheduler/base/thread_load_tracker_unittest.cc
index 2315805c765e4f85823f8f9cb7038a9610bd0014..23072d439fab90516e9476860f7d681a13cddd25 100644
--- a/third_party/WebKit/Source/platform/scheduler/base/thread_load_tracker_unittest.cc
+++ b/third_party/WebKit/Source/platform/scheduler/base/thread_load_tracker_unittest.cc
@@ -4,6 +4,8 @@
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+using testing::ElementsAre;
+
 namespace blink {
 namespace scheduler {
 
@@ -19,8 +21,8 @@ base::TimeTicks SecondsToTime(int seconds) {
   return base::TimeTicks() + base::TimeDelta::FromSeconds(seconds);
 }
 
-double Divide(int a, int b) {
-  return static_cast<double>(a) / b;
+base::TimeTicks MillisecondsToTime(int milliseconds) {
+  return base::TimeTicks() + base::TimeDelta::FromMilliseconds(milliseconds);
 }
 
 }  // namespace
@@ -29,44 +31,64 @@ TEST(ThreadLoadTrackerTest, RecordTasks) {
   std::vector<std::pair<base::TimeTicks, double>> result;
 
   ThreadLoadTracker thread_load_tracker(
-      SecondsToTime(1), base::Bind(&AddToVector, base::Unretained(&result)));
+      SecondsToTime(1), base::Bind(&AddToVector, base::Unretained(&result)),
+      base::TimeDelta::FromSeconds(1), base::TimeDelta::FromSeconds(10));
 
-  thread_load_tracker.RecordTaskTime(SecondsToTime(3), SecondsToTime(5));
-  thread_load_tracker.RecordTaskTime(SecondsToTime(7), SecondsToTime(9));
-  thread_load_tracker.RecordTaskTime(SecondsToTime(10), SecondsToTime(13));
-  thread_load_tracker.RecordTaskTime(SecondsToTime(15), SecondsToTime(18));
+  // We should discard first ten seconds of information.
+  thread_load_tracker.RecordTaskTime(SecondsToTime(1), SecondsToTime(3));
 
-  // Because of 10-second delay we're getting information starting with 11s.
-  std::vector<std::pair<base::TimeTicks, double>> expected_result{
-      {SecondsToTime(11), Divide(5, 10)}, {SecondsToTime(12), Divide(6, 11)},
-      {SecondsToTime(13), Divide(7, 12)}, {SecondsToTime(14), Divide(7, 13)},
-      {SecondsToTime(15), Divide(7, 14)}, {SecondsToTime(16), Divide(8, 15)},
-      {SecondsToTime(17), Divide(9, 16)}, {SecondsToTime(18), Divide(10, 17)}};
+  thread_load_tracker.RecordTaskTime(MillisecondsToTime(11300),
+                                     MillisecondsToTime(11400));
+
+  thread_load_tracker.RecordTaskTime(MillisecondsToTime(12900),
+                                     MillisecondsToTime(13100));
+
+  thread_load_tracker.RecordTaskTime(MillisecondsToTime(13700),
+                                     MillisecondsToTime(13800));
+
+  thread_load_tracker.RecordTaskTime(MillisecondsToTime(14500),
+                                     MillisecondsToTime(16500));
 
-  EXPECT_EQ(result, expected_result);
+  thread_load_tracker.RecordIdle(MillisecondsToTime(17500));
+
+  // Because of 10-second delay we're getting information starting with 11s.
+  EXPECT_THAT(result, ElementsAre(std::make_pair(SecondsToTime(11), 0),
+                                  std::make_pair(SecondsToTime(12), 0.1),
+                                  std::make_pair(SecondsToTime(13), 0.1),
+                                  std::make_pair(SecondsToTime(14), 0.2),
+                                  std::make_pair(SecondsToTime(15), 0.5),
+                                  std::make_pair(SecondsToTime(16), 1.0),
+                                  std::make_pair(SecondsToTime(17), 0.5)));
 }
 
 TEST(ThreadLoadTrackerTest, PauseAndResume) {
   std::vector<std::pair<base::TimeTicks, double>> result;
 
   ThreadLoadTracker thread_load_tracker(
-      SecondsToTime(1), base::Bind(&AddToVector, base::Unretained(&result)));
+      SecondsToTime(1), base::Bind(&AddToVector, base::Unretained(&result)),
+      base::TimeDelta::FromSeconds(1), base::TimeDelta::FromSeconds(10));
 
   thread_load_tracker.RecordTaskTime(SecondsToTime(3), SecondsToTime(4));
   thread_load_tracker.Pause(SecondsToTime(5));
   // This task should be ignored.
   thread_load_tracker.RecordTaskTime(SecondsToTime(10), SecondsToTime(11));
   thread_load_tracker.Resume(SecondsToTime(15));
-  // We're counting only last second.
-  thread_load_tracker.RecordTaskTime(SecondsToTime(14), SecondsToTime(16));
-  thread_load_tracker.RecordTaskTime(SecondsToTime(22), SecondsToTime(23));
+  thread_load_tracker.RecordTaskTime(MillisecondsToTime(20900),
+                                     MillisecondsToTime(21100));
+
+  thread_load_tracker.RecordIdle(MillisecondsToTime(23500));
+
+  thread_load_tracker.Pause(MillisecondsToTime(23500));
+  thread_load_tracker.Resume(SecondsToTime(26));
 
-  std::vector<std::pair<base::TimeTicks, double>> expected_result{
-      {SecondsToTime(21), Divide(2, 10)},
-      {SecondsToTime(22), Divide(2, 11)},
-      {SecondsToTime(23), Divide(3, 12)}};
+  thread_load_tracker.RecordTaskTime(MillisecondsToTime(26100),
+                                     MillisecondsToTime(26200));
+  thread_load_tracker.RecordIdle(MillisecondsToTime(27500));
 
-  EXPECT_EQ(result, expected_result);
+  EXPECT_THAT(result, ElementsAre(std::make_pair(SecondsToTime(21), 0.1),
+                                  std::make_pair(SecondsToTime(22), 0.1),
+                                  std::make_pair(SecondsToTime(23), 0),
+                                  std::make_pair(SecondsToTime(27), 0.1)));
 }
 
 }  // namespace scheduler