Optimize for TouchStart responsiveness

components/scheduler/renderer/user_model_unittest.cc

Index: components/scheduler/renderer/user_model_unittest.cc
diff --git a/components/scheduler/renderer/user_model_unittest.cc b/components/scheduler/renderer/user_model_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..cf0b9c3be63c9b1295a2313334c8712174e71ba1
--- /dev/null
+++ b/components/scheduler/renderer/user_model_unittest.cc
@@ -0,0 +1,248 @@
+// 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/scheduler/renderer/user_model.h"
+
+#include "base/test/simple_test_tick_clock.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace scheduler {
+
+class UserModelTest : public testing::Test {
+ public:
+  UserModelTest() {}
+  ~UserModelTest() override {}
+
+  void SetUp() override {
+    clock_.reset(new base::SimpleTestTickClock());
+    clock_->Advance(base::TimeDelta::FromMicroseconds(5000));
+
+    user_model_.reset(new UserModel());
+  }
+
+ protected:
+  static base::TimeDelta priority_escalation_after_input_duration() {
+    return base::TimeDelta::FromMilliseconds(
+        UserModel::kPriorityEscalationAfterInputMillis);
+  }
+
+  static base::TimeDelta subsequent_input_expected_after_input_duration() {
+    return base::TimeDelta::FromMilliseconds(
+        UserModel::kExpectSubsequentInputMillis);
+  }
+
+  static base::TimeDelta minimum_typical_scroll_duration_millis() {
+    return base::TimeDelta::FromMilliseconds(
+        UserModel::kMinimumTypicalScrollDurationMillis);
+  }
+
+  scoped_ptr<base::SimpleTestTickClock> clock_;
+  scoped_ptr<UserModel> user_model_;
+};
+
+TEST_F(UserModelTest, TimeLeftInInputEscalatedPolicy_NoInput) {
+  EXPECT_EQ(base::TimeDelta(),
+            user_model_->TimeLeftInInputEscalatedPolicy(clock_->NowTicks()));
+}
+
+TEST_F(UserModelTest, TimeLeftInInputEscalatedPolicy_ImmediatelyAfterInput) {
+  user_model_->DidHandleInputEventOnCompositorThread(
+      blink::WebInputEvent::Type::TouchStart,
+      RendererScheduler::InputEventState::EVENT_CONSUMED_BY_COMPOSITOR,
+      clock_->NowTicks());
+  EXPECT_EQ(priority_escalation_after_input_duration(),
+            user_model_->TimeLeftInInputEscalatedPolicy(clock_->NowTicks()));
+}
+
+TEST_F(UserModelTest, TimeLeftInInputEscalatedPolicy_ShortlyAfterInput) {
+  user_model_->DidHandleInputEventOnCompositorThread(
+      blink::WebInputEvent::Type::TouchStart,
+      RendererScheduler::InputEventState::EVENT_CONSUMED_BY_COMPOSITOR,
+      clock_->NowTicks());
+  base::TimeDelta delta(base::TimeDelta::FromMilliseconds(10));
+  clock_->Advance(delta);
+  EXPECT_EQ(priority_escalation_after_input_duration() - delta,
+            user_model_->TimeLeftInInputEscalatedPolicy(clock_->NowTicks()));
+}
+
+TEST_F(UserModelTest, TimeLeftInInputEscalatedPolicy_LongAfterInput) {
+  user_model_->DidHandleInputEventOnCompositorThread(
+      blink::WebInputEvent::Type::TouchStart,
+      RendererScheduler::InputEventState::EVENT_CONSUMED_BY_COMPOSITOR,
+      clock_->NowTicks());
+  clock_->Advance(priority_escalation_after_input_duration() * 2);
+  EXPECT_EQ(base::TimeDelta(),
+            user_model_->TimeLeftInInputEscalatedPolicy(clock_->NowTicks()));
+}
+
+TEST_F(UserModelTest, TouchStartExpectedSoon_UseCase_NONE_NoRecentInput) {
+  base::TimeDelta prediction_valid_duration;
+  EXPECT_FALSE(user_model_->TouchStartExpectedSoon(
+      RendererScheduler::UseCase::NONE, clock_->NowTicks(),
+      &prediction_valid_duration));
+  EXPECT_EQ(base::TimeDelta(), prediction_valid_duration);
+}
+
+TEST_F(UserModelTest,
+       TouchStartExpectedSoon_UseCase_NONE_ImmediatelyAfterInput) {
+  user_model_->DidHandleInputEventOnCompositorThread(
+      blink::WebInputEvent::Type::TouchEnd,
+      RendererScheduler::InputEventState::EVENT_CONSUMED_BY_COMPOSITOR,
+      clock_->NowTicks());
+
+  base::TimeDelta prediction_valid_duration;
+  EXPECT_TRUE(user_model_->TouchStartExpectedSoon(
+      RendererScheduler::UseCase::NONE, clock_->NowTicks(),
+      &prediction_valid_duration));
+  EXPECT_EQ(subsequent_input_expected_after_input_duration(),
+            prediction_valid_duration);
+}
+
+TEST_F(UserModelTest, TouchStartExpectedSoon_UseCase_NONE_ShortlyAfterInput) {
+  user_model_->DidHandleInputEventOnCompositorThread(
+      blink::WebInputEvent::Type::TouchEnd,
+      RendererScheduler::InputEventState::EVENT_CONSUMED_BY_COMPOSITOR,
+      clock_->NowTicks());
+
+  base::TimeDelta delta(base::TimeDelta::FromMilliseconds(10));
+  clock_->Advance(delta);
+
+  base::TimeDelta prediction_valid_duration;
+  EXPECT_TRUE(user_model_->TouchStartExpectedSoon(
+      RendererScheduler::UseCase::NONE, clock_->NowTicks(),
+      &prediction_valid_duration));
+  EXPECT_EQ(subsequent_input_expected_after_input_duration() - delta,
+            prediction_valid_duration);
+}
+
+TEST_F(UserModelTest, TouchStartExpectedSoon_UseCase_NONE_LongAfterInput) {
+  user_model_->DidHandleInputEventOnCompositorThread(
+      blink::WebInputEvent::Type::TouchEnd,
+      RendererScheduler::InputEventState::EVENT_CONSUMED_BY_COMPOSITOR,
+      clock_->NowTicks());
+  clock_->Advance(subsequent_input_expected_after_input_duration() * 2);
+
+  base::TimeDelta prediction_valid_duration;
+  EXPECT_FALSE(user_model_->TouchStartExpectedSoon(
+      RendererScheduler::UseCase::NONE, clock_->NowTicks(),
+      &prediction_valid_duration));
+  EXPECT_EQ(base::TimeDelta(), prediction_valid_duration);
+}
+
+TEST_F(UserModelTest,
+       TouchStartExpectedSoon_COMPOSITOR_GESTURE_ImmediatelyAfterInput) {
+  user_model_->DidHandleInputEventOnCompositorThread(
+      blink::WebInputEvent::Type::TouchStart,
+      RendererScheduler::InputEventState::EVENT_CONSUMED_BY_COMPOSITOR,
+      clock_->NowTicks());
+
+  base::TimeDelta prediction_valid_duration;
+  EXPECT_FALSE(user_model_->TouchStartExpectedSoon(
+      RendererScheduler::UseCase::COMPOSITOR_GESTURE, clock_->NowTicks(),
+      &prediction_valid_duration));
+  EXPECT_EQ(minimum_typical_scroll_duration_millis(),
+            prediction_valid_duration);
+}
+
+TEST_F(UserModelTest,
+       TouchStartExpectedSoon_COMPOSITOR_GESTURE_ShortlyAfterInput) {
+  user_model_->DidHandleInputEventOnCompositorThread(
+      blink::WebInputEvent::Type::TouchStart,
+      RendererScheduler::InputEventState::EVENT_CONSUMED_BY_COMPOSITOR,
+      clock_->NowTicks());
+
+  base::TimeDelta delta(base::TimeDelta::FromMilliseconds(10));
+  clock_->Advance(delta);
+
+  base::TimeDelta prediction_valid_duration;
+  EXPECT_FALSE(user_model_->TouchStartExpectedSoon(
+      RendererScheduler::UseCase::COMPOSITOR_GESTURE, clock_->NowTicks(),
+      &prediction_valid_duration));
+  EXPECT_EQ(minimum_typical_scroll_duration_millis() - delta,
+            prediction_valid_duration);
+}
+
+TEST_F(UserModelTest,
+       TouchStartExpectedSoon_COMPOSITOR_GESTURE_LongAfterInput) {
+  user_model_->DidHandleInputEventOnCompositorThread(
+      blink::WebInputEvent::Type::TouchStart,
+      RendererScheduler::InputEventState::EVENT_CONSUMED_BY_COMPOSITOR,
+      clock_->NowTicks());
+
+  clock_->Advance(minimum_typical_scroll_duration_millis() * 2);
+
+  base::TimeDelta prediction_valid_duration;
+  // Note this isn't a bug, the UseCase will change to NONE eventually so it's
+  // OK for this to always be true after minimum_typical_scroll_duration_millis
+  EXPECT_TRUE(user_model_->TouchStartExpectedSoon(
+      RendererScheduler::UseCase::COMPOSITOR_GESTURE, clock_->NowTicks(),
+      &prediction_valid_duration));
+  EXPECT_EQ(base::TimeDelta(), prediction_valid_duration);
+}
+
+TEST_F(UserModelTest,
+       TouchStartExpectedSoon_MAIN_THREAD_GESTURE_ImmediatelyAfterInput) {
+  user_model_->DidHandleInputEventOnCompositorThread(
+      blink::WebInputEvent::Type::TouchStart,
+      RendererScheduler::InputEventState::EVENT_CONSUMED_BY_COMPOSITOR,
+      clock_->NowTicks());
+  // DidHandleInputEventOnMainThread is always a little bit delayed.
+  base::TimeDelta delay(base::TimeDelta::FromMilliseconds(5));
+  clock_->Advance(delay);
+  user_model_->DidHandleInputEventOnMainThread(clock_->NowTicks());
+
+  base::TimeDelta prediction_valid_duration;
+  EXPECT_FALSE(user_model_->TouchStartExpectedSoon(
+      RendererScheduler::UseCase::MAIN_THREAD_GESTURE, clock_->NowTicks(),
+      &prediction_valid_duration));
+  EXPECT_EQ(minimum_typical_scroll_duration_millis() - delay,
+            prediction_valid_duration);
+}
+
+TEST_F(UserModelTest,
+       TouchStartExpectedSoon_MAIN_THREAD_GESTURE_ShortlyAfterInput) {
+  user_model_->DidHandleInputEventOnCompositorThread(
+      blink::WebInputEvent::Type::TouchStart,
+      RendererScheduler::InputEventState::EVENT_CONSUMED_BY_COMPOSITOR,
+      clock_->NowTicks());
+  // DidHandleInputEventOnMainThread is always a little bit delayed.
+  base::TimeDelta delay(base::TimeDelta::FromMilliseconds(5));
+  clock_->Advance(delay);
+  user_model_->DidHandleInputEventOnMainThread(clock_->NowTicks());
+
+  base::TimeDelta delta(base::TimeDelta::FromMilliseconds(10));
+  clock_->Advance(delta);
+
+  base::TimeDelta prediction_valid_duration;
+  EXPECT_FALSE(user_model_->TouchStartExpectedSoon(
+      RendererScheduler::UseCase::MAIN_THREAD_GESTURE, clock_->NowTicks(),
+      &prediction_valid_duration));
+  EXPECT_EQ(minimum_typical_scroll_duration_millis() - delta - delay,
+            prediction_valid_duration);
+}
+
+TEST_F(UserModelTest,
+       TouchStartExpectedSoon_MAIN_THREAD_GESTURE_LongAfterInput) {
+  user_model_->DidHandleInputEventOnCompositorThread(
+      blink::WebInputEvent::Type::TouchStart,
+      RendererScheduler::InputEventState::EVENT_CONSUMED_BY_COMPOSITOR,
+      clock_->NowTicks());
+  // DidHandleInputEventOnMainThread is always a little bit delayed.
+  base::TimeDelta delay(base::TimeDelta::FromMilliseconds(5));
+  clock_->Advance(delay);
+  user_model_->DidHandleInputEventOnMainThread(clock_->NowTicks());
+
+  clock_->Advance(minimum_typical_scroll_duration_millis() * 2);
+
+  base::TimeDelta prediction_valid_duration;
+  // Note this isn't a bug, the UseCase will change to NONE eventually so it's
+  // OK for this to always be true after minimum_typical_scroll_duration_millis
+  EXPECT_TRUE(user_model_->TouchStartExpectedSoon(
+      RendererScheduler::UseCase::MAIN_THREAD_GESTURE, clock_->NowTicks(),
+      &prediction_valid_duration));
+  EXPECT_EQ(base::TimeDelta(), prediction_valid_duration);
+}
+
+}  // namespace scheduler