a === b -> identical(a, b)

samples/swarm/swarm_ui_lib/touch/Momentum.dart

 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 /**
  * Implementations can be used to simulate the deceleration of an element within
  * a certain region. To use this behavior you need to provide an initial
  * velocity that is meant to represent the gesture that is initiating this
  * deceleration. You also provide the bounds of the region that the element
  * exists in, and the current offset of the element within that region. The
@@ skipping 260 matching lines @@
 
   /**
    * Helper method to calculate initial velocity.
    * The [velocity] passed here should be in terms of number of
    * pixels / millisecond. Returns the adjusted x and y velocities.
    */
   void _adjustInitialVelocityAndBouncingState(num v) {
     velocity = v * _MS_PER_FRAME * _INITIAL_VELOCITY_BOOST_FACTOR;
 
     if (velocity.abs() < _MIN_VELOCITY) {
-      if (_minCoord !== null && _currentOffset < _minCoord) {
+      if (_minCoord != null && _currentOffset < _minCoord) {
         velocity = (_minCoord - _currentOffset) * _POST_BOUNCE_COEFFICIENT;
         velocity = Math.max(velocity, _MIN_STEP_VELOCITY);
         _bouncingState = BouncingState.BOUNCING_BACK;
-      } else if (_maxCoord !== null && _currentOffset > _maxCoord) {
+      } else if (_maxCoord != null && _currentOffset > _maxCoord) {
         velocity = (_currentOffset - _maxCoord) * _POST_BOUNCE_COEFFICIENT;
         velocity = -Math.max(velocity, _MIN_STEP_VELOCITY);
         _bouncingState = BouncingState.BOUNCING_BACK;
       }
     }
   }
 
   /**
    * Apply deceleration.
    */
   void _adjustVelocity() {
     num speed = velocity.abs();
     velocity *= _DECELERATION_FACTOR;
     if (customDecelerationFactor != null) {
       velocity *= customDecelerationFactor;
     }
     // This isn't really how static friction works but it is a plausible
     // approximation.
     if (speed < _MAX_VELOCITY_STATIC_FRICTION) {
       velocity *= _DECELERATION_FACTOR_STATIC_FRICTION;
     }
 
     num stretchDistance;
-    if (_minCoord !== null && _currentOffset < _minCoord) {
+    if (_minCoord != null && _currentOffset < _minCoord) {
       stretchDistance = _minCoord - _currentOffset;
     } else {
-      if (_maxCoord !== null && _currentOffset > _maxCoord) {
+      if (_maxCoord != null && _currentOffset > _maxCoord) {
         stretchDistance = _maxCoord - _currentOffset;
       }
     }
     if (stretchDistance != null) {
       if (stretchDistance * velocity < 0) {
         _bouncingState = _bouncingState == BouncingState.BOUNCING_BACK ?
             BouncingState.NOT_BOUNCING : BouncingState.BOUNCING_AWAY;
         velocity += stretchDistance * _PRE_BOUNCE_COEFFICIENT;
       } else {
         _bouncingState = BouncingState.BOUNCING_BACK;
         velocity = stretchDistance > 0 ?
             Math.max(stretchDistance * _POST_BOUNCE_COEFFICIENT,
                      _MIN_STEP_VELOCITY) :
             Math.min(stretchDistance * _POST_BOUNCE_COEFFICIENT,
                      -_MIN_STEP_VELOCITY);
       }
     } else {
       _bouncingState = BouncingState.NOT_BOUNCING;
     }
   }
 
   void step() {
     // It is common for scrolling to be disabled so in these cases we want to
     // avoid needless calculations.
-    if (velocity !== null) {
+    if (velocity != null) {
       _currentOffset += velocity;
       _adjustVelocity();
     }
   }
 
   void stepAll() {
     while(!isDone()) {
       step();
     }
   }
@@ skipping 81 matching lines @@
   Coordinate calculateVelocity(Coordinate start_, Coordinate target,
                                [num decelerationFactor = null]) {
     return new Coordinate(
         physicsX.solve(start_.x, target.x, decelerationFactor),
         physicsY.solve(start_.y, target.y, decelerationFactor));
   }
 
   bool start(Coordinate velocity, Coordinate minCoord, Coordinate maxCoord,
              Coordinate initialOffset, [num decelerationFactor = null]) {
     _customDecelerationFactor = _defaultDecelerationFactor;
-    if (decelerationFactor !== null) {
+    if (decelerationFactor != null) {
       _customDecelerationFactor = decelerationFactor;
     }
 
-    if (_stepTimeout !== null) {
+    if (_stepTimeout != null) {
       Env.cancelRequestAnimationFrame(_stepTimeout);
       _stepTimeout = null;
     }
 
-    assert (_stepTimeout === null);
+    assert (_stepTimeout == null);
     assert(minCoord.x <= maxCoord.x);
     assert(minCoord.y <= maxCoord.y);
     _previousOffset = initialOffset.clone();
     physicsX.configure(minCoord.x, maxCoord.x, initialOffset.x,
                        _customDecelerationFactor, velocity.x);
     physicsY.configure(minCoord.y, maxCoord.y, initialOffset.y,
                        _customDecelerationFactor, velocity.y);
     if (!physicsX.isDone() || !physicsY.isDone()) {
       _calculateMoves();
       if (!_moves.isEmpty) {
@@ skipping 24 matching lines @@
 
   /**
    * Calculate the next offset of the element and animate it to that position.
    */
   void _step(num timestamp) {
     _stepTimeout = null;
 
     // Prune moves that are more than 1 frame behind when we have more
     // available moves.
     num lastEpoch = timestamp - SingleDimensionPhysics._MS_PER_FRAME;
-    while (!_moves.isEmpty && _moves.first !== _moves.last
+    while (!_moves.isEmpty && !identical(_moves.first, _moves.last)
         && _moves.first.time < lastEpoch) {
       _moves.removeFirst();
     }
 
     if (!_moves.isEmpty) {
       final move = _moves.removeFirst();
       _delegate.onDecelerate(move.x, move.y);
       if (!_moves.isEmpty) {
         num nextTime = _moves.first.time;
-        assert(_stepTimeout === null);
+        assert(_stepTimeout == null);
         _stepTimeout = Env.requestAnimationFrame(_step, null, nextTime);
       } else {
         stop();
       }
     }
   }
 
   void abort() {
     _decelerating = false;
     _moves.clear();
-    if (_stepTimeout !== null) {
+    if (_stepTimeout != null) {
       Env.cancelRequestAnimationFrame(_stepTimeout);
       _stepTimeout = null;
     }
   }
 
   Coordinate stop() {
     final wasDecelerating = _decelerating;
     _decelerating = false;
     Coordinate velocity;
     if (!_moves.isEmpty) {
       final move = _moves.first;
       // This is a workaround for the ugly hacks that get applied when a user
       // passed a velocity in to this Momentum implementation.
       num velocityScale = SingleDimensionPhysics._MS_PER_FRAME *
           SingleDimensionPhysics._INITIAL_VELOCITY_BOOST_FACTOR;
       velocity = new Coordinate(
           move.vx / velocityScale, move.vy / velocityScale);
     } else {
       velocity = new Coordinate(0, 0);
     }
     _moves.clear();
-    if (_stepTimeout !== null) {
+    if (_stepTimeout != null) {
       Env.cancelRequestAnimationFrame(_stepTimeout);
       _stepTimeout = null;
     }
     if (wasDecelerating) {
       _delegate.onDecelerationEnd();
     }
     return velocity;
   }
 
   Coordinate get destination {
     if (!_moves.isEmpty) {
       final lastMove = _moves.last;
       return new Coordinate(lastMove.x, lastMove.y);
     } else {
       return null;
     }
   }
 }