Refactor Future constructors.

pkg/scheduled_test/lib/src/schedule.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.
 
 library schedule;
 
 import 'dart:async';
 import 'dart:collection';
 
 import 'package:stack_trace/stack_trace.dart';
@@ skipping 113 matching lines @@
     _onComplete = new TaskQueue._("onComplete", this);
     _onException = new TaskQueue._("onException", this);
     _currentQueue = _tasks;
 
     heartbeat();
   }
 
   /// Sets up this schedule by running [setUp], then runs all the task queues in
   /// order. Any errors in [setUp] will cause [onException] to run.
   Future run(void setUp()) {
-    return new Future.immediate(null).then((_) {
+    return new Future.value().then((_) {
       try {
         setUp();
       } catch (e, stackTrace) {
         // Even though the scheduling failed, we need to run the onException and
         // onComplete queues, so we set the schedule state to RUNNING.
         _state = ScheduleState.RUNNING;
         throw new ScheduleError.from(this, e, stackTrace: stackTrace);
       }
 
       _state = ScheduleState.RUNNING;
@@ skipping 280 matching lines @@
   /// If this is called when this queue is currently running, it will run [fn]
   /// on the next event loop iteration rather than adding it to a queue--this is
   /// known as a "nested task". The current task will not complete until [fn]
   /// (and any [Future] it returns) has finished running. Any errors in [fn]
   /// will automatically be handled. Nested tasks run in parallel, unlike
   /// top-level tasks which run in sequence.
   Future schedule(fn(), [String description]) {
     if (isRunning) {
       var task = _schedule.currentTask;
       var wrappedFn = () => _schedule.wrapFuture(
-          new Future.immediate(null).then((_) => fn()));
+          new Future.value().then((_) => fn()));
       if (task == null) return wrappedFn();
       return task.runChild(wrappedFn, description);
     }
 
     var task = new Task(() {
-      return new Future.of(fn).catchError((e) {
+      return new Future.sync(fn).catchError((e) {
         throw new ScheduleError.from(_schedule, e);
       });
     }, description, this);
     _contents.add(task);
     return task.result;
   }
 
   /// Runs all the tasks in this queue in order.
   Future _run() {
     _schedule._currentQueue = this;
@@ skipping 98 matching lines @@
 
   /// Notifies the queue that it has timed out and it needs to terminate
   /// immediately with a timeout error.
   void _signalTimeout(ScheduleError error) {
     _pendingCallbacks.clear();
     if (!isRunningTasks) {
       _noPendingCallbacksCompleter.completeError(error);
     } else if (_taskFuture != null) {
       // Catch errors coming off the old task future, in case it completes after
       // timing out.
-      _taskFuture.substitute(new Future.immediateError(error)).catchError((e) {
+      _taskFuture.substitute(new Future.error(error)).catchError((e) {
         _schedule._signalPostTimeoutError(e);
       });
     } else {
       // This branch probably won't be reached, but it's conceivable that the
       // event loop might get pumped when _taskFuture is null but we haven't yet
       // finished running all the tasks.
       _signalError(error);
     }
   }
 
@@ skipping 27 matching lines @@
           return prefixLines(childString,
               firstPrefix: "  $prefix ", prefix: "  | ");
         }).join('\n');
         taskString = '$taskString\n$childrenString';
       }
 
       return taskString;
     }).join("\n");
   }
 }