demo_launcher/lib/main.dart does not have bottom-overscroll

sky/sdk/lib/widgets/scrollable.dart

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 import 'dart:sky' as sky;
 
 import '../animation/generators.dart';
 import '../animation/mechanics.dart';
 import '../animation/scroll_behavior.dart';
 import '../theme/view_configuration.dart' as config;
 import 'basic.dart';
 import 'material.dart';
 
 const double _kMillisecondsPerSecond = 1000.0;
 
 double _velocityForFlingGesture(double eventVelocity) {
   return eventVelocity.clamp(-config.kMaxFlingVelocity, config.kMaxFlingVelocity) /
     _kMillisecondsPerSecond;
 }
 
 abstract class ScrollClient {
   bool ancestorScrolled(Scrollable ancestor);
 }
 
 enum ScrollDirection { vertical, horizontal }
 
 abstract class Scrollable extends StatefulComponent {
 
   Scrollable({
-   String key,
-   this.backgroundColor,
-   this.direction: ScrollDirection.vertical
+    String key,
+    this.backgroundColor,
+    this.direction: ScrollDirection.vertical
   }) : super(key: key);
 
   Color backgroundColor;
   ScrollDirection direction;
 
   void syncFields(Scrollable source) {
     backgroundColor = source.backgroundColor;
     direction == source.direction;
   }
 
@@ skipping 72 matching lines @@
   bool scrollBy(double scrollDelta) {
     var newScrollOffset = scrollBehavior.applyCurve(_scrollOffset, scrollDelta);
     return scrollTo(newScrollOffset);
   }
 
   void didUnmount() {
     _stopSimulation();
     super.didUnmount();
   }
 
+  void settleScrollOffset() {
+    _startSimulation(_createParticle());
+  }
+
   void _stopSimulation() {
     if (_simulation == null)
       return;
     _simulation.cancel();
     _simulation = null;
   }
 
   void _startSimulation(Particle particle) {
     _stopSimulation();
     _simulation = scrollBehavior.release(particle);
     if (_simulation == null)
       return;
     _simulation.onTick.listen((_) => scrollTo(particle.position));
   }
 
   Particle _createParticle([double velocity = 0.0]) {
     return new Particle(position: _scrollOffset, velocity: velocity);
   }
 
   void _handlePointerDown(_) {
     _stopSimulation();
   }
 
   void _handlePointerUpOrCancel(_) {
     if (_simulation == null)
-      _startSimulation(_createParticle());
+      settleScrollOffset();
   }
 
   void _handleScrollUpdate(sky.GestureEvent event) {
     scrollBy(direction == ScrollDirection.horizontal ? event.dx : -event.dy);
   }
 
   void _handleFlingStart(sky.GestureEvent event) {
     double eventVelocity = direction == ScrollDirection.horizontal
       ? -event.velocityX
       : -event.velocityY;
     _startSimulation(_createParticle(_velocityForFlingGesture(eventVelocity)));
   }
 
   void _handleFlingCancel(sky.GestureEvent event) {
-    _startSimulation(_createParticle());
+    settleScrollOffset();
   }
 
   void _handleWheel(sky.WheelEvent event) {
     scrollBy(-event.offsetY);
   }
 
 }