Revert "Fix observatory tests broken by running dartfmt."

runtime/lib/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.
 
 import 'dart:_internal' hide Symbol;
 
 // 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`.
 //
 // To ensure the timers are ordered by insertion time, the _Timer class has a
 // `_id` field set when added to the heap.
 //
 // [0] http://en.wikipedia.org/wiki/Binary_heap
 class _TimerHeap {
   List<_Timer> _list;
   int _used = 0;
 
-  _TimerHeap([int initSize = 7]) : _list = new List<_Timer>(initSize);
+  _TimerHeap([int initSize = 7])
+      : _list = new List<_Timer>(initSize);
 
   bool get isEmpty => _used == 0;
 
   _Timer get first => _list[0];
 
   bool isFirst(_Timer timer) => timer._indexOrNext == 0;
 
   void add(_Timer timer) {
     if (_used == _list.length) {
       _resize();
@@ skipping 102 matching lines @@
   // ids are recycled after ID_MASK enqueues or when the timer queue is empty.
   static const _ID_MASK = 0x1fffffff;
   static int _idCount = 0;
 
   static RawReceivePort _receivePort;
   static SendPort _sendPort;
   static int _scheduledWakeupTime;
 
   static bool _handlingCallbacks = false;
 
-  Function _callback; // Closure to call when timer fires. null if canceled.
-  int _wakeupTime; // Expiration time.
-  final int _milliSeconds; // Duration specified at creation.
-  final bool _repeating; // Indicates periodic timers.
-  var _indexOrNext; // Index if part of the TimerHeap, link otherwise.
-  int _id; // Incrementing id to enable sorting of timers with same expiry.
+  Function _callback;  // Closure to call when timer fires. null if canceled.
+  int _wakeupTime;  // Expiration time.
+  final int _milliSeconds;  // Duration specified at creation.
+  final bool _repeating;  // Indicates periodic timers.
+  var _indexOrNext;  // Index if part of the TimerHeap, link otherwise.
+  int _id;  // Incrementing id to enable sorting of timers with same expiry.
+
 
   // Get the next available id. We accept collisions and reordering when the
   // _idCount overflows and the timers expire at the same millisecond.
   static int _nextId() {
     var result = _idCount;
     _idCount = (_idCount + 1) & _ID_MASK;
     return result;
   }
 
-  _Timer._internal(
-      this._callback, this._wakeupTime, this._milliSeconds, this._repeating)
-      : _id = _nextId();
 
-  static Timer _createTimer(
-      void callback(Timer timer), int milliSeconds, bool repeating) {
+  _Timer._internal(this._callback,
+                   this._wakeupTime,
+                   this._milliSeconds,
+                   this._repeating) : _id = _nextId();
+
+
+  static Timer _createTimer(void callback(Timer timer),
+                            int milliSeconds,
+                            bool repeating) {
     // Negative timeouts are treated as if 0 timeout.
     if (milliSeconds < 0) {
       milliSeconds = 0;
     }
     // Add one because DateTime.now() is assumed to round down
     // to nearest millisecond, not up, so that time + duration is before
     // duration milliseconds from now. Using microsecond timers like
     // Stopwatch allows detecting that the timer fires early.
     int now = VMLibraryHooks.timerMillisecondClock();
     int wakeupTime = (milliSeconds == 0) ? now : (now + 1 + milliSeconds);
 
-    _Timer timer =
-        new _Timer._internal(callback, wakeupTime, milliSeconds, repeating);
+    _Timer timer = new _Timer._internal(callback,
+                                        wakeupTime,
+                                        milliSeconds,
+                                        repeating);
     // Enqueue this newly created timer in the appropriate structure and
     // notify if necessary.
     timer._enqueue();
     return timer;
   }
 
+
   factory _Timer(int milliSeconds, void callback(Timer timer)) {
     return _createTimer(callback, milliSeconds, false);
   }
 
+
   factory _Timer.periodic(int milliSeconds, void callback(Timer timer)) {
     return _createTimer(callback, milliSeconds, true);
   }
 
+
   bool get _isInHeap => _indexOrNext is int;
 
+
   int _compareTo(_Timer other) {
     int c = _wakeupTime - other._wakeupTime;
     if (c != 0) return c;
     return _id - other._id;
   }
 
+
   bool get isActive => _callback != null;
 
+
   // Cancels a set timer. The timer is removed from the timer heap if it is a
   // non-zero timer. Zero timers are kept in the list as they need to consume
   // the corresponding pending message.
   void cancel() {
     _callback = null;
     // Only heap timers are really removed. Zero timers need to consume their
     // corresponding wakeup message so they are left in the queue.
     if (!_isInHeap) return;
     bool update = _heap.isFirst(this);
     _heap.remove(this);
     if (update) {
       _notifyEventHandler();
     }
   }
 
+
   void _advanceWakeupTime() {
     // Recalculate the next wakeup time. For repeating timers with a 0 timeout
     // the next wakeup time is now.
     _id = _nextId();
     if (_milliSeconds > 0) {
       _wakeupTime += _milliSeconds;
     } else {
       _wakeupTime = VMLibraryHooks.timerMillisecondClock();
     }
   }
 
+
   // Adds a timer to the heap or timer list. Timers with the same wakeup time
   // are enqueued in order and notified in FIFO order.
   void _enqueue() {
     if (_milliSeconds == 0) {
       if (_firstZeroTimer == null) {
         _lastZeroTimer = this;
         _firstZeroTimer = this;
       } else {
         _lastZeroTimer._indexOrNext = this;
         _lastZeroTimer = this;
       }
       // Every zero timer gets its own event.
       _notifyZeroHandler();
     } else {
       _heap.add(this);
       if (_heap.isFirst(this)) {
         _notifyEventHandler();
       }
     }
   }
 
+
   // Enqeue one message for each zero timer. To be able to distinguish from
   // EventHandler messages we send a _ZERO_EVENT instead of a _TIMEOUT_EVENT.
   static void _notifyZeroHandler() {
     if (_sendPort == null) {
       _createTimerHandler();
     }
     _sendPort.send(_ZERO_EVENT);
   }
 
+
   // Handle the notification of a zero timer. Make sure to also execute non-zero
   // timers with a lower expiration time.
   static List _queueFromZeroEvent() {
     var pendingTimers = new List();
     assert(_firstZeroTimer != null);
     // Collect pending timers from the timer heap that have an expiration prior
     // to the currently notified zero timer.
     var timer;
     while (!_heap.isEmpty && (_heap.first._compareTo(_firstZeroTimer) < 0)) {
       timer = _heap.removeFirst();
       pendingTimers.add(timer);
     }
     // Append the first zero timer to the pending timers.
     timer = _firstZeroTimer;
     _firstZeroTimer = timer._indexOrNext;
     timer._indexOrNext = null;
     pendingTimers.add(timer);
     return pendingTimers;
   }
 
+
   static void _notifyEventHandler() {
     if (_handlingCallbacks) {
       // While we are already handling callbacks we will not notify the event
       // handler. _handleTimeout will call _notifyEventHandler once all pending
       // timers are processed.
       return;
     }
 
     // If there are no pending timers. Close down the receive port.
     if ((_firstZeroTimer == null) && _heap.isEmpty) {
@@ skipping 12 matching lines @@
 
     // Only send a message if the requested wakeup time differs from the
     // already scheduled wakeup time.
     var wakeupTime = _heap.first._wakeupTime;
     if ((_scheduledWakeupTime == null) ||
         (wakeupTime != _scheduledWakeupTime)) {
       _scheduleWakeup(wakeupTime);
     }
   }
 
+
   static List _queueFromTimeoutEvent() {
     var pendingTimers = new List();
     if (_firstZeroTimer != null) {
       // Collect pending timers from the timer heap that have an expiration
       // prior to the next zero timer.
       // By definition the first zero timer has been scheduled before the
       // current time, meaning all timers which are "less than" the first zero
       // timer are expired. The first zero timer will be dispatched when its
       // corresponding message is delivered.
       var timer;
       while (!_heap.isEmpty && (_heap.first._compareTo(_firstZeroTimer) < 0)) {
         timer = _heap.removeFirst();
         pendingTimers.add(timer);
       }
     } else {
       // Collect pending timers from the timer heap which have expired at this
       // time.
       var currentTime = VMLibraryHooks.timerMillisecondClock();
       var timer;
       while (!_heap.isEmpty && (_heap.first._wakeupTime <= currentTime)) {
         timer = _heap.removeFirst();
         pendingTimers.add(timer);
       }
     }
     return pendingTimers;
   }
 
+
   static void _runTimers(List pendingTimers) {
     // If there are no pending timers currently reset the id space before we
     // have a chance to enqueue new timers.
     if (_heap.isEmpty && (_firstZeroTimer == null)) {
       _idCount = 0;
     }
 
     // Fast exit if no pending timers.
     if (pendingTimers.length == 0) {
       return;
@@ skipping 29 matching lines @@
           if (immediateCallback != null) {
             immediateCallback();
           }
         }
       }
     } finally {
       _handlingCallbacks = false;
     }
   }
 
+
   static void _handleMessage(msg) {
     var pendingTimers;
     if (msg == _ZERO_EVENT) {
       pendingTimers = _queueFromZeroEvent();
       assert(pendingTimers.length > 0);
     } else {
       assert(msg == _TIMEOUT_EVENT);
-      _scheduledWakeupTime = null; // Consumed the last scheduled wakeup now.
+      _scheduledWakeupTime = null;  // Consumed the last scheduled wakeup now.
       pendingTimers = _queueFromTimeoutEvent();
     }
     _runTimers(pendingTimers);
     // Notify the event handler or shutdown the port if no more pending
     // timers are present.
     _notifyEventHandler();
   }
 
+
   // Tell the event handler to wake this isolate at a specific time.
   static void _scheduleWakeup(int wakeupTime) {
     if (_sendPort == null) {
       _createTimerHandler();
     }
     VMLibraryHooks.eventHandlerSendData(null, _sendPort, wakeupTime);
     _scheduledWakeupTime = wakeupTime;
   }
 
+
   // Cancel pending wakeups in the event handler.
   static void _cancelWakeup() {
     assert(_sendPort != null);
     VMLibraryHooks.eventHandlerSendData(null, _sendPort, _NO_TIMER);
     _scheduledWakeupTime = null;
   }
 
+
   // Create a receive port and register a message handler for the timer
   // events.
   static void _createTimerHandler() {
     assert(_receivePort == null);
     assert(_sendPort == null);
     _receivePort = new RawReceivePort(_handleMessage);
     _sendPort = _receivePort.sendPort;
     _scheduledWakeupTime = null;
   }
 
+
   static void _shutdownTimerHandler() {
     _receivePort.close();
     _receivePort = null;
     _sendPort = null;
     _scheduledWakeupTime = null;
   }
 
+
   // The Timer factory registered with the dart:async library by the embedder.
-  static Timer _factory(
-      int milliSeconds, void callback(Timer timer), bool repeating) {
+  static Timer _factory(int milliSeconds,
+                        void callback(Timer timer),
+                        bool repeating) {
     if (repeating) {
       return new _Timer.periodic(milliSeconds, callback);
     }
     return new _Timer(milliSeconds, callback);
   }
 }
 
+
 _setupHooks() {
   VMLibraryHooks.timerFactory = _Timer._factory;
 }