Prevent viewport.showOnScreen from scrolling the viewport if the specified Rect is already visible.

packages/flutter/lib/src/rendering/sliver_persistent_header.dart

@@ -196,6 +196,68 @@ abstract class RenderSliverPersistentHeader extends RenderSliver with RenderObje
     _lastStretchOffset = stretchOffset;
   }
 
+  @override
+  void showOnScreen({
+    RenderObject descendant,
+    Rect rect,
+    Duration duration = Duration.zero,
+    Curve curve = Curves.ease,
+  }) {
+    assert(child != null);
+    final Rect childBounds = descendant != null
+      ? MatrixUtils.transformRect(descendant.getTransformTo(child), rect ?? descendant.paintBounds)
+      : null;
+
+    // Trims the part of `rect` that protrudes `child`'s leading edge.
+    //
+    // If the `rect` a descendant specified in its showOnScreen call exceeds
+    // the leading edge of this sliver (which is usually the same as that of
+    // `child`), the viewport will move towards the leading edge (reduce its
+    // scroll offset) to unpin the persistent header. This is almost always
+    // undesirable.
+    //
+    // See: https://github.com/flutter/flutter/issues/25507.
+    Rect trim(Rect original, {
+      double top = -double.infinity,
+      double right = double.infinity,
+      double bottom = double.infinity,
+      double left = -double.infinity,
+    }) {
+      if (original == null)
+        return null;
+
+      return Rect.fromLTRB(
+        math.max(original.left, left),
+        math.max(original.top, top),
+        math.min(original.right, right),
+        math.min(original.bottom, bottom),
+      );
+    }
+
+    Rect newRect;
+    switch (applyGrowthDirectionToAxisDirection(constraints.axisDirection, constraints.growthDirection)) {
+      case AxisDirection.up:
+        newRect = trim(childBounds ?? rect, bottom: childExtent);
+        break;
+      case AxisDirection.right:
+        newRect = trim(childBounds ?? rect, left: 0);
+        break;
+      case AxisDirection.down:
+        newRect = trim(childBounds ?? rect, top: 0);
+        break;
+      case AxisDirection.left:
+        newRect = trim(childBounds ?? rect, right: childExtent);
+        break;
+    }
+
+    super.showOnScreen(
+      descendant: descendant == null ? this : child,
+      rect: newRect,
+      duration: duration,
+      curve: curve,
+    );
+  }
+
   /// Returns the distance from the leading _visible_ edge of the sliver to the
   /// side of the child closest to that edge, in the scroll axis direction.
   ///
@@ -585,6 +647,61 @@ abstract class RenderSliverFloatingPersistentHeader extends RenderSliverPersiste
     _lastActualScrollOffset = constraints.scrollOffset;
   }
 
+  @override
+  void showOnScreen({
+    RenderObject descendant,
+    Rect rect,
+    Duration duration = Duration.zero,
+    Curve curve = Curves.ease,
+  }) {
+    assert(child != null);
+    final Rect childBounds = descendant != null
+      ? MatrixUtils.transformRect(descendant.getTransformTo(child), rect ?? descendant.paintBounds)
+      : null;
+
+    double minTargetExtent;
+    switch (applyGrowthDirectionToAxisDirection(constraints.axisDirection, constraints.growthDirection)) {
+      case AxisDirection.up:
+        minTargetExtent = childExtent - (childBounds?.top ?? 0);
+        break;
+      case AxisDirection.right:
+        minTargetExtent = childBounds?.right ?? childExtent;
+        break;
+      case AxisDirection.down:
+        minTargetExtent = childBounds?.bottom ?? childExtent;
+        break;
+      case AxisDirection.left:
+        minTargetExtent = childExtent - (childBounds?.left ?? 0);
+        break;
+    }
+
+    minTargetExtent = minTargetExtent.clamp(childExtent, maxExtent) as double;
+    // Expands the header if needed, with animation if possible.
+    if (minTargetExtent > childExtent) {
+      if (snapConfiguration != null) {
+        _controller ??= AnimationController(vsync: snapConfiguration.vsync, duration: duration);
+        _controller.duration = duration;
+        _animation = _controller
+          .drive(
+            Tween<double>(
+              begin: _effectiveScrollOffset,
+              end: maxExtent - minTargetExtent ,
+            ).chain(CurveTween(curve: curve)),
+          );
+      } else {
+        _effectiveScrollOffset = maxExtent - minTargetExtent;
+        markNeedsLayout();
+      }
+    }
+
+    super.showOnScreen(
+      descendant: descendant == null ? this : child,
+      rect: childBounds,
+      duration: duration,
+      curve: curve,
+    );
+  }
+
   @override
   double childMainAxisPosition(RenderBox child) {
     assert(child == this.child);

packages/flutter/lib/src/rendering/viewport.dart

@@ -783,7 +783,6 @@ abstract class RenderViewportBase<ParentDataClass extends ContainerParentDataMix
     final double offsetDifference = offset.pixels - targetOffset;
 
     final Matrix4 transform = target.getTransformTo(this);
-    applyPaintTransform(child, transform);
     Rect targetRect = MatrixUtils.transformRect(transform, rect);
 
     switch (axisDirection) {
@@ -986,16 +985,61 @@ abstract class RenderViewportBase<ParentDataClass extends ContainerParentDataMix
       );
     }
 
-    final Rect newRect = RenderViewportBase.showInViewport(
-      descendant: descendant,
-      viewport: this,
-      offset: offset,
-      rect: rect,
-      duration: duration,
-      curve: curve,
+    RenderObject child = descendant;
+    RenderSliver childSliver;
+
+    do {
+      if (child is RenderSliver) {
+        childSliver = child;
+      }
+
+      final RenderObject parent = child.parent as RenderObject;
+      child = parent;
+      assert(child != null, '$descendant must be a descendant of $this.');
+    } while (child != this);
+
+    assert(childSliver.parent == this);
+    Rect localRect = MatrixUtils.transformRect(
+      (descendant ?? this).getTransformTo(this),
+      rect ?? descendant?.paintBounds ?? paintBounds,
     );
+
+    final double extentOfPinnedSlivers = maxScrollObstructionExtentBefore(childSliver);
+    assert(extentOfPinnedSlivers >= 0);
+
+    bool canSkipScrolling = true;
+    switch (applyGrowthDirectionToAxisDirection(axisDirection, childSliver.constraints.growthDirection)) {
+      case AxisDirection.up:
+        canSkipScrolling = canSkipScrolling && localRect.top >= 0;
+        canSkipScrolling = canSkipScrolling && localRect.bottom <= size.height - extentOfPinnedSlivers;
+        break;
+      case AxisDirection.right:
+        canSkipScrolling = canSkipScrolling && localRect.left >= extentOfPinnedSlivers;
+        canSkipScrolling = canSkipScrolling && localRect.right <= size.width;
+        break;
+      case AxisDirection.down:
+        canSkipScrolling = canSkipScrolling && localRect.top >= extentOfPinnedSlivers;
+        canSkipScrolling = canSkipScrolling && localRect.bottom <= size.height;
+        break;
+      case AxisDirection.left:
+        canSkipScrolling = canSkipScrolling && localRect.left >= 0;
+        canSkipScrolling = canSkipScrolling && localRect.right <= size.width - extentOfPinnedSlivers;
+        break;
+    }
+
+    if (!canSkipScrolling) {
+      localRect = RenderViewportBase.showInViewport(
+        descendant: descendant,
+        viewport: this,
+        offset: offset,
+        rect: rect,
+        duration: duration,
+        curve: curve,
+      );
+    }
+
     super.showOnScreen(
-      rect: newRect,
+      rect: localRect,
       duration: duration,
       curve: curve,
     );

packages/flutter/lib/src/widgets/editable_text.dart

@@ -1686,13 +1686,11 @@ class EditableTextState extends State<EditableText> with AutomaticKeepAliveClien
           bottomSpacing,
         );
       }
-      final Rect inflatedRect = Rect.fromLTRB(
-          newCaretRect.left - widget.scrollPadding.left,
-          newCaretRect.top - widget.scrollPadding.top,
-          newCaretRect.right + widget.scrollPadding.right,
-          newCaretRect.bottom + bottomSpacing,
-      );
-      _editableKey.currentContext.findRenderObject().showOnScreen(
+
+      final Rect inflatedRect = widget.scrollPadding
+        .copyWith(bottom: bottomSpacing)
+        .inflateRect(newCaretRect);
+      renderEditable.showOnScreen(
         rect: inflatedRect,
         duration: _caretAnimationDuration,
         curve: _caretAnimationCurve,