diff --git a/packages/flutter/lib/src/material/app_bar.dart b/packages/flutter/lib/src/material/app_bar.dart
index d4d9c3e..7122452 100644
--- a/packages/flutter/lib/src/material/app_bar.dart
+++ b/packages/flutter/lib/src/material/app_bar.dart
@@ -817,12 +817,18 @@
     @required this.topPadding,
     @required this.floating,
     @required this.pinned,
+    @required this.vsync,
     @required this.snapConfiguration,
     @required this.stretchConfiguration,
+    @required this.showOnScreenConfiguration,
     @required this.shape,
     @required this.toolbarHeight,
     @required this.leadingWidth,
   }) : assert(primary || topPadding == 0.0),
+       assert(
+         !floating || (snapConfiguration == null && showOnScreenConfiguration == null) || vsync != null,
+         'vsync cannot be null when snapConfiguration or showOnScreenConfiguration is not null, and floating is true',
+       ),
        _bottomHeight = bottom?.preferredSize?.height ?? 0.0;
 
   final Widget leading;
@@ -861,12 +867,18 @@
   double get maxExtent => math.max(topPadding + (expandedHeight ?? (toolbarHeight ?? kToolbarHeight) + _bottomHeight), minExtent);
 
   @override
+  final TickerProvider vsync;
+
+  @override
   final FloatingHeaderSnapConfiguration snapConfiguration;
 
   @override
   final OverScrollHeaderStretchConfiguration stretchConfiguration;
 
   @override
+  final PersistentHeaderShowOnScreenConfiguration showOnScreenConfiguration;
+
+  @override
   Widget build(BuildContext context, double shrinkOffset, bool overlapsContent) {
     final double visibleMainHeight = maxExtent - shrinkOffset - topPadding;
     final double extraToolbarHeight = math.max(minExtent - _bottomHeight - topPadding - (toolbarHeight ?? kToolbarHeight), 0.0);
@@ -935,8 +947,10 @@
         || topPadding != oldDelegate.topPadding
         || pinned != oldDelegate.pinned
         || floating != oldDelegate.floating
+        || vsync != oldDelegate.vsync
         || snapConfiguration != oldDelegate.snapConfiguration
         || stretchConfiguration != oldDelegate.stretchConfiguration
+        || showOnScreenConfiguration != oldDelegate.showOnScreenConfiguration
         || forceElevated != oldDelegate.forceElevated
         || toolbarHeight != oldDelegate.toolbarHeight
         || leadingWidth != leadingWidth;
@@ -1325,9 +1339,14 @@
   /// into view.
   ///
   /// If [snap] is true then a scroll that exposes the floating app bar will
-  /// trigger an animation that slides the entire app bar into view. Similarly if
-  /// a scroll dismisses the app bar, the animation will slide the app bar
-  /// completely out of view.
+  /// trigger an animation that slides the entire app bar into view. Similarly
+  /// if a scroll dismisses the app bar, the animation will slide the app bar
+  /// completely out of view. Additionally, setting [snap] to true will fully
+  /// expand the floating app bar when the framework tries to reveal the
+  /// contents of the app bar by calling [RenderObject.showOnScreen]. For
+  /// example, when a [TextField] in the floating app bar gains focus, if [snap]
+  /// is true, the framework will always fully expand the floating app bar, in
+  /// order to reveal the focused [TextField].
   ///
   /// Snapping only applies when the app bar is floating, not when the app bar
   /// appears at the top of its scroll view.
@@ -1382,17 +1401,21 @@
 class _SliverAppBarState extends State<SliverAppBar> with TickerProviderStateMixin {
   FloatingHeaderSnapConfiguration _snapConfiguration;
   OverScrollHeaderStretchConfiguration _stretchConfiguration;
+  PersistentHeaderShowOnScreenConfiguration _showOnScreenConfiguration;
 
   void _updateSnapConfiguration() {
     if (widget.snap && widget.floating) {
       _snapConfiguration = FloatingHeaderSnapConfiguration(
-        vsync: this,
         curve: Curves.easeOut,
         duration: const Duration(milliseconds: 200),
       );
     } else {
       _snapConfiguration = null;
     }
+
+    _showOnScreenConfiguration = widget.floating & widget.snap
+      ? const PersistentHeaderShowOnScreenConfiguration(minShowOnScreenExtent: double.infinity)
+      : null;
   }
 
   void _updateStretchConfiguration() {
@@ -1438,6 +1461,7 @@
         floating: widget.floating,
         pinned: widget.pinned,
         delegate: _SliverAppBarDelegate(
+          vsync: this,
           leading: widget.leading,
           automaticallyImplyLeading: widget.automaticallyImplyLeading,
           title: widget.title,
@@ -1464,6 +1488,7 @@
           shape: widget.shape,
           snapConfiguration: _snapConfiguration,
           stretchConfiguration: _stretchConfiguration,
+          showOnScreenConfiguration: _showOnScreenConfiguration,
           toolbarHeight: widget.toolbarHeight,
           leadingWidth: widget.leadingWidth,
         ),
diff --git a/packages/flutter/lib/src/rendering/sliver_persistent_header.dart b/packages/flutter/lib/src/rendering/sliver_persistent_header.dart
index 54d9348..4913b2a 100644
--- a/packages/flutter/lib/src/rendering/sliver_persistent_header.dart
+++ b/packages/flutter/lib/src/rendering/sliver_persistent_header.dart
@@ -17,6 +17,15 @@
 import 'viewport.dart';
 import 'viewport_offset.dart';
 
+// Trims the specified edges of the given `Rect` [original], so that they do not
+// exceed the given values.
+Rect? _trim(Rect? original, {
+  double top = -double.infinity,
+  double right = double.infinity,
+  double bottom = double.infinity,
+  double left = -double.infinity,
+}) => original?.intersect(Rect.fromLTRB(left, top, right, bottom));
+
 /// Specifies how a stretched header is to trigger an [AsyncCallback].
 ///
 /// See also:
@@ -39,6 +48,60 @@
   final AsyncCallback? onStretchTrigger;
 }
 
+/// {@template flutter.rendering.persistentHeader.showOnScreenConfiguration}
+/// Specifies how a pinned header or a floating header should react to
+/// [RenderObject.showOnScreen] calls.
+/// {@endtemplate}
+@immutable
+class PersistentHeaderShowOnScreenConfiguration {
+  /// Creates an object that specifies how a pinned or floating persistent header
+  /// should behave in response to [RenderObject.showOnScreen] calls.
+  const PersistentHeaderShowOnScreenConfiguration({
+    this.minShowOnScreenExtent = double.negativeInfinity,
+    this.maxShowOnScreenExtent = double.infinity,
+  }) : assert(minShowOnScreenExtent <= maxShowOnScreenExtent);
+
+  /// The smallest the floating header can expand to in the main axis direction,
+  /// in response to a [RenderObject.showOnScreen] call, in addition to its
+  /// [RenderSliverPersistentHeader.minExtent].
+  ///
+  /// When a floating persistent header is told to show a [Rect] on screen, it
+  /// may expand itself to accomodate the [Rect]. The minimum extent that is
+  /// allowed for such expansion is either
+  /// [RenderSliverPersistentHeader.minExtent] or [minShowOnScreenExtent],
+  /// whichever is larger. If the persistent header's current extent is already
+  /// larger than that maximum extent, it will remain unchanged.
+  ///
+  /// This parameter can be set to the persistent header's `maxExtent` (or
+  /// `double.infinity`) so the persistent header will always try to expand when
+  /// [RenderObject.showOnScreen] is called on it.
+  ///
+  /// Defaults to [double.negativeInfinity], must be less than or equal to
+  /// [maxShowOnScreenExtent]. Has no effect unless the persistent header is a
+  /// floating header.
+  final double minShowOnScreenExtent;
+
+  /// The biggest the floating header can expand to in the main axis direction,
+  /// in response to a [RenderObject.showOnScreen] call, in addition to its
+  /// [RenderSliverPersistentHeader.maxExtent].
+  ///
+  /// When a floating persistent header is told to show a [Rect] on screen, it
+  /// may expand itself to accomodate the [Rect]. The maximum extent that is
+  /// allowed for such expansion is either
+  /// [RenderSliverPersistentHeader.maxExtent] or [maxShowOnScreenExtent],
+  /// whichever is smaller. If the persistent header's current extent is already
+  /// larger than that maximum extent, it will remain unchanged.
+  ///
+  /// This parameter can be set to the persistent header's `minExtent` (or
+  /// `double.negativeInfinity`) so the persistent header will never try to
+  /// expand when [RenderObject.showOnScreen] is called on it.
+  ///
+  /// Defaults to [double.infinity], must be greater than or equal to
+  /// [minShowOnScreenExtent]. Has no effect unless the persistent header is a
+  /// floating header.
+  final double maxShowOnScreenExtent;
+}
+
 /// A base class for slivers that have a [RenderBox] child which scrolls
 /// normally, except that when it hits the leading edge (typically the top) of
 /// the viewport, it shrinks to a minimum size ([minExtent]).
@@ -347,11 +410,18 @@
   RenderSliverPinnedPersistentHeader({
     RenderBox? child,
     OverScrollHeaderStretchConfiguration? stretchConfiguration,
+    this.showOnScreenConfiguration = const PersistentHeaderShowOnScreenConfiguration(),
   }) : super(
     child: child,
     stretchConfiguration: stretchConfiguration,
   );
 
+  /// Specifies the persistent header's behavior when `showOnScreen` is called.
+  ///
+  /// If set to null, the persistent header will delegate the `showOnScreen` call
+  /// to it's parent [RenderObject].
+  PersistentHeaderShowOnScreenConfiguration? showOnScreenConfiguration;
+
   @override
   void performLayout() {
     final SliverConstraints constraints = this.constraints;
@@ -377,6 +447,41 @@
 
   @override
   double childMainAxisPosition(RenderBox child) => 0.0;
+
+  @override
+  void showOnScreen({
+    RenderObject? descendant,
+    Rect? rect,
+    Duration duration = Duration.zero,
+    Curve curve = Curves.ease,
+  }) {
+    final Rect? localBounds = descendant != null
+      ? MatrixUtils.transformRect(descendant.getTransformTo(this), rect ?? descendant.paintBounds)
+      : rect;
+
+    Rect? newRect;
+    switch (applyGrowthDirectionToAxisDirection(constraints.axisDirection, constraints.growthDirection)) {
+      case AxisDirection.up:
+        newRect = _trim(localBounds, bottom: childExtent);
+        break;
+      case AxisDirection.right:
+        newRect = _trim(localBounds, left: 0);
+        break;
+      case AxisDirection.down:
+        newRect = _trim(localBounds, top: 0);
+        break;
+      case AxisDirection.left:
+        newRect = _trim(localBounds, right: childExtent);
+        break;
+    }
+
+    super.showOnScreen(
+      descendant: this,
+      rect: newRect,
+      duration: duration,
+      curve: curve,
+    );
+  }
 }
 
 /// Specifies how a floating header is to be "snapped" (animated) into or out
@@ -393,16 +498,23 @@
   /// Creates an object that specifies how a floating header is to be "snapped"
   /// (animated) into or out of view.
   FloatingHeaderSnapConfiguration({
-    required this.vsync,
+    @Deprecated(
+      'Specify SliverPersistentHeaderDelegate.vsync instead. '
+      'This feature was deprecated after v1.19.0.'
+    )
+    this.vsync,
     this.curve = Curves.ease,
     this.duration = const Duration(milliseconds: 300),
-  }) : assert(vsync != null),
-       assert(curve != null),
+  }) : assert(curve != null),
        assert(duration != null);
 
-  /// The [TickerProvider] for the [AnimationController] that causes a
-  /// floating header to snap in or out of view.
-  final TickerProvider vsync;
+  /// The [TickerProvider] for the [AnimationController] that causes a floating
+  /// header to snap in or out of view.
+  @Deprecated(
+    'Specify SliverPersistentHeaderDelegate.vsync instead. '
+    'This feature was deprecated after v1.19.0.'
+  )
+  final TickerProvider? vsync;
 
   /// The snap animation curve.
   final Curve curve;
@@ -425,13 +537,15 @@
   /// direction.
   RenderSliverFloatingPersistentHeader({
     RenderBox? child,
-    FloatingHeaderSnapConfiguration? snapConfiguration,
+    TickerProvider? vsync,
+    this.snapConfiguration,
     OverScrollHeaderStretchConfiguration? stretchConfiguration,
-  }) : _snapConfiguration = snapConfiguration,
+    required this.showOnScreenConfiguration,
+  }) : _vsync = vsync,
        super(
-      child: child,
-      stretchConfiguration: stretchConfiguration,
-    );
+    child: child,
+    stretchConfiguration: stretchConfiguration,
+  );
 
   AnimationController? _controller;
   late Animation<double> _animation;
@@ -449,6 +563,22 @@
     super.detach();
   }
 
+
+  /// A [TickerProvider] to use when animating the scroll position.
+  TickerProvider? get vsync => _vsync;
+  TickerProvider? _vsync;
+  set vsync(TickerProvider? value) {
+    if (value == _vsync)
+      return;
+    _vsync = value;
+    if (value == null) {
+      _controller?.dispose();
+      _controller = null;
+    } else {
+      _controller?.resync(value);
+    }
+  }
+
   /// Defines the parameters used to snap (animate) the floating header in and
   /// out of view.
   ///
@@ -461,20 +591,13 @@
   ///    start or stop the floating header's animation.
   ///  * [SliverAppBar], which creates a header that can be pinned, floating,
   ///    and snapped into view via the corresponding parameters.
-  FloatingHeaderSnapConfiguration? get snapConfiguration => _snapConfiguration;
-  FloatingHeaderSnapConfiguration? _snapConfiguration;
-  set snapConfiguration(FloatingHeaderSnapConfiguration? value) {
-    if (value == _snapConfiguration)
-      return;
-    if (value == null) {
-      _controller?.dispose();
-      _controller = null;
-    } else {
-      if (_snapConfiguration != null && value.vsync != _snapConfiguration!.vsync)
-        _controller?.resync(value.vsync);
-    }
-    _snapConfiguration = value;
-  }
+  FloatingHeaderSnapConfiguration? snapConfiguration;
+
+  /// {@macro flutter.rendering.persistentHeader.showOnScreenConfiguration}
+  ///
+  /// If set to null, the persistent header will delegate the `showOnScreen` call
+  /// to it's parent [RenderObject].
+  PersistentHeaderShowOnScreenConfiguration? showOnScreenConfiguration;
 
   /// Updates [geometry], and returns the new value for [childMainAxisPosition].
   ///
@@ -499,38 +622,52 @@
     return stretchOffset > 0 ? 0.0 : math.min(0.0, paintExtent - childExtent);
   }
 
+  void _updateAnimation(Duration duration, double endValue, Curve curve) {
+    assert(duration != null);
+    assert(endValue != null);
+    assert(curve != null);
+    assert(
+      vsync != null,
+      'vsync must not be null if the floating header changes size animatedly.',
+    );
+
+    final AnimationController effectiveController =
+      _controller ??= AnimationController(vsync: vsync!, duration: duration)
+                        ..addListener(() {
+      if (_effectiveScrollOffset == _animation.value)
+        return;
+      _effectiveScrollOffset = _animation.value;
+      markNeedsLayout();
+    });
+
+    _animation = effectiveController.drive(
+      Tween<double>(
+        begin: _effectiveScrollOffset,
+        end: endValue,
+      ).chain(CurveTween(curve: curve)),
+    );
+  }
+
   /// If the header isn't already fully exposed, then scroll it into view.
   void maybeStartSnapAnimation(ScrollDirection direction) {
-    if (snapConfiguration == null)
+    final FloatingHeaderSnapConfiguration? snap = snapConfiguration;
+    if (snap == null)
       return;
     if (direction == ScrollDirection.forward && _effectiveScrollOffset! <= 0.0)
       return;
     if (direction == ScrollDirection.reverse && _effectiveScrollOffset! >= maxExtent)
       return;
 
-    final TickerProvider vsync = snapConfiguration!.vsync;
-    final Duration duration = snapConfiguration!.duration;
-    _controller ??= AnimationController(vsync: vsync, duration: duration)
-      ..addListener(() {
-        if (_effectiveScrollOffset == _animation.value)
-          return;
-        _effectiveScrollOffset = _animation.value;
-        markNeedsLayout();
-      });
-
-    _animation = _controller!.drive(
-      Tween<double>(
-        begin: _effectiveScrollOffset,
-        end: direction == ScrollDirection.forward ? 0.0 : maxExtent,
-      ).chain(CurveTween(
-        curve: snapConfiguration!.curve,
-      )),
+    _updateAnimation(
+      snap.duration,
+      direction == ScrollDirection.forward ? 0.0 : maxExtent,
+      snap.curve,
     );
-
-    _controller!.forward(from: 0.0);
+    _controller?.forward(from: 0.0);
   }
 
-  /// If a header snap animation is underway then stop it.
+  /// If a header snap animation or a [showOnScreen] expand animation is underway
+  /// then stop it.
   void maybeStopSnapAnimation(ScrollDirection direction) {
     _controller?.stop();
   }
@@ -568,6 +705,79 @@
   }
 
   @override
+  void showOnScreen({
+    RenderObject? descendant,
+    Rect? rect,
+    Duration duration = Duration.zero,
+    Curve curve = Curves.ease,
+  }) {
+    final PersistentHeaderShowOnScreenConfiguration? showOnScreen = showOnScreenConfiguration;
+    if (showOnScreen == null)
+      return super.showOnScreen(descendant: descendant, rect: rect, duration: duration, curve: curve);
+
+    assert(child != null || descendant == null);
+    // We prefer the child's coordinate space (instead of the sliver's) because
+    // it's easier for us to convert the target rect into target extents: when
+    // the sliver is sitting above the leading edge (not possible with pinned
+    // headers), the leading edge of the sliver and the leading edge of the child
+    // will not be aligned. The only exception is when child is null (and thus
+    // descendant == null).
+    final Rect? childBounds = descendant != null
+      ? MatrixUtils.transformRect(descendant.getTransformTo(child), rect ?? descendant.paintBounds)
+      : rect;
+
+    double targetExtent;
+    Rect? targetRect;
+    switch (applyGrowthDirectionToAxisDirection(constraints.axisDirection, constraints.growthDirection)) {
+      case AxisDirection.up:
+        targetExtent = childExtent - (childBounds?.top ?? 0);
+        targetRect = _trim(childBounds, bottom: childExtent);
+        break;
+      case AxisDirection.right:
+        targetExtent = childBounds?.right ?? childExtent;
+        targetRect = _trim(childBounds, left: 0);
+        break;
+      case AxisDirection.down:
+        targetExtent = childBounds?.bottom ?? childExtent;
+        targetRect = _trim(childBounds, top: 0);
+        break;
+      case AxisDirection.left:
+        targetExtent = childExtent - (childBounds?.left ?? 0);
+        targetRect = _trim(childBounds, right: childExtent);
+        break;
+    }
+
+    // A stretch header can have a bigger childExtent than maxExtent.
+    final double effectiveMaxExtent = math.max(childExtent, maxExtent);
+
+    targetExtent = targetExtent.clamp(
+        showOnScreen.minShowOnScreenExtent,
+        showOnScreen.maxShowOnScreenExtent,
+      )
+      // Clamp the value back to the valid range after applying additional
+      // constriants. Contracting is not allowed.
+      .clamp(childExtent, effectiveMaxExtent);
+
+    // Expands the header if needed, with animation.
+    if (targetExtent > childExtent) {
+      final double targetScrollOffset = maxExtent - targetExtent;
+      assert(
+        vsync != null,
+        'vsync must not be null if the floating header changes size animatedly.',
+      );
+      _updateAnimation(duration, targetScrollOffset, curve);
+      _controller?.forward(from: 0.0);
+    }
+
+    super.showOnScreen(
+      descendant: descendant == null ? this : child,
+      rect: targetRect,
+      duration: duration,
+      curve: curve,
+    );
+  }
+
+  @override
   double childMainAxisPosition(RenderBox child) {
     assert(child == this.child);
     return _childPosition ?? 0.0;
@@ -594,12 +804,16 @@
   /// scroll direction.
   RenderSliverFloatingPinnedPersistentHeader({
     RenderBox? child,
+    TickerProvider? vsync,
     FloatingHeaderSnapConfiguration? snapConfiguration,
     OverScrollHeaderStretchConfiguration? stretchConfiguration,
+    PersistentHeaderShowOnScreenConfiguration? showOnScreenConfiguration,
   }) : super(
     child: child,
+    vsync: vsync,
     snapConfiguration: snapConfiguration,
     stretchConfiguration: stretchConfiguration,
+    showOnScreenConfiguration: showOnScreenConfiguration,
   );
 
   @override
diff --git a/packages/flutter/lib/src/rendering/viewport.dart b/packages/flutter/lib/src/rendering/viewport.dart
index 4497ddc..f47d40b 100644
--- a/packages/flutter/lib/src/rendering/viewport.dart
+++ b/packages/flutter/lib/src/rendering/viewport.dart
@@ -816,7 +816,7 @@
     final RenderSliver sliver = child as RenderSliver;
 
     double targetMainAxisExtent;
-    // The scroll offset within `child` to `rect`.
+    // The scroll offset of `rect` within `child`.
     switch (applyGrowthDirectionToAxisDirection(axisDirection, growthDirection)) {
       case AxisDirection.up:
         leadingScrollOffset += pivotExtent - rectLocal.bottom;
@@ -836,6 +836,14 @@
         break;
     }
 
+    // So far leadingScrollOffset is the scroll offset of `rect` in the `child`
+    // sliver's sliver coordinate system. The sign of this value indicates
+    // whether the `rect` protrudes the leading edge of the `child` sliver. When
+    // this value is non-negative and `child`'s `maxScrollObstructionExtent` is
+    // greater than 0, we assume `rect` can't be obstructed by the leading edge
+    // of the viewport (i.e. its pinned to the leading edge).
+    final bool isPinned = sliver.geometry!.maxScrollObstructionExtent > 0 && leadingScrollOffset >= 0;
+
     // The scroll offset in the viewport to `rect`.
     leadingScrollOffset = scrollOffsetOf(sliver, leadingScrollOffset);
 
@@ -845,11 +853,16 @@
     final Matrix4 transform = target.getTransformTo(this);
     Rect targetRect = MatrixUtils.transformRect(transform, rect);
     final double extentOfPinnedSlivers = maxScrollObstructionExtentBefore(sliver);
+
     switch (sliver.constraints.growthDirection) {
       case GrowthDirection.forward:
+        if (isPinned && alignment <= 0)
+          return RevealedOffset(offset: double.infinity, rect: targetRect);
         leadingScrollOffset -= extentOfPinnedSlivers;
         break;
       case GrowthDirection.reverse:
+        if (isPinned && alignment >= 1)
+          return RevealedOffset(offset: double.negativeInfinity, rect: targetRect);
         // If child's growth direction is reverse, when viewport.offset is
         // `leadingScrollOffset`, it is positioned just outside of the leading
         // edge of the viewport.
diff --git a/packages/flutter/lib/src/widgets/sliver_persistent_header.dart b/packages/flutter/lib/src/widgets/sliver_persistent_header.dart
index 673e1cb..4f70ba5 100644
--- a/packages/flutter/lib/src/widgets/sliver_persistent_header.dart
+++ b/packages/flutter/lib/src/widgets/sliver_persistent_header.dart
@@ -6,6 +6,7 @@
 
 import 'package:flutter/foundation.dart';
 import 'package:flutter/rendering.dart';
+import 'package:flutter/scheduler.dart' show TickerProvider;
 
 import 'framework.dart';
 
@@ -59,6 +60,12 @@
   /// different value.
   double get maxExtent;
 
+  /// A [TickerProvider] to use when animating the header's size changes.
+  ///
+  /// Must not be null if the persistent header is a floating header, and
+  /// [snapConfiguration] or [showOnScreenConfiguration] is not null.
+  TickerProvider get vsync => null;
+
   /// Specifies how floating headers should animate in and out of view.
   ///
   /// If the value of this property is null, then floating headers will
@@ -81,6 +88,12 @@
   /// Defaults to null.
   OverScrollHeaderStretchConfiguration get stretchConfiguration => null;
 
+  /// Specifies how floating headers and pinned pinned headers should behave in
+  /// response to [RenderObject.showOnScreen] calls.
+  ///
+  /// Defaults to null.
+  PersistentHeaderShowOnScreenConfiguration get showOnScreenConfiguration => null;
+
   /// Whether this delegate is meaningfully different from the old delegate.
   ///
   /// If this returns false, then the header might not be rebuilt, even though
@@ -346,7 +359,8 @@
   @override
   _RenderSliverPersistentHeaderForWidgetsMixin createRenderObject(BuildContext context) {
     return _RenderSliverPinnedPersistentHeaderForWidgets(
-      stretchConfiguration: delegate.stretchConfiguration
+      stretchConfiguration: delegate.stretchConfiguration,
+      showOnScreenConfiguration: delegate.showOnScreenConfiguration,
     );
   }
 }
@@ -356,9 +370,11 @@
   _RenderSliverPinnedPersistentHeaderForWidgets({
     RenderBox child,
     OverScrollHeaderStretchConfiguration stretchConfiguration,
+    PersistentHeaderShowOnScreenConfiguration showOnScreenConfiguration,
   }) : super(
     child: child,
     stretchConfiguration: stretchConfiguration,
+    showOnScreenConfiguration: showOnScreenConfiguration,
   );
 }
 
@@ -374,15 +390,19 @@
   @override
   _RenderSliverPersistentHeaderForWidgetsMixin createRenderObject(BuildContext context) {
     return _RenderSliverFloatingPersistentHeaderForWidgets(
+      vsync: delegate.vsync,
       snapConfiguration: delegate.snapConfiguration,
       stretchConfiguration: delegate.stretchConfiguration,
+      showOnScreenConfiguration: delegate.showOnScreenConfiguration,
     );
   }
 
   @override
   void updateRenderObject(BuildContext context, _RenderSliverFloatingPersistentHeaderForWidgets renderObject) {
+    renderObject.vsync = delegate.vsync;
     renderObject.snapConfiguration = delegate.snapConfiguration;
     renderObject.stretchConfiguration = delegate.stretchConfiguration;
+    renderObject.showOnScreenConfiguration = delegate.showOnScreenConfiguration;
   }
 }
 
@@ -390,12 +410,16 @@
   with _RenderSliverPersistentHeaderForWidgetsMixin {
   _RenderSliverFloatingPinnedPersistentHeaderForWidgets({
     RenderBox child,
+    @required TickerProvider vsync,
     FloatingHeaderSnapConfiguration snapConfiguration,
     OverScrollHeaderStretchConfiguration stretchConfiguration,
+    PersistentHeaderShowOnScreenConfiguration showOnScreenConfiguration,
   }) : super(
     child: child,
+    vsync: vsync,
     snapConfiguration: snapConfiguration,
     stretchConfiguration: stretchConfiguration,
+    showOnScreenConfiguration: showOnScreenConfiguration,
   );
 }
 
@@ -411,15 +435,19 @@
   @override
   _RenderSliverPersistentHeaderForWidgetsMixin createRenderObject(BuildContext context) {
     return _RenderSliverFloatingPinnedPersistentHeaderForWidgets(
+      vsync: delegate.vsync,
       snapConfiguration: delegate.snapConfiguration,
       stretchConfiguration: delegate.stretchConfiguration,
+      showOnScreenConfiguration: delegate.showOnScreenConfiguration,
     );
   }
 
   @override
   void updateRenderObject(BuildContext context, _RenderSliverFloatingPinnedPersistentHeaderForWidgets renderObject) {
+    renderObject.vsync = delegate.vsync;
     renderObject.snapConfiguration = delegate.snapConfiguration;
     renderObject.stretchConfiguration = delegate.stretchConfiguration;
+    renderObject.showOnScreenConfiguration = delegate.showOnScreenConfiguration;
   }
 }
 
@@ -427,11 +455,15 @@
   with _RenderSliverPersistentHeaderForWidgetsMixin {
   _RenderSliverFloatingPersistentHeaderForWidgets({
     RenderBox child,
+    @required TickerProvider vsync,
     FloatingHeaderSnapConfiguration snapConfiguration,
     OverScrollHeaderStretchConfiguration stretchConfiguration,
+    PersistentHeaderShowOnScreenConfiguration showOnScreenConfiguration,
   }) : super(
     child: child,
+    vsync: vsync,
     snapConfiguration: snapConfiguration,
     stretchConfiguration: stretchConfiguration,
+    showOnScreenConfiguration: showOnScreenConfiguration,
   );
 }
diff --git a/packages/flutter/test/material/app_bar_test.dart b/packages/flutter/test/material/app_bar_test.dart
index 93938a4..1f8e4cc 100644
--- a/packages/flutter/test/material/app_bar_test.dart
+++ b/packages/flutter/test/material/app_bar_test.dart
@@ -1975,6 +1975,41 @@
     expect(tester.getCenter(appBarTitle).dy, tester.getCenter(toolbar).dy);
   });
 
+  testWidgets('SliverAppBar configures the delegate properly', (WidgetTester tester) async {
+    Future<void> buildAndVerifyDelegate({ bool pinned, bool floating, bool snap }) async {
+      await tester.pumpWidget(
+        MaterialApp(
+          home: CustomScrollView(
+            slivers: <Widget>[
+              SliverAppBar(
+                title: const Text('Jumbo'),
+                pinned: pinned,
+                floating: floating,
+                snap: snap,
+              ),
+            ],
+          ),
+        ),
+      );
+
+      final SliverPersistentHeaderDelegate delegate = tester
+        .widget<SliverPersistentHeader>(find.byType(SliverPersistentHeader))
+        .delegate;
+
+      // Ensure we have a non-null vsync when it's needed.
+      if (!floating || (delegate.snapConfiguration == null && delegate.showOnScreenConfiguration == null))
+        expect(delegate.vsync, isNotNull);
+
+      expect(delegate.showOnScreenConfiguration != null, snap && floating);
+    }
+
+    await buildAndVerifyDelegate(pinned: false, floating: true, snap: false);
+    await buildAndVerifyDelegate(pinned: false, floating: true, snap: true);
+
+    await buildAndVerifyDelegate(pinned: true, floating: true, snap: false);
+    await buildAndVerifyDelegate(pinned: true, floating: true, snap: true);
+  });
+
   testWidgets('AppBar respects toolbarHeight', (WidgetTester tester) async {
     await tester.pumpWidget(
       MaterialApp(
diff --git a/packages/flutter/test/rendering/sliver_persistent_header_test.dart b/packages/flutter/test/rendering/sliver_persistent_header_test.dart
index ab18603..bafe3b0 100644
--- a/packages/flutter/test/rendering/sliver_persistent_header_test.dart
+++ b/packages/flutter/test/rendering/sliver_persistent_header_test.dart
@@ -49,7 +49,7 @@
 class TestRenderSliverFloatingPersistentHeader extends RenderSliverFloatingPersistentHeader {
   TestRenderSliverFloatingPersistentHeader({
     RenderBox child,
-  }) : super(child: child);
+  }) : super(child: child, vsync: null, showOnScreenConfiguration: null);
 
   @override
   double get maxExtent => 200;
@@ -61,7 +61,7 @@
 class TestRenderSliverFloatingPinnedPersistentHeader extends RenderSliverFloatingPinnedPersistentHeader {
   TestRenderSliverFloatingPinnedPersistentHeader({
     RenderBox child,
-  }) : super(child: child);
+  }) : super(child: child, vsync: null, showOnScreenConfiguration: null);
 
   @override
   double get maxExtent => 200;
diff --git a/packages/flutter/test/rendering/viewport_test.dart b/packages/flutter/test/rendering/viewport_test.dart
index f4c65a6..eed1589 100644
--- a/packages/flutter/test/rendering/viewport_test.dart
+++ b/packages/flutter/test/rendering/viewport_test.dart
@@ -16,6 +16,38 @@
 import 'package:flutter/rendering.dart';
 import 'package:flutter/widgets.dart';
 
+class _TestSliverPersistentHeaderDelegate extends SliverPersistentHeaderDelegate {
+  _TestSliverPersistentHeaderDelegate({
+    this.key,
+    this.minExtent,
+    this.maxExtent,
+    this.child,
+    this.vsync = const TestVSync(),
+    this.showOnScreenConfiguration = const PersistentHeaderShowOnScreenConfiguration(),
+  });
+
+  final Key key;
+  final Widget child;
+
+  @override
+  final double maxExtent;
+
+  @override
+  final double minExtent;
+
+  @override
+  final TickerProvider vsync;
+
+  @override
+  final PersistentHeaderShowOnScreenConfiguration showOnScreenConfiguration;
+
+  @override
+  Widget build(BuildContext context, double shrinkOffset, bool overlapsContent) => child ?? SizedBox.expand(key: key);
+
+  @override
+  bool shouldRebuild(_TestSliverPersistentHeaderDelegate oldDelegate) => true;
+}
+
 void main() {
   testWidgets('Viewport getOffsetToReveal - down', (WidgetTester tester) async {
     List<Widget> children;
@@ -1027,6 +1059,488 @@
     expect(controller.offset, 300.0);
   });
 
+  testWidgets(
+    'Viewport showOnScreen should not scroll if the rect is already visible, even if it does not scroll linearly',
+    (WidgetTester tester) async {
+      List<Widget> children;
+      ScrollController controller;
+
+      const Key headerKey = Key('header');
+      await tester.pumpWidget(
+        Directionality(
+          textDirection: TextDirection.ltr,
+          child: Center(
+            child: Container(
+              height: 600.0,
+              child: CustomScrollView(
+                controller: controller = ScrollController(initialScrollOffset: 300.0),
+                slivers: children = List<Widget>.generate(20, (int i) {
+                  return i == 10
+                  ? SliverPersistentHeader(
+                    pinned: true,
+                    floating: false,
+                    delegate: _TestSliverPersistentHeaderDelegate(
+                      minExtent: 100,
+                      maxExtent: 300,
+                      key: headerKey,
+                    ),
+                  )
+                  : SliverToBoxAdapter(
+                    child: Container(
+                      height: 300.0,
+                      child: Text('Tile $i'),
+                    ),
+                  );
+                }),
+              ),
+            ),
+          ),
+        ),
+      );
+
+      controller.jumpTo(300.0 * 15);
+      await tester.pumpAndSettle();
+
+      final Finder pinnedHeaderContent = find.descendant(
+        of: find.byWidget(children[10]),
+        matching: find.byKey(headerKey),
+      );
+
+      // The persistent header is pinned to the leading edge thus still visible,
+      // the viewport should not scroll.
+      tester.renderObject(pinnedHeaderContent).showOnScreen();
+      await tester.pumpAndSettle();
+      expect(controller.offset, 300.0 * 15);
+
+      // The 11th child will be partially obstructed by the persistent header,
+      // the viewport should scroll to reveal it.
+      controller.jumpTo(
+        11 * 300.0  // Preceding headers
+        + 200.0     // Shrinks the pinned header to minExtent
+        + 100.0     // Obstructs the leading 100 pixels of the 11th header
+      );
+      await tester.pumpAndSettle();
+
+      tester.renderObject(find.byWidget(children[11], skipOffstage: false)).showOnScreen();
+      await tester.pumpAndSettle();
+      expect(controller.offset, lessThan(11 * 300.0 + 200.0 + 100.0));
+  });
+
+  void testFloatingHeaderShowOnScreen({ bool animated = true, Axis axis = Axis.vertical }) {
+    final TickerProvider vsync = animated ? const TestVSync() : null;
+    const Key headerKey = Key('header');
+    List<Widget> children;
+    ScrollController controller;
+
+    Widget buildList({ SliverPersistentHeader floatingHeader, bool reversed = false }) {
+      return Directionality(
+        textDirection: TextDirection.ltr,
+        child: Center(
+          child: Container(
+            height: 400.0,
+            width: 400.0,
+            child: CustomScrollView(
+              scrollDirection: axis,
+              center: reversed ? const Key('19') : null,
+              controller: controller = ScrollController(initialScrollOffset: 300.0),
+              slivers: children = List<Widget>.generate(20, (int i) {
+                  return i == 10
+                  ? floatingHeader
+                  : SliverToBoxAdapter(
+                    key: (i == 19) ? const Key('19') : null,
+                    child: Container(
+                      height: 300.0,
+                      width: 300,
+                      child: Text('Tile $i'),
+                    ),
+                  );
+              }),
+            ),
+          ),
+        ),
+      );
+    }
+
+    double mainAxisExtent(WidgetTester tester, Finder finder) {
+      final RenderObject renderObject = tester.renderObject(finder);
+      if (renderObject is RenderSliver) {
+        return renderObject.geometry.paintExtent;
+      }
+
+      final RenderBox renderBox = renderObject as RenderBox;
+      switch (axis) {
+        case Axis.horizontal:
+          return renderBox.size.width;
+        case Axis.vertical:
+          return renderBox.size.height;
+      }
+      assert(false);
+      return null;
+    }
+
+    group('animated: $animated, scrollDirection: $axis', () {
+      testWidgets(
+        'RenderViewportBase.showOnScreen',
+        (WidgetTester tester) async {
+          await tester.pumpWidget(
+            buildList(
+              floatingHeader: SliverPersistentHeader(
+                pinned: true,
+                floating: true,
+                delegate: _TestSliverPersistentHeaderDelegate(minExtent: 100, maxExtent: 300, key: headerKey, vsync: vsync),
+              ),
+            )
+          );
+
+          final Finder pinnedHeaderContent = find.byKey(headerKey, skipOffstage: false);
+
+          controller.jumpTo(300.0 * 15);
+          await tester.pumpAndSettle();
+          expect(mainAxisExtent(tester, pinnedHeaderContent), lessThan(300));
+
+          // The persistent header is pinned to the leading edge thus still visible,
+          // the viewport should not scroll.
+          tester.renderObject(pinnedHeaderContent).showOnScreen(
+            descendant: tester.renderObject(pinnedHeaderContent),
+            rect: Offset.zero & const Size(300, 300),
+          );
+          await tester.pumpAndSettle();
+          // The header expands but doesn't move.
+          expect(controller.offset, 300.0 * 15);
+          expect(mainAxisExtent(tester, pinnedHeaderContent), 300);
+
+          // The rect specifies that the persistent header needs to be 1 pixel away
+          // from the leading edge of the viewport. Ignore the 1 pixel, the viewport
+          // should not scroll.
+          //
+          // See: https://github.com/flutter/flutter/issues/25507.
+          tester.renderObject(pinnedHeaderContent).showOnScreen(
+            descendant: tester.renderObject(pinnedHeaderContent),
+            rect: const Offset(-1, -1) & const Size(300, 300),
+          );
+          await tester.pumpAndSettle();
+          expect(controller.offset, 300.0 * 15);
+          expect(mainAxisExtent(tester, pinnedHeaderContent), 300);
+      });
+
+      testWidgets(
+        'RenderViewportBase.showOnScreen but no child',
+        (WidgetTester tester) async {
+          await tester.pumpWidget(
+            buildList(
+              floatingHeader: SliverPersistentHeader(
+                key: headerKey,
+                pinned: true,
+                floating: true,
+                delegate: _TestSliverPersistentHeaderDelegate(minExtent: 100, maxExtent: 300, child: null, vsync: vsync),
+              ),
+            )
+          );
+
+          final Finder pinnedHeaderContent = find.byKey(headerKey, skipOffstage: false);
+
+          controller.jumpTo(300.0 * 15);
+          await tester.pumpAndSettle();
+          expect(mainAxisExtent(tester, pinnedHeaderContent), lessThan(300));
+
+          // The persistent header is pinned to the leading edge thus still visible,
+          // the viewport should not scroll.
+          tester.renderObject(pinnedHeaderContent).showOnScreen(
+            rect: Offset.zero & const Size(300, 300),
+          );
+          await tester.pumpAndSettle();
+          // The header expands but doesn't move.
+          expect(controller.offset, 300.0 * 15);
+          expect(mainAxisExtent(tester, pinnedHeaderContent), 300);
+
+          // The rect specifies that the persistent header needs to be 1 pixel away
+          // from the leading edge of the viewport. Ignore the 1 pixel, the viewport
+          // should not scroll.
+          //
+          // See: https://github.com/flutter/flutter/issues/25507.
+          tester.renderObject(pinnedHeaderContent).showOnScreen(
+            rect: const Offset(-1, -1) & const Size(300, 300),
+          );
+          await tester.pumpAndSettle();
+          expect(controller.offset, 300.0 * 15);
+          expect(mainAxisExtent(tester, pinnedHeaderContent), 300);
+      });
+
+      testWidgets(
+        'RenderViewportBase.showOnScreen with maxShowOnScreenExtent ',
+        (WidgetTester tester) async {
+          await tester.pumpWidget(
+            buildList(
+              floatingHeader: SliverPersistentHeader(
+                pinned: true,
+                floating: true,
+                delegate: _TestSliverPersistentHeaderDelegate(
+                  minExtent: 100,
+                  maxExtent: 300,
+                  key: headerKey,
+                  vsync: vsync,
+                  showOnScreenConfiguration: const PersistentHeaderShowOnScreenConfiguration(maxShowOnScreenExtent: 200),
+                ),
+              ),
+            )
+          );
+
+          final Finder pinnedHeaderContent = find.byKey(headerKey, skipOffstage: false);
+
+          controller.jumpTo(300.0 * 15);
+          await tester.pumpAndSettle();
+          // childExtent was initially 100.
+          expect(mainAxisExtent(tester, pinnedHeaderContent), 100);
+
+          tester.renderObject(pinnedHeaderContent).showOnScreen(
+            descendant: tester.renderObject(pinnedHeaderContent),
+            rect: Offset.zero & const Size(300, 300),
+          );
+          await tester.pumpAndSettle();
+          // The header doesn't move. It would have expanded to 300 but
+          // maxShowOnScreenExtent is 200, preventing it from doing so.
+          expect(controller.offset, 300.0 * 15);
+          expect(mainAxisExtent(tester, pinnedHeaderContent), 200);
+
+          // ignoreLeading still works.
+          tester.renderObject(pinnedHeaderContent).showOnScreen(
+            descendant: tester.renderObject(pinnedHeaderContent),
+            rect: const Offset(-1, -1) & const Size(300, 300),
+          );
+          await tester.pumpAndSettle();
+          expect(controller.offset, 300.0 * 15);
+          expect(mainAxisExtent(tester, pinnedHeaderContent), 200);
+
+          // Move the viewport so that its childExtent reaches 250.
+          controller.jumpTo(300.0 * 10 + 50.0);
+          await tester.pumpAndSettle();
+          expect(mainAxisExtent(tester, pinnedHeaderContent), 250);
+
+          // Doesn't move, doesn't expand or shrink, leading still ignored.
+          tester.renderObject(pinnedHeaderContent).showOnScreen(
+            descendant: tester.renderObject(pinnedHeaderContent),
+            rect: const Offset(-1, -1) & const Size(300, 300),
+          );
+          await tester.pumpAndSettle();
+          expect(controller.offset, 300.0 * 10 + 50.0);
+          expect(mainAxisExtent(tester, pinnedHeaderContent), 250);
+      });
+
+      testWidgets(
+        'RenderViewportBase.showOnScreen with minShowOnScreenExtent ',
+        (WidgetTester tester) async {
+          await tester.pumpWidget(
+            buildList(
+              floatingHeader: SliverPersistentHeader(
+                pinned: true,
+                floating: true,
+                delegate: _TestSliverPersistentHeaderDelegate(
+                  minExtent: 100,
+                  maxExtent: 300,
+                  key: headerKey,
+                  vsync: vsync,
+                  showOnScreenConfiguration: const PersistentHeaderShowOnScreenConfiguration(minShowOnScreenExtent: 200),
+                ),
+              ),
+            )
+          );
+
+          final Finder pinnedHeaderContent = find.byKey(headerKey, skipOffstage: false);
+
+          controller.jumpTo(300.0 * 15);
+          await tester.pumpAndSettle();
+          // childExtent was initially 100.
+          expect(mainAxisExtent(tester, pinnedHeaderContent), 100);
+
+          tester.renderObject(pinnedHeaderContent).showOnScreen(
+            descendant: tester.renderObject(pinnedHeaderContent),
+            rect: Offset.zero & const Size(110, 110),
+          );
+          await tester.pumpAndSettle();
+          // The header doesn't move. It would have expanded to 110 but
+          // minShowOnScreenExtent is 200, preventing it from doing so.
+          expect(controller.offset, 300.0 * 15);
+          expect(mainAxisExtent(tester, pinnedHeaderContent), 200);
+
+          // ignoreLeading still works.
+          tester.renderObject(pinnedHeaderContent).showOnScreen(
+            descendant: tester.renderObject(pinnedHeaderContent),
+            rect: const Offset(-1, -1) & const Size(110, 110),
+          );
+          await tester.pumpAndSettle();
+          expect(controller.offset, 300.0 * 15);
+          expect(mainAxisExtent(tester, pinnedHeaderContent), 200);
+
+          // Move the viewport so that its childExtent reaches 250.
+          controller.jumpTo(300.0 * 10 + 50.0);
+          await tester.pumpAndSettle();
+          expect(mainAxisExtent(tester, pinnedHeaderContent), 250);
+
+          // Doesn't move, doesn't expand or shrink, leading still ignored.
+          tester.renderObject(pinnedHeaderContent).showOnScreen(
+            descendant: tester.renderObject(pinnedHeaderContent),
+            rect: const Offset(-1, -1) & const Size(110, 110),
+          );
+          await tester.pumpAndSettle();
+          expect(controller.offset, 300.0 * 10 + 50.0);
+          expect(mainAxisExtent(tester, pinnedHeaderContent), 250);
+      });
+
+      testWidgets(
+        'RenderViewportBase.showOnScreen should not scroll if the rect is already visible, '
+        'even if it does not scroll linearly (reversed order version)',
+        (WidgetTester tester) async {
+          await tester.pumpWidget(
+            buildList(
+              floatingHeader: SliverPersistentHeader(
+                pinned: true,
+                floating: true,
+                delegate: _TestSliverPersistentHeaderDelegate(minExtent: 100, maxExtent: 300, key: headerKey, vsync: vsync),
+              ),
+              reversed: true,
+            )
+          );
+
+          controller.jumpTo(-300.0 * 15);
+          await tester.pumpAndSettle();
+
+          final Finder pinnedHeaderContent = find.byKey(headerKey, skipOffstage: false);
+
+          // The persistent header is pinned to the leading edge thus still visible,
+          // the viewport should not scroll.
+          tester.renderObject(pinnedHeaderContent).showOnScreen();
+          await tester.pumpAndSettle();
+          expect(controller.offset, -300.0 * 15);
+
+          // children[9] will be partially obstructed by the persistent header,
+          // the viewport should scroll to reveal it.
+          controller.jumpTo(
+            - 8 * 300.0 // Preceding headers 11 - 18, children[11]'s top edge is aligned to the leading edge.
+            - 400.0     // Viewport height. children[10] (the pinned header) becomes pinned at the bottom of the screen.
+            - 200.0     // Shrinks the pinned header to minExtent (100).
+            - 100.0     // Obstructs the leading 100 pixels of the 11th header
+          );
+          await tester.pumpAndSettle();
+
+          tester.renderObject(find.byWidget(children[9], skipOffstage: false)).showOnScreen();
+          await tester.pumpAndSettle();
+          expect(controller.offset, -8 * 300.0 - 400.0 - 200.0);
+      });
+    });
+  }
+
+  group('Floating header showOnScreen', () {
+    testFloatingHeaderShowOnScreen(animated: true, axis: Axis.vertical);
+    testFloatingHeaderShowOnScreen(animated: true, axis: Axis.horizontal);
+  });
+
+  group('RenderViewport getOffsetToReveal renderBox to sliver coordinates conversion', () {
+    const EdgeInsets padding = EdgeInsets.fromLTRB(22, 22, 34, 34);
+    const Key centerKey = Key('5');
+    Widget buildList({ Axis axis, bool reverse = false, bool reverseGrowth = false }) {
+      return Directionality(
+        textDirection: TextDirection.ltr,
+        child: Center(
+          child: Container(
+            height: 400.0,
+            width: 400.0,
+            child: CustomScrollView(
+              scrollDirection: axis,
+              reverse: reverse,
+              center: reverseGrowth ? centerKey : null,
+              slivers: List<Widget>.generate(6, (int i) {
+                return SliverPadding(
+                  key: i == 5 ? centerKey : null,
+                  padding: padding,
+                  sliver: SliverToBoxAdapter(
+                    child: Container(
+                      padding: padding,
+                      height: 300.0,
+                      width: 300.0,
+                      child: Text('Tile $i'),
+                    ),
+                  ),
+                );
+              }),
+            ),
+          ),
+        ),
+      );
+    }
+
+    testWidgets('up, forward growth', (WidgetTester tester) async {
+      await tester.pumpWidget(buildList(axis: Axis.vertical, reverse: true, reverseGrowth: false));
+      final RenderAbstractViewport viewport = tester.allRenderObjects.whereType<RenderAbstractViewport>().first;
+
+      final RenderObject target = tester.renderObject(find.text('Tile 5', skipOffstage: false));
+      final double revealOffset = viewport.getOffsetToReveal(target, 0.0).offset;
+      expect(revealOffset, (300.0 + padding.horizontal)  * 5 + 34.0 * 2);
+    });
+
+    testWidgets('up, reverse growth', (WidgetTester tester) async {
+      await tester.pumpWidget(buildList(axis: Axis.vertical, reverse: true, reverseGrowth: true));
+      final RenderAbstractViewport viewport = tester.allRenderObjects.whereType<RenderAbstractViewport>().first;
+
+      final RenderObject target = tester.renderObject(find.text('Tile 0', skipOffstage: false));
+      final double revealOffset = viewport.getOffsetToReveal(target, 0.0).offset;
+      expect(revealOffset, -(300.0 + padding.horizontal)  * 5 + 34.0 * 2);
+    });
+
+    testWidgets('right, forward growth', (WidgetTester tester) async {
+      await tester.pumpWidget(buildList(axis: Axis.horizontal, reverse: false, reverseGrowth: false));
+      final RenderAbstractViewport viewport = tester.allRenderObjects.whereType<RenderAbstractViewport>().first;
+
+      final RenderObject target = tester.renderObject(find.text('Tile 5', skipOffstage: false));
+      final double revealOffset = viewport.getOffsetToReveal(target, 0.0).offset;
+      expect(revealOffset, (300.0 + padding.horizontal)  * 5 + 22.0 * 2);
+    });
+
+    testWidgets('right, reverse growth', (WidgetTester tester) async {
+      await tester.pumpWidget(buildList(axis: Axis.horizontal, reverse: false, reverseGrowth: true));
+      final RenderAbstractViewport viewport = tester.allRenderObjects.whereType<RenderAbstractViewport>().first;
+
+      final RenderObject target = tester.renderObject(find.text('Tile 0', skipOffstage: false));
+      final double revealOffset = viewport.getOffsetToReveal(target, 0.0).offset;
+      expect(revealOffset, -(300.0 + padding.horizontal)  * 5 + 22.0 * 2);
+    });
+
+    testWidgets('down, forward growth', (WidgetTester tester) async {
+      await tester.pumpWidget(buildList(axis: Axis.vertical, reverse: false, reverseGrowth: false));
+      final RenderAbstractViewport viewport = tester.allRenderObjects.whereType<RenderAbstractViewport>().first;
+
+      final RenderObject target = tester.renderObject(find.text('Tile 5', skipOffstage: false));
+      final double revealOffset = viewport.getOffsetToReveal(target, 0.0).offset;
+      expect(revealOffset, (300.0 + padding.horizontal)  * 5 + 22.0 * 2);
+    });
+
+    testWidgets('down, reverse growth', (WidgetTester tester) async {
+      await tester.pumpWidget(buildList(axis: Axis.vertical, reverse: false, reverseGrowth: true));
+      final RenderAbstractViewport viewport = tester.allRenderObjects.whereType<RenderAbstractViewport>().first;
+
+      final RenderObject target = tester.renderObject(find.text('Tile 0', skipOffstage: false));
+      final double revealOffset = viewport.getOffsetToReveal(target, 0.0).offset;
+      expect(revealOffset, -(300.0 + padding.horizontal)  * 5 + 22.0 * 2);
+    });
+
+    testWidgets('left, forward growth', (WidgetTester tester) async {
+      await tester.pumpWidget(buildList(axis: Axis.horizontal, reverse: true, reverseGrowth: false));
+      final RenderAbstractViewport viewport = tester.allRenderObjects.whereType<RenderAbstractViewport>().first;
+
+      final RenderObject target = tester.renderObject(find.text('Tile 5', skipOffstage: false));
+      final double revealOffset = viewport.getOffsetToReveal(target, 0.0).offset;
+      expect(revealOffset, (300.0 + padding.horizontal)  * 5 + 34.0 * 2);
+    });
+
+    testWidgets('left, reverse growth', (WidgetTester tester) async {
+      await tester.pumpWidget(buildList(axis: Axis.horizontal, reverse: true, reverseGrowth: true));
+      final RenderAbstractViewport viewport = tester.allRenderObjects.whereType<RenderAbstractViewport>().first;
+
+      final RenderObject target = tester.renderObject(find.text('Tile 0', skipOffstage: false));
+      final double revealOffset = viewport.getOffsetToReveal(target, 0.0).offset;
+      expect(revealOffset, -(300.0 + padding.horizontal)  * 5 + 34.0 * 2);
+    });
+  });
+
   testWidgets('RenderViewportBase.showOnScreen reports the correct targetRect', (WidgetTester tester) async {
     final ScrollController innerController = ScrollController();
     final ScrollController outerController = ScrollController();
diff --git a/packages/flutter/test/widgets/editable_text_show_on_screen_test.dart b/packages/flutter/test/widgets/editable_text_show_on_screen_test.dart
index 7ef32db..0530c55 100644
--- a/packages/flutter/test/widgets/editable_text_show_on_screen_test.dart
+++ b/packages/flutter/test/widgets/editable_text_show_on_screen_test.dart
@@ -10,6 +10,35 @@
 import 'package:flutter/widgets.dart';
 import 'package:flutter/services.dart';
 
+class _TestSliverPersistentHeaderDelegate extends SliverPersistentHeaderDelegate {
+  _TestSliverPersistentHeaderDelegate({
+    this.minExtent,
+    this.maxExtent,
+    this.child,
+    this.vsync = const TestVSync(),
+    this.showOnScreenConfiguration = const PersistentHeaderShowOnScreenConfiguration(),
+  });
+
+  final Widget child;
+
+  @override
+  final double maxExtent;
+
+  @override
+  final double minExtent;
+
+  @override
+  final TickerProvider vsync;
+
+  @override
+  final PersistentHeaderShowOnScreenConfiguration showOnScreenConfiguration;
+
+  @override
+  Widget build(BuildContext context, double shrinkOffset, bool overlapsContent) => child;
+
+  @override
+  bool shouldRebuild(_TestSliverPersistentHeaderDelegate oldDelegate) => true;
+}
 
 void main() {
   const TextStyle textStyle = TextStyle();
@@ -339,6 +368,131 @@
     expect(scrollController.offset, greaterThan(0.0));
     expect(find.byKey(container), findsNothing);
   });
+
+  testWidgets(
+    'A pinned persistent header should not scroll when its descendant EditableText gains focus',
+    (WidgetTester tester) async {
+      // Regression test for https://github.com/flutter/flutter/issues/25507.
+      ScrollController controller;
+      final TextEditingController textEditingController = TextEditingController();
+      final FocusNode focusNode = FocusNode();
+
+      const Key headerKey = Key('header');
+      await tester.pumpWidget(
+        MaterialApp(
+          home: Center(
+            child: SizedBox(
+              height: 600.0,
+              width: 600.0,
+              child: CustomScrollView(
+                controller: controller = ScrollController(initialScrollOffset: 0),
+                slivers: List<Widget>.generate(50, (int i) {
+                  return i == 10
+                  ? SliverPersistentHeader(
+                    pinned: true,
+                    floating: false,
+                    delegate: _TestSliverPersistentHeaderDelegate(
+                      minExtent: 50,
+                      maxExtent: 50,
+                      child: Container(
+                        alignment: Alignment.topCenter,
+                        child: EditableText(
+                          key: headerKey,
+                          backgroundCursorColor: Colors.grey,
+                          controller: textEditingController,
+                          focusNode: focusNode,
+                          style: textStyle,
+                          cursorColor: cursorColor,
+                        ),
+                      ),
+                    ),
+                  )
+                  : SliverToBoxAdapter(
+                    child: Container(
+                      height: 100.0,
+                      child: Text('Tile $i'),
+                    ),
+                  );
+                }),
+              ),
+            ),
+          ),
+        ),
+      );
+
+      // The persistent header should now be pinned at the top.
+      controller.jumpTo(100.0 * 15);
+      await tester.pumpAndSettle();
+      expect(controller.offset, 100.0 * 15);
+
+      focusNode.requestFocus();
+      await tester.pumpAndSettle();
+      // The scroll offset should remain the same.
+      expect(controller.offset, 100.0 * 15);
+  });
+
+  testWidgets(
+    'A pinned persistent header should not scroll when its descendant EditableText gains focus (no animation)',
+    (WidgetTester tester) async {
+      // Regression test for https://github.com/flutter/flutter/issues/25507.
+      ScrollController controller;
+      final TextEditingController textEditingController = TextEditingController();
+      final FocusNode focusNode = FocusNode();
+
+      const Key headerKey = Key('header');
+      await tester.pumpWidget(
+        MaterialApp(
+          home: Center(
+            child: SizedBox(
+              height: 600.0,
+              width: 600.0,
+              child: CustomScrollView(
+                controller: controller = ScrollController(initialScrollOffset: 0),
+                slivers: List<Widget>.generate(50, (int i) {
+                  return i == 10
+                    ? SliverPersistentHeader(
+                      pinned: true,
+                      floating: false,
+                      delegate: _TestSliverPersistentHeaderDelegate(
+                        minExtent: 50,
+                        maxExtent: 50,
+                        vsync: null,
+                        child: Container(
+                          alignment: Alignment.topCenter,
+                          child: EditableText(
+                            key: headerKey,
+                            backgroundCursorColor: Colors.grey,
+                            controller: textEditingController,
+                            focusNode: focusNode,
+                            style: textStyle,
+                            cursorColor: cursorColor,
+                          ),
+                        ),
+                      ),
+                    )
+                    : SliverToBoxAdapter(
+                      child: Container(
+                        height: 100.0,
+                        child: Text('Tile $i'),
+                      ),
+                    );
+                }),
+              ),
+            ),
+          ),
+        ),
+      );
+
+      // The persistent header should now be pinned at the top.
+      controller.jumpTo(100.0 * 15);
+      await tester.pumpAndSettle();
+      expect(controller.offset, 100.0 * 15);
+
+      focusNode.requestFocus();
+      await tester.pumpAndSettle();
+      // The scroll offset should remain the same.
+      expect(controller.offset, 100.0 * 15);
+  });
 }
 
 class NoImplicitScrollPhysics extends AlwaysScrollableScrollPhysics {