[Android] Add a native pull-to-refresh overscroll effect

content/browser/android/overscroll_refresh_unittest.cc

+// Copyright 2014 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 "cc/layers/layer.h"
+#include "content/browser/android/overscroll_refresh.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/base/android/system_ui_resource_manager.h"
+
+namespace content {
+
+gfx::SizeF DefaultViewportSize() {
+  return gfx::SizeF(512, 512);
+}
+
+class OverscrollRefreshTest : public OverscrollRefreshClient,
+                              public ui::SystemUIResourceManager,
+                              public testing::Test {
+ public:
+  OverscrollRefreshTest() : refresh_triggered_(false) {}
+
+ protected:
+  bool GetAndResetRefreshTriggered() {
+    bool triggered = refresh_triggered_;
+    refresh_triggered_ = false;
+    return triggered;
+  }
+
+  // MockOverscrollRefreshClient implementation.
+  void TriggerRefresh() override { refresh_triggered_ = true; }
+
+  bool IsTriggeredRefreshActive() const override { return true; }

[Ted C, 2014/10/31 23:52:06]

Should this return refresh_triggered_ instead?

[jdduke (slow), 2014/11/06 00:10:37]

Oops, yeah, I had a test for this codepath earlier then decided against it as we
really just want to make sure that the animation terminates after a timeout,
even when the client always reports that the refresh operation is live. Added a
comment for why return true is appropriate here.

+
+  // SystemUIResoruceManager implementation.
+  void PreloadResource(ui::SystemUIResourceType) override {}
+
+  cc::UIResourceId GetUIResourceId(ui::SystemUIResourceType) override {
+    return 0;
+  }
+
+ private:
+  bool refresh_triggered_;
+};
+
+TEST_F(OverscrollRefreshTest, Basic) {
+  OverscrollRefresh effect(this, this);
+
+  gfx::Vector2dF origin_scroll_offset;
+  effect.UpdateDisplay(DefaultViewportSize(), origin_scroll_offset);
+  EXPECT_FALSE(effect.IsActive());
+  EXPECT_FALSE(effect.IsPendingScrollUpdateAck());
+
+  effect.OnScrollBegin();
+  EXPECT_FALSE(effect.IsActive());
+  EXPECT_TRUE(effect.IsPendingScrollUpdateAck());
+
+  // The initial scroll should not be consumed, as it should first be offered
+  // to content.
+  gfx::Vector2dF scroll_up(0, 10);
+  EXPECT_FALSE(effect.WillHandleScrollUpdate(scroll_up));
+  EXPECT_FALSE(effect.IsActive());
+  EXPECT_TRUE(effect.IsPendingScrollUpdateAck());
+
+  // The unconsumed, overscrolling scroll will trigger the effect.
+  bool consumed = false;
+  effect.OnScrollUpdateAck(consumed);
+  EXPECT_TRUE(effect.IsActive());
+  EXPECT_FALSE(effect.IsPendingScrollUpdateAck());
+
+  // Further scrolls will be consumed.
+  EXPECT_TRUE(effect.WillHandleScrollUpdate(gfx::Vector2dF(0, 50)));
+  EXPECT_TRUE(effect.IsActive());
+
+  // Even scrolls in the down direction should be consumed.
+  EXPECT_TRUE(effect.WillHandleScrollUpdate(gfx::Vector2dF(0, -50)));
+  EXPECT_TRUE(effect.IsActive());
+
+  // Feed enough scrolls to the effect to exceeds tht threshold.
+  EXPECT_TRUE(effect.WillHandleScrollUpdate(gfx::Vector2dF(0, 100)));
+  EXPECT_TRUE(effect.WillHandleScrollUpdate(gfx::Vector2dF(0, 100)));
+  EXPECT_TRUE(effect.WillHandleScrollUpdate(gfx::Vector2dF(0, 100)));
+  EXPECT_TRUE(effect.WillHandleScrollUpdate(gfx::Vector2dF(0, 100)));
+  EXPECT_TRUE(effect.WillHandleScrollUpdate(gfx::Vector2dF(0, 100)));
+  EXPECT_TRUE(effect.IsActive());
+
+  // Ending the scroll while beyond the threshold should trigger a refresh.
+  gfx::Vector2dF zero_velocity;
+  EXPECT_FALSE(GetAndResetRefreshTriggered());
+  effect.OnScrollEnd(zero_velocity);
+  EXPECT_TRUE(effect.IsActive());
+  EXPECT_TRUE(GetAndResetRefreshTriggered());
+
+  // Ensure animation doesn't explode.
+  base::TimeTicks initial_time = base::TimeTicks::Now();
+  base::TimeTicks current_time = initial_time;
+  scoped_refptr<cc::Layer> layer = cc::Layer::Create();
+  while (effect.Animate(current_time, layer.get()))
+    current_time += base::TimeDelta::FromMilliseconds(16);
+
+  // The effect should terminate in a timely fashion.
+  EXPECT_GT(current_time.ToInternalValue(), initial_time.ToInternalValue());
+  EXPECT_LE(
+      current_time.ToInternalValue(),
+      (initial_time + base::TimeDelta::FromSeconds(10)).ToInternalValue());
+  EXPECT_FALSE(effect.IsActive());
+}
+
+TEST_F(OverscrollRefreshTest, NotTriggeredIfBelowThreshold) {
+  OverscrollRefresh effect(this, this);
+  effect.UpdateDisplay(DefaultViewportSize(), gfx::Vector2dF());
+  effect.OnScrollBegin();
+  ASSERT_FALSE(effect.WillHandleScrollUpdate(gfx::Vector2dF(0, 10)));
+  ASSERT_TRUE(effect.IsPendingScrollUpdateAck());
+  effect.OnScrollUpdateAck(false);
+  ASSERT_TRUE(effect.IsActive());
+
+  // Terminating the pull before it exceeds the threshold will prevent refresh.
+  EXPECT_TRUE(effect.WillHandleScrollUpdate(gfx::Vector2dF(0, 10)));
+  effect.OnScrollEnd(gfx::Vector2dF());
+  EXPECT_FALSE(GetAndResetRefreshTriggered());
+}
+
+TEST_F(OverscrollRefreshTest, NotTriggeredIfInitialYOffsetIsZero) {

[Ted C, 2014/10/31 23:52:05]

Is[Not]Zero?

[jdduke (slow), 2014/11/06 00:10:37]

Done.

[Ted C, 2014/11/06 19:25:40]

Really?

[jdduke (slow), 2014/11/07 18:33:44]

No :( I'm a bad person.

+  OverscrollRefresh effect(this, this);
+
+  // A positive y scroll offset at the start of scroll will prevent activation,
+  // even if the subsequent scroll overscrolls upward.
+  gfx::Vector2dF nonzero_offset(0, 10);
+  effect.UpdateDisplay(DefaultViewportSize(), nonzero_offset);
+  effect.OnScrollBegin();
+
+  effect.UpdateDisplay(DefaultViewportSize(), gfx::Vector2dF());
+  ASSERT_FALSE(effect.WillHandleScrollUpdate(gfx::Vector2dF(0, 10)));
+  EXPECT_FALSE(effect.IsActive());
+  EXPECT_FALSE(effect.IsPendingScrollUpdateAck());
+  effect.OnScrollUpdateAck(false);
+  EXPECT_FALSE(effect.IsActive());
+  EXPECT_FALSE(effect.IsPendingScrollUpdateAck());
+  EXPECT_FALSE(effect.WillHandleScrollUpdate(gfx::Vector2dF(0, 500)));
+  effect.OnScrollEnd(gfx::Vector2dF());
+  EXPECT_FALSE(GetAndResetRefreshTriggered());
+}
+
+TEST_F(OverscrollRefreshTest, NotTriggeredIfInitialScrollDownward) {
+  OverscrollRefresh effect(this, this);
+  effect.UpdateDisplay(DefaultViewportSize(), gfx::Vector2dF());
+  effect.OnScrollBegin();
+
+  // A downward initial scroll will prevent activation, even if the subsequent
+  // scroll overscrolls upward.
+  ASSERT_FALSE(effect.WillHandleScrollUpdate(gfx::Vector2dF(0, -10)));
+  EXPECT_FALSE(effect.IsActive());
+  EXPECT_FALSE(effect.IsPendingScrollUpdateAck());
+
+  effect.OnScrollUpdateAck(false);
+  EXPECT_FALSE(effect.IsActive());
+  EXPECT_FALSE(effect.IsPendingScrollUpdateAck());
+  EXPECT_FALSE(effect.WillHandleScrollUpdate(gfx::Vector2dF(0, 500)));
+  effect.OnScrollEnd(gfx::Vector2dF());
+  EXPECT_FALSE(GetAndResetRefreshTriggered());
+}
+
+TEST_F(OverscrollRefreshTest, NotTriggeredIfInitialScrollConsumed) {
+  OverscrollRefresh effect(this, this);
+  effect.UpdateDisplay(DefaultViewportSize(), gfx::Vector2dF());
+  effect.OnScrollBegin();
+  ASSERT_FALSE(effect.WillHandleScrollUpdate(gfx::Vector2dF(0, 10)));
+  ASSERT_TRUE(effect.IsPendingScrollUpdateAck());
+
+  // Consumption of the initial scroll should prevent future activation.
+  effect.OnScrollUpdateAck(true);
+  EXPECT_FALSE(effect.IsActive());
+  EXPECT_FALSE(effect.IsPendingScrollUpdateAck());
+  EXPECT_FALSE(effect.WillHandleScrollUpdate(gfx::Vector2dF(0, 500)));
+  effect.OnScrollUpdateAck(false);
+  EXPECT_FALSE(effect.IsActive());
+  EXPECT_FALSE(effect.IsPendingScrollUpdateAck());
+  EXPECT_FALSE(effect.WillHandleScrollUpdate(gfx::Vector2dF(0, 500)));
+  effect.OnScrollEnd(gfx::Vector2dF());
+  EXPECT_FALSE(GetAndResetRefreshTriggered());
+}
+
+TEST_F(OverscrollRefreshTest, NotTriggeredIfInitialScrollsJanked) {
+  OverscrollRefresh effect(this, this);
+  effect.UpdateDisplay(DefaultViewportSize(), gfx::Vector2dF());
+  effect.OnScrollBegin();
+  ASSERT_FALSE(effect.WillHandleScrollUpdate(gfx::Vector2dF(0, 10)));
+  ASSERT_TRUE(effect.IsPendingScrollUpdateAck());
+  effect.OnScrollUpdateAck(false);
+  ASSERT_TRUE(effect.IsActive());
+
+  // It should take more than just one or two large scrolls to trigger,
+  // mitigating likelihood of jank triggering the effect.
+  EXPECT_TRUE(effect.WillHandleScrollUpdate(gfx::Vector2dF(0, 500)));
+  EXPECT_TRUE(effect.WillHandleScrollUpdate(gfx::Vector2dF(0, 500)));
+  effect.OnScrollEnd(gfx::Vector2dF());
+  EXPECT_FALSE(GetAndResetRefreshTriggered());
+}
+
+TEST_F(OverscrollRefreshTest, NotTriggeredIfFlungDownward) {
+  OverscrollRefresh effect(this, this);
+  effect.UpdateDisplay(DefaultViewportSize(), gfx::Vector2dF());
+  effect.OnScrollBegin();
+  ASSERT_FALSE(effect.WillHandleScrollUpdate(gfx::Vector2dF(0, 10)));
+  ASSERT_TRUE(effect.IsPendingScrollUpdateAck());
+  effect.OnScrollUpdateAck(false);
+  ASSERT_TRUE(effect.IsActive());
+
+  // Ensure the pull exceeds the necessary threshold.
+  EXPECT_TRUE(effect.WillHandleScrollUpdate(gfx::Vector2dF(0, 50)));
+  EXPECT_TRUE(effect.WillHandleScrollUpdate(gfx::Vector2dF(0, 50)));
+  EXPECT_TRUE(effect.WillHandleScrollUpdate(gfx::Vector2dF(0, 50)));
+  EXPECT_TRUE(effect.WillHandleScrollUpdate(gfx::Vector2dF(0, 50)));
+  EXPECT_TRUE(effect.WillHandleScrollUpdate(gfx::Vector2dF(0, 50)));
+  EXPECT_TRUE(effect.WillHandleScrollUpdate(gfx::Vector2dF(0, 50)));
+
+  // Terminating the pull with a down-directed fling should prevent triggering.
+  effect.OnScrollEnd(gfx::Vector2dF(0, -1000));
+  EXPECT_FALSE(GetAndResetRefreshTriggered());
+}
+
+}  // namespace content