Merge pull request #1710 from abarth/scroll_anchor

Preliminaries for scroll anchoring

packages/flutter/lib/src/material/tabs.dart

@@ -777,7 +777,7 @@ class _TabBarState<T> extends ScrollableState<TabBar<T>> implements TabBarSelect
         onSizeChanged: _handleViewportSizeChanged,
         child: new Viewport(
           scrollDirection: Axis.horizontal,
-          scrollOffset: new Offset(scrollOffset, 0.0),
+          paintOffset: scrollOffsetToPixelDelta(scrollOffset),
           child: contents
         )
       );
@@ -929,12 +929,12 @@ class _TabBarViewState extends PageableListState<TabBarView> implements TabBarSe
       controller.value = scrollOffset / 2.0;
   }
 
-  Future fling(Offset scrollVelocity) {
+  Future fling(double scrollVelocity) {
     if (_selection == null || _selection.valueIsChanging)
       return new Future.value();
 
-    if (scrollVelocity.dx.abs() > _kMinFlingVelocity) {
-      final int selectionDelta = scrollVelocity.dx > 0 ? -1 : 1;
+    if (scrollVelocity.abs() > _kMinFlingVelocity) {
+      final int selectionDelta = scrollVelocity.sign.truncate();
       final int targetIndex = (_selection.index + selectionDelta).clamp(0, _tabCount - 1);
       _selection.value = _selection.values[targetIndex];
       return new Future.value();

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

@@ -314,10 +314,12 @@ class RenderGrid extends RenderVirtualViewport<GridParentData> {
     int virtualChildBase: 0,
     int virtualChildCount,
     Offset paintOffset: Offset.zero,
+    Painter overlayPainter,
     LayoutCallback callback
   }) : _delegate = delegate, _virtualChildBase = virtualChildBase, super(
     virtualChildCount: virtualChildCount,
     paintOffset: paintOffset,
+    overlayPainter: overlayPainter,
     callback: callback
   ) {
     assert(delegate != null);
@@ -338,6 +340,15 @@ class RenderGrid extends RenderVirtualViewport<GridParentData> {
     _delegate = newDelegate;
   }
 
+  void set scrollDirection(Axis value) {
+    assert(() {
+      if (value != Axis.vertical)
+        throw new RenderingError('RenderGrid doesn\'t yet support horizontal scrolling.');
+      return true;
+    });
+    super.scrollDirection = value;
+  }
+
   int get virtualChildCount => super.virtualChildCount ?? childCount;
 
   /// The virtual index of the first child.

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

@@ -11,7 +11,7 @@ import 'viewport.dart';
 /// Parent data for use with [RenderList].
 class ListParentData extends ContainerBoxParentDataMixin<RenderBox> { }
 
-class RenderList extends RenderVirtualViewport<ListParentData> implements HasScrollDirection {
+class RenderList extends RenderVirtualViewport<ListParentData> {
   RenderList({
     List<RenderBox> children,
     double itemExtent,
@@ -19,13 +19,15 @@ class RenderList extends RenderVirtualViewport<ListParentData> implements HasScr
     int virtualChildCount,
     Offset paintOffset: Offset.zero,
     Axis scrollDirection: Axis.vertical,
+    Painter overlayPainter,
     LayoutCallback callback
   }) : _itemExtent = itemExtent,
        _padding = padding,
-       _scrollDirection = scrollDirection,
        super(
          virtualChildCount: virtualChildCount,
          paintOffset: paintOffset,
+         scrollDirection: scrollDirection,
+         overlayPainter: overlayPainter,
          callback: callback
        ) {
     addAll(children);
@@ -50,15 +52,6 @@ class RenderList extends RenderVirtualViewport<ListParentData> implements HasScr
     markNeedsLayout();
   }
 
-  Axis get scrollDirection => _scrollDirection;
-  Axis _scrollDirection;
-  void set scrollDirection (Axis newValue) {
-    if (_scrollDirection == newValue)
-      return;
-    _scrollDirection = newValue;
-    markNeedsLayout();
-  }
-
   void setupParentData(RenderBox child) {
     if (child.parentData is! ListParentData)
       child.parentData = new ListParentData();

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

@@ -9,30 +9,31 @@ import 'package:vector_math/vector_math_64.dart';
 import 'box.dart';
 import 'object.dart';
 
+enum ViewportAnchor {
+  start,
+  end,
+}
+
 abstract class HasScrollDirection {
   Axis get scrollDirection;
 }
 
-/// A render object that's bigger on the inside.
-///
-/// The child of a viewport can layout to a larger size than the viewport
-/// itself. If that happens, only a portion of the child will be visible through
-/// the viewport. The portion of the child that is visible is controlled by the
-/// scroll offset.
+/// A base class for render objects that are bigger on the inside.
 ///
-/// Viewport is the core scrolling primitive in the system, but it can be used
-/// in other situations.
-class RenderViewport extends RenderBox with RenderObjectWithChildMixin<RenderBox>
-    implements HasScrollDirection {
-
-  RenderViewport({
-    RenderBox child,
-    Offset scrollOffset: Offset.zero,
-    Axis scrollDirection: Axis.vertical
-  }) : _scrollOffset = scrollOffset,
-       _scrollDirection = scrollDirection {
-    assert(_offsetIsSane(scrollOffset, scrollDirection));
-    this.child = child;
+/// This class holds the common fields for viewport render objects but does not
+/// have a child model. See [RenderViewport] for a viewport with a single child
+/// and [RenderVirtualViewport] for a viewport with multiple children.
+class RenderViewportBase extends RenderBox implements HasScrollDirection {
+  RenderViewportBase(
+    Offset paintOffset,
+    Axis scrollDirection,
+    Painter overlayPainter
+  ) : _paintOffset = paintOffset,
+      _scrollDirection = scrollDirection,
+      _overlayPainter = overlayPainter {
+    assert(paintOffset != null);
+    assert(scrollDirection != null);
+    assert(_offsetIsSane(_paintOffset, scrollDirection));
   }
 
   bool _offsetIsSane(Offset offset, Axis direction) {
@@ -47,13 +48,14 @@ class RenderViewport extends RenderBox with RenderObjectWithChildMixin<RenderBox
   /// The offset at which to paint the child.
   ///
   /// The offset can be non-zero only in the [scrollDirection].
-  Offset get scrollOffset => _scrollOffset;
-  Offset _scrollOffset;
-  void set scrollOffset(Offset value) {
-    if (value == _scrollOffset)
+  Offset get paintOffset => _paintOffset;
+  Offset _paintOffset;
+  void set paintOffset(Offset value) {
+    assert(value != null);
+    if (value == _paintOffset)
       return;
     assert(_offsetIsSane(value, scrollDirection));
-    _scrollOffset = value;
+    _paintOffset = value;
     markNeedsPaint();
     markNeedsSemanticsUpdate();
   }
@@ -66,13 +68,69 @@ class RenderViewport extends RenderBox with RenderObjectWithChildMixin<RenderBox
   Axis get scrollDirection => _scrollDirection;
   Axis _scrollDirection;
   void set scrollDirection(Axis value) {
+    assert(value != null);
     if (value == _scrollDirection)
       return;
-    assert(_offsetIsSane(scrollOffset, value));
+    assert(_offsetIsSane(_paintOffset, value));
     _scrollDirection = value;
     markNeedsLayout();
   }
 
+  Painter get overlayPainter => _overlayPainter;
+  Painter _overlayPainter;
+  void set overlayPainter(Painter value) {
+    if (_overlayPainter == value)
+      return;
+    if (attached)
+      _overlayPainter?.detach();
+    _overlayPainter = value;
+    if (attached)
+      _overlayPainter?.attach(this);
+    markNeedsPaint();
+  }
+
+  void attach() {
+    super.attach();
+    _overlayPainter?.attach(this);
+  }
+
+  void detach() {
+    super.detach();
+    _overlayPainter?.detach();
+  }
+
+  Offset get _paintOffsetRoundedToIntegerDevicePixels {
+    final double devicePixelRatio = ui.window.devicePixelRatio;
+    int dxInDevicePixels = (_paintOffset.dx * devicePixelRatio).round();
+    int dyInDevicePixels = (_paintOffset.dy * devicePixelRatio).round();
+    return new Offset(dxInDevicePixels / devicePixelRatio,
+                      dyInDevicePixels / devicePixelRatio);
+  }
+
+  void applyPaintTransform(RenderBox child, Matrix4 transform) {
+    final Offset effectivePaintOffset = _paintOffsetRoundedToIntegerDevicePixels;
+    super.applyPaintTransform(child, transform.translate(effectivePaintOffset.dx, effectivePaintOffset.dy));
+  }
+
+}
+
+/// A render object that's bigger on the inside.
+///
+/// The child of a viewport can layout to a larger size than the viewport
+/// itself. If that happens, only a portion of the child will be visible through
+/// the viewport. The portion of the child that is visible is controlled by the
+/// paint offset.
+class RenderViewport extends RenderViewportBase with RenderObjectWithChildMixin<RenderBox> {
+
+  RenderViewport({
+    RenderBox child,
+    Offset paintOffset: Offset.zero,
+    Axis scrollDirection: Axis.vertical,
+    Painter overlayPainter
+  }) : super(paintOffset, scrollDirection, overlayPainter) {
+    this.child = child;
+  }
+
   BoxConstraints _getInnerConstraints(BoxConstraints constraints) {
     BoxConstraints innerConstraints;
     switch (scrollDirection) {
@@ -130,41 +188,30 @@ class RenderViewport extends RenderBox with RenderObjectWithChildMixin<RenderBox
     }
   }
 
-  Offset get _scrollOffsetRoundedToIntegerDevicePixels {
-    double devicePixelRatio = ui.window.devicePixelRatio;
-    int dxInDevicePixels = (scrollOffset.dx * devicePixelRatio).round();
-    int dyInDevicePixels = (scrollOffset.dy * devicePixelRatio).round();
-    return new Offset(dxInDevicePixels / devicePixelRatio,
-                      dyInDevicePixels / devicePixelRatio);
-  }
-
-  bool _wouldNeedClipAtOffset(Offset offset) {
+  bool _shouldClipAtPaintOffset(Offset paintOffset) {
     assert(child != null);
-    return offset < Offset.zero || !(Offset.zero & size).contains(((Offset.zero - offset) & child.size).bottomRight);
+    return paintOffset < Offset.zero || !(Offset.zero & size).contains((paintOffset & child.size).bottomRight);
   }
 
   void paint(PaintingContext context, Offset offset) {
     if (child != null) {
-      Offset roundedScrollOffset = _scrollOffsetRoundedToIntegerDevicePixels;
-      bool _needsClip = _wouldNeedClipAtOffset(roundedScrollOffset);
-      if (_needsClip) {
-        context.pushClipRect(needsCompositing, offset, Point.origin & size, (PaintingContext context, Offset offset) {
-          context.paintChild(child, offset - roundedScrollOffset);
-        });
-      } else {
-        context.paintChild(child, offset - roundedScrollOffset);
+      final Offset effectivePaintOffset = _paintOffsetRoundedToIntegerDevicePixels;
+
+      void paintContents(PaintingContext context, Offset offset) {
+        context.paintChild(child, offset + effectivePaintOffset);
+        _overlayPainter?.paint(context, offset);
       }
+
+      if (_shouldClipAtPaintOffset(effectivePaintOffset)) {
+        context.pushClipRect(needsCompositing, offset, Point.origin & size, paintContents);
+      } else {
+        paintContents(context, offset);
       }
     }
-
-  void applyPaintTransform(RenderBox child, Matrix4 transform) {
-    transform.translate(-scrollOffset.dx, -scrollOffset.dy);
-    super.applyPaintTransform(child, transform);
   }
 
   Rect describeApproximatePaintClip(RenderObject child) {
-    if (child != null &&
-        _wouldNeedClipAtOffset(_scrollOffsetRoundedToIntegerDevicePixels))
+    if (child != null && _shouldClipAtPaintOffset(_paintOffsetRoundedToIntegerDevicePixels))
       return Point.origin & size;
     return null;
   }
@@ -172,7 +219,7 @@ class RenderViewport extends RenderBox with RenderObjectWithChildMixin<RenderBox
   bool hitTestChildren(HitTestResult result, { Point position }) {
     if (child != null) {
       assert(child.parentData is BoxParentData);
-      Point transformed = position + _scrollOffsetRoundedToIntegerDevicePixels;
+      Point transformed = position + -_paintOffsetRoundedToIntegerDevicePixels;
       return child.hitTest(result, position: transformed);
     }
     return false;
@@ -180,17 +227,17 @@ class RenderViewport extends RenderBox with RenderObjectWithChildMixin<RenderBox
 }
 
 abstract class RenderVirtualViewport<T extends ContainerBoxParentDataMixin<RenderBox>>
-    extends RenderBox with ContainerRenderObjectMixin<RenderBox, T>,
+    extends RenderViewportBase with ContainerRenderObjectMixin<RenderBox, T>,
                                     RenderBoxContainerDefaultsMixin<RenderBox, T> {
   RenderVirtualViewport({
     int virtualChildCount,
-    Offset paintOffset,
     LayoutCallback callback,
+    Offset paintOffset: Offset.zero,
+    Axis scrollDirection: Axis.vertical,
     Painter overlayPainter
   }) : _virtualChildCount = virtualChildCount,
-       _paintOffset = paintOffset,
        _callback = callback,
-       _overlayPainter = overlayPainter;
+       super(paintOffset, scrollDirection, overlayPainter);
 
   int get virtualChildCount => _virtualChildCount;
   int _virtualChildCount;
@@ -201,21 +248,7 @@ abstract class RenderVirtualViewport<T extends ContainerBoxParentDataMixin<Rende
     markNeedsLayout();
   }
 
-  /// The offset at which to paint the first item.
-  ///
-  /// Note: you can modify this property from within [callback], if necessary.
-  Offset get paintOffset => _paintOffset;
-  Offset _paintOffset;
-  void set paintOffset(Offset value) {
-    assert(value != null);
-    if (value == _paintOffset)
-      return;
-    _paintOffset = value;
-    markNeedsPaint();
-    markNeedsSemanticsUpdate();
-  }
-
-  /// Called during [layout] to determine the grid's children.
+  /// Called during [layout] to determine the render object's children.
   ///
   /// Typically the callback will mutate the child list appropriately, for
   /// example so the child list contains only visible children.
@@ -228,39 +261,12 @@ abstract class RenderVirtualViewport<T extends ContainerBoxParentDataMixin<Rende
     markNeedsLayout();
   }
 
-  Painter get overlayPainter => _overlayPainter;
-  Painter _overlayPainter;
-  void set overlayPainter(Painter value) {
-    if (_overlayPainter == value)
-      return;
-    if (attached)
-      _overlayPainter?.detach();
-    _overlayPainter = value;
-    if (attached)
-      _overlayPainter?.attach(this);
-    markNeedsPaint();
-  }
-
-  void attach() {
-    super.attach();
-    _overlayPainter?.attach(this);
-  }
-
-  void detach() {
-    super.detach();
-    _overlayPainter?.detach();
-  }
-
-  void applyPaintTransform(RenderBox child, Matrix4 transform) {
-    super.applyPaintTransform(child, transform.translate(paintOffset.dx, paintOffset.dy));
-  }
-
   bool hitTestChildren(HitTestResult result, { Point position }) {
-    return defaultHitTestChildren(result, position: position + -paintOffset);
+    return defaultHitTestChildren(result, position: position + -_paintOffsetRoundedToIntegerDevicePixels);
   }
 
   void _paintContents(PaintingContext context, Offset offset) {
-    defaultPaint(context, offset + paintOffset);
+    defaultPaint(context, offset + _paintOffsetRoundedToIntegerDevicePixels);
     _overlayPainter?.paint(context, offset);
   }
 

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

@@ -797,11 +797,12 @@ class Viewport extends OneChildRenderObjectWidget {
   Viewport({
     Key key,
     this.scrollDirection: Axis.vertical,
-    this.scrollOffset: Offset.zero,
+    this.paintOffset: Offset.zero,
+    this.overlayPainter,
     Widget child
   }) : super(key: key, child: child) {
     assert(scrollDirection != null);
-    assert(scrollOffset != null);
+    assert(paintOffset != null);
   }
 
   /// The direction in which the child is permitted to be larger than the viewport
@@ -814,14 +815,25 @@ class Viewport extends OneChildRenderObjectWidget {
   /// The offset at which to paint the child.
   ///
   /// The offset can be non-zero only in the [scrollDirection].
-  final Offset scrollOffset;
+  final Offset paintOffset;
 
-  RenderViewport createRenderObject() => new RenderViewport(scrollDirection: scrollDirection, scrollOffset: scrollOffset);
+  /// Paints an overlay over the viewport.
+  ///
+  /// Often used to paint scroll bars.
+  final Painter overlayPainter;
+
+  RenderViewport createRenderObject() => new RenderViewport(
+    scrollDirection: scrollDirection,
+    paintOffset: paintOffset,
+    overlayPainter: overlayPainter
+  );
 
   void updateRenderObject(RenderViewport renderObject, Viewport oldWidget) {
     // Order dependency: RenderViewport validates scrollOffset based on scrollDirection.
-    renderObject.scrollDirection = scrollDirection;
-    renderObject.scrollOffset = scrollOffset;
+    renderObject
+      ..scrollDirection = scrollDirection
+      ..paintOffset = paintOffset
+      ..overlayPainter = overlayPainter;
   }
 }
 

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

@@ -5,7 +5,6 @@
 import 'dart:async';
 
 import 'package:flutter/animation.dart';
-import 'package:flutter/gestures.dart';
 import 'package:flutter/rendering.dart';
 
 import 'basic.dart';
@@ -65,12 +64,25 @@ class PageableListState<T extends PageableList> extends ScrollableState<T> {
   int get itemCount => config.children?.length ?? 0;
   int _previousItemCount;
 
-  double pixelToScrollOffset(double value) {
+  double get _pixelsPerScrollUnit {
     final RenderBox box = context.findRenderObject();
     if (box == null || !box.hasSize)
       return 0.0;
-    final double pixelScrollExtent = config.scrollDirection == Axis.vertical ? box.size.height : box.size.width;
-    return pixelScrollExtent == 0.0 ? 0.0 : value / pixelScrollExtent;
+    switch (config.scrollDirection) {
+      case Axis.horizontal:
+        return box.size.width;
+      case Axis.vertical:
+        return box.size.height;
+    }
+  }
+
+  double pixelOffsetToScrollOffset(double pixelOffset) {
+    final double pixelsPerScrollUnit = _pixelsPerScrollUnit;
+    return super.pixelOffsetToScrollOffset(pixelsPerScrollUnit == 0.0 ? 0.0 : pixelOffset / pixelsPerScrollUnit);
+  }
+
+  double scrollOffsetToPixelOffset(double scrollOffset) {
+    return super.scrollOffsetToPixelOffset(scrollOffset * _pixelsPerScrollUnit);
   }
 
   void initState() {
@@ -143,7 +155,7 @@ class PageableListState<T extends PageableList> extends ScrollableState<T> {
 
   ScrollBehavior createScrollBehavior() => scrollBehavior;
 
-  bool get snapScrollOffsetChanges => config.itemsSnapAlignment == ItemsSnapAlignment.item;
+  bool get shouldSnapScrollOffset => config.itemsSnapAlignment == ItemsSnapAlignment.item;
 
   double snapScrollOffset(double newScrollOffset) {
     final double previousItemOffset = newScrollOffset.floorToDouble();
@@ -152,20 +164,19 @@ class PageableListState<T extends PageableList> extends ScrollableState<T> {
       .clamp(scrollBehavior.minScrollOffset, scrollBehavior.maxScrollOffset);
   }
 
-  Future _flingToAdjacentItem(Offset velocity) {
-    final double scrollVelocity = scrollDirectionVelocity(velocity);
+  Future _flingToAdjacentItem(double scrollVelocity) {
     final double newScrollOffset = snapScrollOffset(scrollOffset + scrollVelocity.sign)
       .clamp(snapScrollOffset(scrollOffset - 0.5), snapScrollOffset(scrollOffset + 0.5));
     return scrollTo(newScrollOffset, duration: config.duration, curve: config.curve)
       .then(_notifyPageChanged);
   }
 
-  Future fling(Offset velocity) {
+  Future fling(double scrollVelocity) {
     switch(config.itemsSnapAlignment) {
       case ItemsSnapAlignment.adjacentItem:
-        return _flingToAdjacentItem(velocity);
+        return _flingToAdjacentItem(scrollVelocity);
       default:
-        return super.fling(velocity).then(_notifyPageChanged);
+        return super.fling(scrollVelocity).then(_notifyPageChanged);
     }
   }
 

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

@@ -19,11 +19,6 @@ import 'notification_listener.dart';
 import 'page_storage.dart';
 import 'scroll_behavior.dart';
 
-// The gesture velocity properties are pixels/second, config min,max limits are pixels/ms
-const double _kMillisecondsPerSecond = 1000.0;
-const double _kMinFlingVelocity = -kMaxFlingVelocity * _kMillisecondsPerSecond;
-const double _kMaxFlingVelocity = kMaxFlingVelocity * _kMillisecondsPerSecond;
-
 /// The accuracy to which scrolling is computed.
 final Tolerance kPixelScrollTolerance = new Tolerance(
   velocity: 1.0 / (0.050 * ui.window.devicePixelRatio),  // logical pixels per second
@@ -45,14 +40,16 @@ abstract class Scrollable extends StatefulComponent {
     Key key,
     this.initialScrollOffset,
     this.scrollDirection: Axis.vertical,
+    this.scrollAnchor: ViewportAnchor.start,
     this.onScrollStart,
     this.onScroll,
     this.onScrollEnd,
     this.snapOffsetCallback,
     this.snapAlignmentOffset: 0.0
   }) : super(key: key) {
-    assert(scrollDirection == Axis.vertical ||
-           scrollDirection == Axis.horizontal);
+    assert(scrollDirection == Axis.vertical || scrollDirection == Axis.horizontal);
+    assert(scrollAnchor == ViewportAnchor.start || scrollAnchor == ViewportAnchor.end);
+    assert(snapAlignmentOffset != null);
   }
 
   /// The scroll offset this widget should use when first created.
@@ -61,6 +58,8 @@ abstract class Scrollable extends StatefulComponent {
   /// The axis along which this widget should scroll.
   final Axis scrollDirection;
 
+  final ViewportAnchor scrollAnchor;
+
   /// Called whenever this widget starts to scroll.
   final ScrollListener onScrollStart;
 
@@ -172,13 +171,46 @@ abstract class ScrollableState<T extends Scrollable> extends State<T> {
   /// Scrollable gesture handlers convert their incoming values with this method.
   /// Subclasses that define scrollOffset in units other than pixels must
   /// override this method.
-  double pixelToScrollOffset(double pixelValue) => pixelValue;
+  double pixelOffsetToScrollOffset(double pixelOffset) {
+    switch (config.scrollAnchor) {
+      case ViewportAnchor.start:
+        // We negate the delta here because a positive scroll offset moves the
+        // the content up (or to the left) rather than down (or the right).
+        return -pixelOffset;
+      case ViewportAnchor.end:
+        return pixelOffset;
+    }
+  }
 
-  /// Returns the component of the given velocity in the scroll direction.
-  double scrollDirectionVelocity(Offset scrollVelocity) {
-    return config.scrollDirection == Axis.horizontal
-      ? -scrollVelocity.dx
-      : -scrollVelocity.dy;
+  double scrollOffsetToPixelOffset(double scrollOffset) {
+    switch (config.scrollAnchor) {
+      case ViewportAnchor.start:
+        return -scrollOffset;
+      case ViewportAnchor.end:
+        return scrollOffset;
+    }
+  }
+
+  /// Returns the scroll offset component of the given pixel delta, accounting
+  /// for the scroll direction and scroll anchor.
+  double pixelDeltaToScrollOffset(Offset pixelDelta) {
+    switch (config.scrollDirection) {
+      case Axis.horizontal:
+        return pixelOffsetToScrollOffset(pixelDelta.dx);
+      case Axis.vertical:
+        return pixelOffsetToScrollOffset(pixelDelta.dy);
+    }
+  }
+
+  /// Returns a two-dimensional representation of the scroll offset, accounting
+  /// for the scroll direction and scroll anchor.
+  Offset scrollOffsetToPixelDelta(double scrollOffset) {
+    switch (config.scrollDirection) {
+      case Axis.horizontal:
+        return new Offset(scrollOffsetToPixelOffset(scrollOffset), 0.0);
+      case Axis.vertical:
+        return new Offset(0.0, scrollOffsetToPixelOffset(scrollOffset));
+    }
   }
 
   ScrollBehavior _scrollBehavior;
@@ -244,19 +276,19 @@ abstract class ScrollableState<T extends Scrollable> extends State<T> {
     return _controller.animateTo(newScrollOffset, duration: duration, curve: curve);
   }
 
-  bool _scrollOffsetIsInBounds(double offset) {
+  bool _scrollOffsetIsInBounds(double scrollOffset) {
     if (scrollBehavior is! ExtentScrollBehavior)
       return false;
     ExtentScrollBehavior behavior = scrollBehavior;
-    return offset >= behavior.minScrollOffset && offset < behavior.maxScrollOffset;
+    return scrollOffset >= behavior.minScrollOffset && scrollOffset < behavior.maxScrollOffset;
   }
 
-  Simulation _createFlingSimulation(double velocity) {
-    final Simulation simulation =  scrollBehavior.createFlingScrollSimulation(scrollOffset, velocity);
+  Simulation _createFlingSimulation(double scrollVelocity) {
+    final Simulation simulation =  scrollBehavior.createFlingScrollSimulation(scrollOffset, scrollVelocity);
     if (simulation != null) {
-      final double endVelocity = pixelToScrollOffset(kPixelScrollTolerance.velocity);
-      final double endDistance = pixelToScrollOffset(kPixelScrollTolerance.distance);
-      simulation.tolerance = new Tolerance(velocity: endVelocity.abs(), distance: endDistance);
+      final double endVelocity = pixelOffsetToScrollOffset(kPixelScrollTolerance.velocity) * scrollVelocity.sign;
+      final double endDistance = pixelOffsetToScrollOffset(kPixelScrollTolerance.distance).abs();
+      simulation.tolerance = new Tolerance(velocity: endVelocity, distance: endDistance);
     }
     return simulation;
   }
@@ -267,41 +299,40 @@ abstract class ScrollableState<T extends Scrollable> extends State<T> {
   }
 
   /// Whether this scrollable should attempt to snap scroll offsets.
-  bool get snapScrollOffsetChanges => config.snapOffsetCallback != null;
+  bool get shouldSnapScrollOffset => config.snapOffsetCallback != null;
 
-  Simulation _createSnapSimulation(double velocity) {
-    if (!snapScrollOffsetChanges || velocity == 0.0 || !_scrollOffsetIsInBounds(scrollOffset))
+  Simulation _createSnapSimulation(double scrollVelocity) {
+    if (!shouldSnapScrollOffset || scrollVelocity == 0.0 || !_scrollOffsetIsInBounds(scrollOffset))
       return null;
 
-    Simulation simulation = _createFlingSimulation(velocity);
+    Simulation simulation = _createFlingSimulation(scrollVelocity);
     if (simulation == null)
         return null;
 
-    double endScrollOffset = simulation.x(double.INFINITY);
+    final double endScrollOffset = simulation.x(double.INFINITY);
     if (endScrollOffset.isNaN)
       return null;
 
-    double snappedScrollOffset = snapScrollOffset(endScrollOffset + config.snapAlignmentOffset);
-    double alignedScrollOffset = snappedScrollOffset - config.snapAlignmentOffset;
+    final double snappedScrollOffset = snapScrollOffset(endScrollOffset + config.snapAlignmentOffset);
+    final double alignedScrollOffset = snappedScrollOffset - config.snapAlignmentOffset;
     if (!_scrollOffsetIsInBounds(alignedScrollOffset))
       return null;
 
-    double snapVelocity = velocity.abs() * (alignedScrollOffset - scrollOffset).sign;
-    double endVelocity = pixelToScrollOffset(kPixelScrollTolerance.velocity * velocity.sign);
+    final double snapVelocity = scrollVelocity.abs() * (alignedScrollOffset - scrollOffset).sign;
+    final double endVelocity = pixelOffsetToScrollOffset(kPixelScrollTolerance.velocity).abs() * scrollVelocity.sign;
     Simulation toSnapSimulation =
       scrollBehavior.createSnapScrollSimulation(scrollOffset, alignedScrollOffset, snapVelocity, endVelocity);
     if (toSnapSimulation == null)
       return null;
 
-    double offsetMin = math.min(scrollOffset, alignedScrollOffset);
-    double offsetMax = math.max(scrollOffset, alignedScrollOffset);
-    return new ClampedSimulation(toSnapSimulation, xMin: offsetMin, xMax: offsetMax);
+    final double scrollOffsetMin = math.min(scrollOffset, alignedScrollOffset);
+    final double scrollOffsetMax = math.max(scrollOffset, alignedScrollOffset);
+    return new ClampedSimulation(toSnapSimulation, xMin: scrollOffsetMin, xMax: scrollOffsetMax);
   }
 
-  Future _startToEndAnimation(Offset scrollVelocity) {
-    double velocity = scrollDirectionVelocity(scrollVelocity);
+  Future _startToEndAnimation(double scrollVelocity) {
     _controller.stop();
-    Simulation simulation = _createSnapSimulation(velocity) ?? _createFlingSimulation(velocity);
+    Simulation simulation = _createSnapSimulation(scrollVelocity) ?? _createFlingSimulation(scrollVelocity);
     if (simulation == null)
       return new Future.value();
     return _controller.animateWith(simulation);
@@ -358,8 +389,8 @@ abstract class ScrollableState<T extends Scrollable> extends State<T> {
   /// Calling this function starts a physics-based animation of the scroll
   /// offset with the given value as the initial velocity. The physics
   /// simulation used is determined by the scroll behavior.
-  Future fling(Offset scrollVelocity) {
-    if (scrollVelocity != Offset.zero)
+  Future fling(double scrollVelocity) {
+    if (scrollVelocity != 0.0)
       return _startToEndAnimation(scrollVelocity);
     if (!_controller.isAnimating)
       return settleScrollOffset();
@@ -372,7 +403,7 @@ abstract class ScrollableState<T extends Scrollable> extends State<T> {
   /// offset either to a snap point or to within the scrolling bounds. The
   /// physics simulation used is determined by the scroll behavior.
   Future settleScrollOffset() {
-    return _startToEndAnimation(Offset.zero);
+    return _startToEndAnimation(0.0);
   }
 
   /// Calls the onScrollStart callback.
@@ -408,18 +439,13 @@ abstract class ScrollableState<T extends Scrollable> extends State<T> {
   }
 
   void _handleDragUpdate(double delta) {
-    // We negate the delta here because a positive scroll offset moves the
-    // the content up (or to the left) rather than down (or the right).
-    scrollBy(pixelToScrollOffset(-delta));
-  }
-
-  double _toScrollVelocity(double velocity) {
-    return pixelToScrollOffset(velocity.clamp(_kMinFlingVelocity, _kMaxFlingVelocity) / _kMillisecondsPerSecond);
+    scrollBy(pixelOffsetToScrollOffset(delta));
   }
 
-  Future _handleDragEnd(Offset pixelScrollVelocity) {
-    final Offset scrollVelocity = new Offset(_toScrollVelocity(pixelScrollVelocity.dx), _toScrollVelocity(pixelScrollVelocity.dy));
-    return fling(scrollVelocity).then((_) {
+  Future _handleDragEnd(Offset velocity) {
+    double scrollVelocity = pixelDeltaToScrollOffset(velocity) / Duration.MILLISECONDS_PER_SECOND;
+    // The gesture velocity properties are pixels/second, config min,max limits are pixels/ms
+    return fling(scrollVelocity.clamp(-kMaxFlingVelocity, kMaxFlingVelocity)).then((_) {
       dispatchOnScrollEnd();
     });
   }
@@ -441,15 +467,17 @@ class ScrollNotification extends Notification {
 class ScrollableViewport extends Scrollable {
   ScrollableViewport({
     Key key,
-    this.child,
     double initialScrollOffset,
     Axis scrollDirection: Axis.vertical,
+    ViewportAnchor scrollAnchor: ViewportAnchor.start,
     ScrollListener onScrollStart,
     ScrollListener onScroll,
-    ScrollListener onScrollEnd
+    ScrollListener onScrollEnd,
+    this.child
   }) : super(
     key: key,
     scrollDirection: scrollDirection,
+    scrollAnchor: scrollAnchor,
     initialScrollOffset: initialScrollOffset,
     onScrollStart: onScrollStart,
     onScroll: onScroll,
@@ -488,18 +516,12 @@ class _ScrollableViewportState extends ScrollableState<ScrollableViewport> {
     ));
   }
 
-  Offset get _scrollOffsetVector {
-    if (config.scrollDirection == Axis.horizontal)
-      return new Offset(scrollOffset, 0.0);
-    return new Offset(0.0, scrollOffset);
-  }
-
   Widget buildContent(BuildContext context) {
     return new SizeObserver(
       onSizeChanged: _handleViewportSizeChanged,
       child: new Viewport(
-        scrollOffset: _scrollOffsetVector,
         scrollDirection: config.scrollDirection,
+        paintOffset: scrollOffsetToPixelDelta(scrollOffset),
         child: new SizeObserver(
           onSizeChanged: _handleChildSizeChanged,
           child: config.child

packages/flutter/test/rendering/viewport_test.dart

@@ -24,7 +24,7 @@ void main() {
       ),
       child: size);
 
-    RenderViewport viewport = new RenderViewport(child: red, scrollOffset: new Offset(0.0, -10.0));
+    RenderViewport viewport = new RenderViewport(child: red, paintOffset: new Offset(0.0, 10.0));
     layout(viewport);
 
     HitTestResult result;

packages/flutter/test/widget/snap_scrolling_test.dart

@@ -48,14 +48,11 @@ void set scrollOffset(double value) {
 }
 
 Future fling(double velocity) {
-  Offset velocityOffset = scrollDirection == Axis.vertical
-    ? new Offset(0.0, velocity)
-    : new Offset(velocity, 0.0);
-  return scrollableState.fling(velocityOffset);
+  return scrollableState.fling(velocity);
 }
 
 void main() {
-  test('ScrollableList snap scrolling, fling(-0.8)', () {
+  test('ScrollableList snap scrolling, fling(0.8)', () {
     testWidgets((WidgetTester tester) {
       tester.pumpWidget(buildFrame());
 
@@ -65,7 +62,7 @@ void main() {
 
       Duration dt = const Duration(seconds: 2);
 
-      fling(-0.8);
+      fling(0.8);
       tester.pump(); // Start the scheduler at 0.0
       tester.pump(dt);
       expect(scrollOffset, closeTo(200.0, 1.0));
@@ -74,7 +71,7 @@ void main() {
       tester.pump();
       expect(scrollOffset, 0.0);
 
-      fling(-2.0);
+      fling(2.0);
       tester.pump();
       tester.pump(dt);
       expect(scrollOffset, closeTo(400.0, 1.0));
@@ -83,7 +80,7 @@ void main() {
       tester.pump();
       expect(scrollOffset, 400.0);
 
-      fling(0.8);
+      fling(-0.8);
       tester.pump();
       tester.pump(dt);
       expect(scrollOffset, closeTo(0.0, 1.0));
@@ -92,7 +89,7 @@ void main() {
       tester.pump();
       expect(scrollOffset, 800.0);
 
-      fling(2.0);
+      fling(-2.0);
       tester.pump();
       tester.pump(dt);
       expect(scrollOffset, closeTo(200.0, 1.0));
@@ -102,7 +99,7 @@ void main() {
       expect(scrollOffset, 800.0);
 
       bool completed = false;
-      fling(2.0).then((_) {
+      fling(-2.0).then((_) {
         completed = true;
         expect(scrollOffset, closeTo(200.0, 1.0));
       });

packages/flutter_tools/lib/src/commands/analyze.dart

@@ -298,6 +298,7 @@ class AnalyzeCommand extends FlutterCommand {
       new RegExp(r'\[lint\] Prefer using lowerCamelCase for constant names.'), // sometimes we have no choice (e.g. when matching other platforms)
       new RegExp(r'\[lint\] Avoid defining a one-member abstract class when a simple function will do.'), // too many false-positives; code review should catch real instances
       new RegExp(r'\[info\] TODO.+'),
+      new RegExp('\\[warning\\] Missing concrete implementation of \'RenderObject\\.applyPaintTransform\''), // https://github.com/dart-lang/sdk/issues/25232
       new RegExp(r'[0-9]+ (error|warning|hint|lint).+found\.'),
       new RegExp(r'^$'),
     ];