Clean up style in timer_impl.

sdk/lib/io/timer_impl.dart

 // Copyright (c) 2013, 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.
 
 part of dart.io;
 
 // Timer heap implemented as a array-based binary heap[0].
 // This allows for O(1) `first`, O(log(n)) `remove`/`removeFirst` and O(log(n))
 // `add`.
 //
@@ skipping 172 matching lines @@
   bool get _repeating => _milliSeconds >= 0;
 
   bool get isActive => _callback != null;
 
   // Cancels a set timer. The timer is removed from the timer list and if
   // the given timer is the earliest timer the native timer is reset.
   void cancel() {
     _clear();
     if (!_isInHeap) return;
     assert(_wakeupTime != 0);
-    bool update = _firstZeroTimer == null && _heap.isFirst(this);
+    bool update = (_firstZeroTimer == null) && _heap.isFirst(this);
     _heap.remove(this);
     if (update) {
       _notifyEventHandler();
     }
   }
 
   void _advanceWakeupTime() {
     assert(_milliSeconds >= 0);
     _wakeupTime += _milliSeconds;
   }
 
   // Adds a timer to the timer list. Timers with the same wakeup time are
   // enqueued in order and notified in FIFO order.
   bool _addTimerToHeap() {
     if (_wakeupTime == 0) {
       if (_firstZeroTimer == null) {
-        _lastZeroTimer = _firstZeroTimer = this;
+        _lastZeroTimer = this;
+        _firstZeroTimer = this;
         return true;
       } else {
-        _lastZeroTimer = _lastZeroTimer._indexOrNext = this;
+        _lastZeroTimer._indexOrNext = this;
+        _lastZeroTimer = this;
         return false;
       }
     } else {
       _id = _idCount++;
       _heap.add(this);
       return _firstZeroTimer == null && _heap.isFirst(this);
     }
   }
 
 
@@ skipping 26 matching lines @@
                                 _heap.first._wakeupTime);
       }
     }
   }
 
   static void _handleTimeout(_) {
     int currentTime = new DateTime.now().millisecondsSinceEpoch;
     // Collect all pending timers.
     var timer = _firstZeroTimer;
     var nextTimer = _lastZeroTimer;
-    _firstZeroTimer = _lastZeroTimer = null;
+    _firstZeroTimer = null;
+    _lastZeroTimer = null;
     while (_heap.isNotEmpty && _heap.first._wakeupTime <= currentTime) {
       var next = _heap.removeFirst();
       if (timer == null) {
-        nextTimer = timer = next;
+        nextTimer = next;
+        timer = next;
       } else {
-        nextTimer = nextTimer._indexOrNext = next;
+        nextTimer._indexOrNext = next;
+        nextTimer = next;
       }
     }
 
     // Trigger all of the pending timers. New timers added as part of the
     // callbacks will be enqueued now and notified in the next spin at the
     // earliest.
     _handlingCallbacks = true;
     try {
       while (timer != null) {
         var next = timer._indexOrNext;
@@ skipping 42 matching lines @@
 _getTimerFactoryClosure() {
   return (int milliSeconds, void callback(Timer timer), bool repeating) {
     if (repeating) {
       return new _Timer.periodic(milliSeconds, callback);
     }
     return new _Timer(milliSeconds, callback);
   };
 }