[Android] Disable pull-to-refresh with overflow:hidden

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/android/resources/resource_manager.h"
 
 namespace content {
 
-const float kDragTargetPixels = 100;
-const bool kMirror = false;
-
-gfx::SizeF DefaultViewportSize() {
-  return gfx::SizeF(512, 512);
-}
-
 class OverscrollRefreshTest : public OverscrollRefreshClient,
                               public ui::ResourceManager,
                               public testing::Test {
  public:
   OverscrollRefreshTest()
       : refresh_triggered_(false), still_refreshing_(false) {}
 
   // OverscrollRefreshClient implementation.
   void TriggerRefresh() override {
     refresh_triggered_ = true;
@@ skipping 18 matching lines @@
     refresh_triggered_ = false;
     return triggered;
   }
 
   void PullBeyondActivationThreshold(OverscrollRefresh* effect) {
     for (int i = 0; i < OverscrollRefresh::kMinPullsToActivate; ++i)
       EXPECT_TRUE(effect->WillHandleScrollUpdate(gfx::Vector2dF(0, 100)));
   }
 
  protected:
+
+  scoped_ptr<OverscrollRefresh> CreateEffect() {
+    const float kDragTargetPixels = 100;
+    const bool kMirror = false;
+    scoped_ptr<OverscrollRefresh> effect(
+        new OverscrollRefresh(this, this, kDragTargetPixels, kMirror));
+
+    const gfx::SizeF kViewportSize(512, 512);
+    const gfx::Vector2dF kScrollOffset;
+    const bool kOverflowYHidden = false;
+    effect->UpdateDisplay(kViewportSize, kScrollOffset, kOverflowYHidden);
+
+    return effect.Pass();
+  }
+
   void SignalRefreshCompleted() { still_refreshing_ = false; }
 
  private:
   bool refresh_triggered_;
   bool still_refreshing_;
 };
 
 TEST_F(OverscrollRefreshTest, Basic) {
-  OverscrollRefresh effect(this, this, kDragTargetPixels, kMirror);
+  scoped_ptr<OverscrollRefresh> effect = CreateEffect();
 
-  gfx::Vector2dF origin_scroll_offset;
-  effect.UpdateDisplay(DefaultViewportSize(), origin_scroll_offset);
-  EXPECT_FALSE(effect.IsActive());
-  EXPECT_FALSE(effect.IsAwaitingScrollUpdateAck());
+  EXPECT_FALSE(effect->IsActive());
+  EXPECT_FALSE(effect->IsAwaitingScrollUpdateAck());
 
-  effect.OnScrollBegin();
-  EXPECT_FALSE(effect.IsActive());
-  EXPECT_TRUE(effect.IsAwaitingScrollUpdateAck());
+  effect->OnScrollBegin();
+  EXPECT_FALSE(effect->IsActive());
+  EXPECT_TRUE(effect->IsAwaitingScrollUpdateAck());
 
   // 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.IsAwaitingScrollUpdateAck());
+  EXPECT_FALSE(effect->WillHandleScrollUpdate(scroll_up));
+  EXPECT_FALSE(effect->IsActive());
+  EXPECT_TRUE(effect->IsAwaitingScrollUpdateAck());
 
-  // The unconsumed, overscrolling scroll will trigger the effect.
-  effect.OnScrollUpdateAck(false);
-  EXPECT_TRUE(effect.IsActive());
-  EXPECT_FALSE(effect.IsAwaitingScrollUpdateAck());
+  // The unconsumed, overscrolling scroll will trigger the effect->
+  effect->OnScrollUpdateAck(false);
+  EXPECT_TRUE(effect->IsActive());
+  EXPECT_FALSE(effect->IsAwaitingScrollUpdateAck());
 
   // Further scrolls will be consumed.
-  EXPECT_TRUE(effect.WillHandleScrollUpdate(gfx::Vector2dF(0, 50)));
-  EXPECT_TRUE(effect.IsActive());
+  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());
+  EXPECT_TRUE(effect->WillHandleScrollUpdate(gfx::Vector2dF(0, -50)));
+  EXPECT_TRUE(effect->IsActive());
 
   // Feed enough scrolls to the effect to exceeds the threshold.
-  PullBeyondActivationThreshold(&effect);
-  EXPECT_TRUE(effect.IsActive());
+  PullBeyondActivationThreshold(effect.get());
+  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());
+  effect->OnScrollEnd(zero_velocity);
+  EXPECT_TRUE(effect->IsActive());
   EXPECT_TRUE(GetAndResetRefreshTriggered());
   SignalRefreshCompleted();
 
   // 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()))
+  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());
+  EXPECT_FALSE(effect->IsActive());
 }
 
 TEST_F(OverscrollRefreshTest, AnimationTerminatesEvenIfRefreshNeverTerminates) {
-  OverscrollRefresh effect(this, this, kDragTargetPixels, kMirror);
-  effect.UpdateDisplay(DefaultViewportSize(), gfx::Vector2dF());
-  effect.OnScrollBegin();
-  ASSERT_FALSE(effect.WillHandleScrollUpdate(gfx::Vector2dF(0, 10)));
-  ASSERT_TRUE(effect.IsAwaitingScrollUpdateAck());
-  effect.OnScrollUpdateAck(false);
-  ASSERT_TRUE(effect.IsActive());
-  PullBeyondActivationThreshold(&effect);
-  ASSERT_TRUE(effect.IsActive());
-  effect.OnScrollEnd(gfx::Vector2dF(0, 0));
+  scoped_ptr<OverscrollRefresh> effect = CreateEffect();
+  effect->OnScrollBegin();
+  ASSERT_FALSE(effect->WillHandleScrollUpdate(gfx::Vector2dF(0, 10)));
+  ASSERT_TRUE(effect->IsAwaitingScrollUpdateAck());
+  effect->OnScrollUpdateAck(false);
+  ASSERT_TRUE(effect->IsActive());
+  PullBeyondActivationThreshold(effect.get());
+  ASSERT_TRUE(effect->IsActive());
+  effect->OnScrollEnd(gfx::Vector2dF(0, 0));
   ASSERT_TRUE(GetAndResetRefreshTriggered());
 
   // Verify that the animation terminates even if the triggered refresh
   // action never terminates (i.e., |still_refreshing_| is always true).
   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()))
+  while (effect->Animate(current_time, layer.get()))
     current_time += base::TimeDelta::FromMilliseconds(16);
 
   EXPECT_GT(current_time.ToInternalValue(), initial_time.ToInternalValue());
   EXPECT_LE(
       current_time.ToInternalValue(),
       (initial_time + base::TimeDelta::FromSeconds(10)).ToInternalValue());
-  EXPECT_FALSE(effect.IsActive());
+  EXPECT_FALSE(effect->IsActive());
 }
 
 TEST_F(OverscrollRefreshTest, NotTriggeredIfBelowThreshold) {
-  OverscrollRefresh effect(this, this, kDragTargetPixels, kMirror);
-  effect.UpdateDisplay(DefaultViewportSize(), gfx::Vector2dF());
-  effect.OnScrollBegin();
-  ASSERT_FALSE(effect.WillHandleScrollUpdate(gfx::Vector2dF(0, 10)));
-  ASSERT_TRUE(effect.IsAwaitingScrollUpdateAck());
-  effect.OnScrollUpdateAck(false);
-  ASSERT_TRUE(effect.IsActive());
+  scoped_ptr<OverscrollRefresh> effect = CreateEffect();
+  effect->OnScrollBegin();
+  ASSERT_FALSE(effect->WillHandleScrollUpdate(gfx::Vector2dF(0, 10)));
+  ASSERT_TRUE(effect->IsAwaitingScrollUpdateAck());
+  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_TRUE(effect->WillHandleScrollUpdate(gfx::Vector2dF(0, 10)));
+  effect->OnScrollEnd(gfx::Vector2dF());
   EXPECT_FALSE(GetAndResetRefreshTriggered());
 }
 
 TEST_F(OverscrollRefreshTest, NotTriggeredIfInitialYOffsetIsNotZero) {
-  OverscrollRefresh effect(this, this, kDragTargetPixels, kMirror);
+  scoped_ptr<OverscrollRefresh> effect = CreateEffect();
 
   // A positive y scroll offset at the start of scroll will prevent activation,
   // even if the subsequent scroll overscrolls upward.
+  gfx::SizeF viewport_size(512, 512);
   gfx::Vector2dF nonzero_offset(0, 10);
-  effect.UpdateDisplay(DefaultViewportSize(), nonzero_offset);
-  effect.OnScrollBegin();
+  bool overflow_y_hidden = false;
+  effect->UpdateDisplay(viewport_size, nonzero_offset, overflow_y_hidden);
+  effect->OnScrollBegin();
 
-  effect.UpdateDisplay(DefaultViewportSize(), gfx::Vector2dF());
-  ASSERT_FALSE(effect.WillHandleScrollUpdate(gfx::Vector2dF(0, 10)));
-  EXPECT_FALSE(effect.IsActive());
-  EXPECT_FALSE(effect.IsAwaitingScrollUpdateAck());
-  effect.OnScrollUpdateAck(false);
-  EXPECT_FALSE(effect.IsActive());
-  EXPECT_FALSE(effect.IsAwaitingScrollUpdateAck());
-  EXPECT_FALSE(effect.WillHandleScrollUpdate(gfx::Vector2dF(0, 500)));
-  effect.OnScrollEnd(gfx::Vector2dF());
+  ASSERT_FALSE(effect->WillHandleScrollUpdate(gfx::Vector2dF(0, 10)));
+  EXPECT_FALSE(effect->IsActive());
+  EXPECT_FALSE(effect->IsAwaitingScrollUpdateAck());
+  effect->OnScrollUpdateAck(false);
+  EXPECT_FALSE(effect->IsActive());
+  EXPECT_FALSE(effect->IsAwaitingScrollUpdateAck());
+  EXPECT_FALSE(effect->WillHandleScrollUpdate(gfx::Vector2dF(0, 500)));
+  effect->OnScrollEnd(gfx::Vector2dF());
+  EXPECT_FALSE(GetAndResetRefreshTriggered());
+}
+
+TEST_F(OverscrollRefreshTest, NotTriggeredIfOverflowYHidden) {
+  scoped_ptr<OverscrollRefresh> effect = CreateEffect();
+
+  // "overflow-y: hidden" on the root layer will prevent activation,
+  // even if the subsequent scroll overscrolls upward.
+  gfx::SizeF viewport_size(512, 512);
+  gfx::Vector2dF zero_offset;
+  bool overflow_y_hidden = true;
+  effect->UpdateDisplay(viewport_size, zero_offset, overflow_y_hidden);
+  effect->OnScrollBegin();
+  ASSERT_FALSE(effect->WillHandleScrollUpdate(gfx::Vector2dF(0, 10)));
+  EXPECT_FALSE(effect->IsActive());
+  EXPECT_FALSE(effect->IsAwaitingScrollUpdateAck());
+  effect->OnScrollUpdateAck(false);
+  EXPECT_FALSE(effect->IsActive());
+  EXPECT_FALSE(effect->IsAwaitingScrollUpdateAck());
+  EXPECT_FALSE(effect->WillHandleScrollUpdate(gfx::Vector2dF(0, 500)));
+  effect->OnScrollEnd(gfx::Vector2dF());
   EXPECT_FALSE(GetAndResetRefreshTriggered());
 }
 
 TEST_F(OverscrollRefreshTest, NotTriggeredIfInitialScrollDownward) {
-  OverscrollRefresh effect(this, this, kDragTargetPixels, kMirror);
-  effect.UpdateDisplay(DefaultViewportSize(), gfx::Vector2dF());
-  effect.OnScrollBegin();
+  scoped_ptr<OverscrollRefresh> effect = CreateEffect();
+  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.IsAwaitingScrollUpdateAck());
+  ASSERT_FALSE(effect->WillHandleScrollUpdate(gfx::Vector2dF(0, -10)));
+  EXPECT_FALSE(effect->IsActive());
+  EXPECT_FALSE(effect->IsAwaitingScrollUpdateAck());
 
-  effect.OnScrollUpdateAck(false);
-  EXPECT_FALSE(effect.IsActive());
-  EXPECT_FALSE(effect.IsAwaitingScrollUpdateAck());
-  EXPECT_FALSE(effect.WillHandleScrollUpdate(gfx::Vector2dF(0, 500)));
-  effect.OnScrollEnd(gfx::Vector2dF());
+  effect->OnScrollUpdateAck(false);
+  EXPECT_FALSE(effect->IsActive());
+  EXPECT_FALSE(effect->IsAwaitingScrollUpdateAck());
+  EXPECT_FALSE(effect->WillHandleScrollUpdate(gfx::Vector2dF(0, 500)));
+  effect->OnScrollEnd(gfx::Vector2dF());
   EXPECT_FALSE(GetAndResetRefreshTriggered());
 }
 
 TEST_F(OverscrollRefreshTest, NotTriggeredIfInitialScrollOrTouchConsumed) {
-  OverscrollRefresh effect(this, this, kDragTargetPixels, kMirror);
-  effect.UpdateDisplay(DefaultViewportSize(), gfx::Vector2dF());
-  effect.OnScrollBegin();
-  ASSERT_FALSE(effect.WillHandleScrollUpdate(gfx::Vector2dF(0, 10)));
-  ASSERT_TRUE(effect.IsAwaitingScrollUpdateAck());
+  scoped_ptr<OverscrollRefresh> effect = CreateEffect();
+  effect->OnScrollBegin();
+  ASSERT_FALSE(effect->WillHandleScrollUpdate(gfx::Vector2dF(0, 10)));
+  ASSERT_TRUE(effect->IsAwaitingScrollUpdateAck());
 
   // Consumption of the initial touchmove or scroll should prevent future
   // activation.
-  effect.OnScrollUpdateAck(true);
-  EXPECT_FALSE(effect.IsActive());
-  EXPECT_FALSE(effect.IsAwaitingScrollUpdateAck());
-  EXPECT_FALSE(effect.WillHandleScrollUpdate(gfx::Vector2dF(0, 500)));
-  effect.OnScrollUpdateAck(false);
-  EXPECT_FALSE(effect.IsActive());
-  EXPECT_FALSE(effect.IsAwaitingScrollUpdateAck());
-  EXPECT_FALSE(effect.WillHandleScrollUpdate(gfx::Vector2dF(0, 500)));
-  effect.OnScrollEnd(gfx::Vector2dF());
+  effect->OnScrollUpdateAck(true);
+  EXPECT_FALSE(effect->IsActive());
+  EXPECT_FALSE(effect->IsAwaitingScrollUpdateAck());
+  EXPECT_FALSE(effect->WillHandleScrollUpdate(gfx::Vector2dF(0, 500)));
+  effect->OnScrollUpdateAck(false);
+  EXPECT_FALSE(effect->IsActive());
+  EXPECT_FALSE(effect->IsAwaitingScrollUpdateAck());
+  EXPECT_FALSE(effect->WillHandleScrollUpdate(gfx::Vector2dF(0, 500)));
+  effect->OnScrollEnd(gfx::Vector2dF());
   EXPECT_FALSE(GetAndResetRefreshTriggered());
 }
 
 TEST_F(OverscrollRefreshTest, NotTriggeredIfInitialScrollsJanked) {
-  OverscrollRefresh effect(this, this, kDragTargetPixels, kMirror);
-  effect.UpdateDisplay(DefaultViewportSize(), gfx::Vector2dF());
-  effect.OnScrollBegin();
-  ASSERT_FALSE(effect.WillHandleScrollUpdate(gfx::Vector2dF(0, 10)));
-  ASSERT_TRUE(effect.IsAwaitingScrollUpdateAck());
-  effect.OnScrollUpdateAck(false);
-  ASSERT_TRUE(effect.IsActive());
+  scoped_ptr<OverscrollRefresh> effect = CreateEffect();
+  effect->OnScrollBegin();
+  ASSERT_FALSE(effect->WillHandleScrollUpdate(gfx::Vector2dF(0, 10)));
+  ASSERT_TRUE(effect->IsAwaitingScrollUpdateAck());
+  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());
+  // 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, kDragTargetPixels, kMirror);
-  effect.UpdateDisplay(DefaultViewportSize(), gfx::Vector2dF());
-  effect.OnScrollBegin();
-  ASSERT_FALSE(effect.WillHandleScrollUpdate(gfx::Vector2dF(0, 10)));
-  ASSERT_TRUE(effect.IsAwaitingScrollUpdateAck());
-  effect.OnScrollUpdateAck(false);
-  ASSERT_TRUE(effect.IsActive());
+  scoped_ptr<OverscrollRefresh> effect = CreateEffect();
+  effect->OnScrollBegin();
+  ASSERT_FALSE(effect->WillHandleScrollUpdate(gfx::Vector2dF(0, 10)));
+  ASSERT_TRUE(effect->IsAwaitingScrollUpdateAck());
+  effect->OnScrollUpdateAck(false);
+  ASSERT_TRUE(effect->IsActive());
 
   // Ensure the pull exceeds the necessary threshold.
-  PullBeyondActivationThreshold(&effect);
-  ASSERT_TRUE(effect.IsActive());
+  PullBeyondActivationThreshold(effect.get());
+  ASSERT_TRUE(effect->IsActive());
 
   // Terminating the pull with a down-directed fling should prevent triggering.
-  effect.OnScrollEnd(gfx::Vector2dF(0, -1000));
+  effect->OnScrollEnd(gfx::Vector2dF(0, -1000));
   EXPECT_FALSE(GetAndResetRefreshTriggered());
 }
 
 TEST_F(OverscrollRefreshTest, NotTriggeredIfReleasedWithoutActivation) {
-  OverscrollRefresh effect(this, this, kDragTargetPixels, kMirror);
-  effect.UpdateDisplay(DefaultViewportSize(), gfx::Vector2dF());
-  effect.OnScrollBegin();
-  ASSERT_FALSE(effect.WillHandleScrollUpdate(gfx::Vector2dF(0, 10)));
-  ASSERT_TRUE(effect.IsAwaitingScrollUpdateAck());
-  effect.OnScrollUpdateAck(false);
-  ASSERT_TRUE(effect.IsActive());
+  scoped_ptr<OverscrollRefresh> effect = CreateEffect();
+  effect->OnScrollBegin();
+  ASSERT_FALSE(effect->WillHandleScrollUpdate(gfx::Vector2dF(0, 10)));
+  ASSERT_TRUE(effect->IsAwaitingScrollUpdateAck());
+  effect->OnScrollUpdateAck(false);
+  ASSERT_TRUE(effect->IsActive());
 
   // Ensure the pull exceeds the necessary threshold.
-  PullBeyondActivationThreshold(&effect);
-  ASSERT_TRUE(effect.IsActive());
+  PullBeyondActivationThreshold(effect.get());
+  ASSERT_TRUE(effect->IsActive());
 
   // An early release should prevent the refresh action from firing.
-  effect.ReleaseWithoutActivation();
-  effect.OnScrollEnd(gfx::Vector2dF());
+  effect->ReleaseWithoutActivation();
+  effect->OnScrollEnd(gfx::Vector2dF());
   EXPECT_FALSE(GetAndResetRefreshTriggered());
 
   // The early release should trigger a dismissal animation.
-  EXPECT_TRUE(effect.IsActive());
+  EXPECT_TRUE(effect->IsActive());
   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()))
+  while (effect->Animate(current_time, layer.get()))
     current_time += base::TimeDelta::FromMilliseconds(16);
 
   EXPECT_GT(current_time.ToInternalValue(), initial_time.ToInternalValue());
-  EXPECT_FALSE(effect.IsActive());
+  EXPECT_FALSE(effect->IsActive());
   EXPECT_FALSE(GetAndResetRefreshTriggered());
 }
 
 }  // namespace content