scroll: Avoid overscroll in "scroll to end"

As long as the bottom sliver is size zero (or more generally, as long
as maxScrollExtent does not change during the animation), this is
nearly NFC: I believe the only changes in behavior would come from
differences in rounding.

This change handles the case where the end turns out to be closer
than it looked at the beginning of the animation.  Before this
change, the animation would try to scroll past the end in that case.
Now it stops at exactly the end -- just like it already did in the
case where the end was known exactly in advance, as it currently
always is in the actual message list.

That case is a possibility as soon as there's a bottom sliver with a
message in it: scroll up so the message is offscreen and no longer
built; then have the message edited so it becomes shorter; then scroll
back down.  It's impossible for the viewport to know that the bottom
sliver's content has gotten taller until we actually scroll back down
and cause the message's widget to get built.

Author: gnprice

lib/widgets/scrolling.dart

@@ -262,6 +262,31 @@ class ScrollToEndActivity extends DrivenScrollActivity {
     required super.curve,
     required super.vsync,
   });
+
+  ScrollPosition get _position => delegate as ScrollPosition;
+
+  @override
+  bool applyMoveTo(double value) {
+    bool done = false;
+    if (value > _position.maxScrollExtent) {
+      // The activity has reached the end.
+      // Stop at exactly the end, rather than causing overscroll.
+      // Possibly some overscroll would actually be desirable, but:
+      // TODO(upstream) stretch-overscroll seems busted, inverted:
+      //   Is this formula (from [_StretchController.absorbImpact] really right?
+      //     _stretchSizeTween.end =
+      //       math.min(_stretchIntensity + (_flingFriction / velocity), 1.0);
+      //   Seems to take low velocity to the largest stretch, and high velocity
+      //   to the smallest stretch.
+      //   Specifically, a very slow fling produces a very large stretch,
+      //   while other flings produce small stretches that vary little
+      //   between modest speed (~300 px/s) and top speed (8000 px/s).
+      value = _position.maxScrollExtent;
+      done = true;
+    }
+    if (!super.applyMoveTo(value)) return false;
+    return !done;
+  }
 }
 
 /// A version of [ScrollPosition] adapted for the Zulip message list,

test/widgets/scrolling_test.dart

@@ -417,6 +417,44 @@ void main() {
 
         debugDefaultTargetPlatformOverride = null;
       });
+
+      testWidgets('on overscroll, stop', (tester) async {
+        debugDefaultTargetPlatformOverride = TargetPlatform.iOS;
+        await prepare(tester, topHeight: 400, bottomHeight: 1000);
+
+        // Scroll up…
+        position.jumpTo(400);
+        await tester.pump();
+        check(position.extentAfter).equals(600);
+
+        // … then invoke `scrollToEnd`…
+        position.scrollToEnd();
+        await tester.pump();
+
+        // … but have the bottom sliver turn out to be shorter than it was.
+        await prepare(tester, topHeight: 400, bottomHeight: 600,
+          reuseController: true);
+        check(position.extentAfter).equals(200);
+
+        // Let the scrolling animation proceed until it hits the end.
+        int steps = 0;
+        while (position.extentAfter > 0) {
+          check(++steps).isLessThan(100);
+          await tester.pump(Duration(milliseconds: 11));
+        }
+
+        // This is the very first frame where the position reached the end.
+        // It's at exactly the end, no farther…
+        check(position.pixels - position.maxScrollExtent).equals(0);
+
+        // … and the animation is done.  Nothing further happens.
+        check(position.activity).isA<IdleScrollActivity>();
+        await tester.pump(Duration(milliseconds: 11));
+        check(position.pixels - position.maxScrollExtent).equals(0);
+        check(position.activity).isA<IdleScrollActivity>();
+
+        debugDefaultTargetPlatformOverride = null;
+      });
     });
   });
 }